?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/beast.zip
???????
PK OP�[�*��G G zlib.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_ZLIB_HPP #define BOOST_BEAST_ZLIB_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/zlib/deflate_stream.hpp> #include <boost/beast/zlib/error.hpp> #include <boost/beast/zlib/inflate_stream.hpp> #include <boost/beast/zlib/zlib.hpp> #endif PK OP�[h��z z core.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_HPP #define BOOST_BEAST_CORE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/basic_stream.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffered_read_stream.hpp> #include <boost/beast/core/buffers_adaptor.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/buffers_to_string.hpp> #include <boost/beast/core/detect_ssl.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/file.hpp> #include <boost/beast/core/file_base.hpp> #include <boost/beast/core/file_posix.hpp> #include <boost/beast/core/file_stdio.hpp> #include <boost/beast/core/file_win32.hpp> #include <boost/beast/core/flat_buffer.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/flat_stream.hpp> #include <boost/beast/core/make_printable.hpp> #include <boost/beast/core/multi_buffer.hpp> #include <boost/beast/core/ostream.hpp> #include <boost/beast/core/rate_policy.hpp> #include <boost/beast/core/read_size.hpp> #include <boost/beast/core/role.hpp> #include <boost/beast/core/saved_handler.hpp> #include <boost/beast/core/span.hpp> #include <boost/beast/core/static_buffer.hpp> #include <boost/beast/core/static_string.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/tcp_stream.hpp> #endif PK OP�[�[�� � zlib/zlib.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_ZLIB_HPP #define BOOST_BEAST_ZLIB_ZLIB_HPP #include <boost/beast/core/detail/config.hpp> #include <cstdint> #include <cstdlib> namespace boost { namespace beast { namespace zlib { #if !defined(__MACTYPES__) using Byte = unsigned char; // 8 bits #endif using uInt = unsigned int; // 16 bits or more /* Possible values of the data_type field (though see inflate()) */ enum kind { binary = 0, text = 1, unknown = 2 }; /** Deflate codec parameters. Objects of this type are filled in by callers and provided to the deflate codec to define the input and output areas for the next compress or decompress operation. The application must update next_in and avail_in when avail_in has dropped to zero. It must update next_out and avail_out when avail_out has dropped to zero. The application must initialize zalloc, zfree and opaque before calling the init function. All other fields are set by the compression library and must not be updated by the application. The fields total_in and total_out can be used for statistics or progress reports. After compression, total_in holds the total size of the uncompressed data and may be saved for use in the decompressor (particularly if the decompressor wants to decompress everything in a single step). */ struct z_params { /** A pointer to the next input byte. If there is no more input, this may be set to `nullptr`. */ void const* next_in; /** The number of bytes of input available at `next_in`. If there is no more input, this should be set to zero. */ std::size_t avail_in; /** The total number of input bytes read so far. */ std::size_t total_in = 0; /** A pointer to the next output byte. */ void* next_out; /** The remaining bytes of space at `next_out`. */ std::size_t avail_out; /** The total number of bytes output so far. */ std::size_t total_out = 0; int data_type = unknown; // best guess about the data type: binary or text }; /** Flush option. */ enum class Flush { // order matters none, block, partial, sync, full, finish, trees }; /* compression levels */ enum compression { none = 0, best_speed = 1, best_size = 9, default_size = -1 }; /** Compression strategy. These are used when compressing streams. */ enum class Strategy { /** Default strategy. This is suitable for general purpose compression, and works well in the majority of cases. */ normal, /** Filtered strategy. This strategy should be used when the data be compressed is produced by a filter or predictor. */ filtered, /** Huffman-only strategy. This strategy only performs Huffman encoding, without doing any string matching. */ huffman, /** Run Length Encoding strategy. This strategy limits match distances to one, making it equivalent to run length encoding. This can give better performance for things like PNG image data. */ rle, /** Fixed table strategy. This strategy prevents the use of dynamic Huffman codes, allowing for a simpler decoder for special applications. */ fixed }; } // zlib } // beast } // boost #endif PK OP�[��W� � zlib/impl/error.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_IMPL_ERROR_IPP #define BOOST_BEAST_ZLIB_IMPL_ERROR_IPP #include <boost/beast/zlib/error.hpp> #include <type_traits> namespace boost { namespace beast { namespace zlib { namespace detail { class error_codes : public error_category { public: const char* name() const noexcept override { return "boost.beast.zlib"; } std::string message(int ev) const override { switch(static_cast<error>(ev)) { case error::need_buffers: return "need buffers"; case error::end_of_stream: return "unexpected end of deflate stream"; case error::need_dict: return "need dict"; case error::stream_error: return "stream error"; case error::invalid_block_type: return "invalid block type"; case error::invalid_stored_length: return "invalid stored block length"; case error::too_many_symbols: return "too many symbols"; case error::invalid_code_lengths: return "invalid code lengths"; case error::invalid_bit_length_repeat: return "invalid bit length repeat"; case error::missing_eob: return "missing end of block code"; case error::invalid_literal_length: return "invalid literal/length code"; case error::invalid_distance_code: return "invalid distance code"; case error::invalid_distance: return "invalid distance"; case error::over_subscribed_length: return "over-subscribed length"; case error::incomplete_length_set: return "incomplete length set"; case error::general: default: return "beast.zlib error"; } } error_condition default_error_condition(int ev) const noexcept override { return error_condition{ev, *this}; } bool equivalent(int ev, error_condition const& condition ) const noexcept override { return condition.value() == ev && &condition.category() == this; } bool equivalent(error_code const& error, int ev) const noexcept override { return error.value() == ev && &error.category() == this; } }; } // detail error_code make_error_code(error ev) { static detail::error_codes const cat{}; return error_code{static_cast< std::underlying_type<error>::type>(ev), cat}; } } // zlib } // beast } // boost #endif PK OP�[��� � zlib/impl/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_IMPL_ERROR_HPP #define BOOST_BEAST_ZLIB_IMPL_ERROR_HPP namespace boost { namespace system { template<> struct is_error_code_enum<::boost::beast::zlib::error> { static bool const value = true; }; } // system } // boost namespace boost { namespace beast { namespace zlib { BOOST_BEAST_DECL error_code make_error_code(error ev); } // zlib } // beast } // boost #endif PK OP�[q�V� zlib/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_ERROR_HPP #define BOOST_BEAST_ZLIB_ERROR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> namespace boost { namespace beast { namespace zlib { /** Error codes returned by the deflate codecs. */ enum class error { /** Additional buffers are required. This error indicates that one or both of the buffers provided buffers do not have sufficient available bytes to make forward progress. This does not always indicate a failure condition. @note This is the same as `Z_BUF_ERROR` returned by ZLib. */ need_buffers = 1, /** End of stream reached. @note This is the same as `Z_STREAM_END` returned by ZLib. */ end_of_stream, /** Preset dictionary required This error indicates that a preset dictionary was not provided and is now needed at this point. This does not always indicate a failure condition. @note This is the same as `Z_NEED_DICT` returned by ZLib. */ need_dict, /** Invalid stream or parameters. This error is returned when invalid parameters are passed, or the operation being performed is not consistent with the state of the stream. For example, attempting to write data when the end of stream is already reached. @note This is the same as `Z_STREAM_ERROR` returned by ZLib. */ stream_error, // // Errors generated by basic_deflate_stream // // // Errors generated by basic_inflate_stream // /// Invalid block type invalid_block_type, /// Invalid stored block length invalid_stored_length, /// Too many length or distance symbols too_many_symbols, /// Invalid code lengths invalid_code_lengths, /// Invalid bit length repeat invalid_bit_length_repeat, /// Missing end of block code missing_eob, /// Invalid literal/length code invalid_literal_length, /// Invalid distance code invalid_distance_code, /// Invalid distance too far back invalid_distance, // // Errors generated by inflate_table // /// Over-subscribed length code over_subscribed_length, /// Incomplete length set incomplete_length_set, /// general error general }; } // zlib } // beast } // boost #include <boost/beast/zlib/impl/error.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/zlib/impl/error.ipp> #endif #endif PK OP�[��.� .� zlib/detail/inflate_stream.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_INFLATE_STREAM_IPP #define BOOST_BEAST_ZLIB_DETAIL_INFLATE_STREAM_IPP #include <boost/beast/zlib/detail/inflate_stream.hpp> #include <boost/throw_exception.hpp> #include <array> namespace boost { namespace beast { namespace zlib { namespace detail { void inflate_stream:: doClear() { } void inflate_stream:: doReset(int windowBits) { if(windowBits < 8 || windowBits > 15) BOOST_THROW_EXCEPTION(std::domain_error{ "windowBits out of range"}); w_.reset(windowBits); bi_.flush(); mode_ = HEAD; last_ = 0; dmax_ = 32768U; lencode_ = codes_; distcode_ = codes_; next_ = codes_; back_ = -1; } void inflate_stream:: doWrite(z_params& zs, Flush flush, error_code& ec) { ranges r; r.in.first = static_cast< std::uint8_t const*>(zs.next_in); r.in.last = r.in.first + zs.avail_in; r.in.next = r.in.first; r.out.first = static_cast< std::uint8_t*>(zs.next_out); r.out.last = r.out.first + zs.avail_out; r.out.next = r.out.first; auto const done = [&] { /* Return from inflate(), updating the total counts and the check value. If there was no progress during the inflate() call, return a buffer error. Call updatewindow() to create and/or update the window state. Note: a memory error from inflate() is non-recoverable. */ // VFALCO TODO Don't allocate update the window unless necessary if(/*wsize_ ||*/ (r.out.used() && mode_ < BAD && (mode_ < CHECK || flush != Flush::finish))) w_.write(r.out.first, r.out.used()); zs.next_in = r.in.next; zs.avail_in = r.in.avail(); zs.next_out = r.out.next; zs.avail_out = r.out.avail(); zs.total_in += r.in.used(); zs.total_out += r.out.used(); zs.data_type = bi_.size() + (last_ ? 64 : 0) + (mode_ == TYPE ? 128 : 0) + (mode_ == LEN_ || mode_ == COPY_ ? 256 : 0); if(((! r.in.used() && ! r.out.used()) || flush == Flush::finish) && ! ec) ec = error::need_buffers; }; auto const err = [&](error e) { ec = e; mode_ = BAD; }; if(mode_ == TYPE) mode_ = TYPEDO; for(;;) { switch(mode_) { case HEAD: mode_ = TYPEDO; break; case TYPE: if(flush == Flush::block || flush == Flush::trees) return done(); // fall through case TYPEDO: { if(last_) { bi_.flush_byte(); mode_ = CHECK; break; } if(! bi_.fill(3, r.in.next, r.in.last)) return done(); std::uint8_t v; bi_.read(v, 1); last_ = v != 0; bi_.read(v, 2); switch(v) { case 0: // uncompressed block mode_ = STORED; break; case 1: // fixed Huffman table fixedTables(); mode_ = LEN_; /* decode codes */ if(flush == Flush::trees) return done(); break; case 2: // dynamic Huffman table mode_ = TABLE; break; default: return err(error::invalid_block_type); } break; } case STORED: { bi_.flush_byte(); std::uint32_t v; if(! bi_.fill(32, r.in.next, r.in.last)) return done(); bi_.peek(v, 32); length_ = v & 0xffff; if(length_ != ((v >> 16) ^ 0xffff)) return err(error::invalid_stored_length); // flush instead of read, otherwise // undefined right shift behavior. bi_.flush(); mode_ = COPY_; if(flush == Flush::trees) return done(); BOOST_FALLTHROUGH; } case COPY_: mode_ = COPY; BOOST_FALLTHROUGH; case COPY: { auto copy = length_; if(copy == 0) { mode_ = TYPE; break; } copy = clamp(copy, r.in.avail()); copy = clamp(copy, r.out.avail()); if(copy == 0) return done(); std::memcpy(r.out.next, r.in.next, copy); r.in.next += copy; r.out.next += copy; length_ -= copy; break; } case TABLE: if(! bi_.fill(5 + 5 + 4, r.in.next, r.in.last)) return done(); bi_.read(nlen_, 5); nlen_ += 257; bi_.read(ndist_, 5); ndist_ += 1; bi_.read(ncode_, 4); ncode_ += 4; if(nlen_ > 286 || ndist_ > 30) return err(error::too_many_symbols); have_ = 0; mode_ = LENLENS; BOOST_FALLTHROUGH; case LENLENS: { static std::array<std::uint8_t, 19> constexpr order = {{ 16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15}}; while(have_ < ncode_) { if(! bi_.fill(3, r.in.next, r.in.last)) return done(); bi_.read(lens_[order[have_]], 3); ++have_; } while(have_ < order.size()) lens_[order[have_++]] = 0; next_ = &codes_[0]; lencode_ = next_; lenbits_ = 7; inflate_table(build::codes, &lens_[0], order.size(), &next_, &lenbits_, work_, ec); if(ec) { mode_ = BAD; break; } have_ = 0; mode_ = CODELENS; BOOST_FALLTHROUGH; } case CODELENS: { while(have_ < nlen_ + ndist_) { std::uint16_t v; if(! bi_.fill(lenbits_, r.in.next, r.in.last)) return done(); bi_.peek(v, lenbits_); auto cp = &lencode_[v]; if(cp->val < 16) { bi_.drop(cp->bits); lens_[have_++] = cp->val; } else { std::uint16_t len; std::uint16_t copy; if(cp->val == 16) { if(! bi_.fill(cp->bits + 2, r.in.next, r.in.last)) return done(); bi_.drop(cp->bits); if(have_ == 0) return err(error::invalid_bit_length_repeat); bi_.read(copy, 2); len = lens_[have_ - 1]; copy += 3; } else if(cp->val == 17) { if(! bi_.fill(cp->bits + 3, r.in.next, r.in.last)) return done(); bi_.drop(cp->bits); bi_.read(copy, 3); len = 0; copy += 3; } else { if(! bi_.fill(cp->bits + 7, r.in.next, r.in.last)) return done(); bi_.drop(cp->bits); bi_.read(copy, 7); len = 0; copy += 11; } if(have_ + copy > nlen_ + ndist_) return err(error::invalid_bit_length_repeat); std::fill(&lens_[have_], &lens_[have_ + copy], len); have_ += copy; copy = 0; } } // handle error breaks in while if(mode_ == BAD) break; // check for end-of-block code (better have one) if(lens_[256] == 0) return err(error::missing_eob); /* build code tables -- note: do not change the lenbits or distbits values here (9 and 6) without reading the comments in inftrees.hpp concerning the kEnough constants, which depend on those values */ next_ = &codes_[0]; lencode_ = next_; lenbits_ = 9; inflate_table(build::lens, &lens_[0], nlen_, &next_, &lenbits_, work_, ec); if(ec) { mode_ = BAD; return; } distcode_ = next_; distbits_ = 6; inflate_table(build::dists, lens_ + nlen_, ndist_, &next_, &distbits_, work_, ec); if(ec) { mode_ = BAD; return; } mode_ = LEN_; if(flush == Flush::trees) return done(); BOOST_FALLTHROUGH; } case LEN_: mode_ = LEN; BOOST_FALLTHROUGH; case LEN: { if(r.in.avail() >= 6 && r.out.avail() >= 258) { inflate_fast(r, ec); if(ec) { mode_ = BAD; return; } if(mode_ == TYPE) back_ = -1; break; } if(! bi_.fill(lenbits_, r.in.next, r.in.last)) return done(); std::uint16_t v; back_ = 0; bi_.peek(v, lenbits_); auto cp = &lencode_[v]; if(cp->op && (cp->op & 0xf0) == 0) { auto prev = cp; if(! bi_.fill(prev->bits + prev->op, r.in.next, r.in.last)) return done(); bi_.peek(v, prev->bits + prev->op); cp = &lencode_[prev->val + (v >> prev->bits)]; bi_.drop(prev->bits + cp->bits); back_ += prev->bits + cp->bits; } else { bi_.drop(cp->bits); back_ += cp->bits; } length_ = cp->val; if(cp->op == 0) { mode_ = LIT; break; } if(cp->op & 32) { back_ = -1; mode_ = TYPE; break; } if(cp->op & 64) return err(error::invalid_literal_length); extra_ = cp->op & 15; mode_ = LENEXT; BOOST_FALLTHROUGH; } case LENEXT: if(extra_) { if(! bi_.fill(extra_, r.in.next, r.in.last)) return done(); std::uint16_t v; bi_.read(v, extra_); length_ += v; back_ += extra_; } was_ = length_; mode_ = DIST; BOOST_FALLTHROUGH; case DIST: { if(! bi_.fill(distbits_, r.in.next, r.in.last)) return done(); std::uint16_t v; bi_.peek(v, distbits_); auto cp = &distcode_[v]; if((cp->op & 0xf0) == 0) { auto prev = cp; if(! bi_.fill(prev->bits + prev->op, r.in.next, r.in.last)) return done(); bi_.peek(v, prev->bits + prev->op); cp = &distcode_[prev->val + (v >> prev->bits)]; bi_.drop(prev->bits + cp->bits); back_ += prev->bits + cp->bits; } else { bi_.drop(cp->bits); back_ += cp->bits; } if(cp->op & 64) return err(error::invalid_distance_code); offset_ = cp->val; extra_ = cp->op & 15; mode_ = DISTEXT; BOOST_FALLTHROUGH; } case DISTEXT: if(extra_) { std::uint16_t v; if(! bi_.fill(extra_, r.in.next, r.in.last)) return done(); bi_.read(v, extra_); offset_ += v; back_ += extra_; } #ifdef INFLATE_STRICT if(offset_ > dmax_) return err(error::invalid_distance); #endif mode_ = MATCH; BOOST_FALLTHROUGH; case MATCH: { if(! r.out.avail()) return done(); if(offset_ > r.out.used()) { // copy from window auto offset = static_cast<std::uint16_t>( offset_ - r.out.used()); if(offset > w_.size()) return err(error::invalid_distance); auto const n = clamp(clamp( length_, offset), r.out.avail()); w_.read(r.out.next, offset, n); r.out.next += n; length_ -= n; } else { // copy from output auto in = r.out.next - offset_; auto n = clamp(length_, r.out.avail()); length_ -= n; while(n--) *r.out.next++ = *in++; } if(length_ == 0) mode_ = LEN; break; } case LIT: { if(! r.out.avail()) return done(); auto const v = static_cast<std::uint8_t>(length_); *r.out.next++ = v; mode_ = LEN; break; } case CHECK: mode_ = DONE; BOOST_FALLTHROUGH; case DONE: ec = error::end_of_stream; return done(); case BAD: return done(); case SYNC: default: BOOST_THROW_EXCEPTION(std::logic_error{ "stream error"}); } } } //------------------------------------------------------------------------------ /* Build a set of tables to decode the provided canonical Huffman code. The code lengths are lens[0..codes-1]. The result starts at *table, whose indices are 0..2^bits-1. work is a writable array of at least lens shorts, which is used as a work area. type is the type of code to be generated, build::codes, build::lens, or build::dists. On return, zero is success, -1 is an invalid code, and +1 means that kEnough isn't enough. table on return points to the next available entry's address. bits is the requested root table index bits, and on return it is the actual root table index bits. It will differ if the request is greater than the longest code or if it is less than the shortest code. */ void inflate_stream:: inflate_table( build type, std::uint16_t* lens, std::size_t codes, code** table, unsigned *bits, std::uint16_t* work, error_code& ec) { unsigned len; // a code's length in bits unsigned sym; // index of code symbols unsigned min, max; // minimum and maximum code lengths unsigned root; // number of index bits for root table unsigned curr; // number of index bits for current table unsigned drop; // code bits to drop for sub-table int left; // number of prefix codes available unsigned used; // code entries in table used unsigned huff; // Huffman code unsigned incr; // for incrementing code, index unsigned fill; // index for replicating entries unsigned low; // low bits for current root entry unsigned mask; // mask for low root bits code here; // table entry for duplication code *next; // next available space in table std::uint16_t const* base; // base value table to use std::uint16_t const* extra; // extra bits table to use int end; // use base and extra for symbol > end std::uint16_t count[15+1]; // number of codes of each length std::uint16_t offs[15+1]; // offsets in table for each length // Length codes 257..285 base static std::uint16_t constexpr lbase[31] = { 3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258, 0, 0}; // Length codes 257..285 extra static std::uint16_t constexpr lext[31] = { 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 18, 19, 19, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 16, 72, 78}; // Distance codes 0..29 base static std::uint16_t constexpr dbase[32] = { 1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577, 0, 0}; // Distance codes 0..29 extra static std::uint16_t constexpr dext[32] = { 16, 16, 16, 16, 17, 17, 18, 18, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24, 25, 25, 26, 26, 27, 27, 28, 28, 29, 29, 64, 64}; /* Process a set of code lengths to create a canonical Huffman code. The code lengths are lens[0..codes-1]. Each length corresponds to the symbols 0..codes-1. The Huffman code is generated by first sorting the symbols by length from short to long, and retaining the symbol order for codes with equal lengths. Then the code starts with all zero bits for the first code of the shortest length, and the codes are integer increments for the same length, and zeros are appended as the length increases. For the deflate format, these bits are stored backwards from their more natural integer increment ordering, and so when the decoding tables are built in the large loop below, the integer codes are incremented backwards. This routine assumes, but does not check, that all of the entries in lens[] are in the range 0..15. The caller must assure this. 1..15 is interpreted as that code length. zero means that that symbol does not occur in this code. The codes are sorted by computing a count of codes for each length, creating from that a table of starting indices for each length in the sorted table, and then entering the symbols in order in the sorted table. The sorted table is work[], with that space being provided by the caller. The length counts are used for other purposes as well, i.e. finding the minimum and maximum length codes, determining if there are any codes at all, checking for a valid set of lengths, and looking ahead at length counts to determine sub-table sizes when building the decoding tables. */ /* accumulate lengths for codes (assumes lens[] all in 0..15) */ for (len = 0; len <= 15; len++) count[len] = 0; for (sym = 0; sym < codes; sym++) count[lens[sym]]++; /* bound code lengths, force root to be within code lengths */ root = *bits; for (max = 15; max >= 1; max--) if (count[max] != 0) break; if (root > max) root = max; if (max == 0) { /* no symbols to code at all */ here.op = (std::uint8_t)64; /* invalid code marker */ here.bits = (std::uint8_t)1; here.val = (std::uint16_t)0; *(*table)++ = here; /* make a table to force an error */ *(*table)++ = here; *bits = 1; return; /* no symbols, but wait for decoding to report error */ } for (min = 1; min < max; min++) if (count[min] != 0) break; if (root < min) root = min; /* check for an over-subscribed or incomplete set of lengths */ left = 1; for (len = 1; len <= 15; len++) { left <<= 1; left -= count[len]; if (left < 0) { ec = error::over_subscribed_length; return; } } if (left > 0 && (type == build::codes || max != 1)) { ec = error::incomplete_length_set; return; } /* generate offsets into symbol table for each length for sorting */ offs[1] = 0; for (len = 1; len < 15; len++) offs[len + 1] = offs[len] + count[len]; /* sort symbols by length, by symbol order within each length */ for (sym = 0; sym < codes; sym++) if (lens[sym] != 0) work[offs[lens[sym]]++] = (std::uint16_t)sym; /* Create and fill in decoding tables. In this loop, the table being filled is at next and has curr index bits. The code being used is huff with length len. That code is converted to an index by dropping drop bits off of the bottom. For codes where len is less than drop + curr, those top drop + curr - len bits are incremented through all values to fill the table with replicated entries. root is the number of index bits for the root table. When len exceeds root, sub-tables are created pointed to by the root entry with an index of the low root bits of huff. This is saved in low to check for when a new sub-table should be started. drop is zero when the root table is being filled, and drop is root when sub-tables are being filled. When a new sub-table is needed, it is necessary to look ahead in the code lengths to determine what size sub-table is needed. The length counts are used for this, and so count[] is decremented as codes are entered in the tables. used keeps track of how many table entries have been allocated from the provided *table space. It is checked for build::lens and DIST tables against the constants kEnoughLens and kEnoughDists to guard against changes in the initial root table size constants. See the comments in inftrees.hpp for more information. sym increments through all symbols, and the loop terminates when all codes of length max, i.e. all codes, have been processed. This routine permits incomplete codes, so another loop after this one fills in the rest of the decoding tables with invalid code markers. */ /* set up for code type */ switch (type) { case build::codes: base = extra = work; /* dummy value--not used */ end = 19; break; case build::lens: base = lbase; base -= 257; extra = lext; extra -= 257; end = 256; break; default: /* build::dists */ base = dbase; extra = dext; end = -1; } /* initialize state for loop */ huff = 0; /* starting code */ sym = 0; /* starting code symbol */ len = min; /* starting code length */ next = *table; /* current table to fill in */ curr = root; /* current table index bits */ drop = 0; /* current bits to drop from code for index */ low = (unsigned)(-1); /* trigger new sub-table when len > root */ used = 1U << root; /* use root table entries */ mask = used - 1; /* mask for comparing low */ auto const not_enough = [] { BOOST_THROW_EXCEPTION(std::logic_error{ "insufficient output size when inflating tables"}); }; // check available table space if ((type == build::lens && used > kEnoughLens) || (type == build::dists && used > kEnoughDists)) return not_enough(); /* process all codes and make table entries */ for (;;) { /* create table entry */ here.bits = (std::uint8_t)(len - drop); if ((int)(work[sym]) < end) { here.op = (std::uint8_t)0; here.val = work[sym]; } else if ((int)(work[sym]) > end) { here.op = (std::uint8_t)(extra[work[sym]]); here.val = base[work[sym]]; } else { here.op = (std::uint8_t)(32 + 64); /* end of block */ here.val = 0; } /* replicate for those indices with low len bits equal to huff */ incr = 1U << (len - drop); fill = 1U << curr; min = fill; /* save offset to next table */ do { fill -= incr; next[(huff >> drop) + fill] = here; } while (fill != 0); /* backwards increment the len-bit code huff */ incr = 1U << (len - 1); while (huff & incr) incr >>= 1; if (incr != 0) { huff &= incr - 1; huff += incr; } else huff = 0; /* go to next symbol, update count, len */ sym++; if (--(count[len]) == 0) { if (len == max) break; len = lens[work[sym]]; } /* create new sub-table if needed */ if (len > root && (huff & mask) != low) { /* if first time, transition to sub-tables */ if (drop == 0) drop = root; /* increment past last table */ next += min; /* here min is 1 << curr */ /* determine length of next table */ curr = len - drop; left = (int)(1 << curr); while (curr + drop < max) { left -= count[curr + drop]; if (left <= 0) break; curr++; left <<= 1; } /* check for enough space */ used += 1U << curr; if ((type == build::lens && used > kEnoughLens) || (type == build::dists && used > kEnoughDists)) return not_enough(); /* point entry in root table to sub-table */ low = huff & mask; (*table)[low].op = (std::uint8_t)curr; (*table)[low].bits = (std::uint8_t)root; (*table)[low].val = (std::uint16_t)(next - *table); } } /* fill in remaining table entry if code is incomplete (guaranteed to have at most one remaining entry, since if the code is incomplete, the maximum code length that was allowed to get this far is one bit) */ if (huff != 0) { here.op = 64; // invalid code marker here.bits = (std::uint8_t)(len - drop); here.val = 0; next[huff] = here; } *table += used; *bits = root; } auto inflate_stream:: get_fixed_tables() -> codes const& { struct fixed_codes : codes { code len_[512]; code dist_[32]; fixed_codes() { lencode = len_; lenbits = 9; distcode = dist_; distbits = 5; std::uint16_t lens[320]; std::uint16_t work[288]; std::fill(&lens[ 0], &lens[144], std::uint16_t{8}); std::fill(&lens[144], &lens[256], std::uint16_t{9}); std::fill(&lens[256], &lens[280], std::uint16_t{7}); std::fill(&lens[280], &lens[288], std::uint16_t{8}); { error_code ec; auto next = &len_[0]; inflate_table(build::lens, lens, 288, &next, &lenbits, work, ec); if(ec) BOOST_THROW_EXCEPTION(std::logic_error{ec.message()}); } // VFALCO These fixups are from ZLib len_[ 99].op = 64; len_[227].op = 64; len_[355].op = 64; len_[483].op = 64; { error_code ec; auto next = &dist_[0]; std::fill(&lens[0], &lens[32], std::uint16_t{5}); inflate_table(build::dists, lens, 32, &next, &distbits, work, ec); if(ec) BOOST_THROW_EXCEPTION(std::logic_error{ec.message()}); } } }; static fixed_codes const fc; return fc; } void inflate_stream:: fixedTables() { auto const fc = get_fixed_tables(); lencode_ = fc.lencode; lenbits_ = fc.lenbits; distcode_ = fc.distcode; distbits_ = fc.distbits; } /* Decode literal, length, and distance codes and write out the resulting literal and match bytes until either not enough input or output is available, an end-of-block is encountered, or a data error is encountered. When large enough input and output buffers are supplied to inflate(), for example, a 16K input buffer and a 64K output buffer, more than 95% of the inflate execution time is spent in this routine. Entry assumptions: state->mode_ == LEN zs.avail_in >= 6 zs.avail_out >= 258 start >= zs.avail_out state->bits_ < 8 On return, state->mode_ is one of: LEN -- ran out of enough output space or enough available input TYPE -- reached end of block code, inflate() to interpret next block BAD -- error in block data Notes: - The maximum input bits used by a length/distance pair is 15 bits for the length code, 5 bits for the length extra, 15 bits for the distance code, and 13 bits for the distance extra. This totals 48 bits, or six bytes. Therefore if zs.avail_in >= 6, then there is enough input to avoid checking for available input while decoding. - The maximum bytes that a single length/distance pair can output is 258 bytes, which is the maximum length that can be coded. inflate_fast() requires zs.avail_out >= 258 for each loop to avoid checking for output space. inflate_fast() speedups that turned out slower (on a PowerPC G3 750CXe): - Using bit fields for code structure - Different op definition to avoid & for extra bits (do & for table bits) - Three separate decoding do-loops for direct, window, and wnext == 0 - Special case for distance > 1 copies to do overlapped load and store copy - Explicit branch predictions (based on measured branch probabilities) - Deferring match copy and interspersed it with decoding subsequent codes - Swapping literal/length else - Swapping window/direct else - Larger unrolled copy loops (three is about right) - Moving len -= 3 statement into middle of loop */ void inflate_stream:: inflate_fast(ranges& r, error_code& ec) { unsigned char const* last; // have enough input while in < last unsigned char *end; // while out < end, enough space available std::size_t op; // code bits, operation, extra bits, or window position, window bytes to copy unsigned len; // match length, unused bytes unsigned dist; // match distance unsigned const lmask = (1U << lenbits_) - 1; // mask for first level of length codes unsigned const dmask = (1U << distbits_) - 1; // mask for first level of distance codes last = r.in.next + (r.in.avail() - 5); end = r.out.next + (r.out.avail() - 257); /* decode literals and length/distances until end-of-block or not enough input data or output space */ do { if(bi_.size() < 15) bi_.fill_16(r.in.next); auto cp = &lencode_[bi_.peek_fast() & lmask]; dolen: bi_.drop(cp->bits); op = (unsigned)(cp->op); if(op == 0) { // literal *r.out.next++ = (unsigned char)(cp->val); } else if(op & 16) { // length base len = (unsigned)(cp->val); op &= 15; // number of extra bits if(op) { if(bi_.size() < op) bi_.fill_8(r.in.next); len += (unsigned)bi_.peek_fast() & ((1U << op) - 1); bi_.drop(op); } if(bi_.size() < 15) bi_.fill_16(r.in.next); cp = &distcode_[bi_.peek_fast() & dmask]; dodist: bi_.drop(cp->bits); op = (unsigned)(cp->op); if(op & 16) { // distance base dist = (unsigned)(cp->val); op &= 15; // number of extra bits if(bi_.size() < op) { bi_.fill_8(r.in.next); if(bi_.size() < op) bi_.fill_8(r.in.next); } dist += (unsigned)bi_.peek_fast() & ((1U << op) - 1); #ifdef INFLATE_STRICT if(dist > dmax_) { ec = error::invalid_distance; mode_ = BAD; break; } #endif bi_.drop(op); op = r.out.used(); if(dist > op) { // copy from window op = dist - op; // distance back in window if(op > w_.size()) { ec = error::invalid_distance; mode_ = BAD; break; } auto const n = clamp(len, op); w_.read(r.out.next, op, n); r.out.next += n; len -= n; } if(len > 0) { // copy from output auto in = r.out.next - dist; auto n = clamp(len, r.out.avail()); len -= n; while(n--) *r.out.next++ = *in++; } } else if((op & 64) == 0) { // 2nd level distance code cp = &distcode_[cp->val + (bi_.peek_fast() & ((1U << op) - 1))]; goto dodist; } else { ec = error::invalid_distance_code; mode_ = BAD; break; } } else if((op & 64) == 0) { // 2nd level length code cp = &lencode_[cp->val + (bi_.peek_fast() & ((1U << op) - 1))]; goto dolen; } else if(op & 32) { // end-of-block mode_ = TYPE; break; } else { ec = error::invalid_literal_length; mode_ = BAD; break; } } while(r.in.next < last && r.out.next < end); // return unused bytes (on entry, bits < 8, so in won't go too far back) bi_.rewind(r.in.next); } } // detail } // zlib } // beast } // boost #endif PK OP�[��Lj � zlib/detail/window.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_WINDOW_HPP #define BOOST_BEAST_ZLIB_DETAIL_WINDOW_HPP #include <boost/assert.hpp> #include <boost/make_unique.hpp> #include <cstdint> #include <cstring> #include <memory> namespace boost { namespace beast { namespace zlib { namespace detail { class window { std::unique_ptr<std::uint8_t[]> p_; std::uint16_t i_ = 0; std::uint16_t size_ = 0; std::uint16_t capacity_ = 0; std::uint8_t bits_ = 0; public: int bits() const { return bits_; } unsigned capacity() const { return capacity_; } unsigned size() const { return size_; } void reset(int bits) { if(bits_ != bits) { p_.reset(); bits_ = static_cast<std::uint8_t>(bits); capacity_ = 1U << bits_; } i_ = 0; size_ = 0; } void read(std::uint8_t* out, std::size_t pos, std::size_t n) { if(i_ >= size_) { // window is contiguous std::memcpy(out, &p_[i_ - pos], n); return; } auto i = ((i_ - pos) + capacity_) % capacity_; auto m = capacity_ - i; if(n <= m) { std::memcpy(out, &p_[i], n); return; } std::memcpy(out, &p_[i], m); out += m; std::memcpy(out, &p_[0], n - m); } void write(std::uint8_t const* in, std::size_t n) { if(! p_) p_ = boost::make_unique< std::uint8_t[]>(capacity_); if(n >= capacity_) { i_ = 0; size_ = capacity_; std::memcpy(&p_[0], in + (n - size_), size_); return; } if(i_ + n <= capacity_) { std::memcpy(&p_[i_], in, n); if(size_ >= capacity_ - n) size_ = capacity_; else size_ = static_cast<std::uint16_t>(size_ + n); i_ = static_cast<std::uint16_t>( (i_ + n) % capacity_); return; } auto m = capacity_ - i_; std::memcpy(&p_[i_], in, m); in += m; i_ = static_cast<std::uint16_t>(n - m); std::memcpy(&p_[0], in, i_); size_ = capacity_; } }; } // detail } // zlib } // beast } // boost #endif PK OP�[ ��?. . zlib/detail/deflate_stream.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_DEFLATE_STREAM_IPP #define BOOST_BEAST_ZLIB_DETAIL_DEFLATE_STREAM_IPP #include <boost/beast/zlib/detail/deflate_stream.hpp> #include <boost/beast/zlib/detail/ranges.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/make_unique.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <cstdint> #include <cstdlib> #include <cstring> #include <memory> #include <stdexcept> #include <type_traits> namespace boost { namespace beast { namespace zlib { namespace detail { /* * ALGORITHM * * The "deflation" process depends on being able to identify portions * of the input text which are identical to earlier input (within a * sliding window trailing behind the input currently being processed). * * Each code tree is stored in a compressed form which is itself * a Huffman encoding of the lengths of all the code strings (in * ascending order by source values). The actual code strings are * reconstructed from the lengths in the inflate process, as described * in the deflate specification. * * The most straightforward technique turns out to be the fastest for * most input files: try all possible matches and select the longest. * The key feature of this algorithm is that insertions into the string * dictionary are very simple and thus fast, and deletions are avoided * completely. Insertions are performed at each input character, whereas * string matches are performed only when the previous match ends. So it * is preferable to spend more time in matches to allow very fast string * insertions and avoid deletions. The matching algorithm for small * strings is inspired from that of Rabin & Karp. A brute force approach * is used to find longer strings when a small match has been found. * A similar algorithm is used in comic (by Jan-Mark Wams) and freeze * (by Leonid Broukhis). * A previous version of this file used a more sophisticated algorithm * (by Fiala and Greene) which is guaranteed to run in linear amortized * time, but has a larger average cost, uses more memory and is patented. * However the F&G algorithm may be faster for some highly redundant * files if the parameter max_chain_length (described below) is too large. * * ACKNOWLEDGEMENTS * * The idea of lazy evaluation of matches is due to Jan-Mark Wams, and * I found it in 'freeze' written by Leonid Broukhis. * Thanks to many people for bug reports and testing. * * REFERENCES * * Deutsch, L.P.,"DEFLATE Compressed Data Format Specification". * Available in http://tools.ietf.org/html/rfc1951 * * A description of the Rabin and Karp algorithm is given in the book * "Algorithms" by R. Sedgewick, Addison-Wesley, p252. * * Fiala,E.R., and Greene,D.H. * Data Compression with Finite Windows, Comm.ACM, 32,4 (1989) 490-595 * */ /* Generate the codes for a given tree and bit counts (which need not be optimal). IN assertion: the array bl_count contains the bit length statistics for the given tree and the field len is set for all tree elements. OUT assertion: the field code is set for all tree elements of non zero code length. */ void deflate_stream:: gen_codes(ct_data *tree, int max_code, std::uint16_t *bl_count) { std::uint16_t next_code[maxBits+1]; /* next code value for each bit length */ std::uint16_t code = 0; /* running code value */ int bits; /* bit index */ int n; /* code index */ // The distribution counts are first used to // generate the code values without bit reversal. for(bits = 1; bits <= maxBits; bits++) { code = (code + bl_count[bits-1]) << 1; next_code[bits] = code; } // Check that the bit counts in bl_count are consistent. // The last code must be all ones. BOOST_ASSERT(code + bl_count[maxBits]-1 == (1<<maxBits)-1); for(n = 0; n <= max_code; n++) { int len = tree[n].dl; if(len == 0) continue; tree[n].fc = bi_reverse(next_code[len]++, len); } } auto deflate_stream::get_lut() -> lut_type const& { struct init { lut_type tables; init() { // number of codes at each bit length for an optimal tree //std::uint16_t bl_count[maxBits+1]; // Initialize the mapping length (0..255) -> length code (0..28) std::uint8_t length = 0; for(std::uint8_t code = 0; code < lengthCodes-1; ++code) { tables.base_length[code] = length; auto const run = 1U << tables.extra_lbits[code]; for(unsigned n = 0; n < run; ++n) tables.length_code[length++] = code; } BOOST_ASSERT(length == 0); // Note that the length 255 (match length 258) can be represented // in two different ways: code 284 + 5 bits or code 285, so we // overwrite length_code[255] to use the best encoding: tables.length_code[255] = lengthCodes-1; // Initialize the mapping dist (0..32K) -> dist code (0..29) { std::uint8_t code; std::uint16_t dist = 0; for(code = 0; code < 16; code++) { tables.base_dist[code] = dist; auto const run = 1U << tables.extra_dbits[code]; for(unsigned n = 0; n < run; ++n) tables.dist_code[dist++] = code; } BOOST_ASSERT(dist == 256); // from now on, all distances are divided by 128 dist >>= 7; for(; code < dCodes; ++code) { tables.base_dist[code] = dist << 7; auto const run = 1U << (tables.extra_dbits[code]-7); for(std::size_t n = 0; n < run; ++n) tables.dist_code[256 + dist++] = code; } BOOST_ASSERT(dist == 256); } // Construct the codes of the static literal tree std::uint16_t bl_count[maxBits+1]; std::memset(bl_count, 0, sizeof(bl_count)); unsigned n = 0; while (n <= 143) tables.ltree[n++].dl = 8; bl_count[8] += 144; while (n <= 255) tables.ltree[n++].dl = 9; bl_count[9] += 112; while (n <= 279) tables.ltree[n++].dl = 7; bl_count[7] += 24; while (n <= 287) tables.ltree[n++].dl = 8; bl_count[8] += 8; // Codes 286 and 287 do not exist, but we must include them in the tree // construction to get a canonical Huffman tree (longest code all ones) gen_codes(tables.ltree, lCodes+1, bl_count); for(n = 0; n < dCodes; ++n) { tables.dtree[n].dl = 5; tables.dtree[n].fc = static_cast<std::uint16_t>(bi_reverse(n, 5)); } } }; static init const data; return data.tables; } void deflate_stream:: doReset( int level, int windowBits, int memLevel, Strategy strategy) { if(level == default_size) level = 6; // VFALCO What do we do about this? // until 256-byte window bug fixed if(windowBits == 8) windowBits = 9; if(level < 0 || level > 9) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid level"}); if(windowBits < 8 || windowBits > 15) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid windowBits"}); if(memLevel < 1 || memLevel > max_mem_level) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid memLevel"}); w_bits_ = windowBits; hash_bits_ = memLevel + 7; // 16K elements by default lit_bufsize_ = 1 << (memLevel + 6); level_ = level; strategy_ = strategy; inited_ = false; } void deflate_stream:: doReset() { inited_ = false; } void deflate_stream:: doClear() { inited_ = false; buf_.reset(); } std::size_t deflate_stream:: doUpperBound(std::size_t sourceLen) const { std::size_t complen; std::size_t wraplen; /* conservative upper bound for compressed data */ complen = sourceLen + ((sourceLen + 7) >> 3) + ((sourceLen + 63) >> 6) + 5; /* compute wrapper length */ wraplen = 0; /* if not default parameters, return conservative bound */ if(w_bits_ != 15 || hash_bits_ != 8 + 7) return complen + wraplen; /* default settings: return tight bound for that case */ return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) + (sourceLen >> 25) + 13 - 6 + wraplen; } void deflate_stream:: doTune( int good_length, int max_lazy, int nice_length, int max_chain) { good_match_ = good_length; nice_match_ = nice_length; max_lazy_match_ = max_lazy; max_chain_length_ = max_chain; } void deflate_stream:: doParams(z_params& zs, int level, Strategy strategy, error_code& ec) { compress_func func; if(level == default_size) level = 6; if(level < 0 || level > 9) { ec = error::stream_error; return; } func = get_config(level_).func; if((strategy != strategy_ || func != get_config(level).func) && zs.total_in != 0) { // Flush the last buffer: doWrite(zs, Flush::block, ec); if(ec == error::need_buffers && pending_ == 0) ec = {}; } if(level_ != level) { level_ = level; max_lazy_match_ = get_config(level).max_lazy; good_match_ = get_config(level).good_length; nice_match_ = get_config(level).nice_length; max_chain_length_ = get_config(level).max_chain; } strategy_ = strategy; } // VFALCO boost::optional param is a workaround for // gcc "maybe uninitialized" warning // https://github.com/boostorg/beast/issues/532 // void deflate_stream:: doWrite(z_params& zs, boost::optional<Flush> flush, error_code& ec) { maybe_init(); if(zs.next_in == nullptr && zs.avail_in != 0) BOOST_THROW_EXCEPTION(std::invalid_argument{"invalid input"}); if(zs.next_out == nullptr || (status_ == FINISH_STATE && flush != Flush::finish)) { ec = error::stream_error; return; } if(zs.avail_out == 0) { ec = error::need_buffers; return; } // value of flush param for previous deflate call auto old_flush = boost::make_optional<Flush>( last_flush_.is_initialized(), last_flush_ ? *last_flush_ : Flush::none); last_flush_ = flush; // Flush as much pending output as possible if(pending_ != 0) { flush_pending(zs); if(zs.avail_out == 0) { /* Since avail_out is 0, deflate will be called again with * more output space, but possibly with both pending and * avail_in equal to zero. There won't be anything to do, * but this is not an error situation so make sure we * return OK instead of BUF_ERROR at next call of deflate: */ last_flush_ = boost::none; return; } } else if(zs.avail_in == 0 && ( old_flush && flush <= *old_flush // Caution: depends on enum order ) && flush != Flush::finish) { /* Make sure there is something to do and avoid duplicate consecutive * flushes. For repeated and useless calls with Flush::finish, we keep * returning Z_STREAM_END instead of Z_BUF_ERROR. */ ec = error::need_buffers; return; } // User must not provide more input after the first FINISH: if(status_ == FINISH_STATE && zs.avail_in != 0) { ec = error::need_buffers; return; } /* Start a new block or continue the current one. */ if(zs.avail_in != 0 || lookahead_ != 0 || (flush != Flush::none && status_ != FINISH_STATE)) { block_state bstate; switch(strategy_) { case Strategy::huffman: bstate = deflate_huff(zs, flush.get()); break; case Strategy::rle: bstate = deflate_rle(zs, flush.get()); break; default: { bstate = (this->*(get_config(level_).func))(zs, flush.get()); break; } } if(bstate == finish_started || bstate == finish_done) { status_ = FINISH_STATE; } if(bstate == need_more || bstate == finish_started) { if(zs.avail_out == 0) { last_flush_ = boost::none; /* avoid BUF_ERROR next call, see above */ } return; /* If flush != Flush::none && avail_out == 0, the next call of deflate should use the same flush parameter to make sure that the flush is complete. So we don't have to output an empty block here, this will be done at next call. This also ensures that for a very small output buffer, we emit at most one empty block. */ } if(bstate == block_done) { if(flush == Flush::partial) { tr_align(); } else if(flush != Flush::block) { /* FULL_FLUSH or SYNC_FLUSH */ tr_stored_block(nullptr, 0L, 0); /* For a full flush, this empty block will be recognized * as a special marker by inflate_sync(). */ if(flush == Flush::full) { clear_hash(); // forget history if(lookahead_ == 0) { strstart_ = 0; block_start_ = 0L; insert_ = 0; } } } flush_pending(zs); if(zs.avail_out == 0) { last_flush_ = boost::none; /* avoid BUF_ERROR at next call, see above */ return; } } } if(flush == Flush::finish) { ec = error::end_of_stream; return; } } // VFALCO Warning: untested void deflate_stream:: doDictionary(Byte const* dict, uInt dictLength, error_code& ec) { if(lookahead_) { ec = error::stream_error; return; } maybe_init(); /* if dict would fill window, just replace the history */ if(dictLength >= w_size_) { clear_hash(); strstart_ = 0; block_start_ = 0L; insert_ = 0; dict += dictLength - w_size_; /* use the tail */ dictLength = w_size_; } /* insert dict into window and hash */ z_params zs; zs.avail_in = dictLength; zs.next_in = (const Byte *)dict; zs.avail_out = 0; zs.next_out = 0; fill_window(zs); while(lookahead_ >= minMatch) { uInt str = strstart_; uInt n = lookahead_ - (minMatch-1); do { update_hash(ins_h_, window_[str + minMatch-1]); prev_[str & w_mask_] = head_[ins_h_]; head_[ins_h_] = (std::uint16_t)str; str++; } while(--n); strstart_ = str; lookahead_ = minMatch-1; fill_window(zs); } strstart_ += lookahead_; block_start_ = (long)strstart_; insert_ = lookahead_; lookahead_ = 0; match_length_ = prev_length_ = minMatch-1; match_available_ = 0; } void deflate_stream:: doPrime(int bits, int value, error_code& ec) { maybe_init(); if((Byte *)(d_buf_) < pending_out_ + ((Buf_size + 7) >> 3)) { ec = error::need_buffers; return; } do { int put = Buf_size - bi_valid_; if(put > bits) put = bits; bi_buf_ |= (std::uint16_t)((value & ((1 << put) - 1)) << bi_valid_); bi_valid_ += put; tr_flush_bits(); value >>= put; bits -= put; } while(bits); } void deflate_stream:: doPending(unsigned* value, int* bits) { if(value != 0) *value = pending_; if(bits != 0) *bits = bi_valid_; } //-------------------------------------------------------------------------- // Do lazy initialization void deflate_stream:: init() { // Caller must set these: // w_bits_ // hash_bits_ // lit_bufsize_ // level_ // strategy_ w_size_ = 1 << w_bits_; w_mask_ = w_size_ - 1; hash_size_ = 1 << hash_bits_; hash_mask_ = hash_size_ - 1; hash_shift_ = ((hash_bits_+minMatch-1)/minMatch); auto const nwindow = w_size_ * 2*sizeof(Byte); auto const nprev = w_size_ * sizeof(std::uint16_t); auto const nhead = hash_size_ * sizeof(std::uint16_t); auto const noverlay = lit_bufsize_ * (sizeof(std::uint16_t)+2); auto const needed = nwindow + nprev + nhead + noverlay; if(! buf_ || buf_size_ != needed) { buf_ = boost::make_unique_noinit< std::uint8_t[]>(needed); buf_size_ = needed; } window_ = reinterpret_cast<Byte*>(buf_.get()); prev_ = reinterpret_cast<std::uint16_t*>(buf_.get() + nwindow); std::memset(prev_, 0, nprev); head_ = reinterpret_cast<std::uint16_t*>(buf_.get() + nwindow + nprev); /* We overlay pending_buf_ and d_buf_ + l_buf_. This works since the average output size for(length, distance) codes is <= 24 bits. */ auto overlay = reinterpret_cast<std::uint16_t*>( buf_.get() + nwindow + nprev + nhead); // nothing written to window_ yet high_water_ = 0; pending_buf_ = reinterpret_cast<std::uint8_t*>(overlay); pending_buf_size_ = static_cast<std::uint32_t>(lit_bufsize_) * (sizeof(std::uint16_t) + 2L); d_buf_ = overlay + lit_bufsize_ / sizeof(std::uint16_t); l_buf_ = pending_buf_ + (1 + sizeof(std::uint16_t)) * lit_bufsize_; pending_ = 0; pending_out_ = pending_buf_; status_ = BUSY_STATE; last_flush_ = Flush::none; tr_init(); lm_init(); inited_ = true; } /* Initialize the "longest match" routines for a new zlib stream */ void deflate_stream:: lm_init() { window_size_ = (std::uint32_t)2L*w_size_; clear_hash(); /* Set the default configuration parameters: */ // VFALCO TODO just copy the config struct max_lazy_match_ = get_config(level_).max_lazy; good_match_ = get_config(level_).good_length; nice_match_ = get_config(level_).nice_length; max_chain_length_ = get_config(level_).max_chain; strstart_ = 0; block_start_ = 0L; lookahead_ = 0; insert_ = 0; match_length_ = prev_length_ = minMatch-1; match_available_ = 0; ins_h_ = 0; } // Initialize a new block. // void deflate_stream:: init_block() { for(int n = 0; n < lCodes; n++) dyn_ltree_[n].fc = 0; for(int n = 0; n < dCodes; n++) dyn_dtree_[n].fc = 0; for(int n = 0; n < blCodes; n++) bl_tree_[n].fc = 0; dyn_ltree_[END_BLOCK].fc = 1; opt_len_ = 0L; static_len_ = 0L; last_lit_ = 0; matches_ = 0; } /* Restore the heap property by moving down the tree starting at node k, exchanging a node with the smallest of its two sons if necessary, stopping when the heap property is re-established (each father smaller than its two sons). */ void deflate_stream:: pqdownheap( ct_data const* tree, // the tree to restore int k) // node to move down { int v = heap_[k]; int j = k << 1; // left son of k while(j <= heap_len_) { // Set j to the smallest of the two sons: if(j < heap_len_ && smaller(tree, heap_[j+1], heap_[j])) j++; // Exit if v is smaller than both sons if(smaller(tree, v, heap_[j])) break; // Exchange v with the smallest son heap_[k] = heap_[j]; k = j; // And continue down the tree, // setting j to the left son of k j <<= 1; } heap_[k] = v; } /* Remove the smallest element from the heap and recreate the heap with one less element. Updates heap and heap_len. */ void deflate_stream:: pqremove(ct_data const* tree, int& top) { top = heap_[kSmallest]; heap_[kSmallest] = heap_[heap_len_--]; pqdownheap(tree, kSmallest); } /* Compute the optimal bit lengths for a tree and update the total bit length for the current block. IN assertion: the fields freq and dad are set, heap[heap_max] and above are the tree nodes sorted by increasing frequency. OUT assertions: the field len is set to the optimal bit length, the array bl_count contains the frequencies for each bit length. The length opt_len is updated; static_len is also updated if stree is not null. */ void deflate_stream:: gen_bitlen(tree_desc *desc) { ct_data *tree = desc->dyn_tree; int max_code = desc->max_code; ct_data const* stree = desc->stat_desc->static_tree; std::uint8_t const *extra = desc->stat_desc->extra_bits; int base = desc->stat_desc->extra_base; int max_length = desc->stat_desc->max_length; int h; // heap index int n, m; // iterate over the tree elements int bits; // bit length int xbits; // extra bits std::uint16_t f; // frequency int overflow = 0; // number of elements with bit length too large std::fill(&bl_count_[0], &bl_count_[maxBits+1], std::uint16_t{0}); /* In a first pass, compute the optimal bit lengths (which may * overflow in the case of the bit length tree). */ tree[heap_[heap_max_]].dl = 0; // root of the heap for(h = heap_max_+1; h < HEAP_SIZE; h++) { n = heap_[h]; bits = tree[tree[n].dl].dl + 1; if(bits > max_length) bits = max_length, overflow++; // We overwrite tree[n].dl which is no longer needed tree[n].dl = (std::uint16_t)bits; if(n > max_code) continue; // not a leaf node bl_count_[bits]++; xbits = 0; if(n >= base) xbits = extra[n-base]; f = tree[n].fc; opt_len_ += (std::uint32_t)f * (bits + xbits); if(stree) static_len_ += (std::uint32_t)f * (stree[n].dl + xbits); } if(overflow == 0) return; // Find the first bit length which could increase: do { bits = max_length-1; while(bl_count_[bits] == 0) bits--; bl_count_[bits]--; // move one leaf down the tree bl_count_[bits+1] += 2; // move one overflow item as its brother bl_count_[max_length]--; /* The brother of the overflow item also moves one step up, * but this does not affect bl_count[max_length] */ overflow -= 2; } while(overflow > 0); /* Now recompute all bit lengths, scanning in increasing frequency. * h is still equal to HEAP_SIZE. (It is simpler to reconstruct all * lengths instead of fixing only the wrong ones. This idea is taken * from 'ar' written by Haruhiko Okumura.) */ for(bits = max_length; bits != 0; bits--) { n = bl_count_[bits]; while(n != 0) { m = heap_[--h]; if(m > max_code) continue; if((unsigned) tree[m].dl != (unsigned) bits) { opt_len_ += ((long)bits - (long)tree[m].dl) *(long)tree[m].fc; tree[m].dl = (std::uint16_t)bits; } n--; } } } /* Construct one Huffman tree and assigns the code bit strings and lengths. Update the total bit length for the current block. IN assertion: the field freq is set for all tree elements. OUT assertions: the fields len and code are set to the optimal bit length and corresponding code. The length opt_len is updated; static_len is also updated if stree is not null. The field max_code is set. */ void deflate_stream:: build_tree(tree_desc *desc) { ct_data *tree = desc->dyn_tree; ct_data const* stree = desc->stat_desc->static_tree; int elems = desc->stat_desc->elems; int n, m; // iterate over heap elements int max_code = -1; // largest code with non zero frequency int node; // new node being created /* Construct the initial heap, with least frequent element in * heap[kSmallest]. The sons of heap[n] are heap[2*n] and heap[2*n+1]. * heap[0] is not used. */ heap_len_ = 0; heap_max_ = HEAP_SIZE; for(n = 0; n < elems; n++) { if(tree[n].fc != 0) { heap_[++(heap_len_)] = max_code = n; depth_[n] = 0; } else { tree[n].dl = 0; } } /* The pkzip format requires that at least one distance code exists, * and that at least one bit should be sent even if there is only one * possible code. So to avoid special checks later on we force at least * two codes of non zero frequency. */ while(heap_len_ < 2) { node = heap_[++(heap_len_)] = (max_code < 2 ? ++max_code : 0); tree[node].fc = 1; depth_[node] = 0; opt_len_--; if(stree) static_len_ -= stree[node].dl; // node is 0 or 1 so it does not have extra bits } desc->max_code = max_code; /* The elements heap[heap_len/2+1 .. heap_len] are leaves of the tree, * establish sub-heaps of increasing lengths: */ for(n = heap_len_/2; n >= 1; n--) pqdownheap(tree, n); /* Construct the Huffman tree by repeatedly combining the least two * frequent nodes. */ node = elems; /* next internal node of the tree */ do { pqremove(tree, n); /* n = node of least frequency */ m = heap_[kSmallest]; /* m = node of next least frequency */ heap_[--(heap_max_)] = n; /* keep the nodes sorted by frequency */ heap_[--(heap_max_)] = m; /* Create a new node father of n and m */ tree[node].fc = tree[n].fc + tree[m].fc; depth_[node] = (std::uint8_t)((depth_[n] >= depth_[m] ? depth_[n] : depth_[m]) + 1); tree[n].dl = tree[m].dl = (std::uint16_t)node; /* and insert the new node in the heap */ heap_[kSmallest] = node++; pqdownheap(tree, kSmallest); } while(heap_len_ >= 2); heap_[--(heap_max_)] = heap_[kSmallest]; /* At this point, the fields freq and dad are set. We can now * generate the bit lengths. */ gen_bitlen((tree_desc *)desc); /* The field len is now set, we can generate the bit codes */ gen_codes(tree, max_code, bl_count_); } /* Scan a literal or distance tree to determine the frequencies of the codes in the bit length tree. */ void deflate_stream:: scan_tree( ct_data *tree, // the tree to be scanned int max_code) // and its largest code of non zero frequency { int n; // iterates over all tree elements int prevlen = -1; // last emitted length int curlen; // length of current code int nextlen = tree[0].dl; // length of next code std::uint16_t count = 0; // repeat count of the current code int max_count = 7; // max repeat count int min_count = 4; // min repeat count if(nextlen == 0) { max_count = 138; min_count = 3; } tree[max_code+1].dl = (std::uint16_t)0xffff; // guard for(n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].dl; if(++count < max_count && curlen == nextlen) { continue; } else if(count < min_count) { bl_tree_[curlen].fc += count; } else if(curlen != 0) { if(curlen != prevlen) bl_tree_[curlen].fc++; bl_tree_[REP_3_6].fc++; } else if(count <= 10) { bl_tree_[REPZ_3_10].fc++; } else { bl_tree_[REPZ_11_138].fc++; } count = 0; prevlen = curlen; if(nextlen == 0) { max_count = 138; min_count = 3; } else if(curlen == nextlen) { max_count = 6; min_count = 3; } else { max_count = 7; min_count = 4; } } } /* Send a literal or distance tree in compressed form, using the codes in bl_tree. */ void deflate_stream:: send_tree( ct_data *tree, // the tree to be scanned int max_code) // and its largest code of non zero frequency { int n; // iterates over all tree elements int prevlen = -1; // last emitted length int curlen; // length of current code int nextlen = tree[0].dl; // length of next code int count = 0; // repeat count of the current code int max_count = 7; // max repeat count int min_count = 4; // min repeat count // tree[max_code+1].dl = -1; // guard already set if(nextlen == 0) { max_count = 138; min_count = 3; } for(n = 0; n <= max_code; n++) { curlen = nextlen; nextlen = tree[n+1].dl; if(++count < max_count && curlen == nextlen) { continue; } else if(count < min_count) { do { send_code(curlen, bl_tree_); } while (--count != 0); } else if(curlen != 0) { if(curlen != prevlen) { send_code(curlen, bl_tree_); count--; } BOOST_ASSERT(count >= 3 && count <= 6); send_code(REP_3_6, bl_tree_); send_bits(count-3, 2); } else if(count <= 10) { send_code(REPZ_3_10, bl_tree_); send_bits(count-3, 3); } else { send_code(REPZ_11_138, bl_tree_); send_bits(count-11, 7); } count = 0; prevlen = curlen; if(nextlen == 0) { max_count = 138; min_count = 3; } else if(curlen == nextlen) { max_count = 6; min_count = 3; } else { max_count = 7; min_count = 4; } } } /* Construct the Huffman tree for the bit lengths and return the index in bl_order of the last bit length code to send. */ int deflate_stream:: build_bl_tree() { int max_blindex; // index of last bit length code of non zero freq // Determine the bit length frequencies for literal and distance trees scan_tree((ct_data *)dyn_ltree_, l_desc_.max_code); scan_tree((ct_data *)dyn_dtree_, d_desc_.max_code); // Build the bit length tree: build_tree((tree_desc *)(&(bl_desc_))); /* opt_len now includes the length of the tree representations, except * the lengths of the bit lengths codes and the 5+5+4 bits for the counts. */ /* Determine the number of bit length codes to send. The pkzip format * requires that at least 4 bit length codes be sent. (appnote.txt says * 3 but the actual value used is 4.) */ for(max_blindex = blCodes-1; max_blindex >= 3; max_blindex--) { if(bl_tree_[lut_.bl_order[max_blindex]].dl != 0) break; } // Update opt_len to include the bit length tree and counts opt_len_ += 3*(max_blindex+1) + 5+5+4; return max_blindex; } /* Send the header for a block using dynamic Huffman trees: the counts, the lengths of the bit length codes, the literal tree and the distance tree. IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. */ void deflate_stream:: send_all_trees( int lcodes, int dcodes, int blcodes) // number of codes for each tree { int rank; // index in bl_order BOOST_ASSERT(lcodes >= 257 && dcodes >= 1 && blcodes >= 4); BOOST_ASSERT(lcodes <= lCodes && dcodes <= dCodes && blcodes <= blCodes); send_bits(lcodes-257, 5); // not +255 as stated in appnote.txt send_bits(dcodes-1, 5); send_bits(blcodes-4, 4); // not -3 as stated in appnote.txt for(rank = 0; rank < blcodes; rank++) send_bits(bl_tree_[lut_.bl_order[rank]].dl, 3); send_tree((ct_data *)dyn_ltree_, lcodes-1); // literal tree send_tree((ct_data *)dyn_dtree_, dcodes-1); // distance tree } /* Send the block data compressed using the given Huffman trees */ void deflate_stream:: compress_block( ct_data const* ltree, // literal tree ct_data const* dtree) // distance tree { unsigned dist; /* distance of matched string */ int lc; /* match length or unmatched char (if dist == 0) */ unsigned lx = 0; /* running index in l_buf */ unsigned code; /* the code to send */ int extra; /* number of extra bits to send */ if(last_lit_ != 0) { do { dist = d_buf_[lx]; lc = l_buf_[lx++]; if(dist == 0) { send_code(lc, ltree); /* send a literal byte */ } else { /* Here, lc is the match length - minMatch */ code = lut_.length_code[lc]; send_code(code+literals+1, ltree); /* send the length code */ extra = lut_.extra_lbits[code]; if(extra != 0) { lc -= lut_.base_length[code]; send_bits(lc, extra); /* send the extra length bits */ } dist--; /* dist is now the match distance - 1 */ code = d_code(dist); BOOST_ASSERT(code < dCodes); send_code(code, dtree); /* send the distance code */ extra = lut_.extra_dbits[code]; if(extra != 0) { dist -= lut_.base_dist[code]; send_bits(dist, extra); /* send the extra distance bits */ } } /* literal or match pair ? */ /* Check that the overlay between pending_buf and d_buf+l_buf is ok: */ BOOST_ASSERT((uInt)(pending_) < lit_bufsize_ + 2*lx); } while(lx < last_lit_); } send_code(END_BLOCK, ltree); } /* Check if the data type is TEXT or BINARY, using the following algorithm: - TEXT if the two conditions below are satisfied: a) There are no non-portable control characters belonging to the "black list" (0..6, 14..25, 28..31). b) There is at least one printable character belonging to the "white list" (9 {TAB}, 10 {LF}, 13 {CR}, 32..255). - BINARY otherwise. - The following partially-portable control characters form a "gray list" that is ignored in this detection algorithm: (7 {BEL}, 8 {BS}, 11 {VT}, 12 {FF}, 26 {SUB}, 27 {ESC}). IN assertion: the fields fc of dyn_ltree are set. */ int deflate_stream:: detect_data_type() { /* black_mask is the bit mask of black-listed bytes * set bits 0..6, 14..25, and 28..31 * 0xf3ffc07f = binary 11110011111111111100000001111111 */ unsigned long black_mask = 0xf3ffc07fUL; int n; // Check for non-textual ("black-listed") bytes. for(n = 0; n <= 31; n++, black_mask >>= 1) if((black_mask & 1) && (dyn_ltree_[n].fc != 0)) return binary; // Check for textual ("white-listed") bytes. */ if(dyn_ltree_[9].fc != 0 || dyn_ltree_[10].fc != 0 || dyn_ltree_[13].fc != 0) return text; for(n = 32; n < literals; n++) if(dyn_ltree_[n].fc != 0) return text; /* There are no "black-listed" or "white-listed" bytes: * this stream either is empty or has tolerated ("gray-listed") bytes only. */ return binary; } /* Flush the bit buffer and align the output on a byte boundary */ void deflate_stream:: bi_windup() { if(bi_valid_ > 8) put_short(bi_buf_); else if(bi_valid_ > 0) put_byte((Byte)bi_buf_); bi_buf_ = 0; bi_valid_ = 0; } /* Flush the bit buffer, keeping at most 7 bits in it. */ void deflate_stream:: bi_flush() { if(bi_valid_ == 16) { put_short(bi_buf_); bi_buf_ = 0; bi_valid_ = 0; } else if(bi_valid_ >= 8) { put_byte((Byte)bi_buf_); bi_buf_ >>= 8; bi_valid_ -= 8; } } /* Copy a stored block, storing first the length and its one's complement if requested. */ void deflate_stream:: copy_block( char *buf, // the input data unsigned len, // its length int header) // true if block header must be written { bi_windup(); // align on byte boundary if(header) { put_short((std::uint16_t)len); put_short((std::uint16_t)~len); } if(buf) std::memcpy(&pending_buf_[pending_], buf, len); pending_ += len; } //------------------------------------------------------------------------------ /* Initialize the tree data structures for a new zlib stream. */ void deflate_stream:: tr_init() { l_desc_.dyn_tree = dyn_ltree_; l_desc_.stat_desc = &lut_.l_desc; d_desc_.dyn_tree = dyn_dtree_; d_desc_.stat_desc = &lut_.d_desc; bl_desc_.dyn_tree = bl_tree_; bl_desc_.stat_desc = &lut_.bl_desc; bi_buf_ = 0; bi_valid_ = 0; // Initialize the first block of the first file: init_block(); } /* Send one empty static block to give enough lookahead for inflate. This takes 10 bits, of which 7 may remain in the bit buffer. */ void deflate_stream:: tr_align() { send_bits(STATIC_TREES<<1, 3); send_code(END_BLOCK, lut_.ltree); bi_flush(); } /* Flush the bits in the bit buffer to pending output (leaves at most 7 bits) */ void deflate_stream:: tr_flush_bits() { bi_flush(); } /* Send a stored block */ void deflate_stream:: tr_stored_block( char *buf, // input block std::uint32_t stored_len, // length of input block int last) // one if this is the last block for a file { send_bits((STORED_BLOCK<<1)+last, 3); // send block type copy_block(buf, (unsigned)stored_len, 1); // with header } void deflate_stream:: tr_tally_dist(std::uint16_t dist, std::uint8_t len, bool& flush) { d_buf_[last_lit_] = dist; l_buf_[last_lit_++] = len; dist--; dyn_ltree_[lut_.length_code[len]+literals+1].fc++; dyn_dtree_[d_code(dist)].fc++; flush = (last_lit_ == lit_bufsize_-1); } void deflate_stream:: tr_tally_lit(std::uint8_t c, bool& flush) { d_buf_[last_lit_] = 0; l_buf_[last_lit_++] = c; dyn_ltree_[c].fc++; flush = (last_lit_ == lit_bufsize_-1); } //------------------------------------------------------------------------------ /* Determine the best encoding for the current block: dynamic trees, static trees or store, and output the encoded block to the zip file. */ void deflate_stream:: tr_flush_block( z_params& zs, char *buf, // input block, or NULL if too old std::uint32_t stored_len, // length of input block int last) // one if this is the last block for a file { std::uint32_t opt_lenb; std::uint32_t static_lenb; // opt_len and static_len in bytes int max_blindex = 0; // index of last bit length code of non zero freq // Build the Huffman trees unless a stored block is forced if(level_ > 0) { // Check if the file is binary or text if(zs.data_type == unknown) zs.data_type = detect_data_type(); // Construct the literal and distance trees build_tree((tree_desc *)(&(l_desc_))); build_tree((tree_desc *)(&(d_desc_))); /* At this point, opt_len and static_len are the total bit lengths of * the compressed block data, excluding the tree representations. */ /* Build the bit length tree for the above two trees, and get the index * in bl_order of the last bit length code to send. */ max_blindex = build_bl_tree(); /* Determine the best encoding. Compute the block lengths in bytes. */ opt_lenb = (opt_len_+3+7)>>3; static_lenb = (static_len_+3+7)>>3; if(static_lenb <= opt_lenb) opt_lenb = static_lenb; } else { // VFALCO This assertion fails even in the original ZLib, // happens with strategy == Z_HUFFMAN_ONLY, see: // https://github.com/madler/zlib/issues/172 #if 0 BOOST_ASSERT(buf); #endif opt_lenb = static_lenb = stored_len + 5; // force a stored block } #ifdef FORCE_STORED if(buf != (char*)0) { /* force stored block */ #else if(stored_len+4 <= opt_lenb && buf != (char*)0) { /* 4: two words for the lengths */ #endif /* The test buf != NULL is only necessary if LIT_BUFSIZE > WSIZE. * Otherwise we can't have processed more than WSIZE input bytes since * the last block flush, because compression would have been * successful. If LIT_BUFSIZE <= WSIZE, it is never too late to * transform a block into a stored block. */ tr_stored_block(buf, stored_len, last); #ifdef FORCE_STATIC } else if(static_lenb >= 0) { // force static trees #else } else if(strategy_ == Strategy::fixed || static_lenb == opt_lenb) { #endif send_bits((STATIC_TREES<<1)+last, 3); compress_block(lut_.ltree, lut_.dtree); } else { send_bits((DYN_TREES<<1)+last, 3); send_all_trees(l_desc_.max_code+1, d_desc_.max_code+1, max_blindex+1); compress_block((const ct_data *)dyn_ltree_, (const ct_data *)dyn_dtree_); } /* The above check is made mod 2^32, for files larger than 512 MB * and std::size_t implemented on 32 bits. */ init_block(); if(last) bi_windup(); } void deflate_stream:: fill_window(z_params& zs) { unsigned n, m; unsigned more; // Amount of free space at the end of the window. std::uint16_t *p; uInt wsize = w_size_; do { more = (unsigned)(window_size_ - (std::uint32_t)lookahead_ -(std::uint32_t)strstart_); // VFALCO We don't support systems below 32-bit #if 0 // Deal with !@#$% 64K limit: if(sizeof(int) <= 2) { if(more == 0 && strstart_ == 0 && lookahead_ == 0) { more = wsize; } else if(more == (unsigned)(-1)) { /* Very unlikely, but possible on 16 bit machine if * strstart == 0 && lookahead == 1 (input done a byte at time) */ more--; } } #endif /* If the window is almost full and there is insufficient lookahead, move the upper half to the lower one to make room in the upper half. */ if(strstart_ >= wsize+max_dist()) { std::memcpy(window_, window_+wsize, (unsigned)wsize); match_start_ -= wsize; strstart_ -= wsize; // we now have strstart >= max_dist block_start_ -= (long) wsize; /* Slide the hash table (could be avoided with 32 bit values at the expense of memory usage). We slide even when level == 0 to keep the hash table consistent if we switch back to level > 0 later. (Using level 0 permanently is not an optimal usage of zlib, so we don't care about this pathological case.) */ n = hash_size_; p = &head_[n]; do { m = *--p; *p = (std::uint16_t)(m >= wsize ? m-wsize : 0); } while(--n); n = wsize; p = &prev_[n]; do { m = *--p; *p = (std::uint16_t)(m >= wsize ? m-wsize : 0); /* If n is not on any hash chain, prev[n] is garbage but its value will never be used. */ } while(--n); more += wsize; } if(zs.avail_in == 0) break; /* If there was no sliding: strstart <= WSIZE+max_dist-1 && lookahead <= kMinLookahead - 1 && more == window_size - lookahead - strstart => more >= window_size - (kMinLookahead-1 + WSIZE + max_dist-1) => more >= window_size - 2*WSIZE + 2 In the BIG_MEM or MMAP case (not yet supported), window_size == input_size + kMinLookahead && strstart + lookahead_ <= input_size => more >= kMinLookahead. Otherwise, window_size == 2*WSIZE so more >= 2. If there was sliding, more >= WSIZE. So in all cases, more >= 2. */ n = read_buf(zs, window_ + strstart_ + lookahead_, more); lookahead_ += n; // Initialize the hash value now that we have some input: if(lookahead_ + insert_ >= minMatch) { uInt str = strstart_ - insert_; ins_h_ = window_[str]; update_hash(ins_h_, window_[str + 1]); while(insert_) { update_hash(ins_h_, window_[str + minMatch-1]); prev_[str & w_mask_] = head_[ins_h_]; head_[ins_h_] = (std::uint16_t)str; str++; insert_--; if(lookahead_ + insert_ < minMatch) break; } } /* If the whole input has less than minMatch bytes, ins_h is garbage, but this is not important since only literal bytes will be emitted. */ } while(lookahead_ < kMinLookahead && zs.avail_in != 0); /* If the kWinInit bytes after the end of the current data have never been written, then zero those bytes in order to avoid memory check reports of the use of uninitialized (or uninitialised as Julian writes) bytes by the longest match routines. Update the high water mark for the next time through here. kWinInit is set to maxMatch since the longest match routines allow scanning to strstart + maxMatch, ignoring lookahead. */ if(high_water_ < window_size_) { std::uint32_t curr = strstart_ + (std::uint32_t)(lookahead_); std::uint32_t winit; if(high_water_ < curr) { /* Previous high water mark below current data -- zero kWinInit bytes or up to end of window, whichever is less. */ winit = window_size_ - curr; if(winit > kWinInit) winit = kWinInit; std::memset(window_ + curr, 0, (unsigned)winit); high_water_ = curr + winit; } else if(high_water_ < (std::uint32_t)curr + kWinInit) { /* High water mark at or above current data, but below current data plus kWinInit -- zero out to current data plus kWinInit, or up to end of window, whichever is less. */ winit = (std::uint32_t)curr + kWinInit - high_water_; if(winit > window_size_ - high_water_) winit = window_size_ - high_water_; std::memset(window_ + high_water_, 0, (unsigned)winit); high_water_ += winit; } } } /* Flush as much pending output as possible. All write() output goes through this function so some applications may wish to modify it to avoid allocating a large strm->next_out buffer and copying into it. (See also read_buf()). */ void deflate_stream:: flush_pending(z_params& zs) { tr_flush_bits(); auto len = clamp(pending_, zs.avail_out); if(len == 0) return; std::memcpy(zs.next_out, pending_out_, len); zs.next_out = static_cast<std::uint8_t*>(zs.next_out) + len; pending_out_ += len; zs.total_out += len; zs.avail_out -= len; pending_ -= len; if(pending_ == 0) pending_out_ = pending_buf_; } /* Flush the current block, with given end-of-file flag. IN assertion: strstart is set to the end of the current match. */ void deflate_stream:: flush_block(z_params& zs, bool last) { tr_flush_block(zs, (block_start_ >= 0L ? (char *)&window_[(unsigned)block_start_] : (char *)0), (std::uint32_t)((long)strstart_ - block_start_), last); block_start_ = strstart_; flush_pending(zs); } /* Read a new buffer from the current input stream, update the adler32 and total number of bytes read. All write() input goes through this function so some applications may wish to modify it to avoid allocating a large strm->next_in buffer and copying from it. (See also flush_pending()). */ int deflate_stream:: read_buf(z_params& zs, Byte *buf, unsigned size) { auto len = clamp(zs.avail_in, size); if(len == 0) return 0; zs.avail_in -= len; std::memcpy(buf, zs.next_in, len); zs.next_in = static_cast< std::uint8_t const*>(zs.next_in) + len; zs.total_in += len; return (int)len; } /* Set match_start to the longest match starting at the given string and return its length. Matches shorter or equal to prev_length are discarded, in which case the result is equal to prev_length and match_start is garbage. IN assertions: cur_match is the head of the hash chain for the current string (strstart) and its distance is <= max_dist, and prev_length >= 1 OUT assertion: the match length is not greater than s->lookahead_. For 80x86 and 680x0, an optimized version will be provided in match.asm or match.S. The code will be functionally equivalent. */ uInt deflate_stream:: longest_match(IPos cur_match) { unsigned chain_length = max_chain_length_;/* max hash chain length */ Byte *scan = window_ + strstart_; /* current string */ Byte *match; /* matched string */ int len; /* length of current match */ int best_len = prev_length_; /* best match length so far */ int nice_match = nice_match_; /* stop if match long enough */ IPos limit = strstart_ > (IPos)max_dist() ? strstart_ - (IPos)max_dist() : 0; /* Stop when cur_match becomes <= limit. To simplify the code, * we prevent matches with the string of window index 0. */ std::uint16_t *prev = prev_; uInt wmask = w_mask_; Byte *strend = window_ + strstart_ + maxMatch; Byte scan_end1 = scan[best_len-1]; Byte scan_end = scan[best_len]; /* The code is optimized for HASH_BITS >= 8 and maxMatch-2 multiple of 16. * It is easy to get rid of this optimization if necessary. */ BOOST_ASSERT(hash_bits_ >= 8 && maxMatch == 258); /* Do not waste too much time if we already have a good match: */ if(prev_length_ >= good_match_) { chain_length >>= 2; } /* Do not look for matches beyond the end of the input. This is necessary * to make deflate deterministic. */ if((uInt)nice_match > lookahead_) nice_match = lookahead_; BOOST_ASSERT((std::uint32_t)strstart_ <= window_size_-kMinLookahead); do { BOOST_ASSERT(cur_match < strstart_); match = window_ + cur_match; /* Skip to next match if the match length cannot increase * or if the match length is less than 2. Note that the checks below * for insufficient lookahead only occur occasionally for performance * reasons. Therefore uninitialized memory will be accessed, and * conditional jumps will be made that depend on those values. * However the length of the match is limited to the lookahead, so * the output of deflate is not affected by the uninitialized values. */ if( match[best_len] != scan_end || match[best_len-1] != scan_end1 || *match != *scan || *++match != scan[1]) continue; /* The check at best_len-1 can be removed because it will be made * again later. (This heuristic is not always a win.) * It is not necessary to compare scan[2] and match[2] since they * are always equal when the other bytes match, given that * the hash keys are equal and that HASH_BITS >= 8. */ scan += 2, match++; BOOST_ASSERT(*scan == *match); /* We check for insufficient lookahead only every 8th comparison; * the 256th check will be made at strstart+258. */ do { } while( *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && *++scan == *++match && scan < strend); BOOST_ASSERT(scan <= window_+(unsigned)(window_size_-1)); len = maxMatch - (int)(strend - scan); scan = strend - maxMatch; if(len > best_len) { match_start_ = cur_match; best_len = len; if(len >= nice_match) break; scan_end1 = scan[best_len-1]; scan_end = scan[best_len]; } } while((cur_match = prev[cur_match & wmask]) > limit && --chain_length != 0); if((uInt)best_len <= lookahead_) return (uInt)best_len; return lookahead_; } //------------------------------------------------------------------------------ /* Copy without compression as much as possible from the input stream, return the current block state. This function does not insert new strings in the dictionary since uncompressible data is probably not useful. This function is used only for the level=0 compression option. NOTE: this function should be optimized to avoid extra copying from window to pending_buf. */ auto deflate_stream:: f_stored(z_params& zs, Flush flush) -> block_state { /* Stored blocks are limited to 0xffff bytes, pending_buf is limited * to pending_buf_size, and each stored block has a 5 byte header: */ std::uint32_t max_block_size = 0xffff; std::uint32_t max_start; if(max_block_size > pending_buf_size_ - 5) { max_block_size = pending_buf_size_ - 5; } /* Copy as much as possible from input to output: */ for(;;) { /* Fill the window as much as possible: */ if(lookahead_ <= 1) { BOOST_ASSERT(strstart_ < w_size_+max_dist() || block_start_ >= (long)w_size_); fill_window(zs); if(lookahead_ == 0 && flush == Flush::none) return need_more; if(lookahead_ == 0) break; /* flush the current block */ } BOOST_ASSERT(block_start_ >= 0L); strstart_ += lookahead_; lookahead_ = 0; /* Emit a stored block if pending_buf will be full: */ max_start = block_start_ + max_block_size; if(strstart_ == 0 || (std::uint32_t)strstart_ >= max_start) { /* strstart == 0 is possible when wraparound on 16-bit machine */ lookahead_ = (uInt)(strstart_ - max_start); strstart_ = (uInt)max_start; flush_block(zs, false); if(zs.avail_out == 0) return need_more; } /* Flush if we may have to slide, otherwise block_start may become * negative and the data will be gone: */ if(strstart_ - (uInt)block_start_ >= max_dist()) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } } insert_ = 0; if(flush == Flush::finish) { flush_block(zs, true); if(zs.avail_out == 0) return finish_started; return finish_done; } if((long)strstart_ > block_start_) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } return block_done; } /* Compress as much as possible from the input stream, return the current block state. This function does not perform lazy evaluation of matches and inserts new strings in the dictionary only for unmatched strings or for short matches. It is used only for the fast compression options. */ auto deflate_stream:: f_fast(z_params& zs, Flush flush) -> block_state { IPos hash_head; /* head of the hash chain */ bool bflush; /* set if current block must be flushed */ for(;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need maxMatch bytes * for the next match, plus minMatch bytes to insert the * string following the next match. */ if(lookahead_ < kMinLookahead) { fill_window(zs); if(lookahead_ < kMinLookahead && flush == Flush::none) return need_more; if(lookahead_ == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = 0; if(lookahead_ >= minMatch) { insert_string(hash_head); } /* Find the longest match, discarding those <= prev_length. * At this point we have always match_length < minMatch */ if(hash_head != 0 && strstart_ - hash_head <= max_dist()) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ match_length_ = longest_match (hash_head); /* longest_match() sets match_start */ } if(match_length_ >= minMatch) { tr_tally_dist(static_cast<std::uint16_t>(strstart_ - match_start_), static_cast<std::uint8_t>(match_length_ - minMatch), bflush); lookahead_ -= match_length_; /* Insert new strings in the hash table only if the match length * is not too large. This saves time but degrades compression. */ if(match_length_ <= max_lazy_match_ && lookahead_ >= minMatch) { match_length_--; /* string at strstart already in table */ do { strstart_++; insert_string(hash_head); /* strstart never exceeds WSIZE-maxMatch, so there are * always minMatch bytes ahead. */ } while(--match_length_ != 0); strstart_++; } else { strstart_ += match_length_; match_length_ = 0; ins_h_ = window_[strstart_]; update_hash(ins_h_, window_[strstart_+1]); /* If lookahead < minMatch, ins_h is garbage, but it does not * matter since it will be recomputed at next deflate call. */ } } else { /* No match, output a literal byte */ tr_tally_lit(window_[strstart_], bflush); lookahead_--; strstart_++; } if(bflush) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } } insert_ = strstart_ < minMatch-1 ? strstart_ : minMatch-1; if(flush == Flush::finish) { flush_block(zs, true); if(zs.avail_out == 0) return finish_started; return finish_done; } if(last_lit_) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } return block_done; } /* Same as above, but achieves better compression. We use a lazy evaluation for matches: a match is finally adopted only if there is no better match at the next window position. */ auto deflate_stream:: f_slow(z_params& zs, Flush flush) -> block_state { IPos hash_head; /* head of hash chain */ bool bflush; /* set if current block must be flushed */ /* Process the input block. */ for(;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need maxMatch bytes * for the next match, plus minMatch bytes to insert the * string following the next match. */ if(lookahead_ < kMinLookahead) { fill_window(zs); if(lookahead_ < kMinLookahead && flush == Flush::none) return need_more; if(lookahead_ == 0) break; /* flush the current block */ } /* Insert the string window[strstart .. strstart+2] in the * dictionary, and set hash_head to the head of the hash chain: */ hash_head = 0; if(lookahead_ >= minMatch) insert_string(hash_head); /* Find the longest match, discarding those <= prev_length. */ prev_length_ = match_length_, prev_match_ = match_start_; match_length_ = minMatch-1; if(hash_head != 0 && prev_length_ < max_lazy_match_ && strstart_ - hash_head <= max_dist()) { /* To simplify the code, we prevent matches with the string * of window index 0 (in particular we have to avoid a match * of the string with itself at the start of the input file). */ match_length_ = longest_match(hash_head); /* longest_match() sets match_start */ if(match_length_ <= 5 && (strategy_ == Strategy::filtered || (match_length_ == minMatch && strstart_ - match_start_ > kTooFar) )) { /* If prev_match is also minMatch, match_start is garbage * but we will ignore the current match anyway. */ match_length_ = minMatch-1; } } /* If there was a match at the previous step and the current * match is not better, output the previous match: */ if(prev_length_ >= minMatch && match_length_ <= prev_length_) { /* Do not insert strings in hash table beyond this. */ uInt max_insert = strstart_ + lookahead_ - minMatch; tr_tally_dist( static_cast<std::uint16_t>(strstart_ -1 - prev_match_), static_cast<std::uint8_t>(prev_length_ - minMatch), bflush); /* Insert in hash table all strings up to the end of the match. * strstart-1 and strstart are already inserted. If there is not * enough lookahead, the last two strings are not inserted in * the hash table. */ lookahead_ -= prev_length_-1; prev_length_ -= 2; do { if(++strstart_ <= max_insert) insert_string(hash_head); } while(--prev_length_ != 0); match_available_ = 0; match_length_ = minMatch-1; strstart_++; if(bflush) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } } else if(match_available_) { /* If there was no match at the previous position, output a * single literal. If there was a match but the current match * is longer, truncate the previous match to a single literal. */ tr_tally_lit(window_[strstart_-1], bflush); if(bflush) flush_block(zs, false); strstart_++; lookahead_--; if(zs.avail_out == 0) return need_more; } else { /* There is no previous match to compare with, wait for * the next step to decide. */ match_available_ = 1; strstart_++; lookahead_--; } } BOOST_ASSERT(flush != Flush::none); if(match_available_) { tr_tally_lit(window_[strstart_-1], bflush); match_available_ = 0; } insert_ = strstart_ < minMatch-1 ? strstart_ : minMatch-1; if(flush == Flush::finish) { flush_block(zs, true); if(zs.avail_out == 0) return finish_started; return finish_done; } if(last_lit_) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } return block_done; } /* For Strategy::rle, simply look for runs of bytes, generate matches only of distance one. Do not maintain a hash table. (It will be regenerated if this run of deflate switches away from Strategy::rle.) */ auto deflate_stream:: f_rle(z_params& zs, Flush flush) -> block_state { bool bflush; // set if current block must be flushed uInt prev; // byte at distance one to match Byte *scan, *strend; // scan goes up to strend for length of run for(;;) { /* Make sure that we always have enough lookahead, except * at the end of the input file. We need maxMatch bytes * for the longest run, plus one for the unrolled loop. */ if(lookahead_ <= maxMatch) { fill_window(zs); if(lookahead_ <= maxMatch && flush == Flush::none) { return need_more; } if(lookahead_ == 0) break; /* flush the current block */ } /* See how many times the previous byte repeats */ match_length_ = 0; if(lookahead_ >= minMatch && strstart_ > 0) { scan = window_ + strstart_ - 1; prev = *scan; if(prev == *++scan && prev == *++scan && prev == *++scan) { strend = window_ + strstart_ + maxMatch; do { } while(prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && prev == *++scan && scan < strend); match_length_ = maxMatch - (int)(strend - scan); if(match_length_ > lookahead_) match_length_ = lookahead_; } BOOST_ASSERT(scan <= window_+(uInt)(window_size_-1)); } /* Emit match if have run of minMatch or longer, else emit literal */ if(match_length_ >= minMatch) { tr_tally_dist(std::uint16_t{1}, static_cast<std::uint8_t>(match_length_ - minMatch), bflush); lookahead_ -= match_length_; strstart_ += match_length_; match_length_ = 0; } else { /* No match, output a literal byte */ tr_tally_lit(window_[strstart_], bflush); lookahead_--; strstart_++; } if(bflush) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } } insert_ = 0; if(flush == Flush::finish) { flush_block(zs, true); if(zs.avail_out == 0) return finish_started; return finish_done; } if(last_lit_) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } return block_done; } /* =========================================================================== * For Strategy::huffman, do not look for matches. Do not maintain a hash table. * (It will be regenerated if this run of deflate switches away from Huffman.) */ auto deflate_stream:: f_huff(z_params& zs, Flush flush) -> block_state { bool bflush; // set if current block must be flushed for(;;) { // Make sure that we have a literal to write. if(lookahead_ == 0) { fill_window(zs); if(lookahead_ == 0) { if(flush == Flush::none) return need_more; break; // flush the current block } } // Output a literal byte match_length_ = 0; tr_tally_lit(window_[strstart_], bflush); lookahead_--; strstart_++; if(bflush) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } } insert_ = 0; if(flush == Flush::finish) { flush_block(zs, true); if(zs.avail_out == 0) return finish_started; return finish_done; } if(last_lit_) { flush_block(zs, false); if(zs.avail_out == 0) return need_more; } return block_done; } } // detail } // zlib } // beast } // boost #endif PK OP�[��G��f �f zlib/detail/deflate_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_DEFLATE_STREAM_HPP #define BOOST_BEAST_ZLIB_DETAIL_DEFLATE_STREAM_HPP #include <boost/beast/zlib/error.hpp> #include <boost/beast/zlib/zlib.hpp> #include <boost/beast/zlib/detail/ranges.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <cstdint> #include <cstdlib> #include <cstring> #include <memory> #include <stdexcept> #include <type_traits> namespace boost { namespace beast { namespace zlib { namespace detail { class deflate_stream { protected: // Upper limit on code length static std::uint8_t constexpr maxBits = 15; // Number of length codes, not counting the special END_BLOCK code static std::uint16_t constexpr lengthCodes = 29; // Number of literal bytes 0..255 static std::uint16_t constexpr literals = 256; // Number of Literal or Length codes, including the END_BLOCK code static std::uint16_t constexpr lCodes = literals + 1 + lengthCodes; // Number of distance code lengths static std::uint16_t constexpr dCodes = 30; // Number of codes used to transfer the bit lengths static std::uint16_t constexpr blCodes = 19; // Number of distance codes static std::uint16_t constexpr distCodeLen = 512; // Size limit on bit length codes static std::uint8_t constexpr maxBlBits= 7; static std::uint16_t constexpr minMatch = 3; static std::uint16_t constexpr maxMatch = 258; // Can't change minMatch without also changing code, see original zlib BOOST_STATIC_ASSERT(minMatch == 3); // end of block literal code static std::uint16_t constexpr END_BLOCK = 256; // repeat previous bit length 3-6 times (2 bits of repeat count) static std::uint8_t constexpr REP_3_6 = 16; // repeat a zero length 3-10 times (3 bits of repeat count) static std::uint8_t constexpr REPZ_3_10 = 17; // repeat a zero length 11-138 times (7 bits of repeat count) static std::uint8_t constexpr REPZ_11_138 = 18; // The three kinds of block type static std::uint8_t constexpr STORED_BLOCK = 0; static std::uint8_t constexpr STATIC_TREES = 1; static std::uint8_t constexpr DYN_TREES = 2; // Maximum value for memLevel in deflateInit2 static std::uint8_t constexpr max_mem_level = 9; // Default memLevel static std::uint8_t constexpr DEF_MEM_LEVEL = max_mem_level; /* Note: the deflate() code requires max_lazy >= minMatch and max_chain >= 4 For deflate_fast() (levels <= 3) good is ignored and lazy has a different meaning. */ // maximum heap size static std::uint16_t constexpr HEAP_SIZE = 2 * lCodes + 1; // size of bit buffer in bi_buf static std::uint8_t constexpr Buf_size = 16; // Matches of length 3 are discarded if their distance exceeds kTooFar static std::size_t constexpr kTooFar = 4096; /* Minimum amount of lookahead, except at the end of the input file. See deflate.c for comments about the minMatch+1. */ static std::size_t constexpr kMinLookahead = maxMatch + minMatch+1; /* Number of bytes after end of data in window to initialize in order to avoid memory checker errors from longest match routines */ static std::size_t constexpr kWinInit = maxMatch; // Describes a single value and its code string. struct ct_data { std::uint16_t fc; // frequency count or bit string std::uint16_t dl; // parent node in tree or length of bit string bool operator==(ct_data const& rhs) const { return fc == rhs.fc && dl == rhs.dl; } }; struct static_desc { ct_data const* static_tree;// static tree or NULL std::uint8_t const* extra_bits; // extra bits for each code or NULL std::uint16_t extra_base; // base index for extra_bits std::uint16_t elems; // max number of elements in the tree std::uint8_t max_length; // max bit length for the codes }; struct lut_type { // Number of extra bits for each length code std::uint8_t const extra_lbits[lengthCodes] = { 0,0,0,0,0,0,0,0,1,1,1,1,2,2,2,2,3,3,3,3,4,4,4,4,5,5,5,5,0 }; // Number of extra bits for each distance code std::uint8_t const extra_dbits[dCodes] = { 0,0,0,0,1,1,2,2,3,3,4,4,5,5,6,6,7,7,8,8,9,9,10,10,11,11,12,12,13,13 }; // Number of extra bits for each bit length code std::uint8_t const extra_blbits[blCodes] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,2,3,7 }; // The lengths of the bit length codes are sent in order // of decreasing probability, to avoid transmitting the // lengths for unused bit length codes. std::uint8_t const bl_order[blCodes] = { 16,17,18,0,8,7,9,6,10,5,11,4,12,3,13,2,14,1,15 }; ct_data ltree[lCodes + 2]; ct_data dtree[dCodes]; // Distance codes. The first 256 values correspond to the distances // 3 .. 258, the last 256 values correspond to the top 8 bits of // the 15 bit distances. std::uint8_t dist_code[distCodeLen]; std::uint8_t length_code[maxMatch-minMatch+1]; std::uint8_t base_length[lengthCodes]; std::uint16_t base_dist[dCodes]; static_desc l_desc = { ltree, extra_lbits, literals+1, lCodes, maxBits }; static_desc d_desc = { dtree, extra_dbits, 0, dCodes, maxBits }; static_desc bl_desc = { nullptr, extra_blbits, 0, blCodes, maxBlBits }; }; struct tree_desc { ct_data *dyn_tree; /* the dynamic tree */ int max_code; /* largest code with non zero frequency */ static_desc const* stat_desc; /* the corresponding static tree */ }; enum block_state { need_more, /* block not completed, need more input or more output */ block_done, /* block flush performed */ finish_started, /* finish started, need only more output at next deflate */ finish_done /* finish done, accept no more input or output */ }; // VFALCO This might not be needed, e.g. for zip/gzip enum StreamStatus { EXTRA_STATE = 69, NAME_STATE = 73, COMMENT_STATE = 91, HCRC_STATE = 103, BUSY_STATE = 113, FINISH_STATE = 666 }; /* A std::uint16_t is an index in the character window. We use short instead of int to * save space in the various tables. IPos is used only for parameter passing. */ using IPos = unsigned; using self = deflate_stream; typedef block_state(self::*compress_func)(z_params& zs, Flush flush); //-------------------------------------------------------------------------- lut_type const& lut_; bool inited_ = false; std::size_t buf_size_; std::unique_ptr<std::uint8_t[]> buf_; int status_; // as the name implies Byte* pending_buf_; // output still pending std::uint32_t pending_buf_size_; // size of pending_buf Byte* pending_out_; // next pending byte to output to the stream uInt pending_; // nb of bytes in the pending buffer boost::optional<Flush> last_flush_; // value of flush param for previous deflate call uInt w_size_; // LZ77 window size (32K by default) uInt w_bits_; // log2(w_size) (8..16) uInt w_mask_; // w_size - 1 /* Sliding window. Input bytes are read into the second half of the window, and move to the first half later to keep a dictionary of at least wSize bytes. With this organization, matches are limited to a distance of wSize-maxMatch bytes, but this ensures that IO is always performed with a length multiple of the block size. Also, it limits the window size to 64K. To do: use the user input buffer as sliding window. */ Byte *window_ = nullptr; /* Actual size of window: 2*wSize, except when the user input buffer is directly used as sliding window. */ std::uint32_t window_size_; /* Link to older string with same hash index. To limit the size of this array to 64K, this link is maintained only for the last 32K strings. An index in this array is thus a window index modulo 32K. */ std::uint16_t* prev_; std::uint16_t* head_; // Heads of the hash chains or 0 uInt ins_h_; // hash index of string to be inserted uInt hash_size_; // number of elements in hash table uInt hash_bits_; // log2(hash_size) uInt hash_mask_; // hash_size-1 /* Number of bits by which ins_h must be shifted at each input step. It must be such that after minMatch steps, the oldest byte no longer takes part in the hash key, that is: hash_shift * minMatch >= hash_bits */ uInt hash_shift_; /* Window position at the beginning of the current output block. Gets negative when the window is moved backwards. */ long block_start_; uInt match_length_; // length of best match IPos prev_match_; // previous match int match_available_; // set if previous match exists uInt strstart_; // start of string to insert uInt match_start_; // start of matching string uInt lookahead_; // number of valid bytes ahead in window /* Length of the best match at previous step. Matches not greater than this are discarded. This is used in the lazy match evaluation. */ uInt prev_length_; /* To speed up deflation, hash chains are never searched beyond this length. A higher limit improves compression ratio but degrades the speed. */ uInt max_chain_length_; /* Attempt to find a better match only when the current match is strictly smaller than this value. This mechanism is used only for compression levels >= 4. OR Insert new strings in the hash table only if the match length is not greater than this length. This saves time but degrades compression. used only for compression levels <= 3. */ uInt max_lazy_match_; int level_; // compression level (1..9) Strategy strategy_; // favor or force Huffman coding // Use a faster search when the previous match is longer than this uInt good_match_; int nice_match_; // Stop searching when current match exceeds this ct_data dyn_ltree_[ HEAP_SIZE]; // literal and length tree ct_data dyn_dtree_[ 2*dCodes+1]; // distance tree ct_data bl_tree_[ 2*blCodes+1]; // Huffman tree for bit lengths tree_desc l_desc_; // desc. for literal tree tree_desc d_desc_; // desc. for distance tree tree_desc bl_desc_; // desc. for bit length tree // number of codes at each bit length for an optimal tree std::uint16_t bl_count_[maxBits+1]; // Index within the heap array of least frequent node in the Huffman tree static std::size_t constexpr kSmallest = 1; /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used. The same heap array is used to build all trees. */ int heap_[2*lCodes+1]; // heap used to build the Huffman trees int heap_len_; // number of elements in the heap int heap_max_; // element of largest frequency // Depth of each subtree used as tie breaker for trees of equal frequency std::uint8_t depth_[2*lCodes+1]; std::uint8_t *l_buf_; // buffer for literals or lengths /* Size of match buffer for literals/lengths. There are 4 reasons for limiting lit_bufsize to 64K: - frequencies can be kept in 16 bit counters - if compression is not successful for the first block, all input data is still in the window so we can still emit a stored block even when input comes from standard input. (This can also be done for all blocks if lit_bufsize is not greater than 32K.) - if compression is not successful for a file smaller than 64K, we can even emit a stored file instead of a stored block (saving 5 bytes). This is applicable only for zip (not gzip or zlib). - creating new Huffman trees less frequently may not provide fast adaptation to changes in the input data statistics. (Take for example a binary file with poorly compressible code followed by a highly compressible string table.) Smaller buffer sizes give fast adaptation but have of course the overhead of transmitting trees more frequently. - I can't count above 4 */ uInt lit_bufsize_; uInt last_lit_; // running index in l_buf_ /* Buffer for distances. To simplify the code, d_buf_ and l_buf_ have the same number of elements. To use different lengths, an extra flag array would be necessary. */ std::uint16_t* d_buf_; std::uint32_t opt_len_; // bit length of current block with optimal trees std::uint32_t static_len_; // bit length of current block with static trees uInt matches_; // number of string matches in current block uInt insert_; // bytes at end of window left to insert /* Output buffer. Bits are inserted starting at the bottom (least significant bits). */ std::uint16_t bi_buf_; /* Number of valid bits in bi_buf._ All bits above the last valid bit are always zero. */ int bi_valid_; /* High water mark offset in window for initialized bytes -- bytes above this are set to zero in order to avoid memory check warnings when longest match routines access bytes past the input. This is then updated to the new high water mark. */ std::uint32_t high_water_; //-------------------------------------------------------------------------- deflate_stream() : lut_(get_lut()) { } /* In order to simplify the code, particularly on 16 bit machines, match distances are limited to MAX_DIST instead of WSIZE. */ std::size_t max_dist() const { return w_size_ - kMinLookahead; } void put_byte(std::uint8_t c) { pending_buf_[pending_++] = c; } void put_short(std::uint16_t w) { put_byte(w & 0xff); put_byte(w >> 8); } /* Send a value on a given number of bits. IN assertion: length <= 16 and value fits in length bits. */ void send_bits(int value, int length) { if(bi_valid_ > (int)Buf_size - length) { bi_buf_ |= (std::uint16_t)value << bi_valid_; put_short(bi_buf_); bi_buf_ = (std::uint16_t)value >> (Buf_size - bi_valid_); bi_valid_ += length - Buf_size; } else { bi_buf_ |= (std::uint16_t)(value) << bi_valid_; bi_valid_ += length; } } // Send a code of the given tree void send_code(int value, ct_data const* tree) { send_bits(tree[value].fc, tree[value].dl); } /* Mapping from a distance to a distance code. dist is the distance - 1 and must not have side effects. _dist_code[256] and _dist_code[257] are never used. */ std::uint8_t d_code(unsigned dist) { if(dist < 256) return lut_.dist_code[dist]; return lut_.dist_code[256+(dist>>7)]; } /* Update a hash value with the given input byte IN assertion: all calls to to update_hash are made with consecutive input characters, so that a running hash key can be computed from the previous key instead of complete recalculation each time. */ void update_hash(uInt& h, std::uint8_t c) { h = ((h << hash_shift_) ^ c) & hash_mask_; } /* Initialize the hash table (avoiding 64K overflow for 16 bit systems). prev[] will be initialized on the fly. */ void clear_hash() { head_[hash_size_-1] = 0; std::memset((Byte *)head_, 0, (unsigned)(hash_size_-1)*sizeof(*head_)); } /* Compares two subtrees, using the tree depth as tie breaker when the subtrees have equal frequency. This minimizes the worst case length. */ bool smaller(ct_data const* tree, int n, int m) { return tree[n].fc < tree[m].fc || (tree[n].fc == tree[m].fc && depth_[n] <= depth_[m]); } /* Insert string str in the dictionary and set match_head to the previous head of the hash chain (the most recent string with same hash key). Return the previous length of the hash chain. If this file is compiled with -DFASTEST, the compression level is forced to 1, and no hash chains are maintained. IN assertion: all calls to to INSERT_STRING are made with consecutive input characters and the first minMatch bytes of str are valid (except for the last minMatch-1 bytes of the input file). */ void insert_string(IPos& hash_head) { update_hash(ins_h_, window_[strstart_ + (minMatch-1)]); hash_head = prev_[strstart_ & w_mask_] = head_[ins_h_]; head_[ins_h_] = (std::uint16_t)strstart_; } //-------------------------------------------------------------------------- /* Values for max_lazy_match, good_match and max_chain_length, depending on * the desired pack level (0..9). The values given below have been tuned to * exclude worst case performance for pathological files. Better values may be * found for specific files. */ struct config { std::uint16_t good_length; /* reduce lazy search above this match length */ std::uint16_t max_lazy; /* do not perform lazy search above this match length */ std::uint16_t nice_length; /* quit search above this match length */ std::uint16_t max_chain; compress_func func; config( std::uint16_t good_length_, std::uint16_t max_lazy_, std::uint16_t nice_length_, std::uint16_t max_chain_, compress_func func_) : good_length(good_length_) , max_lazy(max_lazy_) , nice_length(nice_length_) , max_chain(max_chain_) , func(func_) { } }; static config get_config(std::size_t level) { switch(level) { // good lazy nice chain case 0: return { 0, 0, 0, 0, &self::deflate_stored}; // store only case 1: return { 4, 4, 8, 4, &self::deflate_fast}; // max speed, no lazy matches case 2: return { 4, 5, 16, 8, &self::deflate_fast}; case 3: return { 4, 6, 32, 32, &self::deflate_fast}; case 4: return { 4, 4, 16, 16, &self::deflate_slow}; // lazy matches case 5: return { 8, 16, 32, 32, &self::deflate_slow}; case 6: return { 8, 16, 128, 128, &self::deflate_slow}; case 7: return { 8, 32, 128, 256, &self::deflate_slow}; case 8: return { 32, 128, 258, 1024, &self::deflate_slow}; default: case 9: return { 32, 258, 258, 4096, &self::deflate_slow}; // max compression } } void maybe_init() { if(! inited_) init(); } template<class Unsigned> static Unsigned bi_reverse(Unsigned code, unsigned len); BOOST_BEAST_DECL static void gen_codes(ct_data *tree, int max_code, std::uint16_t *bl_count); BOOST_BEAST_DECL static lut_type const& get_lut(); BOOST_BEAST_DECL void doReset (int level, int windowBits, int memLevel, Strategy strategy); BOOST_BEAST_DECL void doReset (); BOOST_BEAST_DECL void doClear (); BOOST_BEAST_DECL std::size_t doUpperBound (std::size_t sourceLen) const; BOOST_BEAST_DECL void doTune (int good_length, int max_lazy, int nice_length, int max_chain); BOOST_BEAST_DECL void doParams (z_params& zs, int level, Strategy strategy, error_code& ec); BOOST_BEAST_DECL void doWrite (z_params& zs, boost::optional<Flush> flush, error_code& ec); BOOST_BEAST_DECL void doDictionary (Byte const* dict, uInt dictLength, error_code& ec); BOOST_BEAST_DECL void doPrime (int bits, int value, error_code& ec); BOOST_BEAST_DECL void doPending (unsigned* value, int* bits); BOOST_BEAST_DECL void init (); BOOST_BEAST_DECL void lm_init (); BOOST_BEAST_DECL void init_block (); BOOST_BEAST_DECL void pqdownheap (ct_data const* tree, int k); BOOST_BEAST_DECL void pqremove (ct_data const* tree, int& top); BOOST_BEAST_DECL void gen_bitlen (tree_desc *desc); BOOST_BEAST_DECL void build_tree (tree_desc *desc); BOOST_BEAST_DECL void scan_tree (ct_data *tree, int max_code); BOOST_BEAST_DECL void send_tree (ct_data *tree, int max_code); BOOST_BEAST_DECL int build_bl_tree (); BOOST_BEAST_DECL void send_all_trees (int lcodes, int dcodes, int blcodes); BOOST_BEAST_DECL void compress_block (ct_data const* ltree, ct_data const* dtree); BOOST_BEAST_DECL int detect_data_type (); BOOST_BEAST_DECL void bi_windup (); BOOST_BEAST_DECL void bi_flush (); BOOST_BEAST_DECL void copy_block (char *buf, unsigned len, int header); BOOST_BEAST_DECL void tr_init (); BOOST_BEAST_DECL void tr_align (); BOOST_BEAST_DECL void tr_flush_bits (); BOOST_BEAST_DECL void tr_stored_block (char *bu, std::uint32_t stored_len, int last); BOOST_BEAST_DECL void tr_tally_dist (std::uint16_t dist, std::uint8_t len, bool& flush); BOOST_BEAST_DECL void tr_tally_lit (std::uint8_t c, bool& flush); BOOST_BEAST_DECL void tr_flush_block (z_params& zs, char *buf, std::uint32_t stored_len, int last); BOOST_BEAST_DECL void fill_window (z_params& zs); BOOST_BEAST_DECL void flush_pending (z_params& zs); BOOST_BEAST_DECL void flush_block (z_params& zs, bool last); BOOST_BEAST_DECL int read_buf (z_params& zs, Byte *buf, unsigned size); BOOST_BEAST_DECL uInt longest_match (IPos cur_match); BOOST_BEAST_DECL block_state f_stored (z_params& zs, Flush flush); BOOST_BEAST_DECL block_state f_fast (z_params& zs, Flush flush); BOOST_BEAST_DECL block_state f_slow (z_params& zs, Flush flush); BOOST_BEAST_DECL block_state f_rle (z_params& zs, Flush flush); BOOST_BEAST_DECL block_state f_huff (z_params& zs, Flush flush); block_state deflate_stored(z_params& zs, Flush flush) { return f_stored(zs, flush); } block_state deflate_fast(z_params& zs, Flush flush) { return f_fast(zs, flush); } block_state deflate_slow(z_params& zs, Flush flush) { return f_slow(zs, flush); } block_state deflate_rle(z_params& zs, Flush flush) { return f_rle(zs, flush); } block_state deflate_huff(z_params& zs, Flush flush) { return f_huff(zs, flush); } }; //-------------------------------------------------------------------------- // Reverse the first len bits of a code template<class Unsigned> Unsigned deflate_stream:: bi_reverse(Unsigned code, unsigned len) { BOOST_STATIC_ASSERT(std::is_unsigned<Unsigned>::value); BOOST_ASSERT(len <= 8 * sizeof(unsigned)); Unsigned res = 0; do { res |= code & 1; code >>= 1; res <<= 1; } while(--len > 0); return res >> 1; } } // detail } // zlib } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/zlib/detail/deflate_stream.ipp> #endif #endif PK OP�[<�9��$ �$ zlib/detail/inflate_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_INFLATE_STREAM_HPP #define BOOST_BEAST_ZLIB_DETAIL_INFLATE_STREAM_HPP #include <boost/beast/zlib/error.hpp> #include <boost/beast/zlib/zlib.hpp> #include <boost/beast/zlib/detail/bitstream.hpp> #include <boost/beast/zlib/detail/ranges.hpp> #include <boost/beast/zlib/detail/window.hpp> #if 0 #include <boost/beast/core/detail/type_traits.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <array> #include <cstdint> #include <cstring> #include <stdexcept> #endif namespace boost { namespace beast { namespace zlib { namespace detail { class inflate_stream { protected: inflate_stream() { w_.reset(15); } BOOST_BEAST_DECL void doClear(); BOOST_BEAST_DECL void doReset(int windowBits); BOOST_BEAST_DECL void doWrite(z_params& zs, Flush flush, error_code& ec); void doReset() { doReset(w_.bits()); } private: enum Mode { HEAD, // i: waiting for magic header FLAGS, // i: waiting for method and flags (gzip) TIME, // i: waiting for modification time (gzip) OS, // i: waiting for extra flags and operating system (gzip) EXLEN, // i: waiting for extra length (gzip) EXTRA, // i: waiting for extra bytes (gzip) NAME, // i: waiting for end of file name (gzip) COMMENT, // i: waiting for end of comment (gzip) HCRC, // i: waiting for header crc (gzip) TYPE, // i: waiting for type bits, including last-flag bit TYPEDO, // i: same, but skip check to exit inflate on new block STORED, // i: waiting for stored size (length and complement) COPY_, // i/o: same as COPY below, but only first time in COPY, // i/o: waiting for input or output to copy stored block TABLE, // i: waiting for dynamic block table lengths LENLENS, // i: waiting for code length code lengths CODELENS, // i: waiting for length/lit and distance code lengths LEN_, // i: same as LEN below, but only first time in LEN, // i: waiting for length/lit/eob code LENEXT, // i: waiting for length extra bits DIST, // i: waiting for distance code DISTEXT,// i: waiting for distance extra bits MATCH, // o: waiting for output space to copy string LIT, // o: waiting for output space to write literal CHECK, // i: waiting for 32-bit check value LENGTH, // i: waiting for 32-bit length (gzip) DONE, // finished check, done -- remain here until reset BAD, // got a data error -- remain here until reset SYNC // looking for synchronization bytes to restart inflate() }; /* Structure for decoding tables. Each entry provides either the information needed to do the operation requested by the code that indexed that table entry, or it provides a pointer to another table that indexes more bits of the code. op indicates whether the entry is a pointer to another table, a literal, a length or distance, an end-of-block, or an invalid code. For a table pointer, the low four bits of op is the number of index bits of that table. For a length or distance, the low four bits of op is the number of extra bits to get after the code. bits is the number of bits in this code or part of the code to drop off of the bit buffer. val is the actual byte to output in the case of a literal, the base length or distance, or the offset from the current table to the next table. Each entry is four bytes. op values as set by inflate_table(): 00000000 - literal 0000tttt - table link, tttt != 0 is the number of table index bits 0001eeee - length or distance, eeee is the number of extra bits 01100000 - end of block 01000000 - invalid code */ struct code { std::uint8_t op; // operation, extra bits, table bits std::uint8_t bits; // bits in this part of the code std::uint16_t val; // offset in table or code value }; /* Maximum size of the dynamic table. The maximum number of code structures is 1444, which is the sum of 852 for literal/length codes and 592 for distance codes. These values were found by exhaustive searches using the program examples/enough.c found in the zlib distribtution. The arguments to that program are the number of symbols, the initial root table size, and the maximum bit length of a code. "enough 286 9 15" for literal/length codes returns returns 852, and "enough 30 6 15" for distance codes returns 592. The initial root table size (9 or 6) is found in the fifth argument of the inflate_table() calls in inflate.c and infback.c. If the root table size is changed, then these maximum sizes would be need to be recalculated and updated. */ static std::uint16_t constexpr kEnoughLens = 852; static std::uint16_t constexpr kEnoughDists = 592; static std::uint16_t constexpr kEnough = kEnoughLens + kEnoughDists; struct codes { code const* lencode; code const* distcode; unsigned lenbits; // VFALCO use std::uint8_t unsigned distbits; }; // Type of code to build for inflate_table() enum class build { codes, lens, dists }; BOOST_BEAST_DECL static void inflate_table( build type, std::uint16_t* lens, std::size_t codes, code** table, unsigned *bits, std::uint16_t* work, error_code& ec); BOOST_BEAST_DECL static codes const& get_fixed_tables(); BOOST_BEAST_DECL void fixedTables(); BOOST_BEAST_DECL void inflate_fast(ranges& r, error_code& ec); bitstream bi_; Mode mode_ = HEAD; // current inflate mode int last_ = 0; // true if processing last block unsigned dmax_ = 32768U; // zlib header max distance (INFLATE_STRICT) // sliding window window w_; // for string and stored block copying unsigned length_; // literal or length of data to copy unsigned offset_; // distance back to copy string from // for table and code decoding unsigned extra_; // extra bits needed // dynamic table building unsigned ncode_; // number of code length code lengths unsigned nlen_; // number of length code lengths unsigned ndist_; // number of distance code lengths unsigned have_; // number of code lengths in lens[] unsigned short lens_[320]; // temporary storage for code lengths unsigned short work_[288]; // work area for code table building code codes_[kEnough]; // space for code tables code *next_ = codes_; // next available space in codes[] int back_ = -1; // bits back of last unprocessed length/lit unsigned was_; // initial length of match // fixed and dynamic code tables code const* lencode_ = codes_ ; // starting table for length/literal codes code const* distcode_ = codes_; // starting table for distance codes unsigned lenbits_; // index bits for lencode unsigned distbits_; // index bits for distcode }; } // detail } // zlib } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/zlib/detail/inflate_stream.ipp> #endif #endif PK OP�[̔��e e zlib/detail/bitstream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_BITSTREAM_HPP #define BOOST_BEAST_ZLIB_DETAIL_BITSTREAM_HPP #include <boost/assert.hpp> #include <cstdint> #include <iterator> namespace boost { namespace beast { namespace zlib { namespace detail { class bitstream { using value_type = std::uint32_t; value_type v_ = 0; unsigned n_ = 0; public: // returns the number of bits in the reservoir unsigned size() const { return n_; } // discard n bits void drop(std::size_t n) { BOOST_ASSERT(n <= n_); n_ -= static_cast<unsigned>(n); v_ >>= n; } // flush everything void flush() { n_ = 0; v_ = 0; } // flush to the next byte boundary void flush_byte() { drop(n_ % 8); } // ensure at least n bits template<class FwdIt> bool fill(std::size_t n, FwdIt& first, FwdIt const& last); // fill 8 bits, unchecked template<class FwdIt> void fill_8(FwdIt& it); // fill 16 bits, unchecked template<class FwdIt> void fill_16(FwdIt& it); // return n bits template<class Unsigned> void peek(Unsigned& value, std::size_t n); // return everything in the reservoir value_type peek_fast() const { return v_; } // return n bits, and consume template<class Unsigned> void read(Unsigned& value, std::size_t n); // rewind by the number of whole bytes stored (unchecked) template<class BidirIt> void rewind(BidirIt& it); }; template<class FwdIt> bool bitstream:: fill(std::size_t n, FwdIt& first, FwdIt const& last) { while(n_ < n) { if(first == last) return false; v_ += static_cast<value_type>(*first++) << n_; n_ += 8; } return true; } template<class FwdIt> void bitstream:: fill_8(FwdIt& it) { v_ += static_cast<value_type>(*it++) << n_; n_ += 8; } template<class FwdIt> void bitstream:: fill_16(FwdIt& it) { v_ += static_cast<value_type>(*it++) << n_; n_ += 8; v_ += static_cast<value_type>(*it++) << n_; n_ += 8; } template<class Unsigned> void bitstream:: peek(Unsigned& value, std::size_t n) { BOOST_ASSERT(n <= sizeof(value)*8); BOOST_ASSERT(n <= n_); value = static_cast<Unsigned>( v_ & ((1ULL << n) - 1)); } template<class Unsigned> void bitstream:: read(Unsigned& value, std::size_t n) { BOOST_ASSERT(n < sizeof(v_)*8); BOOST_ASSERT(n <= n_); value = static_cast<Unsigned>( v_ & ((1ULL << n) - 1)); v_ >>= n; n_ -= static_cast<unsigned>(n); } template<class BidirIt> void bitstream:: rewind(BidirIt& it) { auto len = n_ >> 3; it = std::prev(it, len); n_ &= 7; v_ &= (1U << n_) - 1; } } // detail } // zlib } // beast } // boost #endif PK OP�[�7!\� � zlib/detail/ranges.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_DETAIL_RANGES_HPP #define BOOST_BEAST_ZLIB_DETAIL_RANGES_HPP #include <cstdint> #include <type_traits> namespace boost { namespace beast { namespace zlib { namespace detail { struct ranges { template<bool isConst> struct range { using iter_t = typename std::conditional<isConst, std::uint8_t const*, std::uint8_t*>::type; iter_t first; iter_t last; iter_t next; // total bytes in range std::size_t size() const { return last - first; } // bytes consumed std::size_t used() const { return next - first; } // bytes remaining std::size_t avail() const { return last - next; } }; range<true> in; range<false> out; }; // Clamp u to v where u and v are different types template<class U, class V> U clamp(U u, V v) { if(u > v) u = static_cast<U>(v); return u; } } // detail } // zlib } // beast } // boost #endif PK OP�[�� ,? ,? zlib/deflate_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_ZLIB_DEFLATE_STREAM_HPP #define BOOST_BEAST_ZLIB_DEFLATE_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/zlib/error.hpp> #include <boost/beast/zlib/zlib.hpp> #include <boost/beast/zlib/detail/deflate_stream.hpp> #include <algorithm> #include <cstdlib> #include <cstdint> #include <cstring> #include <memory> namespace boost { namespace beast { namespace zlib { // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ /** Raw deflate compressor. This is a port of zlib's "deflate" functionality to C++. */ class deflate_stream : private detail::deflate_stream { public: /** Construct a default deflate stream. Upon construction, the stream settings will be set to these default values: @li `level = 6` @li `windowBits = 15` @li `memLevel = 8` @li `strategy = Strategy::normal` Although the stream is ready to be used immediately after construction, any required internal buffers are not dynamically allocated until needed. */ deflate_stream() { reset(6, 15, DEF_MEM_LEVEL, Strategy::normal); } /** Reset the stream and compression settings. This function initializes the stream to the specified compression settings. Although the stream is ready to be used immediately after a reset, any required internal buffers are not dynamically allocated until needed. @note Any unprocessed input or pending output from previous calls are discarded. */ void reset( int level, int windowBits, int memLevel, Strategy strategy) { doReset(level, windowBits, memLevel, strategy); } /** Reset the stream without deallocating memory. This function performs the equivalent of calling `clear` followed by `reset` with the same compression settings, without deallocating the internal buffers. @note Any unprocessed input or pending output from previous calls are discarded. */ void reset() { doReset(); } /** Clear the stream. This function resets the stream and frees all dynamically allocated internal buffers. The compression settings are left unchanged. @note Any unprocessed input or pending output from previous calls are discarded. */ void clear() { doClear(); } /** Returns the upper limit on the size of a compressed block. This function makes a conservative estimate of the maximum number of bytes needed to store the result of compressing a block of data based on the current compression level and strategy. @param sourceLen The size of the uncompressed data. @return The maximum number of resulting compressed bytes. */ std::size_t upper_bound(std::size_t sourceLen) const { return doUpperBound(sourceLen); } /** Fine tune internal compression parameters. Compression parameters should only be tuned by someone who understands the algorithm used by zlib's deflate for searching for the best matching string, and even then only by the most fanatic optimizer trying to squeeze out the last compressed bit for their specific input data. Read the deflate.c source code (ZLib) for the meaning of the max_lazy, good_length, nice_length, and max_chain parameters. */ void tune( int good_length, int max_lazy, int nice_length, int max_chain) { doTune(good_length, max_lazy, nice_length, max_chain); } /** Compress input and write output. This function compresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. In each call, one or both of these actions are performed: @li Compress more input starting at `zs.next_in` and update `zs.next_in` and `zs.avail_in` accordingly. If not all input can be processed (because there is not enough room in the output buffer), `zs.next_in` and `zs.avail_in` are updated and processing will resume at this point for the next call. @li Provide more output starting at `zs.next_out` and update `zs.next_out` and `zs.avail_out` accordingly. This action is forced if the parameter flush is not `Flush::none`. Forcing flush frequently degrades the compression ratio, so this parameter should be set only when necessary (in interactive applications). Some output may be provided even if flush is not set. Before the call, the application must ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating `zs.avail_in` or `zs.avail_out` accordingly; `zs.avail_out` should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full (`zs.avail_out == 0`), or after each call of `write`. If `write` returns no error with zero `zs.avail_out`, it must be called again after making room in the output buffer because there might be more output pending. Normally the parameter flush is set to `Flush::none`, which allows deflate to decide how much data to accumulate before producing output, in order to maximize compression. If the parameter flush is set to `Flush::sync`, all pending output is flushed to the output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input data available so far. In particular `zs.avail_in` is zero after the call if enough output space has been provided before the call. Flushing may degrade compression for some compression algorithms and so it should be used only when necessary. This completes the current deflate block and follows it with an empty stored block that is three bits plus filler bits to the next byte, followed by the four bytes `{ 0x00, 0x00 0xff 0xff }`. If flush is set to `Flush::partial`, all pending output is flushed to the output buffer, but the output is not aligned to a byte boundary. All of the input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. This completes the current deflate block and follows it with an empty fixed codes block that is 10 bits long. This assures that enough bytes are output in order for the decompressor to finish the block before the empty fixed code block. If flush is set to `Flush::block`, a deflate block is completed and emitted, as for `Flush::sync`, but the output is not aligned on a byte boundary, and up to seven bits of the current block are held to be written as the next byte after the next deflate block is completed. In this case, the decompressor may not be provided enough bits at this point in order to complete decompression of the data provided so far to the compressor. It may need to wait for the next block to be emitted. This is for advanced applications that need to control the emission of deflate blocks. If flush is set to `Flush::full`, all output is flushed as with `Flush::sync`, and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using `Flush::full` too often can seriously degrade compression. If `write` returns with `zs.avail_out == 0`, this function must be called again with the same value of the flush parameter and more output space (updated `zs.avail_out`), until the flush is complete (`write` returns with non-zero `zs.avail_out`). In the case of a `Flush::full`or `Flush::sync`, make sure that `zs.avail_out` is greater than six to avoid repeated flush markers due to `zs.avail_out == 0` on return. If the parameter flush is set to `Flush::finish`, pending input is processed, pending output is flushed and deflate returns the error `error::end_of_stream` if there was enough output space; if deflate returns with no error, this function must be called again with `Flush::finish` and more output space (updated `zs.avail_out`) but no more input data, until it returns the error `error::end_of_stream` or another error. After `write` has returned the `error::end_of_stream` error, the only possible operations on the stream are to reset or destroy. `Flush::finish` can be used immediately after initialization if all the compression is to be done in a single step. In this case, `zs.avail_out` must be at least value returned by `upper_bound` (see below). Then `write` is guaranteed to return the `error::end_of_stream` error. If not enough output space is provided, deflate will not return `error::end_of_stream`, and it must be called again as described above. `write` returns no error if some progress has been made (more input processed or more output produced), `error::end_of_stream` if all input has been consumed and all output has been produced (only when flush is set to `Flush::finish`), `error::stream_error` if the stream state was inconsistent (for example if `zs.next_in` or `zs.next_out` was `nullptr`), `error::need_buffers` if no progress is possible (for example `zs.avail_in` or `zs.avail_out` was zero). Note that `error::need_buffers` is not fatal, and `write` can be called again with more input and more output space to continue compressing. */ void write( z_params& zs, Flush flush, error_code& ec) { doWrite(zs, flush, ec); } /** Update the compression level and strategy. This function dynamically updates the compression level and compression strategy. The interpretation of level and strategy is as in @ref reset. This can be used to switch between compression and straight copy of the input data, or to switch to a different kind of input data requiring a different strategy. If the compression level is changed, the input available so far is compressed with the old level (and may be flushed); the new level will take effect only at the next call of @ref write. Before the call of `params`, the stream state must be set as for a call of @ref write, since the currently available input may have to be compressed and flushed. In particular, `zs.avail_out` must be non-zero. @return `Z_OK` if success, `Z_STREAM_ERROR` if the source stream state was inconsistent or if a parameter was invalid, `error::need_buffers` if `zs.avail_out` was zero. */ void params( z_params& zs, int level, Strategy strategy, error_code& ec) { doParams(zs, level, strategy, ec); } /** Return bits pending in the output. This function returns the number of bytes and bits of output that have been generated, but not yet provided in the available output. The bytes not provided would be due to the available output space having being consumed. The number of bits of output not provided are between 0 and 7, where they await more bits to join them in order to fill out a full byte. If pending or bits are `nullptr`, then those values are not set. @return `Z_OK` if success, or `Z_STREAM_ERROR` if the source stream state was inconsistent. */ void pending(unsigned *value, int *bits) { doPending(value, bits); } /** Insert bits into the compressed output stream. This function inserts bits in the deflate output stream. The intent is that this function is used to start off the deflate output with the bits leftover from a previous deflate stream when appending to it. As such, this function can only be used for raw deflate, and must be used before the first `write` call after an initialization. `bits` must be less than or equal to 16, and that many of the least significant bits of `value` will be inserted in the output. @return `error::need_buffers` if there was not enough room in the internal buffer to insert the bits. */ void prime(int bits, int value, error_code& ec) { return doPrime(bits, value, ec); } }; /** Returns the upper limit on the size of a compressed block. This function makes a conservative estimate of the maximum number of bytes needed to store the result of compressing a block of data. @param bytes The size of the uncompressed data. @return The maximum number of resulting compressed bytes. */ std::size_t deflate_upper_bound(std::size_t bytes); /* For the default windowBits of 15 and memLevel of 8, this function returns a close to exact, as well as small, upper bound on the compressed size. They are coded as constants here for a reason--if the #define's are changed, then this function needs to be changed as well. The return value for 15 and 8 only works for those exact settings. For any setting other than those defaults for windowBits and memLevel, the value returned is a conservative worst case for the maximum expansion resulting from using fixed blocks instead of stored blocks, which deflate can emit on compressed data for some combinations of the parameters. This function could be more sophisticated to provide closer upper bounds for every combination of windowBits and memLevel. But even the conservative upper bound of about 14% expansion does not seem onerous for output buffer allocation. */ inline std::size_t deflate_upper_bound(std::size_t bytes) { return bytes + ((bytes + 7) >> 3) + ((bytes + 63) >> 6) + 5 + 6; } } // zlib } // beast } // boost #endif PK OP�[䶔�) �) zlib/inflate_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // This is a derivative work based on Zlib, copyright below: /* Copyright (C) 1995-2013 Jean-loup Gailly and Mark Adler This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. Jean-loup Gailly Mark Adler jloup@gzip.org madler@alumni.caltech.edu The data format used by the zlib library is described by RFCs (Request for Comments) 1950 to 1952 in the files http://tools.ietf.org/html/rfc1950 (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). */ #ifndef BOOST_BEAST_ZLIB_INFLATE_STREAM_HPP #define BOOST_BEAST_ZLIB_INFLATE_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/zlib/detail/inflate_stream.hpp> namespace boost { namespace beast { namespace zlib { /** Raw deflate stream decompressor. This implements a raw deflate stream decompressor. The deflate protocol is a compression protocol described in "DEFLATE Compressed Data Format Specification version 1.3" located here: https://tools.ietf.org/html/rfc1951 The implementation is a refactored port to C++ of ZLib's "inflate". A more detailed description of ZLib is at http://zlib.net/. Compression can be done in a single step if the buffers are large enough (for example if an input file is memory mapped), or can be done by repeated calls of the compression function. In the latter case, the application must provide more input and/or consume the output (providing more output space) before each call. */ class inflate_stream : private detail::inflate_stream { public: /** Construct a raw deflate decompression stream. The window size is set to the default of 15 bits. */ inflate_stream() = default; /** Reset the stream. This puts the stream in a newly constructed state with the previously specified window size, but without de-allocating any dynamically created structures. */ void reset() { doReset(); } /** Reset the stream. This puts the stream in a newly constructed state with the specified window size, but without de-allocating any dynamically created structures. */ void reset(int windowBits) { doReset(windowBits); } /** Put the stream in a newly constructed state. All dynamically allocated memory is de-allocated. */ void clear() { doClear(); } /** Decompress input and produce output. This function decompresses as much data as possible, and stops when the input buffer becomes empty or the output buffer becomes full. It may introduce some output latency (reading input without producing any output) except when forced to flush. One or both of the following actions are performed: @li Decompress more input starting at `zs.next_in` and update `zs.next_in` and `zs.avail_in` accordingly. If not all input can be processed (because there is not enough room in the output buffer), `zs.next_in` is updated and processing will resume at this point for the next call. @li Provide more output starting at `zs.next_out` and update `zs.next_out` and `zs.avail_out` accordingly. `write` provides as much output as possible, until there is no more input data or no more space in the output buffer (see below about the flush parameter). Before the call, the application should ensure that at least one of the actions is possible, by providing more input and/or consuming more output, and updating the values in `zs` accordingly. The application can consume the uncompressed output when it wants, for example when the output buffer is full (`zs.avail_out == 0`), or after each call. If `write` returns no error and with zero `zs.avail_out`, it must be called again after making room in the output buffer because there might be more output pending. The flush parameter may be `Flush::none`, `Flush::sync`, `Flush::finish`, `Flush::block`, or `Flush::trees`. `Flush::sync` requests to flush as much output as possible to the output buffer. `Flush::block` requests to stop if and when it gets to the next deflate block boundary. When decoding the zlib or gzip format, this will cause `write` to return immediately after the header and before the first block. When doing a raw inflate, `write` will go ahead and process the first block, and will return when it gets to the end of that block, or when it runs out of data. The `Flush::block` option assists in appending to or combining deflate streams. Also to assist in this, on return `write` will set `zs.data_type` to the number of unused bits in the last byte taken from `zs.next_in`, plus 64 if `write` is currently decoding the last block in the deflate stream, plus 128 if `write` returned immediately after decoding an end-of-block code or decoding the complete header up to just before the first byte of the deflate stream. The end-of-block will not be indicated until all of the uncompressed data from that block has been written to `zs.next_out`. The number of unused bits may in general be greater than seven, except when bit 7 of `zs.data_type` is set, in which case the number of unused bits will be less than eight. `zs.data_type` is set as noted here every time `write` returns for all flush options, and so can be used to determine the amount of currently consumed input in bits. The `Flush::trees` option behaves as `Flush::block` does, but it also returns when the end of each deflate block header is reached, before any actual data in that block is decoded. This allows the caller to determine the length of the deflate block header for later use in random access within a deflate block. 256 is added to the value of `zs.data_type` when `write` returns immediately after reaching the end of the deflate block header. `write` should normally be called until it returns `error::end_of_stream` or another error. However if all decompression is to be performed in a single step (a single call of `write`), the parameter flush should be set to `Flush::finish`. In this case all pending input is processed and all pending output is flushed; `zs.avail_out` must be large enough to hold all of the uncompressed data for the operation to complete. (The size of the uncompressed data may have been saved by the compressor for this purpose.) The use of `Flush::finish` is not required to perform an inflation in one step. However it may be used to inform inflate that a faster approach can be used for the single call. `Flush::finish` also informs inflate to not maintain a sliding window if the stream completes, which reduces inflate's memory footprint. If the stream does not complete, either because not all of the stream is provided or not enough output space is provided, then a sliding window will be allocated and `write` can be called again to continue the operation as if `Flush::none` had been used. In this implementation, `write` always flushes as much output as possible to the output buffer, and always uses the faster approach on the first call. So the effects of the flush parameter in this implementation are on the return value of `write` as noted below, when `write` returns early when `Flush::block` or `Flush::trees` is used, and when `write` avoids the allocation of memory for a sliding window when `Flush::finish` is used. If a preset dictionary is needed after this call, `write` sets `zs.adler` to the Adler-32 checksum of the dictionary chosen by the compressor and returns `error::need_dictionary`; otherwise it sets `zs.adler` to the Adler-32 checksum of all output produced so far (that is, `zs.total_out bytes`) and returns no error, `error::end_of_stream`, or an error code as described below. At the end of the stream, `write` checks that its computed adler32 checksum is equal to that saved by the compressor and returns `error::end_of_stream` only if the checksum is correct. This function returns no error if some progress has been made (more input processed or more output produced), `error::end_of_stream` if the end of the compressed data has been reached and all uncompressed output has been produced, `error::need_dictionary` if a preset dictionary is needed at this point, `error::invalid_data` if the input data was corrupted (input stream not conforming to the zlib format or incorrect check value), `error::stream_error` if the stream structure was inconsistent (for example if `zs.next_in` or `zs.next_out` was null), `error::need_buffers` if no progress is possible or if there was not enough room in the output buffer when `Flush::finish` is used. Note that `error::need_buffers` is not fatal, and `write` can be called again with more input and more output space to continue decompressing. */ void write(z_params& zs, Flush flush, error_code& ec) { doWrite(zs, flush, ec); } }; } // zlib } // beast } // boost #endif PK OP�[�b� � & _experimental/unit_test/suite_info.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_SUITE_INFO_HPP #define BOOST_BEAST_UNIT_TEST_SUITE_INFO_HPP #include <cstring> #include <functional> #include <string> #include <utility> namespace boost { namespace beast { namespace unit_test { class runner; /** Associates a unit test type with metadata. */ class suite_info { using run_type = std::function<void(runner&)>; std::string name_; std::string module_; std::string library_; bool manual_; run_type run_; public: suite_info( std::string name, std::string module, std::string library, bool manual, run_type run) : name_(std::move(name)) , module_(std::move(module)) , library_(std::move(library)) , manual_(manual) , run_(std::move(run)) { } std::string const& name() const { return name_; } std::string const& module() const { return module_; } std::string const& library() const { return library_; } /// Returns `true` if this suite only runs manually. bool manual() const { return manual_; } /// Return the canonical suite name as a string. std::string full_name() const { return library_ + "." + module_ + "." + name_; } /// Run a new instance of the associated test suite. void run(runner& r) const { run_(r); } friend bool operator<(suite_info const& lhs, suite_info const& rhs) { return std::tie(lhs.library_, lhs.module_, lhs.name_) < std::tie(rhs.library_, rhs.module_, rhs.name_); } }; //------------------------------------------------------------------------------ /// Convenience for producing suite_info for a given test type. template<class Suite> suite_info make_suite_info( std::string name, std::string module, std::string library, bool manual) { return suite_info( std::move(name), std::move(module), std::move(library), manual, [](runner& r) { Suite{}(r); } ); } } // unit_test } // beast } // boost #endif PK OP�[|8-�� � " _experimental/unit_test/amount.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_AMOUNT_HPP #define BOOST_BEAST_UNIT_TEST_AMOUNT_HPP #include <cstddef> #include <ostream> #include <string> namespace boost { namespace beast { namespace unit_test { /** Utility for producing nicely composed output of amounts with units. */ class amount { private: std::size_t n_; std::string const& what_; public: amount(amount const&) = default; amount& operator=(amount const&) = delete; template<class = void> amount(std::size_t n, std::string const& what); friend std::ostream& operator<<(std::ostream& s, amount const& t); }; template<class> amount::amount(std::size_t n, std::string const& what) : n_(n) , what_(what) { } inline std::ostream& operator<<(std::ostream& s, amount const& t) { s << t.n_ << " " << t.what_ <<((t.n_ != 1) ? "s" : ""); return s; } } // unit_test } // beast } // boost #endif PK OP�[8�d)< )< ! _experimental/unit_test/suite.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_SUITE_HPP #define BOOST_BEAST_UNIT_TEST_SUITE_HPP #include <boost/beast/_experimental/unit_test/runner.hpp> #include <boost/throw_exception.hpp> #include <ostream> #include <sstream> #include <string> namespace boost { namespace beast { namespace unit_test { namespace detail { template<class String> std::string make_reason(String const& reason, char const* file, int line) { std::string s(reason); if(! s.empty()) s.append(": "); char const* path = file + strlen(file); while(path != file) { #ifdef _MSC_VER if(path[-1] == '\\') #else if(path[-1] == '/') #endif break; --path; } s.append(path); s.append("("); s.append(std::to_string(line)); s.append(")"); return s; } } // detail class thread; enum abort_t { no_abort_on_fail, abort_on_fail }; /** A testsuite class. Derived classes execute a series of testcases, where each testcase is a series of pass/fail tests. To provide a unit test using this class, derive from it and use the BOOST_BEAST_DEFINE_UNIT_TEST macro in a translation unit. */ class suite { private: bool abort_ = false; bool aborted_ = false; runner* runner_ = nullptr; // This exception is thrown internally to stop the current suite // in the event of a failure, if the option to stop is set. struct abort_exception : public std::exception { char const* what() const noexcept override { return "test suite aborted"; } }; template<class CharT, class Traits, class Allocator> class log_buf : public std::basic_stringbuf<CharT, Traits, Allocator> { suite& suite_; public: explicit log_buf(suite& self) : suite_(self) { } ~log_buf() { sync(); } int sync() override { auto const& s = this->str(); if(s.size() > 0) suite_.runner_->log(s); this->str(""); return 0; } }; template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class log_os : public std::basic_ostream<CharT, Traits> { log_buf<CharT, Traits, Allocator> buf_; public: explicit log_os(suite& self) : std::basic_ostream<CharT, Traits>(&buf_) , buf_(self) { } }; class scoped_testcase; class testcase_t { suite& suite_; std::stringstream ss_; public: explicit testcase_t(suite& self) : suite_(self) { } /** Open a new testcase. A testcase is a series of evaluated test conditions. A test suite may have multiple test cases. A test is associated with the last opened testcase. When the test first runs, a default unnamed case is opened. Tests with only one case may omit the call to testcase. @param abort Determines if suite continues running after a failure. */ void operator()(std::string const& name, abort_t abort = no_abort_on_fail); scoped_testcase operator()(abort_t abort); template<class T> scoped_testcase operator<<(T const& t); }; public: /** Logging output stream. Text sent to the log output stream will be forwarded to the output stream associated with the runner. */ log_os<char> log; /** Memberspace for declaring test cases. */ testcase_t testcase; /** Returns the "current" running suite. If no suite is running, nullptr is returned. */ static suite* this_suite() { return *p_this_suite(); } suite() : log(*this) , testcase(*this) { } virtual ~suite() = default; suite(suite const&) = delete; suite& operator=(suite const&) = delete; /** Invokes the test using the specified runner. Data members are set up here instead of the constructor as a convenience to writing the derived class to avoid repetition of forwarded constructor arguments to the base. Normally this is called by the framework for you. */ template<class = void> void operator()(runner& r); /** Record a successful test condition. */ template<class = void> void pass(); /** Record a failure. @param reason Optional text added to the output on a failure. @param file The source code file where the test failed. @param line The source code line number where the test failed. */ /** @{ */ template<class String> void fail(String const& reason, char const* file, int line); template<class = void> void fail(std::string const& reason = ""); /** @} */ /** Evaluate a test condition. This function provides improved logging by incorporating the file name and line number into the reported output on failure, as well as additional text specified by the caller. @param shouldBeTrue The condition to test. The condition is evaluated in a boolean context. @param reason Optional added text to output on a failure. @param file The source code file where the test failed. @param line The source code line number where the test failed. @return `true` if the test condition indicates success. */ /** @{ */ template<class Condition> bool expect(Condition const& shouldBeTrue) { return expect(shouldBeTrue, ""); } template<class Condition, class String> bool expect(Condition const& shouldBeTrue, String const& reason); template<class Condition> bool expect(Condition const& shouldBeTrue, char const* file, int line) { return expect(shouldBeTrue, "", file, line); } template<class Condition, class String> bool expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line); /** @} */ // // DEPRECATED // // Expect an exception from f() template<class F, class String> bool except(F&& f, String const& reason); template<class F> bool except(F&& f) { return except(f, ""); } template<class E, class F, class String> bool except(F&& f, String const& reason); template<class E, class F> bool except(F&& f) { return except<E>(f, ""); } template<class F, class String> bool unexcept(F&& f, String const& reason); template<class F> bool unexcept(F&& f) { return unexcept(f, ""); } /** Return the argument associated with the runner. */ std::string const& arg() const { return runner_->arg(); } // DEPRECATED // @return `true` if the test condition indicates success(a false value) template<class Condition, class String> bool unexpected(Condition shouldBeFalse, String const& reason); template<class Condition> bool unexpected(Condition shouldBeFalse) { return unexpected(shouldBeFalse, ""); } private: friend class thread; static suite** p_this_suite() { static suite* pts = nullptr; return &pts; } /** Runs the suite. */ virtual void run() = 0; void propagate_abort(); template<class = void> void run(runner& r); }; //------------------------------------------------------------------------------ // Helper for streaming testcase names class suite::scoped_testcase { private: suite& suite_; std::stringstream& ss_; public: scoped_testcase& operator=(scoped_testcase const&) = delete; ~scoped_testcase() { auto const& name = ss_.str(); if(! name.empty()) suite_.runner_->testcase(name); } scoped_testcase(suite& self, std::stringstream& ss) : suite_(self) , ss_(ss) { ss_.clear(); ss_.str({}); } template<class T> scoped_testcase(suite& self, std::stringstream& ss, T const& t) : suite_(self) , ss_(ss) { ss_.clear(); ss_.str({}); ss_ << t; } template<class T> scoped_testcase& operator<<(T const& t) { ss_ << t; return *this; } }; //------------------------------------------------------------------------------ inline void suite::testcase_t::operator()( std::string const& name, abort_t abort) { suite_.abort_ = abort == abort_on_fail; suite_.runner_->testcase(name); } inline suite::scoped_testcase suite::testcase_t::operator()(abort_t abort) { suite_.abort_ = abort == abort_on_fail; return { suite_, ss_ }; } template<class T> inline suite::scoped_testcase suite::testcase_t::operator<<(T const& t) { return { suite_, ss_, t }; } //------------------------------------------------------------------------------ template<class> void suite:: operator()(runner& r) { *p_this_suite() = this; try { run(r); *p_this_suite() = nullptr; } catch(...) { *p_this_suite() = nullptr; throw; } } template<class Condition, class String> bool suite:: expect( Condition const& shouldBeTrue, String const& reason) { if(shouldBeTrue) { pass(); return true; } fail(reason); return false; } template<class Condition, class String> bool suite:: expect(Condition const& shouldBeTrue, String const& reason, char const* file, int line) { if(shouldBeTrue) { pass(); return true; } fail(detail::make_reason(reason, file, line)); return false; } // DEPRECATED template<class F, class String> bool suite:: except(F&& f, String const& reason) { try { f(); fail(reason); return false; } catch(...) { pass(); } return true; } template<class E, class F, class String> bool suite:: except(F&& f, String const& reason) { try { f(); fail(reason); return false; } catch(E const&) { pass(); } return true; } template<class F, class String> bool suite:: unexcept(F&& f, String const& reason) { try { f(); pass(); return true; } catch(...) { fail(reason); } return false; } template<class Condition, class String> bool suite:: unexpected( Condition shouldBeFalse, String const& reason) { bool const b = static_cast<bool>(shouldBeFalse); if(! b) pass(); else fail(reason); return ! b; } template<class> void suite:: pass() { propagate_abort(); runner_->pass(); } // ::fail template<class> void suite:: fail(std::string const& reason) { propagate_abort(); runner_->fail(reason); if(abort_) { aborted_ = true; BOOST_THROW_EXCEPTION(abort_exception()); } } template<class String> void suite:: fail(String const& reason, char const* file, int line) { fail(detail::make_reason(reason, file, line)); } inline void suite:: propagate_abort() { if(abort_ && aborted_) BOOST_THROW_EXCEPTION(abort_exception()); } template<class> void suite:: run(runner& r) { runner_ = &r; try { run(); } catch(abort_exception const&) { // ends the suite } catch(std::exception const& e) { runner_->fail("unhandled exception: " + std::string(e.what())); } catch(...) { runner_->fail("unhandled exception"); } } #ifndef BEAST_PASS #define BEAST_PASS() ::boost::beast::unit_test::suite::this_suite()->pass() #endif #ifndef BEAST_FAIL #define BEAST_FAIL() ::boost::beast::unit_test::suite::this_suite()->fail("", __FILE__, __LINE__) #endif #ifndef BEAST_EXPECT /** Check a precondition. If the condition is false, the file and line number are reported. */ #define BEAST_EXPECT(cond) ::boost::beast::unit_test::suite::this_suite()->expect(cond, __FILE__, __LINE__) #endif #ifndef BEAST_EXPECTS /** Check a precondition. If the condition is false, the file and line number are reported. */ #define BEAST_EXPECTS(cond, reason) ((cond) ? \ (::boost::beast::unit_test::suite::this_suite()->pass(), true) : \ (::boost::beast::unit_test::suite::this_suite()->fail((reason), __FILE__, __LINE__), false)) #endif /** Ensure an exception is thrown */ #define BEAST_THROWS( EXPR, EXCEP ) \ try { \ EXPR; \ BEAST_FAIL(); \ } \ catch(EXCEP const&) { \ BEAST_PASS(); \ } \ catch(...) { \ BEAST_FAIL(); \ } } // unit_test } // beast } // boost //------------------------------------------------------------------------------ // detail: // This inserts the suite with the given manual flag #define BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,manual) \ static ::boost::beast::unit_test::detail::insert_suite <Class##_test> \ Library ## Module ## Class ## _test_instance( \ #Class, #Module, #Library, manual) //------------------------------------------------------------------------------ // Preprocessor directives for controlling unit test definitions. // If this is already defined, don't redefine it. This allows // programs to provide custom behavior for testsuite definitions // #ifndef BEAST_DEFINE_TESTSUITE /** Enables insertion of test suites into the global container. The default is to insert all test suite definitions into the global container. If BEAST_DEFINE_TESTSUITE is user defined, this macro has no effect. */ #ifndef BEAST_NO_UNIT_TEST_INLINE #define BEAST_NO_UNIT_TEST_INLINE 0 #endif /** Define a unit test suite. Library Identifies the library. Module Identifies the module. Class The type representing the class being tested. The declaration for the class implementing the test should be the same as Class ## _test. For example, if Class is aged_ordered_container, the test class must be declared as: @code struct aged_ordered_container_test : beast::unit_test::suite { //... }; @endcode The macro invocation must appear in the same namespace as the test class. */ #if BEAST_NO_UNIT_TEST_INLINE #define BEAST_DEFINE_TESTSUITE(Class,Module,Library) #else #include <boost/beast/_experimental/unit_test/global_suites.hpp> #define BEAST_DEFINE_TESTSUITE(Library,Module,Class) \ BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,false) #define BEAST_DEFINE_TESTSUITE_MANUAL(Library,Module,Class) \ BEAST_DEFINE_TESTSUITE_INSERT(Library,Module,Class,true) #endif #endif //------------------------------------------------------------------------------ #endif PK OP�[6��e e & _experimental/unit_test/suite_list.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_SUITE_LIST_HPP #define BOOST_BEAST_UNIT_TEST_SUITE_LIST_HPP #include <boost/beast/_experimental/unit_test/suite_info.hpp> #include <boost/beast/_experimental/unit_test/detail/const_container.hpp> #include <boost/assert.hpp> #include <typeindex> #include <set> #include <unordered_set> namespace boost { namespace beast { namespace unit_test { /// A container of test suites. class suite_list : public detail::const_container <std::set <suite_info>> { private: #ifndef NDEBUG std::unordered_set<std::string> names_; std::unordered_set<std::type_index> classes_; #endif public: /** Insert a suite into the set. The suite must not already exist. */ template<class Suite> void insert( char const* name, char const* module, char const* library, bool manual); }; //------------------------------------------------------------------------------ template<class Suite> void suite_list::insert( char const* name, char const* module, char const* library, bool manual) { #ifndef NDEBUG { std::string s; s = std::string(library) + "." + module + "." + name; auto const result(names_.insert(s)); BOOST_ASSERT(result.second); // Duplicate name } { auto const result(classes_.insert( std::type_index(typeid(Suite)))); BOOST_ASSERT(result.second); // Duplicate type } #endif cont().emplace(make_suite_info<Suite>( name, module, library, manual)); } } // unit_test } // beast } // boost #endif PK OP�[���5U U # _experimental/unit_test/dstream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_DSTREAM_HPP #define BOOST_BEAST_UNIT_TEST_DSTREAM_HPP #include <boost/config.hpp> #include <ios> #include <memory> #include <ostream> #include <sstream> #include <streambuf> #include <string> #ifdef BOOST_WINDOWS #include <boost/winapi/basic_types.hpp> #include <boost/winapi/debugapi.hpp> #endif namespace boost { namespace beast { namespace unit_test { #ifdef BOOST_WINDOWS namespace detail { template<class CharT, class Traits, class Allocator> class dstream_buf : public std::basic_stringbuf<CharT, Traits, Allocator> { using ostream = std::basic_ostream<CharT, Traits>; ostream& os_; bool dbg_; template<class T> void write(T const*) = delete; void write(char const* s) { if(dbg_) boost::winapi::OutputDebugStringA(s); os_ << s; } void write(wchar_t const* s) { if(dbg_) boost::winapi::OutputDebugStringW(s); os_ << s; } public: explicit dstream_buf(ostream& os) : os_(os) , dbg_(boost::winapi::IsDebuggerPresent() != 0) { } ~dstream_buf() { sync(); } int sync() override { write(this->str().c_str()); this->str(""); return 0; } }; } // detail /** std::ostream with Visual Studio IDE redirection. Instances of this stream wrap a specified `std::ostream` (such as `std::cout` or `std::cerr`). If the IDE debugger is attached when the stream is created, output will be additionally copied to the Visual Studio Output window. */ template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT> > class basic_dstream : public std::basic_ostream<CharT, Traits> { detail::dstream_buf< CharT, Traits, Allocator> buf_; public: /** Construct a stream. @param os The output stream to wrap. */ explicit basic_dstream(std::ostream& os) : std::basic_ostream<CharT, Traits>(&buf_) , buf_(os) { if(os.flags() & std::ios::unitbuf) std::unitbuf(*this); } }; using dstream = basic_dstream<char>; using dwstream = basic_dstream<wchar_t>; #else using dstream = std::ostream&; using dwstream = std::wostream&; #endif } // unit_test } // beast } // boost #endif PK OP�[�Oռ� � ! _experimental/unit_test/match.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_MATCH_HPP #define BOOST_BEAST_UNIT_TEST_MATCH_HPP #include <boost/beast/_experimental/unit_test/suite_info.hpp> #include <string> namespace boost { namespace beast { namespace unit_test { // Predicate for implementing matches class selector { public: enum mode_t { // Run all tests except manual ones all, // Run tests that match in any field automatch, // Match on suite suite, // Match on library library, // Match on module (used internally) module, // Match nothing (used internally) none }; private: mode_t mode_; std::string pat_; std::string library_; public: template<class = void> explicit selector(mode_t mode, std::string const& pattern = ""); template<class = void> bool operator()(suite_info const& s); }; //------------------------------------------------------------------------------ template<class> selector::selector(mode_t mode, std::string const& pattern) : mode_(mode) , pat_(pattern) { if(mode_ == automatch && pattern.empty()) mode_ = all; } template<class> bool selector::operator()(suite_info const& s) { switch(mode_) { case automatch: // suite or full name if(s.name() == pat_ || s.full_name() == pat_) { mode_ = none; return true; } // check module if(pat_ == s.module()) { mode_ = module; library_ = s.library(); return ! s.manual(); } // check library if(pat_ == s.library()) { mode_ = library; return ! s.manual(); } return false; case suite: return pat_ == s.name(); case module: return pat_ == s.module() && ! s.manual(); case library: return pat_ == s.library() && ! s.manual(); case none: return false; case all: default: // fall through break; }; return ! s.manual(); } //------------------------------------------------------------------------------ // Utility functions for producing predicates to select suites. /** Returns a predicate that implements a smart matching rule. The predicate checks the suite, module, and library fields of the suite_info in that order. When it finds a match, it changes modes depending on what was found: If a suite is matched first, then only the suite is selected. The suite may be marked manual. If a module is matched first, then only suites from that module and library not marked manual are selected from then on. If a library is matched first, then only suites from that library not marked manual are selected from then on. */ inline selector match_auto(std::string const& name) { return selector(selector::automatch, name); } /** Return a predicate that matches all suites not marked manual. */ inline selector match_all() { return selector(selector::all); } /** Returns a predicate that matches a specific suite. */ inline selector match_suite(std::string const& name) { return selector(selector::suite, name); } /** Returns a predicate that matches all suites in a library. */ inline selector match_library(std::string const& name) { return selector(selector::library, name); } } // unit_test } // beast } // boost #endif PK OP�[� PW� � # _experimental/unit_test/results.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_RESULTS_HPP #define BOOST_BEAST_UNIT_TEST_RESULTS_HPP #include <boost/beast/_experimental/unit_test/detail/const_container.hpp> #include <string> #include <vector> namespace boost { namespace beast { namespace unit_test { /** Holds a set of test condition outcomes in a testcase. */ class case_results { public: /** Holds the result of evaluating one test condition. */ struct test { explicit test(bool pass_) : pass(pass_) { } test(bool pass_, std::string const& reason_) : pass(pass_) , reason(reason_) { } bool pass; std::string reason; }; private: class tests_t : public detail::const_container <std::vector <test>> { private: std::size_t failed_; public: tests_t() : failed_(0) { } /** Returns the total number of test conditions. */ std::size_t total() const { return cont().size(); } /** Returns the number of failed test conditions. */ std::size_t failed() const { return failed_; } /** Register a successful test condition. */ void pass() { cont().emplace_back(true); } /** Register a failed test condition. */ void fail(std::string const& reason = "") { ++failed_; cont().emplace_back(false, reason); } }; class log_t : public detail::const_container <std::vector <std::string>> { public: /** Insert a string into the log. */ void insert(std::string const& s) { cont().push_back(s); } }; std::string name_; public: explicit case_results(std::string const& name = "") : name_(name) { } /** Returns the name of this testcase. */ std::string const& name() const { return name_; } /** Memberspace for a container of test condition outcomes. */ tests_t tests; /** Memberspace for a container of testcase log messages. */ log_t log; }; //-------------------------------------------------------------------------- /** Holds the set of testcase results in a suite. */ class suite_results : public detail::const_container <std::vector <case_results>> { private: std::string name_; std::size_t total_ = 0; std::size_t failed_ = 0; public: explicit suite_results(std::string const& name = "") : name_(name) { } /** Returns the name of this suite. */ std::string const& name() const { return name_; } /** Returns the total number of test conditions. */ std::size_t total() const { return total_; } /** Returns the number of failures. */ std::size_t failed() const { return failed_; } /** Insert a set of testcase results. */ /** @{ */ void insert(case_results&& r) { cont().emplace_back(std::move(r)); total_ += r.tests.total(); failed_ += r.tests.failed(); } void insert(case_results const& r) { cont().push_back(r); total_ += r.tests.total(); failed_ += r.tests.failed(); } /** @} */ }; //------------------------------------------------------------------------------ // VFALCO TODO Make this a template class using scoped allocators /** Holds the results of running a set of testsuites. */ class results : public detail::const_container <std::vector <suite_results>> { private: std::size_t m_cases; std::size_t total_; std::size_t failed_; public: results() : m_cases(0) , total_(0) , failed_(0) { } /** Returns the total number of test cases. */ std::size_t cases() const { return m_cases; } /** Returns the total number of test conditions. */ std::size_t total() const { return total_; } /** Returns the number of failures. */ std::size_t failed() const { return failed_; } /** Insert a set of suite results. */ /** @{ */ void insert(suite_results&& r) { m_cases += r.size(); total_ += r.total(); failed_ += r.failed(); cont().emplace_back(std::move(r)); } void insert(suite_results const& r) { m_cases += r.size(); total_ += r.total(); failed_ += r.failed(); cont().push_back(r); } /** @} */ }; } // unit_test } // beast } // boost #endif PK OP�[e;u�d d ) _experimental/unit_test/global_suites.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_GLOBAL_SUITES_HPP #define BOOST_BEAST_UNIT_TEST_GLOBAL_SUITES_HPP #include <boost/beast/_experimental/unit_test/suite_list.hpp> namespace boost { namespace beast { namespace unit_test { namespace detail { /// Holds test suites registered during static initialization. inline suite_list& global_suites() { static suite_list s; return s; } template<class Suite> struct insert_suite { insert_suite(char const* name, char const* module, char const* library, bool manual) { global_suites().insert<Suite>( name, module, library, manual); } }; } // detail /// Holds test suites registered during static initialization. inline suite_list const& global_suites() { return detail::global_suites(); } } // unit_test } // beast } // boost #endif PK OP�[�䴻 � " _experimental/unit_test/runner.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_RUNNER_H_INCLUDED #define BOOST_BEAST_UNIT_TEST_RUNNER_H_INCLUDED #include <boost/beast/_experimental/unit_test/suite_info.hpp> #include <boost/assert.hpp> #include <mutex> #include <ostream> #include <string> namespace boost { namespace beast { namespace unit_test { /** Unit test runner interface. Derived classes can customize the reporting behavior. This interface is injected into the unit_test class to receive the results of the tests. */ class runner { std::string arg_; bool default_ = false; bool failed_ = false; bool cond_ = false; std::recursive_mutex mutex_; public: runner() = default; virtual ~runner() = default; runner(runner const&) = delete; runner& operator=(runner const&) = delete; /** Set the argument string. The argument string is available to suites and allows for customization of the test. Each suite defines its own syntax for the argument string. The same argument is passed to all suites. */ void arg(std::string const& s) { arg_ = s; } /** Returns the argument string. */ std::string const& arg() const { return arg_; } /** Run the specified suite. @return `true` if any conditions failed. */ template<class = void> bool run(suite_info const& s); /** Run a sequence of suites. The expression `FwdIter::value_type` must be convertible to `suite_info`. @return `true` if any conditions failed. */ template<class FwdIter> bool run(FwdIter first, FwdIter last); /** Conditionally run a sequence of suites. pred will be called as: @code bool pred(suite_info const&); @endcode @return `true` if any conditions failed. */ template<class FwdIter, class Pred> bool run_if(FwdIter first, FwdIter last, Pred pred = Pred{}); /** Run all suites in a container. @return `true` if any conditions failed. */ template<class SequenceContainer> bool run_each(SequenceContainer const& c); /** Conditionally run suites in a container. pred will be called as: @code bool pred(suite_info const&); @endcode @return `true` if any conditions failed. */ template<class SequenceContainer, class Pred> bool run_each_if(SequenceContainer const& c, Pred pred = Pred{}); protected: /// Called when a new suite starts. virtual void on_suite_begin(suite_info const&) { } /// Called when a suite ends. virtual void on_suite_end() { } /// Called when a new case starts. virtual void on_case_begin(std::string const&) { } /// Called when a new case ends. virtual void on_case_end() { } /// Called for each passing condition. virtual void on_pass() { } /// Called for each failing condition. virtual void on_fail(std::string const&) { } /// Called when a test logs output. virtual void on_log(std::string const&) { } private: friend class suite; // Start a new testcase. template<class = void> void testcase(std::string const& name); template<class = void> void pass(); template<class = void> void fail(std::string const& reason); template<class = void> void log(std::string const& s); }; //------------------------------------------------------------------------------ template<class> bool runner::run(suite_info const& s) { // Enable 'default' testcase default_ = true; failed_ = false; on_suite_begin(s); s.run(*this); // Forgot to call pass or fail. BOOST_ASSERT(cond_); on_case_end(); on_suite_end(); return failed_; } template<class FwdIter> bool runner::run(FwdIter first, FwdIter last) { bool failed(false); for(;first != last; ++first) failed = run(*first) || failed; return failed; } template<class FwdIter, class Pred> bool runner::run_if(FwdIter first, FwdIter last, Pred pred) { bool failed(false); for(;first != last; ++first) if(pred(*first)) failed = run(*first) || failed; return failed; } template<class SequenceContainer> bool runner::run_each(SequenceContainer const& c) { bool failed(false); for(auto const& s : c) failed = run(s) || failed; return failed; } template<class SequenceContainer, class Pred> bool runner::run_each_if(SequenceContainer const& c, Pred pred) { bool failed(false); for(auto const& s : c) if(pred(s)) failed = run(s) || failed; return failed; } template<class> void runner::testcase(std::string const& name) { std::lock_guard<std::recursive_mutex> lock(mutex_); // Name may not be empty BOOST_ASSERT(default_ || ! name.empty()); // Forgot to call pass or fail BOOST_ASSERT(default_ || cond_); if(! default_) on_case_end(); default_ = false; cond_ = false; on_case_begin(name); } template<class> void runner::pass() { std::lock_guard<std::recursive_mutex> lock(mutex_); if(default_) testcase(""); on_pass(); cond_ = true; } template<class> void runner::fail(std::string const& reason) { std::lock_guard<std::recursive_mutex> lock(mutex_); if(default_) testcase(""); on_fail(reason); failed_ = true; cond_ = true; } template<class> void runner::log(std::string const& s) { std::lock_guard<std::recursive_mutex> lock(mutex_); if(default_) testcase(""); on_log(s); } } // unit_test } // beast } // boost #endif PK OP�[ ")�� � 2 _experimental/unit_test/detail/const_container.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_DETAIL_CONST_CONTAINER_HPP #define BOOST_BEAST_UNIT_TEST_DETAIL_CONST_CONTAINER_HPP namespace boost { namespace beast { namespace unit_test { namespace detail { /** Adapter to constrain a container interface. The interface allows for limited read only operations. Derived classes provide additional behavior. */ template<class Container> class const_container { private: using cont_type = Container; cont_type m_cont; protected: cont_type& cont() { return m_cont; } cont_type const& cont() const { return m_cont; } public: using value_type = typename cont_type::value_type; using size_type = typename cont_type::size_type; using difference_type = typename cont_type::difference_type; using iterator = typename cont_type::const_iterator; using const_iterator = typename cont_type::const_iterator; /** Returns `true` if the container is empty. */ bool empty() const { return m_cont.empty(); } /** Returns the number of items in the container. */ size_type size() const { return m_cont.size(); } /** Returns forward iterators for traversal. */ /** @{ */ const_iterator begin() const { return m_cont.cbegin(); } const_iterator cbegin() const { return m_cont.cbegin(); } const_iterator end() const { return m_cont.cend(); } const_iterator cend() const { return m_cont.cend(); } /** @} */ }; } // detail } // unit_test } // beast } // boost #endif PK OP�[�is� � $ _experimental/unit_test/reporter.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_REPORTER_HPP #define BOOST_BEAST_UNIT_TEST_REPORTER_HPP #include <boost/beast/_experimental/unit_test/amount.hpp> #include <boost/beast/_experimental/unit_test/recorder.hpp> #include <algorithm> #include <chrono> #include <functional> #include <iomanip> #include <iostream> #include <sstream> #include <string> #include <utility> namespace boost { namespace beast { namespace unit_test { namespace detail { /** A simple test runner that writes everything to a stream in real time. The totals are output when the object is destroyed. */ template<class = void> class reporter : public runner { private: using clock_type = std::chrono::steady_clock; struct case_results { std::string name; std::size_t total = 0; std::size_t failed = 0; explicit case_results(std::string name_ = "") : name(std::move(name_)) { } }; struct suite_results { std::string name; std::size_t cases = 0; std::size_t total = 0; std::size_t failed = 0; typename clock_type::time_point start = clock_type::now(); explicit suite_results(std::string name_ = "") : name(std::move(name_)) { } void add(case_results const& r); }; struct results { using run_time = std::pair<std::string, typename clock_type::duration>; enum { max_top = 10 }; std::size_t suites = 0; std::size_t cases = 0; std::size_t total = 0; std::size_t failed = 0; std::vector<run_time> top; typename clock_type::time_point start = clock_type::now(); void add(suite_results const& r); }; std::ostream& os_; results results_; suite_results suite_results_; case_results case_results_; public: reporter(reporter const&) = delete; reporter& operator=(reporter const&) = delete; ~reporter(); explicit reporter(std::ostream& os = std::cout); private: static std::string fmtdur(typename clock_type::duration const& d); virtual void on_suite_begin(suite_info const& info) override; virtual void on_suite_end() override; virtual void on_case_begin(std::string const& name) override; virtual void on_case_end() override; virtual void on_pass() override; virtual void on_fail(std::string const& reason) override; virtual void on_log(std::string const& s) override; }; //------------------------------------------------------------------------------ template<class _> void reporter<_>:: suite_results::add(case_results const& r) { ++cases; total += r.total; failed += r.failed; } template<class _> void reporter<_>:: results::add(suite_results const& r) { ++suites; total += r.total; cases += r.cases; failed += r.failed; auto const elapsed = clock_type::now() - r.start; if(elapsed >= std::chrono::seconds{1}) { auto const iter = std::lower_bound(top.begin(), top.end(), elapsed, [](run_time const& t1, typename clock_type::duration const& t2) { return t1.second > t2; }); if(iter != top.end()) { top.emplace(iter, r.name, elapsed); if(top.size() > max_top) top.resize(max_top); } } } //------------------------------------------------------------------------------ template<class _> reporter<_>:: reporter(std::ostream& os) : os_(os) { } template<class _> reporter<_>::~reporter() { if(results_.top.size() > 0) { os_ << "Longest suite times:\n"; for(auto const& i : results_.top) os_ << std::setw(8) << fmtdur(i.second) << " " << i.first << '\n'; } auto const elapsed = clock_type::now() - results_.start; os_ << fmtdur(elapsed) << ", " << amount{results_.suites, "suite"} << ", " << amount{results_.cases, "case"} << ", " << amount{results_.total, "test"} << " total, " << amount{results_.failed, "failure"} << std::endl; } template<class _> std::string reporter<_>::fmtdur(typename clock_type::duration const& d) { using namespace std::chrono; auto const ms = duration_cast<milliseconds>(d); if(ms < seconds{1}) return std::to_string(ms.count()) + "ms"; std::stringstream ss; ss << std::fixed << std::setprecision(1) << (ms.count()/1000.) << "s"; return ss.str(); } template<class _> void reporter<_>:: on_suite_begin(suite_info const& info) { suite_results_ = suite_results{info.full_name()}; } template<class _> void reporter<_>::on_suite_end() { results_.add(suite_results_); } template<class _> void reporter<_>:: on_case_begin(std::string const& name) { case_results_ = case_results(name); os_ << suite_results_.name << (case_results_.name.empty() ? "" : (" " + case_results_.name)) << std::endl; } template<class _> void reporter<_>:: on_case_end() { suite_results_.add(case_results_); } template<class _> void reporter<_>:: on_pass() { ++case_results_.total; } template<class _> void reporter<_>:: on_fail(std::string const& reason) { ++case_results_.failed; ++case_results_.total; os_ << "#" << case_results_.total << " failed" << (reason.empty() ? "" : ": ") << reason << std::endl; } template<class _> void reporter<_>:: on_log(std::string const& s) { os_ << s; } } // detail using reporter = detail::reporter<>; } // unit_test } // beast } // boost #endif PK OP�[�a�"� � _experimental/unit_test/main.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #include <boost/beast/_experimental/unit_test/amount.hpp> #include <boost/beast/_experimental/unit_test/dstream.hpp> #include <boost/beast/_experimental/unit_test/global_suites.hpp> #include <boost/beast/_experimental/unit_test/match.hpp> #include <boost/beast/_experimental/unit_test/reporter.hpp> #include <boost/beast/_experimental/unit_test/suite.hpp> #include <boost/config.hpp> #include <cstdlib> #include <iostream> #include <vector> #ifdef BOOST_MSVC # ifndef WIN32_LEAN_AND_MEAN // VC_EXTRALEAN # define WIN32_LEAN_AND_MEAN # include <windows.h> # undef WIN32_LEAN_AND_MEAN # else # include <windows.h> # endif #endif // Simple main used to produce stand // alone executables that run unit tests. int main(int ac, char const* av[]) { using namespace std; using namespace boost::beast::unit_test; dstream log(std::cerr); std::unitbuf(log); #ifdef BOOST_MSVC { int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG); flags |= _CRTDBG_LEAK_CHECK_DF; _CrtSetDbgFlag(flags); } #endif if(ac == 2) { std::string const s{av[1]}; if(s == "-h" || s == "--help") { log << "Usage:\n" " " << av[0] << ": { <suite-name>... }" << std::endl; return EXIT_SUCCESS; } } reporter r(log); bool failed; if(ac > 1) { std::vector<selector> v; v.reserve(ac - 1); for(int i = 1; i < ac; ++i) v.emplace_back(selector::automatch, av[i]); auto pred = [&v](suite_info const& si) mutable { for(auto& p : v) if(p(si)) return true; return false; }; failed = r.run_each_if(global_suites(), pred); } else { failed = r.run_each(global_suites()); } if(failed) return EXIT_FAILURE; return EXIT_SUCCESS; } PK OP�[Τ�v� � $ _experimental/unit_test/recorder.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_UNIT_TEST_RECORDER_HPP #define BOOST_BEAST_UNIT_TEST_RECORDER_HPP #include <boost/beast/_experimental/unit_test/results.hpp> #include <boost/beast/_experimental/unit_test/runner.hpp> namespace boost { namespace beast { namespace unit_test { /** A test runner that stores the results. */ class recorder : public runner { results m_results; suite_results m_suite; case_results m_case; public: recorder() = default; /** Returns a report with the results of all completed suites. */ results const& report() const { return m_results; } private: virtual void on_suite_begin(suite_info const& info) override { m_suite = suite_results(info.full_name()); } virtual void on_suite_end() override { m_results.insert(std::move(m_suite)); } virtual void on_case_begin(std::string const& name) override { m_case = case_results(name); } virtual void on_case_end() override { if(m_case.tests.size() > 0) m_suite.insert(std::move(m_case)); } virtual void on_pass() override { m_case.tests.pass(); } virtual void on_fail(std::string const& reason) override { m_case.tests.fail(reason); } virtual void on_log(std::string const& s) override { m_case.log.insert(s); } }; } // unit_test } // beast } // boost #endif PK OP�[�(�4 4 ! _experimental/test/impl/error.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_IMPL_ERROR_IPP #define BOOST_BEAST_TEST_IMPL_ERROR_IPP #include <boost/beast/_experimental/test/error.hpp> namespace boost { namespace beast { namespace test { namespace detail { class error_codes : public error_category { public: BOOST_BEAST_DECL const char* name() const noexcept override { return "boost.beast.test"; } BOOST_BEAST_DECL std::string message(int ev) const override { switch(static_cast<error>(ev)) { default: case error::test_failure: return "An automatic unit test failure occurred"; } } BOOST_BEAST_DECL error_condition default_error_condition(int ev) const noexcept override { return error_condition{ev, *this}; } }; } // detail error_code make_error_code(error e) noexcept { static detail::error_codes const cat{}; return error_code{static_cast< std::underlying_type<error>::type>(e), cat}; } } // test } // beast } // boost #endif PK OP�[N]�3 �3 " _experimental/test/impl/stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_IMPL_STREAM_HPP #define BOOST_BEAST_TEST_IMPL_STREAM_HPP #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/service_base.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/any_io_executor.hpp> #include <boost/asio/dispatch.hpp> #include <boost/asio/post.hpp> #include <mutex> #include <stdexcept> #include <vector> namespace boost { namespace beast { namespace test { //------------------------------------------------------------------------------ struct stream::service_impl { std::mutex m_; std::vector<state*> v_; BOOST_BEAST_DECL void remove(state& impl); }; class stream::service : public beast::detail::service_base<service> { boost::shared_ptr<service_impl> sp_; BOOST_BEAST_DECL void shutdown() override; public: BOOST_BEAST_DECL explicit service(net::execution_context& ctx); BOOST_BEAST_DECL static auto make_impl( net::io_context& ctx, test::fail_count* fc) -> boost::shared_ptr<state>; }; //------------------------------------------------------------------------------ template<class Handler, class Buffers> class stream::read_op : public stream::read_op_base { using ex1_type = net::io_context::executor_type; using ex2_type = net::associated_executor_t<Handler, ex1_type>; struct lambda { Handler h_; boost::weak_ptr<state> wp_; Buffers b_; #if defined(BOOST_ASIO_NO_TS_EXECUTORS) net::any_io_executor wg2_; #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) net::executor_work_guard<ex2_type> wg2_; #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) lambda(lambda&&) = default; lambda(lambda const&) = default; template<class Handler_> lambda( Handler_&& h, boost::shared_ptr<state> const& s, Buffers const& b) : h_(std::forward<Handler_>(h)) , wp_(s) , b_(b) #if defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg2_(net::prefer( net::get_associated_executor( h_, s->ioc.get_executor()), net::execution::outstanding_work.tracked)) #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg2_(net::get_associated_executor( h_, s->ioc.get_executor())) #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) { } using allocator_type = net::associated_allocator_t<Handler>; allocator_type get_allocator() const noexcept { return net::get_associated_allocator(h_); } void operator()(error_code ec) { std::size_t bytes_transferred = 0; auto sp = wp_.lock(); if(! sp) ec = net::error::operation_aborted; if(! ec) { std::lock_guard<std::mutex> lock(sp->m); BOOST_ASSERT(! sp->op); if(sp->b.size() > 0) { bytes_transferred = net::buffer_copy( b_, sp->b.data(), sp->read_max); sp->b.consume(bytes_transferred); sp->nread_bytes += bytes_transferred; } else if (buffer_bytes(b_) > 0) { ec = net::error::eof; } } #if defined(BOOST_ASIO_NO_TS_EXECUTORS) net::dispatch(wg2_, beast::bind_front_handler(std::move(h_), ec, bytes_transferred)); wg2_ = net::any_io_executor(); // probably unnecessary #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) net::dispatch(wg2_.get_executor(), beast::bind_front_handler(std::move(h_), ec, bytes_transferred)); wg2_.reset(); #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) } }; lambda fn_; #if defined(BOOST_ASIO_NO_TS_EXECUTORS) net::any_io_executor wg1_; #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) net::executor_work_guard<ex1_type> wg1_; #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) public: template<class Handler_> read_op( Handler_&& h, boost::shared_ptr<state> const& s, Buffers const& b) : fn_(std::forward<Handler_>(h), s, b) #if defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg1_(net::prefer(s->ioc.get_executor(), net::execution::outstanding_work.tracked)) #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg1_(s->ioc.get_executor()) #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) { } void operator()(error_code ec) override { #if defined(BOOST_ASIO_NO_TS_EXECUTORS) net::post(wg1_, beast::bind_front_handler(std::move(fn_), ec)); wg1_ = net::any_io_executor(); // probably unnecessary #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) net::post(wg1_.get_executor(), beast::bind_front_handler(std::move(fn_), ec)); wg1_.reset(); #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) } }; struct stream::run_read_op { template< class ReadHandler, class MutableBufferSequence> void operator()( ReadHandler&& h, boost::shared_ptr<state> const& in, MutableBufferSequence const& buffers) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); initiate_read( in, std::unique_ptr<read_op_base>{ new read_op< typename std::decay<ReadHandler>::type, MutableBufferSequence>( std::move(h), in, buffers)}, buffer_bytes(buffers)); } }; struct stream::run_write_op { template< class WriteHandler, class ConstBufferSequence> void operator()( WriteHandler&& h, boost::shared_ptr<state> in_, boost::weak_ptr<state> out_, ConstBufferSequence const& buffers) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); ++in_->nwrite; auto const upcall = [&](error_code ec, std::size_t n) { net::post( in_->ioc.get_executor(), beast::bind_front_handler(std::move(h), ec, n)); }; // test failure error_code ec; std::size_t n = 0; if(in_->fc && in_->fc->fail(ec)) return upcall(ec, n); // A request to write 0 bytes to a stream is a no-op. if(buffer_bytes(buffers) == 0) return upcall(ec, n); // connection closed auto out = out_.lock(); if(! out) return upcall(net::error::connection_reset, n); // copy buffers n = std::min<std::size_t>( buffer_bytes(buffers), in_->write_max); { std::lock_guard<std::mutex> lock(out->m); n = net::buffer_copy(out->b.prepare(n), buffers); out->b.commit(n); out->nwrite_bytes += n; out->notify_read(); } BOOST_ASSERT(! ec); upcall(ec, n); } }; //------------------------------------------------------------------------------ template<class MutableBufferSequence> std::size_t stream:: read_some(MutableBufferSequence const& buffers) { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); error_code ec; auto const n = read_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return n; } template<class MutableBufferSequence> std::size_t stream:: read_some(MutableBufferSequence const& buffers, error_code& ec) { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); ++in_->nread; // test failure if(in_->fc && in_->fc->fail(ec)) return 0; // A request to read 0 bytes from a stream is a no-op. if(buffer_bytes(buffers) == 0) { ec = {}; return 0; } std::unique_lock<std::mutex> lock{in_->m}; BOOST_ASSERT(! in_->op); in_->cv.wait(lock, [&]() { return in_->b.size() > 0 || in_->code != status::ok; }); // deliver bytes before eof if(in_->b.size() > 0) { auto const n = net::buffer_copy( buffers, in_->b.data(), in_->read_max); in_->b.consume(n); in_->nread_bytes += n; return n; } // deliver error BOOST_ASSERT(in_->code != status::ok); ec = net::error::eof; return 0; } template<class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) stream:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( run_read_op{}, handler, in_, buffers); } template<class ConstBufferSequence> std::size_t stream:: write_some(ConstBufferSequence const& buffers) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); error_code ec; auto const bytes_transferred = write_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template<class ConstBufferSequence> std::size_t stream:: write_some( ConstBufferSequence const& buffers, error_code& ec) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); ++in_->nwrite; // test failure if(in_->fc && in_->fc->fail(ec)) return 0; // A request to write 0 bytes to a stream is a no-op. if(buffer_bytes(buffers) == 0) { ec = {}; return 0; } // connection closed auto out = out_.lock(); if(! out) { ec = net::error::connection_reset; return 0; } // copy buffers auto n = std::min<std::size_t>( buffer_bytes(buffers), in_->write_max); { std::lock_guard<std::mutex> lock(out->m); n = net::buffer_copy(out->b.prepare(n), buffers); out->b.commit(n); out->nwrite_bytes += n; out->notify_read(); } return n; } template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) stream:: async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( run_write_op{}, handler, in_, out_, buffers); } //------------------------------------------------------------------------------ template<class TeardownHandler> void async_teardown( role_type, stream& s, TeardownHandler&& handler) { error_code ec; if( s.in_->fc && s.in_->fc->fail(ec)) return net::post( s.get_executor(), beast::bind_front_handler( std::move(handler), ec)); s.close(); if( s.in_->fc && s.in_->fc->fail(ec)) ec = net::error::eof; else ec = {}; net::post( s.get_executor(), beast::bind_front_handler( std::move(handler), ec)); } //------------------------------------------------------------------------------ template<class Arg1, class... ArgN> stream connect(stream& to, Arg1&& arg1, ArgN&&... argn) { stream from{ std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...}; from.connect(to); return from; } } // test } // beast } // boost #endif PK OP�[�ޒ� � & _experimental/test/impl/fail_count.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_IMPL_FAIL_COUNT_IPP #define BOOST_BEAST_TEST_IMPL_FAIL_COUNT_IPP #include <boost/beast/_experimental/test/fail_count.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { namespace test { fail_count:: fail_count( std::size_t n, error_code ev) : n_(n) , ec_(ev) { } void fail_count:: fail() { if(i_ < n_) ++i_; if(i_ == n_) BOOST_THROW_EXCEPTION(system_error{ec_}); } bool fail_count:: fail(error_code& ec) { if(i_ < n_) ++i_; if(i_ == n_) { ec = ec_; return true; } ec = {}; return false; } } // test } // beast } // boost #endif PK OP�[oz�� ! _experimental/test/impl/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_IMPL_ERROR_HPP #define BOOST_BEAST_TEST_IMPL_ERROR_HPP #include <boost/beast/core/error.hpp> #include <boost/beast/core/string.hpp> #include <type_traits> namespace boost { namespace system { template<> struct is_error_code_enum< boost::beast::test::error> : std::true_type { }; } // system } // boost namespace boost { namespace beast { namespace test { BOOST_BEAST_DECL error_code make_error_code(error e) noexcept; } // test } // beast } // boost #endif PK OP�[�ac�� � " _experimental/test/impl/stream.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_IMPL_STREAM_IPP #define BOOST_BEAST_TEST_IMPL_STREAM_IPP #include <boost/beast/_experimental/test/stream.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/make_shared.hpp> #include <stdexcept> #include <vector> namespace boost { namespace beast { namespace test { //------------------------------------------------------------------------------ stream:: service:: service(net::execution_context& ctx) : beast::detail::service_base<service>(ctx) , sp_(boost::make_shared<service_impl>()) { } void stream:: service:: shutdown() { std::vector<std::unique_ptr<read_op_base>> v; std::lock_guard<std::mutex> g1(sp_->m_); v.reserve(sp_->v_.size()); for(auto p : sp_->v_) { std::lock_guard<std::mutex> g2(p->m); v.emplace_back(std::move(p->op)); p->code = status::eof; } } auto stream:: service:: make_impl( net::io_context& ctx, test::fail_count* fc) -> boost::shared_ptr<state> { auto& svc = net::use_service<service>(ctx); auto sp = boost::make_shared<state>(ctx, svc.sp_, fc); std::lock_guard<std::mutex> g(svc.sp_->m_); svc.sp_->v_.push_back(sp.get()); return sp; } void stream:: service_impl:: remove(state& impl) { std::lock_guard<std::mutex> g(m_); *std::find( v_.begin(), v_.end(), &impl) = std::move(v_.back()); v_.pop_back(); } //------------------------------------------------------------------------------ void stream::initiate_read( boost::shared_ptr<state> const& in_, std::unique_ptr<stream::read_op_base>&& op, std::size_t buf_size) { std::unique_lock<std::mutex> lock(in_->m); ++in_->nread; if(in_->op != nullptr) BOOST_THROW_EXCEPTION( std::logic_error{"in_->op != nullptr"}); // test failure error_code ec; if(in_->fc && in_->fc->fail(ec)) { lock.unlock(); (*op)(ec); return; } // A request to read 0 bytes from a stream is a no-op. if(buf_size == 0 || buffer_bytes(in_->b.data()) > 0) { lock.unlock(); (*op)(ec); return; } // deliver error if(in_->code != status::ok) { lock.unlock(); (*op)(net::error::eof); return; } // complete when bytes available or closed in_->op = std::move(op); } stream:: state:: state( net::io_context& ioc_, boost::weak_ptr<service_impl> wp_, fail_count* fc_) : ioc(ioc_) , wp(std::move(wp_)) , fc(fc_) { } stream:: state:: ~state() { // cancel outstanding read if(op != nullptr) (*op)(net::error::operation_aborted); } void stream:: state:: remove() noexcept { auto sp = wp.lock(); // If this goes off, it means the lifetime of a test::stream object // extended beyond the lifetime of the associated execution context. BOOST_ASSERT(sp); sp->remove(*this); } void stream:: state:: notify_read() { if(op) { auto op_ = std::move(op); op_->operator()(error_code{}); } else { cv.notify_all(); } } void stream:: state:: cancel_read() { std::unique_ptr<read_op_base> p; { std::lock_guard<std::mutex> lock(m); code = status::eof; p = std::move(op); } if(p != nullptr) (*p)(net::error::operation_aborted); } //------------------------------------------------------------------------------ stream:: ~stream() { close(); in_->remove(); } stream:: stream(stream&& other) { auto in = service::make_impl( other.in_->ioc, other.in_->fc); in_ = std::move(other.in_); out_ = std::move(other.out_); other.in_ = in; } stream& stream:: operator=(stream&& other) { close(); auto in = service::make_impl( other.in_->ioc, other.in_->fc); in_->remove(); in_ = std::move(other.in_); out_ = std::move(other.out_); other.in_ = in; return *this; } //------------------------------------------------------------------------------ stream:: stream(net::io_context& ioc) : in_(service::make_impl(ioc, nullptr)) { } stream:: stream( net::io_context& ioc, fail_count& fc) : in_(service::make_impl(ioc, &fc)) { } stream:: stream( net::io_context& ioc, string_view s) : in_(service::make_impl(ioc, nullptr)) { in_->b.commit(net::buffer_copy( in_->b.prepare(s.size()), net::buffer(s.data(), s.size()))); } stream:: stream( net::io_context& ioc, fail_count& fc, string_view s) : in_(service::make_impl(ioc, &fc)) { in_->b.commit(net::buffer_copy( in_->b.prepare(s.size()), net::buffer(s.data(), s.size()))); } void stream:: connect(stream& remote) { BOOST_ASSERT(! out_.lock()); BOOST_ASSERT(! remote.out_.lock()); std::lock(in_->m, remote.in_->m); std::lock_guard<std::mutex> guard1{in_->m, std::adopt_lock}; std::lock_guard<std::mutex> guard2{remote.in_->m, std::adopt_lock}; out_ = remote.in_; remote.out_ = in_; in_->code = status::ok; remote.in_->code = status::ok; } string_view stream:: str() const { auto const bs = in_->b.data(); if(buffer_bytes(bs) == 0) return {}; net::const_buffer const b = *net::buffer_sequence_begin(bs); return {static_cast<char const*>(b.data()), b.size()}; } void stream:: append(string_view s) { std::lock_guard<std::mutex> lock{in_->m}; in_->b.commit(net::buffer_copy( in_->b.prepare(s.size()), net::buffer(s.data(), s.size()))); } void stream:: clear() { std::lock_guard<std::mutex> lock{in_->m}; in_->b.consume(in_->b.size()); } void stream:: close() { in_->cancel_read(); // disconnect { auto out = out_.lock(); out_.reset(); // notify peer if(out) { std::lock_guard<std::mutex> lock(out->m); if(out->code == status::ok) { out->code = status::eof; out->notify_read(); } } } } void stream:: close_remote() { std::lock_guard<std::mutex> lock{in_->m}; if(in_->code == status::ok) { in_->code = status::eof; in_->notify_read(); } } void teardown( role_type, stream& s, boost::system::error_code& ec) { if( s.in_->fc && s.in_->fc->fail(ec)) return; s.close(); if( s.in_->fc && s.in_->fc->fail(ec)) ec = net::error::eof; else ec = {}; } //------------------------------------------------------------------------------ stream connect(stream& to) { #if defined(BOOST_ASIO_NO_TS_EXECUTORS) stream from{net::query(to.get_executor(), net::execution::context)}; #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) stream from{to.get_executor().context()}; #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) from.connect(to); return from; } void connect(stream& s1, stream& s2) { s1.connect(s2); } } // test } // beast } // boost #endif PK OP�[��� � _experimental/test/handler.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_HANDLER_HPP #define BOOST_BEAST_TEST_HANDLER_HPP #include <boost/beast/_experimental/unit_test/suite.hpp> #include <boost/beast/core/error.hpp> #include <boost/asio/io_context.hpp> #include <boost/core/exchange.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace test { /** A CompletionHandler used for testing. This completion handler is used by tests to ensure correctness of behavior. It is designed as a single type to reduce template instantiations, with configurable settings through constructor arguments. Typically this type will be used in type lists and not instantiated directly; instances of this class are returned by the helper functions listed below. @see success_handler, @ref fail_handler, @ref any_handler */ class handler { boost::optional<error_code> ec_; bool pass_ = false; public: handler() = default; explicit handler(error_code ec) : ec_(ec) { } explicit handler(boost::none_t) { } handler(handler&& other) : ec_(other.ec_) , pass_(boost::exchange(other.pass_, true)) { } ~handler() { BEAST_EXPECT(pass_); } template<class... Args> void operator()(error_code ec, Args&&...) { BEAST_EXPECT(! pass_); // can't call twice BEAST_EXPECTS(! ec_ || ec == *ec_, ec.message()); pass_ = true; } void operator()() { BEAST_EXPECT(! pass_); // can't call twice BEAST_EXPECT(! ec_); pass_ = true; } template<class Arg0, class... Args, class = typename std::enable_if< ! std::is_convertible<Arg0, error_code>::value>::type> void operator()(Arg0&&, Args&&...) { BEAST_EXPECT(! pass_); // can't call twice BEAST_EXPECT(! ec_); pass_ = true; } }; /** Return a test CompletionHandler which requires success. The returned handler can be invoked with any signature whose first parameter is an `error_code`. The handler fails the test if: @li The handler is destroyed without being invoked, or @li The handler is invoked with a non-successful error code. */ inline handler success_handler() noexcept { return handler(error_code{}); } /** Return a test CompletionHandler which requires invocation. The returned handler can be invoked with any signature. The handler fails the test if: @li The handler is destroyed without being invoked. */ inline handler any_handler() noexcept { return handler(boost::none); } /** Return a test CompletionHandler which requires a specific error code. This handler can be invoked with any signature whose first parameter is an `error_code`. The handler fails the test if: @li The handler is destroyed without being invoked. @li The handler is invoked with an error code different from what is specified. @param ec The error code to specify. */ inline handler fail_handler(error_code ec) noexcept { return handler(ec); } /** Run an I/O context. This function runs and dispatches handlers on the specified I/O context, until one of the following conditions is true: @li The I/O context runs out of work. @param ioc The I/O context to run */ inline void run(net::io_context& ioc) { ioc.run(); ioc.restart(); } /** Run an I/O context for a certain amount of time. This function runs and dispatches handlers on the specified I/O context, until one of the following conditions is true: @li The I/O context runs out of work. @li No completions occur and the specified amount of time has elapsed. @param ioc The I/O context to run @param elapsed The maximum amount of time to run for. */ template<class Rep, class Period> void run_for( net::io_context& ioc, std::chrono::duration<Rep, Period> elapsed) { ioc.run_for(elapsed); ioc.restart(); } } // test } // beast } // boost #endif PK OP�[�k��{H {H _experimental/test/stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_STREAM_HPP #define BOOST_BEAST_TEST_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/flat_buffer.hpp> #include <boost/beast/core/role.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/_experimental/test/fail_count.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/error.hpp> #include <boost/asio/executor_work_guard.hpp> #include <boost/asio/io_context.hpp> #include <boost/asio/post.hpp> #include <boost/assert.hpp> #include <boost/shared_ptr.hpp> #include <boost/weak_ptr.hpp> #include <boost/throw_exception.hpp> #include <condition_variable> #include <limits> #include <memory> #include <mutex> #include <utility> #if ! BOOST_BEAST_DOXYGEN namespace boost { namespace asio { namespace ssl { template<typename> class stream; } // ssl } // asio } // boost #endif namespace boost { namespace beast { namespace test { /** A two-way socket useful for unit testing An instance of this class simulates a traditional socket, while also providing features useful for unit testing. Each endpoint maintains an independent buffer called the input area. Writes from one endpoint append data to the peer's pending input area. When an endpoint performs a read and data is present in the input area, the data is delivered to the blocking or asynchronous operation. Otherwise the operation is blocked or deferred until data is made available, or until the endpoints become disconnected. These streams may be used anywhere an algorithm accepts a reference to a synchronous or asynchronous read or write stream. It is possible to use a test stream in a call to `net::read_until`, or in a call to @ref boost::beast::http::async_write for example. As with Boost.Asio I/O objects, a @ref stream constructs with a reference to the `net::io_context` to use for handling asynchronous I/O. For asynchronous operations, the stream follows the same rules as a traditional asio socket with respect to how completion handlers for asynchronous operations are performed. To facilitate testing, these streams support some additional features: @li The input area, represented by a @ref beast::basic_flat_buffer, may be directly accessed by the caller to inspect the contents before or after the remote endpoint writes data. This allows a unit test to verify that the received data matches. @li Data may be manually appended to the input area. This data will delivered in the next call to @ref stream::read_some or @ref stream::async_read_some. This allows predefined test vectors to be set up for testing read algorithms. @li The stream may be constructed with a fail count. The stream will eventually fail with a predefined error after a certain number of operations, where the number of operations is controlled by the test. When a test loops over a range of operation counts, it is possible to exercise every possible point of failure in the algorithm being tested. When used correctly the technique allows the tests to reach a high percentage of code coverage. @par Thread Safety @e Distinct @e objects: Safe.@n @e Shared @e objects: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand. @par Concepts @li <em>SyncReadStream</em> @li <em>SyncWriteStream</em> @li <em>AsyncReadStream</em> @li <em>AsyncWriteStream</em> */ class stream { struct state; boost::shared_ptr<state> in_; boost::weak_ptr<state> out_; enum class status { ok, eof, }; class service; struct service_impl; struct read_op_base { virtual ~read_op_base() = default; virtual void operator()(error_code ec) = 0; }; struct state { friend class stream; net::io_context& ioc; boost::weak_ptr<service_impl> wp; std::mutex m; flat_buffer b; std::condition_variable cv; std::unique_ptr<read_op_base> op; status code = status::ok; fail_count* fc = nullptr; std::size_t nread = 0; std::size_t nread_bytes = 0; std::size_t nwrite = 0; std::size_t nwrite_bytes = 0; std::size_t read_max = (std::numeric_limits<std::size_t>::max)(); std::size_t write_max = (std::numeric_limits<std::size_t>::max)(); BOOST_BEAST_DECL state( net::io_context& ioc_, boost::weak_ptr<service_impl> wp_, fail_count* fc_); BOOST_BEAST_DECL ~state(); BOOST_BEAST_DECL void remove() noexcept; BOOST_BEAST_DECL void notify_read(); BOOST_BEAST_DECL void cancel_read(); }; template<class Handler, class Buffers> class read_op; struct run_read_op; struct run_write_op; BOOST_BEAST_DECL static void initiate_read( boost::shared_ptr<state> const& in, std::unique_ptr<read_op_base>&& op, std::size_t buf_size); #if ! BOOST_BEAST_DOXYGEN // boost::asio::ssl::stream needs these // DEPRECATED template<class> friend class boost::asio::ssl::stream; // DEPRECATED using lowest_layer_type = stream; // DEPRECATED lowest_layer_type& lowest_layer() noexcept { return *this; } // DEPRECATED lowest_layer_type const& lowest_layer() const noexcept { return *this; } #endif public: using buffer_type = flat_buffer; /** Destructor If an asynchronous read operation is pending, it will simply be discarded with no notification to the completion handler. If a connection is established while the stream is destroyed, the peer will see the error `net::error::connection_reset` when performing any reads or writes. */ BOOST_BEAST_DECL ~stream(); /** Move Constructor Moving the stream while asynchronous operations are pending results in undefined behavior. */ BOOST_BEAST_DECL stream(stream&& other); /** Move Assignment Moving the stream while asynchronous operations are pending results in undefined behavior. */ BOOST_BEAST_DECL stream& operator=(stream&& other); /** Construct a stream The stream will be created in a disconnected state. @param ioc The `io_context` object that the stream will use to dispatch handlers for any asynchronous operations. */ BOOST_BEAST_DECL explicit stream(net::io_context& ioc); /** Construct a stream The stream will be created in a disconnected state. @param ioc The `io_context` object that the stream will use to dispatch handlers for any asynchronous operations. @param fc The @ref fail_count to associate with the stream. Each I/O operation performed on the stream will increment the fail count. When the fail count reaches its internal limit, a simulated failure error will be raised. */ BOOST_BEAST_DECL stream( net::io_context& ioc, fail_count& fc); /** Construct a stream The stream will be created in a disconnected state. @param ioc The `io_context` object that the stream will use to dispatch handlers for any asynchronous operations. @param s A string which will be appended to the input area, not including the null terminator. */ BOOST_BEAST_DECL stream( net::io_context& ioc, string_view s); /** Construct a stream The stream will be created in a disconnected state. @param ioc The `io_context` object that the stream will use to dispatch handlers for any asynchronous operations. @param fc The @ref fail_count to associate with the stream. Each I/O operation performed on the stream will increment the fail count. When the fail count reaches its internal limit, a simulated failure error will be raised. @param s A string which will be appended to the input area, not including the null terminator. */ BOOST_BEAST_DECL stream( net::io_context& ioc, fail_count& fc, string_view s); /// Establish a connection BOOST_BEAST_DECL void connect(stream& remote); /// The type of the executor associated with the object. using executor_type = net::io_context::executor_type; /// Return the executor associated with the object. executor_type get_executor() noexcept { return in_->ioc.get_executor(); }; /// Set the maximum number of bytes returned by read_some void read_size(std::size_t n) noexcept { in_->read_max = n; } /// Set the maximum number of bytes returned by write_some void write_size(std::size_t n) noexcept { in_->write_max = n; } /// Direct input buffer access buffer_type& buffer() noexcept { return in_->b; } /// Returns a string view representing the pending input data BOOST_BEAST_DECL string_view str() const; /// Appends a string to the pending input data BOOST_BEAST_DECL void append(string_view s); /// Clear the pending input area BOOST_BEAST_DECL void clear(); /// Return the number of reads std::size_t nread() const noexcept { return in_->nread; } /// Return the number of bytes read std::size_t nread_bytes() const noexcept { return in_->nread_bytes; } /// Return the number of writes std::size_t nwrite() const noexcept { return in_->nwrite; } /// Return the number of bytes written std::size_t nwrite_bytes() const noexcept { return in_->nwrite_bytes; } /** Close the stream. The other end of the connection will see `error::eof` after reading all the remaining data. */ BOOST_BEAST_DECL void close(); /** Close the other end of the stream. This end of the connection will see `error::eof` after reading all the remaining data. */ BOOST_BEAST_DECL void close_remote(); /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @returns The number of bytes read. @throws boost::system::system_error Thrown on failure. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers); /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @param ec Set to indicate what error occurred, if any. @returns The number of bytes read. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers, error_code& ec); /** Start an asynchronous read. This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately. @param buffers The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation. std::size_t bytes_transferred // Number of bytes read. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_read_some` operation may not read all of the requested number of bytes. Consider using the function `net::async_read` if you need to ensure that the requested amount of data is read before the asynchronous operation completes. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @returns The number of bytes written. @throws boost::system::system_error Thrown on failure. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @param ec Set to indicate what error occurred, if any. @returns The number of bytes written. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some( ConstBufferSequence const& buffers, error_code& ec); /** Start an asynchronous write. This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately. @param buffers The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation. std::size_t bytes_transferred // Number of bytes written. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_write_some` operation may not transmit all of the data to the peer. Consider using the function `net::async_write` if you need to ensure that all data is written before the asynchronous operation completes. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler); #if ! BOOST_BEAST_DOXYGEN friend BOOST_BEAST_DECL void teardown( role_type, stream& s, boost::system::error_code& ec); template<class TeardownHandler> friend BOOST_BEAST_DECL void async_teardown( role_type role, stream& s, TeardownHandler&& handler); #endif }; #if ! BOOST_BEAST_DOXYGEN inline void beast_close_socket(stream& s) { s.close(); } #endif #if BOOST_BEAST_DOXYGEN /** Return a new stream connected to the given stream @param to The stream to connect to. @param args Optional arguments forwarded to the new stream's constructor. @return The new, connected stream. */ template<class... Args> stream connect(stream& to, Args&&... args); #else BOOST_BEAST_DECL stream connect(stream& to); BOOST_BEAST_DECL void connect(stream& s1, stream& s2); template<class Arg1, class... ArgN> stream connect(stream& to, Arg1&& arg1, ArgN&&... argn); #endif } // test } // beast } // boost #include <boost/beast/_experimental/test/impl/stream.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/_experimental/test/impl/stream.ipp> #endif #endif PK OP�[���uj j _experimental/test/tcp.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_TCP_HPP #define BOOST_BEAST_TEST_TCP_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/get_io_context.hpp> #include <boost/beast/_experimental/unit_test/suite.hpp> #include <boost/beast/_experimental/test/handler.hpp> #include <boost/asio/ip/tcp.hpp> #include <chrono> namespace boost { namespace beast { namespace test { /** Connect two TCP sockets together. */ template<class Executor> bool connect( net::basic_stream_socket<net::ip::tcp, Executor>& s1, net::basic_stream_socket<net::ip::tcp, Executor>& s2) { auto ioc1 = beast::detail::get_io_context(s1); auto ioc2 = beast::detail::get_io_context(s2); if(! BEAST_EXPECT(ioc1 != nullptr)) return false; if(! BEAST_EXPECT(ioc2 != nullptr)) return false; if(! BEAST_EXPECT(ioc1 == ioc2)) return false; auto& ioc = *ioc1; try { net::basic_socket_acceptor< net::ip::tcp, Executor> a(s1.get_executor()); auto ep = net::ip::tcp::endpoint( net::ip::make_address_v4("127.0.0.1"), 0); a.open(ep.protocol()); a.set_option( net::socket_base::reuse_address(true)); a.bind(ep); a.listen(0); ep = a.local_endpoint(); a.async_accept(s2, test::success_handler()); s1.async_connect(ep, test::success_handler()); run(ioc); if(! BEAST_EXPECT( s1.remote_endpoint() == s2.local_endpoint())) return false; if(! BEAST_EXPECT( s2.remote_endpoint() == s1.local_endpoint())) return false; } catch(std::exception const& e) { beast::unit_test::suite::this_suite()->fail( e.what(), __FILE__, __LINE__); return false; } return true; } } // test } // beast } // boost #endif PK OP�[�ȧ�� � _experimental/test/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_ERROR_HPP #define BOOST_BEAST_TEST_ERROR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> namespace boost { namespace beast { namespace test { /// Error codes returned from unit testing algorithms enum class error { /** The test stream generated a simulated testing error This error is returned by a @ref fail_count object when it generates a simulated error. */ test_failure = 1 }; } // test } // beast } // boost #include <boost/beast/_experimental/test/impl/error.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/_experimental/test/impl/error.ipp> #endif #endif PK OP�[e �� � ! _experimental/test/fail_count.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_TEST_FAIL_COUNT_HPP #define BOOST_BEAST_TEST_FAIL_COUNT_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/_experimental/test/error.hpp> #include <cstdlib> namespace boost { namespace beast { namespace test { /** A countdown to simulated failure On the Nth operation, the class will fail with the specified error code, or the default error code of @ref error::test_failure. Instances of this class may be used to build objects which are specifically designed to aid in writing unit tests, for interfaces which can throw exceptions or return `error_code` values representing failure. */ class fail_count { std::size_t n_; std::size_t i_ = 0; error_code ec_; public: fail_count(fail_count&&) = default; /** Construct a counter @param n The 0-based index of the operation to fail on or after @param ev An optional error code to use when generating a simulated failure */ BOOST_BEAST_DECL explicit fail_count( std::size_t n, error_code ev = error::test_failure); /// Throw an exception on the Nth failure BOOST_BEAST_DECL void fail(); /// Set an error code on the Nth failure BOOST_BEAST_DECL bool fail(error_code& ec); }; } // test } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/_experimental/test/impl/fail_count.ipp> #endif #endif PK OP�[��+ �+ ! _experimental/http/icy_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_ICY_STREAM_HPP #define BOOST_BEAST_HTTP_ICY_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/buffer.hpp> #include <boost/logic/tribool.hpp> #include <type_traits> namespace boost { namespace beast { namespace http { /** Stream wrapper to process Shoutcast HTTP responses This wrapper replaces the word "ICY" in the first HTTP response received on the connection, with "HTTP/1.1". This allows the Beast parser to be used with Shoutcast servers, which send a non-standard HTTP message as the response. For asynchronous operations, the application must ensure that they are are all performed within the same implicit or explicit strand. @par Thread Safety @e Distinct @e objects: Safe.@n @e Shared @e objects: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand. @par Example To use the @ref icy_stream template with an @ref tcp_stream you would write: @code http::icy_stream<tcp_stream> is(ioc); @endcode @tparam NextLayer The type representing the next layer, to which data will be read and written during operations. For synchronous operations, the type must support the <em>SyncStream</em> concept. For asynchronous operations, the type must support the <em>AsyncStream</em> concept. @note A stream object must not be moved or destroyed while there are pending asynchronous operations associated with it. @par Concepts <em>AsyncStream</em>, <em>SyncStream</em> */ template<class NextLayer> class icy_stream { NextLayer stream_; char buf_[8]; unsigned char n_ = 0; bool detect_ = true; struct ops; static net::const_buffer version() { return {"HTTP/1.1", 8}; } public: /// The type of the next layer. using next_layer_type = typename std::remove_reference<NextLayer>::type; /// The type of the executor associated with the object. using executor_type = typename next_layer_type::executor_type; icy_stream(icy_stream&&) = default; icy_stream(icy_stream const&) = default; icy_stream& operator=(icy_stream&&) = default; icy_stream& operator=(icy_stream const&) = default; /** Destructor The treatment of pending operations will be the same as that of the next layer. */ ~icy_stream() = default; /** Constructor Arguments, if any, are forwarded to the next layer's constructor. */ template<class... Args> explicit icy_stream(Args&&... args); //-------------------------------------------------------------------------- /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept { return stream_.get_executor(); } /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type& next_layer() { return stream_; } /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type const& next_layer() const { return stream_; } //-------------------------------------------------------------------------- /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @returns The number of bytes read. @throws system_error Thrown on failure. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers); /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @param ec Set to indicate what error occurred, if any. @returns The number of bytes read. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some( MutableBufferSequence const& buffers, error_code& ec); /** Start an asynchronous read. This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately. @param buffers The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_read_some` operation may not read all of the requested number of bytes. Consider using the function `net::async_read` if you need to ensure that the requested amount of data is read before the asynchronous operation completes. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler = net::default_completion_token_t<executor_type>{}); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @returns The number of bytes written. @throws system_error Thrown on failure. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @param ec Set to indicate what error occurred, if any. @returns The number of bytes written. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some( ConstBufferSequence const& buffers, error_code& ec); /** Start an asynchronous write. This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately. @param buffers The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_write_some` operation may not transmit all of the data to the peer. Consider using the function `net::async_write` if you need to ensure that all data is written before the asynchronous operation completes. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t<executor_type>{}); }; } // http } // beast } // boost #include <boost/beast/_experimental/http/impl/icy_stream.hpp> #endif PK OP�[|�5�( �( & _experimental/http/impl/icy_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP #define BOOST_BEAST_CORE_IMPL_ICY_STREAM_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/coroutine.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <cstring> #include <memory> #include <utility> namespace boost { namespace beast { namespace http { namespace detail { template<class ConstBufferSequence> boost::tribool is_icy(ConstBufferSequence const& buffers) { char buf[3]; auto const n = net::buffer_copy( net::mutable_buffer(buf, 3), buffers); if(n >= 1 && buf[0] != 'I') return false; if(n >= 2 && buf[1] != 'C') return false; if(n >= 3 && buf[2] != 'Y') return false; if(n < 3) return boost::indeterminate; return true; } } // detail template<class NextLayer> struct icy_stream<NextLayer>::ops { template<class Buffers, class Handler> class read_op : public beast::async_base<Handler, beast::executor_type<icy_stream>> , public asio::coroutine { icy_stream& s_; Buffers b_; std::size_t n_ = 0; error_code ec_; bool match_ = false; public: template<class Handler_> read_op( Handler_&& h, icy_stream& s, Buffers const& b) : async_base<Handler, beast::executor_type<icy_stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , b_(b) { (*this)({}, 0, false); } void operator()( error_code ec, std::size_t bytes_transferred, bool cont = true) { BOOST_ASIO_CORO_REENTER(*this) { if(s_.detect_) { BOOST_ASSERT(s_.n_ == 0); for(;;) { // Try to read the first three characters BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::icy_stream::async_read_some")); s_.next_layer().async_read_some( net::mutable_buffer( s_.buf_ + s_.n_, 3 - s_.n_), std::move(*this)); } s_.n_ += static_cast<char>(bytes_transferred); if(ec) goto upcall; auto result = detail::is_icy( net::const_buffer(s_.buf_, s_.n_)); if(boost::indeterminate(result)) continue; if(result) s_.n_ = static_cast<char>(net::buffer_copy( net::buffer(s_.buf_, sizeof(s_.buf_)), icy_stream::version())); break; } s_.detect_ = false; } if(s_.n_ > 0) { bytes_transferred = net::buffer_copy( b_, net::const_buffer(s_.buf_, s_.n_)); s_.n_ -= static_cast<char>(bytes_transferred); std::memmove( s_.buf_, s_.buf_ + bytes_transferred, sizeof(s_.buf_) - bytes_transferred); } else { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::icy_stream::async_read_some")); s_.next_layer().async_read_some( b_, std::move(*this)); } } upcall: if(! cont) { ec_ = ec; n_ = bytes_transferred; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::icy_stream::async_read_some")); s_.next_layer().async_read_some( net::mutable_buffer{}, std::move(*this)); } ec = ec_; bytes_transferred = n_; } this->complete_now(ec, bytes_transferred); } } }; struct run_read_op { template<class ReadHandler, class Buffers> void operator()( ReadHandler&& h, icy_stream* s, Buffers const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_op< Buffers, typename std::decay<ReadHandler>::type>( std::forward<ReadHandler>(h), *s, b); } }; }; //------------------------------------------------------------------------------ template<class NextLayer> template<class... Args> icy_stream<NextLayer>:: icy_stream(Args&&... args) : stream_(std::forward<Args>(args)...) { std::memset(buf_, 0, sizeof(buf_)); } template<class NextLayer> template<class MutableBufferSequence> std::size_t icy_stream<NextLayer>:: read_some(MutableBufferSequence const& buffers) { static_assert(is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); error_code ec; auto n = read_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return n; } template<class NextLayer> template<class MutableBufferSequence> std::size_t icy_stream<NextLayer>:: read_some(MutableBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); std::size_t bytes_transferred; if(detect_) { BOOST_ASSERT(n_ == 0); for(;;) { // Try to read the first three characters bytes_transferred = next_layer().read_some( net::mutable_buffer(buf_ + n_, 3 - n_), ec); n_ += static_cast<char>(bytes_transferred); if(ec) return 0; auto result = detail::is_icy( net::const_buffer(buf_, n_)); if(boost::indeterminate(result)) continue; if(result) n_ = static_cast<char>(net::buffer_copy( net::buffer(buf_, sizeof(buf_)), icy_stream::version())); break; } detect_ = false; } if(n_ > 0) { bytes_transferred = net::buffer_copy( buffers, net::const_buffer(buf_, n_)); n_ -= static_cast<char>(bytes_transferred); std::memmove( buf_, buf_ + bytes_transferred, sizeof(buf_) - bytes_transferred); } else { bytes_transferred = next_layer().read_some(buffers, ec); } return bytes_transferred; } template<class NextLayer> template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) icy_stream<NextLayer>:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(is_async_read_stream<next_layer_type>::value, "AsyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence >::value, "MutableBufferSequence type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( typename ops::run_read_op{}, handler, this, buffers); } template<class NextLayer> template<class MutableBufferSequence> std::size_t icy_stream<NextLayer>:: write_some(MutableBufferSequence const& buffers) { static_assert(is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return stream_.write_some(buffers); } template<class NextLayer> template<class MutableBufferSequence> std::size_t icy_stream<NextLayer>:: write_some(MutableBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return stream_.write_some(buffers, ec); } template<class NextLayer> template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) icy_stream<NextLayer>:: async_write_some( MutableBufferSequence const& buffers, WriteHandler&& handler) { static_assert(is_async_write_stream<next_layer_type>::value, "AsyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return stream_.async_write_some( buffers, std::forward<WriteHandler>(handler)); } } // http } // beast } // boost #endif PK OP�[�b�D(] (] ssl/ssl_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_SSL_STREAM_HPP #define BOOST_BEAST_CORE_SSL_STREAM_HPP #include <boost/beast/core/detail/config.hpp> // This include is necessary to work with `ssl::stream` and `boost::beast::websocket::stream` #include <boost/beast/websocket/ssl.hpp> #include <boost/beast/core/flat_stream.hpp> // VFALCO We include this because anyone who uses ssl will // very likely need to check for ssl::error::stream_truncated #include <boost/asio/ssl/error.hpp> #include <boost/asio/ssl/stream.hpp> #include <cstddef> #include <memory> #include <type_traits> #include <utility> namespace boost { namespace beast { /** Provides stream-oriented functionality using OpenSSL The stream class template provides asynchronous and blocking stream-oriented functionality using SSL. @par Thread Safety @e Distinct @e objects: Safe.@n @e Shared @e objects: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand. @par Example To use this template with a @ref tcp_stream, you would write: @code net::io_context ioc; net::ssl::context ctx{net::ssl::context::tlsv12}; beast::ssl_stream<beast::tcp_stream> sock{ioc, ctx}; @endcode In addition to providing an interface identical to `net::ssl::stream`, the wrapper has the following additional properties: @li Satisfies @b MoveConstructible @li Satisfies @b MoveAssignable @li Constructible from a moved socket. @li Uses @ref flat_stream internally, as a performance work-around for a limitation of `net::ssl::stream` when writing buffer sequences having length greater than one. @par Concepts: @li AsyncReadStream @li AsyncWriteStream @li Stream @li SyncReadStream @li SyncWriteStream */ template<class NextLayer> class ssl_stream : public net::ssl::stream_base { using ssl_stream_type = net::ssl::stream<NextLayer>; using stream_type = boost::beast::flat_stream<ssl_stream_type>; std::unique_ptr<stream_type> p_; public: /// The native handle type of the SSL stream. using native_handle_type = typename ssl_stream_type::native_handle_type; /// Structure for use with deprecated impl_type. using impl_struct = typename ssl_stream_type::impl_struct; /// The type of the next layer. using next_layer_type = typename ssl_stream_type::next_layer_type; /// The type of the executor associated with the object. using executor_type = typename stream_type::executor_type; /** Construct a stream. This constructor creates a stream and initialises the underlying stream object. @param arg The argument to be passed to initialise the underlying stream. @param ctx The SSL context to be used for the stream. */ template<class Arg> ssl_stream( Arg&& arg, net::ssl::context& ctx) : p_(new stream_type{ std::forward<Arg>(arg), ctx}) { } /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept { return p_->get_executor(); } /** Get the underlying implementation in the native type. This function may be used to obtain the underlying implementation of the context. This is intended to allow access to context functionality that is not otherwise provided. @par Example The native_handle() function returns a pointer of type @c SSL* that is suitable for passing to functions such as @c SSL_get_verify_result and @c SSL_get_peer_certificate: @code boost::beast::ssl_stream<net::ip::tcp::socket> ss{ioc, ctx}; // ... establish connection and perform handshake ... if (X509* cert = SSL_get_peer_certificate(ss.native_handle())) { if (SSL_get_verify_result(ss.native_handle()) == X509_V_OK) { // ... } } @endcode */ native_handle_type native_handle() noexcept { return p_->next_layer().native_handle(); } /** Get a reference to the next layer. This function returns a reference to the next layer in a stack of stream layers. @note The next layer is the wrapped stream and not the @ref flat_stream used in the implementation. @return A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller. */ next_layer_type const& next_layer() const noexcept { return p_->next_layer().next_layer(); } /** Get a reference to the next layer. This function returns a reference to the next layer in a stack of stream layers. @note The next layer is the wrapped stream and not the @ref flat_stream used in the implementation. @return A reference to the next layer in the stack of stream layers. Ownership is not transferred to the caller. */ next_layer_type& next_layer() noexcept { return p_->next_layer().next_layer(); } /** Set the peer verification mode. This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context. @param v A bitmask of peer verification modes. @throws boost::system::system_error Thrown on failure. @note Calls @c SSL_set_verify. */ void set_verify_mode(net::ssl::verify_mode v) { p_->next_layer().set_verify_mode(v); } /** Set the peer verification mode. This function may be used to configure the peer verification mode used by the stream. The new mode will override the mode inherited from the context. @param v A bitmask of peer verification modes. See `verify_mode` for available values. @param ec Set to indicate what error occurred, if any. @note Calls @c SSL_set_verify. */ void set_verify_mode(net::ssl::verify_mode v, boost::system::error_code& ec) { p_->next_layer().set_verify_mode(v, ec); } /** Set the peer verification depth. This function may be used to configure the maximum verification depth allowed by the stream. @param depth Maximum depth for the certificate chain verification that shall be allowed. @throws boost::system::system_error Thrown on failure. @note Calls @c SSL_set_verify_depth. */ void set_verify_depth(int depth) { p_->next_layer().set_verify_depth(depth); } /** Set the peer verification depth. This function may be used to configure the maximum verification depth allowed by the stream. @param depth Maximum depth for the certificate chain verification that shall be allowed. @param ec Set to indicate what error occurred, if any. @note Calls @c SSL_set_verify_depth. */ void set_verify_depth( int depth, boost::system::error_code& ec) { p_->next_layer().set_verify_depth(depth, ec); } /** Set the callback used to verify peer certificates. This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate. @param callback The function object to be used for verifying a certificate. The function signature of the handler must be: @code bool verify_callback( bool preverified, // True if the certificate passed pre-verification. verify_context& ctx // The peer certificate and other context. ); @endcode The return value of the callback is true if the certificate has passed verification, false otherwise. @throws boost::system::system_error Thrown on failure. @note Calls @c SSL_set_verify. */ template<class VerifyCallback> void set_verify_callback(VerifyCallback callback) { p_->next_layer().set_verify_callback(callback); } /** Set the callback used to verify peer certificates. This function is used to specify a callback function that will be called by the implementation when it needs to verify a peer certificate. @param callback The function object to be used for verifying a certificate. The function signature of the handler must be: @code bool verify_callback( bool preverified, // True if the certificate passed pre-verification. net::verify_context& ctx // The peer certificate and other context. ); @endcode The return value of the callback is true if the certificate has passed verification, false otherwise. @param ec Set to indicate what error occurred, if any. @note Calls @c SSL_set_verify. */ template<class VerifyCallback> void set_verify_callback(VerifyCallback callback, boost::system::error_code& ec) { p_->next_layer().set_verify_callback(callback, ec); } /** Perform SSL handshaking. This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs. @param type The type of handshaking to be performed, i.e. as a client or as a server. @throws boost::system::system_error Thrown on failure. */ void handshake(handshake_type type) { p_->next_layer().handshake(type); } /** Perform SSL handshaking. This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs. @param type The type of handshaking to be performed, i.e. as a client or as a server. @param ec Set to indicate what error occurred, if any. */ void handshake(handshake_type type, boost::system::error_code& ec) { p_->next_layer().handshake(type, ec); } /** Perform SSL handshaking. This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs. @param type The type of handshaking to be performed, i.e. as a client or as a server. @param buffers The buffered data to be reused for the handshake. @throws boost::system::system_error Thrown on failure. */ template<class ConstBufferSequence> void handshake( handshake_type type, ConstBufferSequence const& buffers) { p_->next_layer().handshake(type, buffers); } /** Perform SSL handshaking. This function is used to perform SSL handshaking on the stream. The function call will block until handshaking is complete or an error occurs. @param type The type of handshaking to be performed, i.e. as a client or as a server. @param buffers The buffered data to be reused for the handshake. @param ec Set to indicate what error occurred, if any. */ template<class ConstBufferSequence> void handshake(handshake_type type, ConstBufferSequence const& buffers, boost::system::error_code& ec) { p_->next_layer().handshake(type, buffers, ec); } /** Start an asynchronous SSL handshake. This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately. @param type The type of handshaking to be performed, i.e. as a client or as a server. @param handler The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error // Result of operation. ); @endcode */ template<class HandshakeHandler> BOOST_ASIO_INITFN_RESULT_TYPE(HandshakeHandler, void(boost::system::error_code)) async_handshake(handshake_type type, BOOST_ASIO_MOVE_ARG(HandshakeHandler) handler) { return p_->next_layer().async_handshake(type, BOOST_ASIO_MOVE_CAST(HandshakeHandler)(handler)); } /** Start an asynchronous SSL handshake. This function is used to asynchronously perform an SSL handshake on the stream. This function call always returns immediately. @param type The type of handshaking to be performed, i.e. as a client or as a server. @param buffers The buffered data to be reused for the handshake. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Amount of buffers used in handshake. ); @endcode */ template<class ConstBufferSequence, class BufferedHandshakeHandler> BOOST_ASIO_INITFN_RESULT_TYPE(BufferedHandshakeHandler, void(boost::system::error_code, std::size_t)) async_handshake(handshake_type type, ConstBufferSequence const& buffers, BOOST_ASIO_MOVE_ARG(BufferedHandshakeHandler) handler) { return p_->next_layer().async_handshake(type, buffers, BOOST_ASIO_MOVE_CAST(BufferedHandshakeHandler)(handler)); } /** Shut down SSL on the stream. This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs. @throws boost::system::system_error Thrown on failure. */ void shutdown() { p_->next_layer().shutdown(); } /** Shut down SSL on the stream. This function is used to shut down SSL on the stream. The function call will block until SSL has been shut down or an error occurs. @param ec Set to indicate what error occurred, if any. */ void shutdown(boost::system::error_code& ec) { p_->next_layer().shutdown(ec); } /** Asynchronously shut down SSL on the stream. This function is used to asynchronously shut down SSL on the stream. This function call always returns immediately. @param handler The handler to be called when the handshake operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error // Result of operation. ); @endcode */ template<class ShutdownHandler> BOOST_ASIO_INITFN_RESULT_TYPE(ShutdownHandler, void(boost::system::error_code)) async_shutdown(BOOST_ASIO_MOVE_ARG(ShutdownHandler) handler) { return p_->next_layer().async_shutdown( BOOST_ASIO_MOVE_CAST(ShutdownHandler)(handler)); } /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @returns The number of bytes written. @throws boost::system::system_error Thrown on failure. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the `net::write` function if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers) { return p_->write_some(buffers); } /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written to the stream. @param ec Set to indicate what error occurred, if any. @returns The number of bytes written. Returns 0 if an error occurred. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the `net::write` function if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers, boost::system::error_code& ec) { return p_->write_some(buffers, ec); } /** Start an asynchronous write. This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately. @param buffers The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The handler to be called when the write operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. ); @endcode @note The `async_write_some` operation may not transmit all of the data to the peer. Consider using the `net::async_write` function if you need to ensure that all data is written before the asynchronous operation completes. */ template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_ASIO_INITFN_RESULT_TYPE(WriteHandler, void(boost::system::error_code, std::size_t)) async_write_some(ConstBufferSequence const& buffers, BOOST_ASIO_MOVE_ARG(WriteHandler) handler) { return p_->async_write_some(buffers, BOOST_ASIO_MOVE_CAST(WriteHandler)(handler)); } /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @returns The number of bytes read. @throws boost::system::system_error Thrown on failure. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the `net::read` function if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers) { return p_->read_some(buffers); } /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @param ec Set to indicate what error occurred, if any. @returns The number of bytes read. Returns 0 if an error occurred. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the `net::read` function if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers, boost::system::error_code& ec) { return p_->read_some(buffers, ec); } /** Start an asynchronous read. This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately. @param buffers The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The handler to be called when the read operation completes. Copies will be made of the handler as required. The equivalent function signature of the handler must be: @code void handler( const boost::system::error_code& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. ); @endcode @note The `async_read_some` operation may not read all of the requested number of bytes. Consider using the `net::async_read` function if you need to ensure that the requested amount of data is read before the asynchronous operation completes. */ template<class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_ASIO_INITFN_RESULT_TYPE(ReadHandler, void(boost::system::error_code, std::size_t)) async_read_some(MutableBufferSequence const& buffers, BOOST_ASIO_MOVE_ARG(ReadHandler) handler) { return p_->async_read_some(buffers, BOOST_ASIO_MOVE_CAST(ReadHandler)(handler)); } // These hooks are used to inform boost::beast::websocket::stream on // how to tear down the connection as part of the WebSocket // protocol specifications #if ! BOOST_BEAST_DOXYGEN template<class SyncStream> friend void teardown( boost::beast::role_type role, ssl_stream<SyncStream>& stream, boost::system::error_code& ec); template<class AsyncStream, class TeardownHandler> friend void async_teardown( boost::beast::role_type role, ssl_stream<AsyncStream>& stream, TeardownHandler&& handler); #endif }; #if ! BOOST_BEAST_DOXYGEN template<class SyncStream> void teardown( boost::beast::role_type role, ssl_stream<SyncStream>& stream, boost::system::error_code& ec) { // Just forward it to the underlying ssl::stream using boost::beast::websocket::teardown; teardown(role, *stream.p_, ec); } template<class AsyncStream, class TeardownHandler> void async_teardown( boost::beast::role_type role, ssl_stream<AsyncStream>& stream, TeardownHandler&& handler) { // Just forward it to the underlying ssl::stream using boost::beast::websocket::async_teardown; async_teardown(role, *stream.p_, std::forward<TeardownHandler>(handler)); } #endif } // beast } // boost #endif PK OP�[�Y�/� � websocket.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_HPP #define BOOST_BEAST_WEBSOCKET_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/websocket/error.hpp> #include <boost/beast/websocket/option.hpp> #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/websocket/stream.hpp> #include <boost/beast/websocket/stream_base.hpp> #include <boost/beast/websocket/stream_fwd.hpp> #include <boost/beast/websocket/teardown.hpp> #endif PK OP�[8 Rc c http.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_HPP #define BOOST_BEAST_HTTP_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/basic_dynamic_body.hpp> #include <boost/beast/http/basic_file_body.hpp> #include <boost/beast/http/basic_parser.hpp> #include <boost/beast/http/buffer_body.hpp> #include <boost/beast/http/chunk_encode.hpp> #include <boost/beast/http/dynamic_body.hpp> #include <boost/beast/http/empty_body.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/field.hpp> #include <boost/beast/http/fields.hpp> #include <boost/beast/http/file_body.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/parser.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/http/serializer.hpp> #include <boost/beast/http/span_body.hpp> #include <boost/beast/http/status.hpp> #include <boost/beast/http/string_body.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/beast/http/vector_body.hpp> #include <boost/beast/http/verb.hpp> #include <boost/beast/http/write.hpp> #endif PK OP�[zR� � version.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_VERSION_HPP #define BOOST_BEAST_VERSION_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/config.hpp> /* BOOST_BEAST_VERSION Identifies the API version of Beast. This is a simple integer that is incremented by one every time a set of code changes is merged to the develop branch. */ #define BOOST_BEAST_VERSION 306 #define BOOST_BEAST_VERSION_STRING "Boost.Beast/" BOOST_STRINGIZE(BOOST_BEAST_VERSION) #endif PK OP�[.{��4 4 src.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_SRC_HPP #define BOOST_BEAST_SRC_HPP /* This file is meant to be included once, in a translation unit of the program, with the macro BOOST_BEAST_SEPARATE_COMPILATION defined. */ #define BOOST_BEAST_SOURCE #include <boost/beast/core/detail/config.hpp> #if defined(BOOST_BEAST_HEADER_ONLY) # error Do not compile Beast library source with BOOST_BEAST_HEADER_ONLY defined #endif #include <boost/beast/_experimental/test/impl/error.ipp> #include <boost/beast/_experimental/test/impl/fail_count.ipp> #include <boost/beast/_experimental/test/impl/stream.ipp> #include <boost/beast/core/detail/base64.ipp> #include <boost/beast/core/detail/sha1.ipp> #include <boost/beast/core/detail/impl/temporary_buffer.ipp> #include <boost/beast/core/impl/error.ipp> #include <boost/beast/core/impl/file_posix.ipp> #include <boost/beast/core/impl/file_stdio.ipp> #include <boost/beast/core/impl/file_win32.ipp> #include <boost/beast/core/impl/flat_static_buffer.ipp> #include <boost/beast/core/impl/saved_handler.ipp> #include <boost/beast/core/impl/static_buffer.ipp> #include <boost/beast/core/impl/string.ipp> #include <boost/beast/http/detail/basic_parser.ipp> #include <boost/beast/http/detail/rfc7230.ipp> #include <boost/beast/http/impl/basic_parser.ipp> #include <boost/beast/http/impl/error.ipp> #include <boost/beast/http/impl/field.ipp> #include <boost/beast/http/impl/fields.ipp> #include <boost/beast/http/impl/rfc7230.ipp> #include <boost/beast/http/impl/status.ipp> #include <boost/beast/http/impl/verb.ipp> #include <boost/beast/websocket/detail/hybi13.ipp> #include <boost/beast/websocket/detail/mask.ipp> #include <boost/beast/websocket/detail/pmd_extension.ipp> #include <boost/beast/websocket/detail/prng.ipp> #include <boost/beast/websocket/detail/service.ipp> #include <boost/beast/websocket/detail/utf8_checker.ipp> #include <boost/beast/websocket/impl/error.ipp> #include <boost/beast/zlib/detail/deflate_stream.ipp> #include <boost/beast/zlib/detail/inflate_stream.ipp> #include <boost/beast/zlib/impl/error.ipp> #endif PK OP�[,Hl��n �n websocket/impl/write.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_WRITE_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_WRITE_HPP #include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/bind_continuation.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/config.hpp> #include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/asio/coroutine.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <memory> namespace boost { namespace beast { namespace websocket { template<class NextLayer, bool deflateSupported> template<class Handler, class Buffers> class stream<NextLayer, deflateSupported>::write_some_op : public beast::async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { enum { do_nomask_nofrag, do_nomask_frag, do_mask_nofrag, do_mask_frag, do_deflate }; boost::weak_ptr<impl_type> wp_; buffers_suffix<Buffers> cb_; detail::frame_header fh_; detail::prepared_key key_; std::size_t bytes_transferred_ = 0; std::size_t remain_; std::size_t in_; int how_; bool fin_; bool more_ = false; // for ubsan bool cont_ = false; public: static constexpr int id = 2; // for soft_mutex template<class Handler_> write_some_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, bool fin, Buffers const& bs) : beast::async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , cb_(bs) , fin_(fin) { auto& impl = *sp; // Set up the outgoing frame header if(! impl.wr_cont) { impl.begin_msg(); fh_.rsv1 = impl.wr_compress; } else { fh_.rsv1 = false; } fh_.rsv2 = false; fh_.rsv3 = false; fh_.op = impl.wr_cont ? detail::opcode::cont : impl.wr_opcode; fh_.mask = impl.role == role_type::client; // Choose a write algorithm if(impl.wr_compress) { how_ = do_deflate; } else if(! fh_.mask) { if(! impl.wr_frag) { how_ = do_nomask_nofrag; } else { BOOST_ASSERT(impl.wr_buf_size != 0); remain_ = buffer_bytes(cb_); if(remain_ > impl.wr_buf_size) how_ = do_nomask_frag; else how_ = do_nomask_nofrag; } } else { if(! impl.wr_frag) { how_ = do_mask_nofrag; } else { BOOST_ASSERT(impl.wr_buf_size != 0); remain_ = buffer_bytes(cb_); if(remain_ > impl.wr_buf_size) how_ = do_mask_frag; else how_ = do_mask_nofrag; } } (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true); }; template<class NextLayer, bool deflateSupported> template<class Buffers, class Handler> void stream<NextLayer, deflateSupported>:: write_some_op<Buffers, Handler>:: operator()( error_code ec, std::size_t bytes_transferred, bool cont) { using beast::detail::clamp; std::size_t n; net::mutable_buffer b; auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; bytes_transferred_ = 0; return this->complete(cont, ec, bytes_transferred_); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { // Acquire the write lock if(! impl.wr_block.try_lock(this)) { do_suspend: BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); impl.op_wr.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::post(std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); } if(impl.check_stop_now(ec)) goto upcall; //------------------------------------------------------------------ if(how_ == do_nomask_nofrag) { // send a single frame fh_.fin = fin_; fh_.len = buffer_bytes(cb_); impl.wr_fb.clear(); detail::write<flat_static_buffer_base>( impl.wr_fb, fh_); impl.wr_cont = ! fin_; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), buffers_cat(impl.wr_fb.data(), cb_), beast::detail::bind_continuation(std::move(*this))); } bytes_transferred_ += clamp(fh_.len); if(impl.check_stop_now(ec)) goto upcall; goto upcall; } //------------------------------------------------------------------ if(how_ == do_nomask_frag) { // send multiple frames for(;;) { n = clamp(remain_, impl.wr_buf_size); fh_.len = n; remain_ -= n; fh_.fin = fin_ ? remain_ == 0 : false; impl.wr_fb.clear(); detail::write<flat_static_buffer_base>( impl.wr_fb, fh_); impl.wr_cont = ! fin_; // Send frame BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), buffers_cat( impl.wr_fb.data(), buffers_prefix(clamp(fh_.len), cb_)), beast::detail::bind_continuation(std::move(*this))); } n = clamp(fh_.len); // restore `n` on yield bytes_transferred_ += n; if(impl.check_stop_now(ec)) goto upcall; if(remain_ == 0) break; cb_.consume(n); fh_.op = detail::opcode::cont; // Give up the write lock in between each frame // so that outgoing control frames might be sent. impl.wr_block.unlock(this); if( impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_ping.maybe_invoke()) { BOOST_ASSERT(impl.wr_block.is_locked()); goto do_suspend; } impl.wr_block.lock(this); } goto upcall; } //------------------------------------------------------------------ if(how_ == do_mask_nofrag) { // send a single frame using multiple writes remain_ = beast::buffer_bytes(cb_); fh_.fin = fin_; fh_.len = remain_; fh_.key = impl.create_mask(); detail::prepare_key(key_, fh_.key); impl.wr_fb.clear(); detail::write<flat_static_buffer_base>( impl.wr_fb, fh_); n = clamp(remain_, impl.wr_buf_size); net::buffer_copy(net::buffer( impl.wr_buf.get(), n), cb_); detail::mask_inplace(net::buffer( impl.wr_buf.get(), n), key_); remain_ -= n; impl.wr_cont = ! fin_; // write frame header and some payload BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), buffers_cat( impl.wr_fb.data(), net::buffer(impl.wr_buf.get(), n)), beast::detail::bind_continuation(std::move(*this))); } // VFALCO What about consuming the buffer on error? bytes_transferred_ += bytes_transferred - impl.wr_fb.size(); if(impl.check_stop_now(ec)) goto upcall; while(remain_ > 0) { cb_.consume(impl.wr_buf_size); n = clamp(remain_, impl.wr_buf_size); net::buffer_copy(net::buffer( impl.wr_buf.get(), n), cb_); detail::mask_inplace(net::buffer( impl.wr_buf.get(), n), key_); remain_ -= n; // write more payload BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), net::buffer(impl.wr_buf.get(), n), beast::detail::bind_continuation(std::move(*this))); } bytes_transferred_ += bytes_transferred; if(impl.check_stop_now(ec)) goto upcall; } goto upcall; } //------------------------------------------------------------------ if(how_ == do_mask_frag) { // send multiple frames for(;;) { n = clamp(remain_, impl.wr_buf_size); remain_ -= n; fh_.len = n; fh_.key = impl.create_mask(); fh_.fin = fin_ ? remain_ == 0 : false; detail::prepare_key(key_, fh_.key); net::buffer_copy(net::buffer( impl.wr_buf.get(), n), cb_); detail::mask_inplace(net::buffer( impl.wr_buf.get(), n), key_); impl.wr_fb.clear(); detail::write<flat_static_buffer_base>( impl.wr_fb, fh_); impl.wr_cont = ! fin_; // Send frame BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), buffers_cat( impl.wr_fb.data(), net::buffer(impl.wr_buf.get(), n)), beast::detail::bind_continuation(std::move(*this))); } n = bytes_transferred - impl.wr_fb.size(); bytes_transferred_ += n; if(impl.check_stop_now(ec)) goto upcall; if(remain_ == 0) break; cb_.consume(n); fh_.op = detail::opcode::cont; // Give up the write lock in between each frame // so that outgoing control frames might be sent. impl.wr_block.unlock(this); if( impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_ping.maybe_invoke()) { BOOST_ASSERT(impl.wr_block.is_locked()); goto do_suspend; } impl.wr_block.lock(this); } goto upcall; } //------------------------------------------------------------------ if(how_ == do_deflate) { // send compressed frames for(;;) { b = net::buffer(impl.wr_buf.get(), impl.wr_buf_size); more_ = impl.deflate(b, cb_, fin_, in_, ec); if(impl.check_stop_now(ec)) goto upcall; n = buffer_bytes(b); if(n == 0) { // The input was consumed, but there is // no output due to compression latency. BOOST_ASSERT(! fin_); BOOST_ASSERT(buffer_bytes(cb_) == 0); goto upcall; } if(fh_.mask) { fh_.key = impl.create_mask(); detail::prepared_key key; detail::prepare_key(key, fh_.key); detail::mask_inplace(b, key); } fh_.fin = ! more_; fh_.len = n; impl.wr_fb.clear(); detail::write< flat_static_buffer_base>(impl.wr_fb, fh_); impl.wr_cont = ! fin_; // Send frame BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, fin_ ? "websocket::async_write" : "websocket::async_write_some" )); net::async_write(impl.stream(), buffers_cat( impl.wr_fb.data(), b), beast::detail::bind_continuation(std::move(*this))); } bytes_transferred_ += in_; if(impl.check_stop_now(ec)) goto upcall; if(more_) { fh_.op = detail::opcode::cont; fh_.rsv1 = false; // Give up the write lock in between each frame // so that outgoing control frames might be sent. impl.wr_block.unlock(this); if( impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_ping.maybe_invoke()) { BOOST_ASSERT(impl.wr_block.is_locked()); goto do_suspend; } impl.wr_block.lock(this); } else { if(fh_.fin) impl.do_context_takeover_write(impl.role); goto upcall; } } } //-------------------------------------------------------------------------- upcall: impl.wr_block.unlock(this); impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_ping.maybe_invoke(); this->complete(cont, ec, bytes_transferred_); } } template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_write_some_op { template< class WriteHandler, class ConstBufferSequence> void operator()( WriteHandler&& h, boost::shared_ptr<impl_type> const& sp, bool fin, ConstBufferSequence const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_some_op< typename std::decay<WriteHandler>::type, ConstBufferSequence>( std::forward<WriteHandler>(h), sp, fin, b); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: write_some(bool fin, ConstBufferSequence const& buffers) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); error_code ec; auto const bytes_transferred = write_some(fin, buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: write_some(bool fin, ConstBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); using beast::detail::clamp; auto& impl = *impl_; std::size_t bytes_transferred = 0; ec = {}; if(impl.check_stop_now(ec)) return bytes_transferred; detail::frame_header fh; if(! impl.wr_cont) { impl.begin_msg(); fh.rsv1 = impl.wr_compress; } else { fh.rsv1 = false; } fh.rsv2 = false; fh.rsv3 = false; fh.op = impl.wr_cont ? detail::opcode::cont : impl.wr_opcode; fh.mask = impl.role == role_type::client; auto remain = buffer_bytes(buffers); if(impl.wr_compress) { buffers_suffix< ConstBufferSequence> cb(buffers); for(;;) { auto b = net::buffer( impl.wr_buf.get(), impl.wr_buf_size); auto const more = impl.deflate( b, cb, fin, bytes_transferred, ec); if(impl.check_stop_now(ec)) return bytes_transferred; auto const n = buffer_bytes(b); if(n == 0) { // The input was consumed, but there // is no output due to compression // latency. BOOST_ASSERT(! fin); BOOST_ASSERT(buffer_bytes(cb) == 0); fh.fin = false; break; } if(fh.mask) { fh.key = this->impl_->create_mask(); detail::prepared_key key; detail::prepare_key(key, fh.key); detail::mask_inplace(b, key); } fh.fin = ! more; fh.len = n; detail::fh_buffer fh_buf; detail::write< flat_static_buffer_base>(fh_buf, fh); impl.wr_cont = ! fin; net::write(impl.stream(), buffers_cat(fh_buf.data(), b), ec); if(impl.check_stop_now(ec)) return bytes_transferred; if(! more) break; fh.op = detail::opcode::cont; fh.rsv1 = false; } if(fh.fin) impl.do_context_takeover_write(impl.role); } else if(! fh.mask) { if(! impl.wr_frag) { // no mask, no autofrag fh.fin = fin; fh.len = remain; detail::fh_buffer fh_buf; detail::write< flat_static_buffer_base>(fh_buf, fh); impl.wr_cont = ! fin; net::write(impl.stream(), buffers_cat(fh_buf.data(), buffers), ec); if(impl.check_stop_now(ec)) return bytes_transferred; bytes_transferred += remain; } else { // no mask, autofrag BOOST_ASSERT(impl.wr_buf_size != 0); buffers_suffix< ConstBufferSequence> cb{buffers}; for(;;) { auto const n = clamp(remain, impl.wr_buf_size); remain -= n; fh.len = n; fh.fin = fin ? remain == 0 : false; detail::fh_buffer fh_buf; detail::write< flat_static_buffer_base>(fh_buf, fh); impl.wr_cont = ! fin; net::write(impl.stream(), beast::buffers_cat(fh_buf.data(), beast::buffers_prefix(n, cb)), ec); bytes_transferred += n; if(impl.check_stop_now(ec)) return bytes_transferred; if(remain == 0) break; fh.op = detail::opcode::cont; cb.consume(n); } } } else if(! impl.wr_frag) { // mask, no autofrag fh.fin = fin; fh.len = remain; fh.key = this->impl_->create_mask(); detail::prepared_key key; detail::prepare_key(key, fh.key); detail::fh_buffer fh_buf; detail::write< flat_static_buffer_base>(fh_buf, fh); buffers_suffix< ConstBufferSequence> cb{buffers}; { auto const n = clamp(remain, impl.wr_buf_size); auto const b = net::buffer(impl.wr_buf.get(), n); net::buffer_copy(b, cb); cb.consume(n); remain -= n; detail::mask_inplace(b, key); impl.wr_cont = ! fin; net::write(impl.stream(), buffers_cat(fh_buf.data(), b), ec); bytes_transferred += n; if(impl.check_stop_now(ec)) return bytes_transferred; } while(remain > 0) { auto const n = clamp(remain, impl.wr_buf_size); auto const b = net::buffer(impl.wr_buf.get(), n); net::buffer_copy(b, cb); cb.consume(n); remain -= n; detail::mask_inplace(b, key); net::write(impl.stream(), b, ec); bytes_transferred += n; if(impl.check_stop_now(ec)) return bytes_transferred; } } else { // mask, autofrag BOOST_ASSERT(impl.wr_buf_size != 0); buffers_suffix< ConstBufferSequence> cb(buffers); for(;;) { fh.key = this->impl_->create_mask(); detail::prepared_key key; detail::prepare_key(key, fh.key); auto const n = clamp(remain, impl.wr_buf_size); auto const b = net::buffer(impl.wr_buf.get(), n); net::buffer_copy(b, cb); detail::mask_inplace(b, key); fh.len = n; remain -= n; fh.fin = fin ? remain == 0 : false; impl.wr_cont = ! fh.fin; detail::fh_buffer fh_buf; detail::write< flat_static_buffer_base>(fh_buf, fh); net::write(impl.stream(), buffers_cat(fh_buf.data(), b), ec); bytes_transferred += n; if(impl.check_stop_now(ec)) return bytes_transferred; if(remain == 0) break; fh.op = detail::opcode::cont; cb.consume(n); } } return bytes_transferred; } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) stream<NextLayer, deflateSupported>:: async_write_some(bool fin, ConstBufferSequence const& bs, WriteHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( run_write_some_op{}, handler, impl_, fin, bs); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: write(ConstBufferSequence const& buffers) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); error_code ec; auto const bytes_transferred = write(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: write(ConstBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return write_some(true, buffers, ec); } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) stream<NextLayer, deflateSupported>:: async_write( ConstBufferSequence const& bs, WriteHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( run_write_some_op{}, handler, impl_, true, bs); } } // websocket } // beast } // boost #endif PK OP�[���G. . websocket/impl/error.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_ERROR_IPP #define BOOST_BEAST_WEBSOCKET_IMPL_ERROR_IPP #include <boost/beast/websocket/error.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { class error_codes : public error_category { public: const char* name() const noexcept override { return "boost.beast.websocket"; } std::string message(int ev) const override { switch(static_cast<error>(ev)) { default: case error::closed: return "The WebSocket stream was gracefully closed at both endpoints"; case error::buffer_overflow: return "The WebSocket operation caused a dynamic buffer overflow"; case error::partial_deflate_block: return "The WebSocket stream produced an incomplete deflate block"; case error::message_too_big: return "The WebSocket message exceeded the locally configured limit"; case error::bad_http_version: return "The WebSocket handshake was not HTTP/1.1"; case error::bad_method: return "The WebSocket handshake method was not GET"; case error::no_host: return "The WebSocket handshake Host field is missing"; case error::no_connection: return "The WebSocket handshake Connection field is missing"; case error::no_connection_upgrade: return "The WebSocket handshake Connection field is missing the upgrade token"; case error::no_upgrade: return "The WebSocket handshake Upgrade field is missing"; case error::no_upgrade_websocket: return "The WebSocket handshake Upgrade field is missing the websocket token"; case error::no_sec_key: return "The WebSocket handshake Sec-WebSocket-Key field is missing"; case error::bad_sec_key: return "The WebSocket handshake Sec-WebSocket-Key field is invalid"; case error::no_sec_version: return "The WebSocket handshake Sec-WebSocket-Version field is missing"; case error::bad_sec_version: return "The WebSocket handshake Sec-WebSocket-Version field is invalid"; case error::no_sec_accept: return "The WebSocket handshake Sec-WebSocket-Accept field is missing"; case error::bad_sec_accept: return "The WebSocket handshake Sec-WebSocket-Accept field is invalid"; case error::upgrade_declined: return "The WebSocket handshake was declined by the remote peer"; case error::bad_opcode: return "The WebSocket frame contained an illegal opcode"; case error::bad_data_frame: return "The WebSocket data frame was unexpected"; case error::bad_continuation: return "The WebSocket continuation frame was unexpected"; case error::bad_reserved_bits: return "The WebSocket frame contained illegal reserved bits"; case error::bad_control_fragment: return "The WebSocket control frame was fragmented"; case error::bad_control_size: return "The WebSocket control frame size was invalid"; case error::bad_unmasked_frame: return "The WebSocket frame was unmasked"; case error::bad_masked_frame: return "The WebSocket frame was masked"; case error::bad_size: return "The WebSocket frame size was not canonical"; case error::bad_frame_payload: return "The WebSocket frame payload was not valid utf8"; case error::bad_close_code: return "The WebSocket close frame reason code was invalid"; case error::bad_close_size: return "The WebSocket close frame payload size was invalid"; case error::bad_close_payload: return "The WebSocket close frame payload was not valid utf8"; } } error_condition default_error_condition(int ev) const noexcept override { switch(static_cast<error>(ev)) { default: case error::closed: case error::buffer_overflow: case error::partial_deflate_block: case error::message_too_big: return {ev, *this}; case error::bad_http_version: case error::bad_method: case error::no_host: case error::no_connection: case error::no_connection_upgrade: case error::no_upgrade: case error::no_upgrade_websocket: case error::no_sec_key: case error::bad_sec_key: case error::no_sec_version: case error::bad_sec_version: case error::no_sec_accept: case error::bad_sec_accept: case error::upgrade_declined: return condition::handshake_failed; case error::bad_opcode: case error::bad_data_frame: case error::bad_continuation: case error::bad_reserved_bits: case error::bad_control_fragment: case error::bad_control_size: case error::bad_unmasked_frame: case error::bad_masked_frame: case error::bad_size: case error::bad_frame_payload: case error::bad_close_code: case error::bad_close_size: case error::bad_close_payload: return condition::protocol_violation; } } }; class error_conditions : public error_category { public: const char* name() const noexcept override { return "boost.beast.websocket"; } std::string message(int cv) const override { switch(static_cast<condition>(cv)) { default: case condition::handshake_failed: return "The WebSocket handshake failed"; case condition::protocol_violation: return "A WebSocket protocol violation occurred"; } } }; } // detail error_code make_error_code(error e) { static detail::error_codes const cat{}; return error_code{static_cast< std::underlying_type<error>::type>(e), cat}; } error_condition make_error_condition(condition c) { static detail::error_conditions const cat{}; return error_condition{static_cast< std::underlying_type<condition>::type>(c), cat}; } } // websocket } // beast } // boost #endif PK OP�[.vUi i websocket/impl/stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_STREAM_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_STREAM_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/websocket/teardown.hpp> #include <boost/beast/websocket/detail/hybi13.hpp> #include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/beast/version.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/http/write.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/asio/steady_timer.hpp> #include <boost/assert.hpp> #include <boost/make_shared.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <chrono> #include <memory> #include <stdexcept> #include <utility> namespace boost { namespace beast { namespace websocket { template<class NextLayer, bool deflateSupported> stream<NextLayer, deflateSupported>:: ~stream() { if(impl_) impl_->remove(); } template<class NextLayer, bool deflateSupported> template<class... Args> stream<NextLayer, deflateSupported>:: stream(Args&&... args) : impl_(boost::make_shared<impl_type>( std::forward<Args>(args)...)) { BOOST_ASSERT(impl_->rd_buf.max_size() >= max_control_frame_size); } template<class NextLayer, bool deflateSupported> auto stream<NextLayer, deflateSupported>:: get_executor() noexcept -> executor_type { return impl_->stream().get_executor(); } template<class NextLayer, bool deflateSupported> auto stream<NextLayer, deflateSupported>:: next_layer() noexcept -> next_layer_type& { return impl_->stream(); } template<class NextLayer, bool deflateSupported> auto stream<NextLayer, deflateSupported>:: next_layer() const noexcept -> next_layer_type const& { return impl_->stream(); } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: is_open() const noexcept { return impl_->status_ == status::open; } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: got_binary() const noexcept { return impl_->rd_op == detail::opcode::binary; } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: is_message_done() const noexcept { return impl_->rd_done; } template<class NextLayer, bool deflateSupported> close_reason const& stream<NextLayer, deflateSupported>:: reason() const noexcept { return impl_->cr; } template<class NextLayer, bool deflateSupported> std::size_t stream<NextLayer, deflateSupported>:: read_size_hint( std::size_t initial_size) const { return impl_->read_size_hint_pmd( initial_size, impl_->rd_done, impl_->rd_remain, impl_->rd_fh); } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer, class> std::size_t stream<NextLayer, deflateSupported>:: read_size_hint(DynamicBuffer& buffer) const { static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); return impl_->read_size_hint_db(buffer); } //------------------------------------------------------------------------------ // // Settings // //------------------------------------------------------------------------------ // decorator template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: set_option(decorator opt) { impl_->decorator_opt = std::move(opt.d_); } // timeout template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: get_option(timeout& opt) { opt = impl_->timeout_opt; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: set_option(timeout const& opt) { impl_->set_option(opt); } // template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: set_option(permessage_deflate const& o) { impl_->set_option_pmd(o); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: get_option(permessage_deflate& o) { impl_->get_option_pmd(o); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: auto_fragment(bool value) { impl_->wr_frag_opt = value; } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: auto_fragment() const { return impl_->wr_frag_opt; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: binary(bool value) { impl_->wr_opcode = value ? detail::opcode::binary : detail::opcode::text; } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: binary() const { return impl_->wr_opcode == detail::opcode::binary; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: control_callback(std::function< void(frame_type, string_view)> cb) { impl_->ctrl_cb = std::move(cb); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: control_callback() { impl_->ctrl_cb = {}; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: read_message_max(std::size_t amount) { impl_->rd_msg_max = amount; } template<class NextLayer, bool deflateSupported> std::size_t stream<NextLayer, deflateSupported>:: read_message_max() const { return impl_->rd_msg_max; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: secure_prng(bool value) { this->impl_->secure_prng_ = value; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: write_buffer_bytes(std::size_t amount) { if(amount < 8) BOOST_THROW_EXCEPTION(std::invalid_argument{ "write buffer size underflow"}); impl_->wr_buf_opt = amount; } template<class NextLayer, bool deflateSupported> std::size_t stream<NextLayer, deflateSupported>:: write_buffer_bytes() const { return impl_->wr_buf_opt; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: text(bool value) { impl_->wr_opcode = value ? detail::opcode::text : detail::opcode::binary; } template<class NextLayer, bool deflateSupported> bool stream<NextLayer, deflateSupported>:: text() const { return impl_->wr_opcode == detail::opcode::text; } //------------------------------------------------------------------------------ // _Fail the WebSocket Connection_ template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: do_fail( std::uint16_t code, // if set, send a close frame first error_code ev, // error code to use upon success error_code& ec) // set to the error, else set to ev { BOOST_ASSERT(ev); impl_->change_status(status::closing); if(code != close_code::none && ! impl_->wr_close) { impl_->wr_close = true; detail::frame_buffer fb; impl_->template write_close< flat_static_buffer_base>(fb, code); net::write(impl_->stream(), fb.data(), ec); if(impl_->check_stop_now(ec)) return; } using beast::websocket::teardown; teardown(impl_->role, impl_->stream(), ec); if(ec == net::error::eof) { // Rationale: // http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error ec = {}; } if(! ec) ec = ev; if(ec && ec != error::closed) impl_->change_status(status::failed); else impl_->change_status(status::closed); impl_->close(); } } // websocket } // beast } // boost #endif PK OP�[��Y�� � websocket/impl/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_ERROR_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_ERROR_HPP namespace boost { namespace system { template<> struct is_error_code_enum<::boost::beast::websocket::error> { static bool const value = true; }; template<> struct is_error_condition_enum<::boost::beast::websocket::condition> { static bool const value = true; }; } // system } // boost namespace boost { namespace beast { namespace websocket { BOOST_BEAST_DECL error_code make_error_code(error e); BOOST_BEAST_DECL error_condition make_error_condition(condition c); } // websocket } // beast } // boost #endif PK OP�[�z�k: k: websocket/impl/close.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_CLOSE_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_CLOSE_HPP #include <boost/beast/websocket/teardown.hpp> #include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/bind_continuation.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <boost/throw_exception.hpp> #include <memory> namespace boost { namespace beast { namespace websocket { /* Close the WebSocket Connection This composed operation sends the close frame if it hasn't already been sent, then reads and discards frames until receiving a close frame. Finally it invokes the teardown operation to shut down the underlying connection. */ template<class NextLayer, bool deflateSupported> template<class Handler> class stream<NextLayer, deflateSupported>::close_op : public beast::stable_async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; error_code ev_; detail::frame_buffer& fb_; public: static constexpr int id = 5; // for soft_mutex template<class Handler_> close_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, close_reason const& cr) : stable_async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , fb_(beast::allocate_stable< detail::frame_buffer>(*this)) { // Serialize the close frame sp->template write_close< flat_static_buffer_base>(fb_, cr); (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { using beast::detail::clamp; auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; return this->complete(cont, ec); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { // Acquire the write lock if(! impl.wr_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); impl.op_close.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); net::post(std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); } if(impl.check_stop_now(ec)) goto upcall; // Can't call close twice // TODO return a custom error code BOOST_ASSERT(! impl.wr_close); // Send close frame impl.wr_close = true; impl.change_status(status::closing); impl.update_timer(this->get_executor()); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); net::async_write(impl.stream(), fb_.data(), beast::detail::bind_continuation(std::move(*this))); } if(impl.check_stop_now(ec)) goto upcall; if(impl.rd_close) { // This happens when the read_op gets a close frame // at the same time close_op is sending the close frame. // The read_op will be suspended on the write block. goto teardown; } // Acquire the read lock if(! impl.rd_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); impl.op_r_close.emplace(std::move(*this)); } impl.rd_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); net::post(std::move(*this)); } BOOST_ASSERT(impl.rd_block.is_locked(this)); if(impl.check_stop_now(ec)) goto upcall; BOOST_ASSERT(! impl.rd_close); } // Read until a receiving a close frame // TODO There should be a timeout on this if(impl.rd_remain > 0) goto read_payload; for(;;) { // Read frame header while(! impl.parse_fh( impl.rd_fh, impl.rd_buf, ev_)) { if(ev_) goto teardown; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); impl.stream().async_read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), beast::detail::bind_continuation(std::move(*this))); } impl.rd_buf.commit(bytes_transferred); if(impl.check_stop_now(ec)) goto upcall; } if(detail::is_control(impl.rd_fh.op)) { // Discard ping or pong frame if(impl.rd_fh.op != detail::opcode::close) { impl.rd_buf.consume(clamp(impl.rd_fh.len)); continue; } // Process close frame // TODO Should we invoke the control callback? BOOST_ASSERT(! impl.rd_close); impl.rd_close = true; auto const mb = buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()); if(impl.rd_fh.len > 0 && impl.rd_fh.mask) detail::mask_inplace(mb, impl.rd_key); detail::read_close(impl.cr, mb, ev_); if(ev_) goto teardown; impl.rd_buf.consume(clamp(impl.rd_fh.len)); goto teardown; } read_payload: // Discard message frame while(impl.rd_buf.size() < impl.rd_remain) { impl.rd_remain -= impl.rd_buf.size(); impl.rd_buf.consume(impl.rd_buf.size()); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); impl.stream().async_read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), beast::detail::bind_continuation(std::move(*this))); } impl.rd_buf.commit(bytes_transferred); if(impl.check_stop_now(ec)) goto upcall; } BOOST_ASSERT(impl.rd_buf.size() >= impl.rd_remain); impl.rd_buf.consume(clamp(impl.rd_remain)); impl.rd_remain = 0; } teardown: // Teardown BOOST_ASSERT(impl.wr_block.is_locked(this)); using beast::websocket::async_teardown; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_close")); async_teardown(impl.role, impl.stream(), beast::detail::bind_continuation(std::move(*this))); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(ec == net::error::eof) { // Rationale: // http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error ec = {}; } if(! ec) ec = ev_; if(ec) impl.change_status(status::failed); else impl.change_status(status::closed); impl.close(); upcall: impl.wr_block.unlock(this); impl.rd_block.try_unlock(this) && impl.op_r_rd.maybe_invoke(); impl.op_rd.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_ping.maybe_invoke() || impl.op_wr.maybe_invoke(); this->complete(cont, ec); } } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_close_op { template<class CloseHandler> void operator()( CloseHandler&& h, boost::shared_ptr<impl_type> const& sp, close_reason const& cr) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<CloseHandler, void(error_code)>::value, "CloseHandler type requirements not met"); close_op< typename std::decay<CloseHandler>::type>( std::forward<CloseHandler>(h), sp, cr); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: close(close_reason const& cr) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); error_code ec; close(cr, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: close(close_reason const& cr, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); using beast::detail::clamp; auto& impl = *impl_; ec = {}; if(impl.check_stop_now(ec)) return; BOOST_ASSERT(! impl.rd_close); // Can't call close twice // TODO return a custom error code BOOST_ASSERT(! impl.wr_close); // Send close frame { impl.wr_close = true; impl.change_status(status::closing); detail::frame_buffer fb; impl.template write_close<flat_static_buffer_base>(fb, cr); net::write(impl.stream(), fb.data(), ec); if(impl.check_stop_now(ec)) return; } // Read until a receiving a close frame error_code ev; if(impl.rd_remain > 0) goto read_payload; for(;;) { // Read frame header while(! impl.parse_fh( impl.rd_fh, impl.rd_buf, ev)) { if(ev) { // Protocol violation return do_fail(close_code::none, ev, ec); } impl.rd_buf.commit(impl.stream().read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), ec)); if(impl.check_stop_now(ec)) return; } if(detail::is_control(impl.rd_fh.op)) { // Discard ping/pong frame if(impl.rd_fh.op != detail::opcode::close) { impl.rd_buf.consume(clamp(impl.rd_fh.len)); continue; } // Handle close frame // TODO Should we invoke the control callback? BOOST_ASSERT(! impl.rd_close); impl.rd_close = true; auto const mb = buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()); if(impl.rd_fh.len > 0 && impl.rd_fh.mask) detail::mask_inplace(mb, impl.rd_key); detail::read_close(impl.cr, mb, ev); if(ev) { // Protocol violation return do_fail(close_code::none, ev, ec); } impl.rd_buf.consume(clamp(impl.rd_fh.len)); break; } read_payload: // Discard message frame while(impl.rd_buf.size() < impl.rd_remain) { impl.rd_remain -= impl.rd_buf.size(); impl.rd_buf.consume(impl.rd_buf.size()); impl.rd_buf.commit( impl.stream().read_some( impl.rd_buf.prepare( read_size( impl.rd_buf, impl.rd_buf.max_size())), ec)); if(impl.check_stop_now(ec)) return; } BOOST_ASSERT( impl.rd_buf.size() >= impl.rd_remain); impl.rd_buf.consume(clamp(impl.rd_remain)); impl.rd_remain = 0; } // _Close the WebSocket Connection_ do_fail(close_code::none, error::closed, ec); if(ec == error::closed) ec = {}; } template<class NextLayer, bool deflateSupported> template<BOOST_BEAST_ASYNC_TPARAM1 CloseHandler> BOOST_BEAST_ASYNC_RESULT1(CloseHandler) stream<NextLayer, deflateSupported>:: async_close(close_reason const& cr, CloseHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); return net::async_initiate< CloseHandler, void(error_code)>( run_close_op{}, handler, impl_, cr); } } // websocket } // beast } // boost #endif PK OP�[�2�� � websocket/impl/rfc6455.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_RFC6455_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_RFC6455_HPP #include <boost/beast/http/fields.hpp> #include <boost/beast/http/rfc7230.hpp> namespace boost { namespace beast { namespace websocket { template<class Allocator> bool is_upgrade(http::header<true, http::basic_fields<Allocator>> const& req) { if(req.version() < 11) return false; if(req.method() != http::verb::get) return false; if(! http::token_list{req[http::field::connection]}.exists("upgrade")) return false; if(! http::token_list{req[http::field::upgrade]}.exists("websocket")) return false; return true; } } // websocket } // beast } // boost #endif PK OP�[Ms�N� N� websocket/impl/read.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_READ_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_READ_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/websocket/teardown.hpp> #include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/read_size.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/bind_continuation.hpp> #include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/config.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <boost/assert.hpp> #include <boost/config.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <limits> #include <memory> namespace boost { namespace beast { namespace websocket { /* Read some message data into a buffer sequence. Also reads and handles control frames. */ template<class NextLayer, bool deflateSupported> template<class Handler, class MutableBufferSequence> class stream<NextLayer, deflateSupported>::read_some_op : public beast::async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; MutableBufferSequence bs_; buffers_suffix<MutableBufferSequence> cb_; std::size_t bytes_written_ = 0; error_code result_; close_code code_; bool did_read_ = false; public: static constexpr int id = 1; // for soft_mutex template<class Handler_> read_some_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, MutableBufferSequence const& bs) : async_base< Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , bs_(bs) , cb_(bs) , code_(close_code::none) { (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { using beast::detail::clamp; auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; bytes_written_ = 0; return this->complete(cont, ec, bytes_written_); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { impl.update_timer(this->get_executor()); acquire_read_lock: // Acquire the read lock if(! impl.rd_block.try_lock(this)) { do_suspend: BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.op_r_rd.emplace(std::move(*this)); } impl.rd_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(impl.rd_block.is_locked(this)); BOOST_ASSERT(!ec); if(impl.check_stop_now(ec)) { BOOST_ASSERT(ec == net::error::operation_aborted); goto upcall; } // VFALCO Should never get here // The only way to get read blocked is if // a `close_op` wrote a close frame BOOST_ASSERT(impl.wr_close); BOOST_ASSERT(impl.status_ != status::open); ec = net::error::operation_aborted; goto upcall; } else { // Make sure the stream is not closed if( impl.status_ == status::closed || impl.status_ == status::failed) { ec = net::error::operation_aborted; goto upcall; } } // if status_ == status::closing, we want to suspend // the read operation until the close completes, // then finish the read with operation_aborted. loop: BOOST_ASSERT(impl.rd_block.is_locked(this)); // See if we need to read a frame header. This // condition is structured to give the decompressor // a chance to emit the final empty deflate block // if(impl.rd_remain == 0 && (! impl.rd_fh.fin || impl.rd_done)) { // Read frame header while(! impl.parse_fh( impl.rd_fh, impl.rd_buf, result_)) { if(result_) { // _Fail the WebSocket Connection_ if(result_ == error::message_too_big) code_ = close_code::too_big; else code_ = close_code::protocol_error; goto close; } BOOST_ASSERT(impl.rd_block.is_locked(this)); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.stream().async_read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), std::move(*this)); } BOOST_ASSERT(impl.rd_block.is_locked(this)); impl.rd_buf.commit(bytes_transferred); if(impl.check_stop_now(ec)) goto upcall; impl.reset_idle(); // Allow a close operation // to acquire the read block impl.rd_block.unlock(this); if( impl.op_r_close.maybe_invoke()) { // Suspend BOOST_ASSERT(impl.rd_block.is_locked()); goto do_suspend; } // Acquire read block impl.rd_block.lock(this); } // Immediately apply the mask to the portion // of the buffer holding payload data. if(impl.rd_fh.len > 0 && impl.rd_fh.mask) detail::mask_inplace(buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()), impl.rd_key); if(detail::is_control(impl.rd_fh.op)) { // Clear this otherwise the next // frame will be considered final. impl.rd_fh.fin = false; // Handle ping frame if(impl.rd_fh.op == detail::opcode::ping) { if(impl.ctrl_cb) { if(! cont) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(cont); // VFALCO call check_stop_now() here? } } { auto const b = buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()); auto const len = buffer_bytes(b); BOOST_ASSERT(len == impl.rd_fh.len); ping_data payload; detail::read_ping(payload, b); impl.rd_buf.consume(len); // Ignore ping when closing if(impl.status_ == status::closing) goto loop; if(impl.ctrl_cb) impl.ctrl_cb( frame_type::ping, payload); impl.rd_fb.clear(); impl.template write_ping< flat_static_buffer_base>(impl.rd_fb, detail::opcode::pong, payload); } // Allow a close operation // to acquire the read block impl.rd_block.unlock(this); impl.op_r_close.maybe_invoke(); // Acquire the write lock if(! impl.wr_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.op_rd.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(impl.check_stop_now(ec)) goto upcall; } // Send pong BOOST_ASSERT(impl.wr_block.is_locked(this)); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::async_write( impl.stream(), impl.rd_fb.data(), beast::detail::bind_continuation(std::move(*this))); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(impl.check_stop_now(ec)) goto upcall; impl.wr_block.unlock(this); impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_ping.maybe_invoke() || impl.op_wr.maybe_invoke(); goto acquire_read_lock; } // Handle pong frame if(impl.rd_fh.op == detail::opcode::pong) { // Ignore pong when closing if(! impl.wr_close && impl.ctrl_cb) { if(! cont) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(cont); } } auto const cb = buffers_prefix(clamp( impl.rd_fh.len), impl.rd_buf.data()); auto const len = buffer_bytes(cb); BOOST_ASSERT(len == impl.rd_fh.len); ping_data payload; detail::read_ping(payload, cb); impl.rd_buf.consume(len); // Ignore pong when closing if(! impl.wr_close && impl.ctrl_cb) impl.ctrl_cb(frame_type::pong, payload); goto loop; } // Handle close frame BOOST_ASSERT(impl.rd_fh.op == detail::opcode::close); { if(impl.ctrl_cb) { if(! cont) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(cont); } } auto const cb = buffers_prefix(clamp( impl.rd_fh.len), impl.rd_buf.data()); auto const len = buffer_bytes(cb); BOOST_ASSERT(len == impl.rd_fh.len); BOOST_ASSERT(! impl.rd_close); impl.rd_close = true; close_reason cr; detail::read_close(cr, cb, result_); if(result_) { // _Fail the WebSocket Connection_ code_ = close_code::protocol_error; goto close; } impl.cr = cr; impl.rd_buf.consume(len); if(impl.ctrl_cb) impl.ctrl_cb(frame_type::close, impl.cr.reason); // See if we are already closing if(impl.status_ == status::closing) { // _Close the WebSocket Connection_ BOOST_ASSERT(impl.wr_close); code_ = close_code::none; result_ = error::closed; goto close; } // _Start the WebSocket Closing Handshake_ code_ = cr.code == close_code::none ? close_code::normal : static_cast<close_code>(cr.code); result_ = error::closed; goto close; } } if(impl.rd_fh.len == 0 && ! impl.rd_fh.fin) { // Empty non-final frame goto loop; } impl.rd_done = false; } if(! impl.rd_deflated()) { if(impl.rd_remain > 0) { if(impl.rd_buf.size() == 0 && impl.rd_buf.max_size() > (std::min)(clamp(impl.rd_remain), buffer_bytes(cb_))) { // Fill the read buffer first, otherwise we // get fewer bytes at the cost of one I/O. BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.stream().async_read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), std::move(*this)); } impl.rd_buf.commit(bytes_transferred); if(impl.check_stop_now(ec)) goto upcall; impl.reset_idle(); if(impl.rd_fh.mask) detail::mask_inplace(buffers_prefix(clamp( impl.rd_remain), impl.rd_buf.data()), impl.rd_key); } if(impl.rd_buf.size() > 0) { // Copy from the read buffer. // The mask was already applied. bytes_transferred = net::buffer_copy(cb_, impl.rd_buf.data(), clamp(impl.rd_remain)); auto const mb = buffers_prefix( bytes_transferred, cb_); impl.rd_remain -= bytes_transferred; if(impl.rd_op == detail::opcode::text) { if(! impl.rd_utf8.write(mb) || (impl.rd_remain == 0 && impl.rd_fh.fin && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ code_ = close_code::bad_payload; result_ = error::bad_frame_payload; goto close; } } bytes_written_ += bytes_transferred; impl.rd_size += bytes_transferred; impl.rd_buf.consume(bytes_transferred); } else { // Read into caller's buffer BOOST_ASSERT(impl.rd_remain > 0); BOOST_ASSERT(buffer_bytes(cb_) > 0); BOOST_ASSERT(buffer_bytes(buffers_prefix( clamp(impl.rd_remain), cb_)) > 0); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.stream().async_read_some(buffers_prefix( clamp(impl.rd_remain), cb_), std::move(*this)); } if(impl.check_stop_now(ec)) goto upcall; impl.reset_idle(); BOOST_ASSERT(bytes_transferred > 0); auto const mb = buffers_prefix( bytes_transferred, cb_); impl.rd_remain -= bytes_transferred; if(impl.rd_fh.mask) detail::mask_inplace(mb, impl.rd_key); if(impl.rd_op == detail::opcode::text) { if(! impl.rd_utf8.write(mb) || (impl.rd_remain == 0 && impl.rd_fh.fin && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ code_ = close_code::bad_payload; result_ = error::bad_frame_payload; goto close; } } bytes_written_ += bytes_transferred; impl.rd_size += bytes_transferred; } } BOOST_ASSERT( ! impl.rd_done ); if( impl.rd_remain == 0 && impl.rd_fh.fin ) impl.rd_done = true; } else { // Read compressed message frame payload: // inflate even if rd_fh_.len == 0, otherwise we // never emit the end-of-stream deflate block. while(buffer_bytes(cb_) > 0) { if( impl.rd_remain > 0 && impl.rd_buf.size() == 0 && ! did_read_) { // read new BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.stream().async_read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), std::move(*this)); } if(impl.check_stop_now(ec)) goto upcall; impl.reset_idle(); BOOST_ASSERT(bytes_transferred > 0); impl.rd_buf.commit(bytes_transferred); if(impl.rd_fh.mask) detail::mask_inplace( buffers_prefix(clamp(impl.rd_remain), impl.rd_buf.data()), impl.rd_key); did_read_ = true; } zlib::z_params zs; { auto const out = buffers_front(cb_); zs.next_out = out.data(); zs.avail_out = out.size(); BOOST_ASSERT(zs.avail_out > 0); } if(impl.rd_remain > 0) { if(impl.rd_buf.size() > 0) { // use what's there auto const in = buffers_prefix( clamp(impl.rd_remain), buffers_front( impl.rd_buf.data())); zs.avail_in = in.size(); zs.next_in = in.data(); } else { break; } } else if(impl.rd_fh.fin) { // append the empty block codes std::uint8_t constexpr empty_block[4] = { 0x00, 0x00, 0xff, 0xff }; zs.next_in = empty_block; zs.avail_in = sizeof(empty_block); impl.inflate(zs, zlib::Flush::sync, ec); if(! ec) { // https://github.com/madler/zlib/issues/280 if(zs.total_out > 0) ec = error::partial_deflate_block; } if(impl.check_stop_now(ec)) goto upcall; impl.do_context_takeover_read(impl.role); impl.rd_done = true; break; } else { break; } impl.inflate(zs, zlib::Flush::sync, ec); if(impl.check_stop_now(ec)) goto upcall; if(impl.rd_msg_max && beast::detail::sum_exceeds( impl.rd_size, zs.total_out, impl.rd_msg_max)) { // _Fail the WebSocket Connection_ code_ = close_code::too_big; result_ = error::message_too_big; goto close; } cb_.consume(zs.total_out); impl.rd_size += zs.total_out; impl.rd_remain -= zs.total_in; impl.rd_buf.consume(zs.total_in); bytes_written_ += zs.total_out; } if(impl.rd_op == detail::opcode::text) { // check utf8 if(! impl.rd_utf8.write( buffers_prefix(bytes_written_, bs_)) || ( impl.rd_done && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ code_ = close_code::bad_payload; result_ = error::bad_frame_payload; goto close; } } } goto upcall; close: // Acquire the write lock if(! impl.wr_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); impl.op_rd.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::post(std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(impl.check_stop_now(ec)) goto upcall; } impl.change_status(status::closing); if(! impl.wr_close) { impl.wr_close = true; // Serialize close frame impl.rd_fb.clear(); impl.template write_close< flat_static_buffer_base>( impl.rd_fb, code_); // Send close frame BOOST_ASSERT(impl.wr_block.is_locked(this)); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); net::async_write(impl.stream(), impl.rd_fb.data(), beast::detail::bind_continuation(std::move(*this))); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(impl.check_stop_now(ec)) goto upcall; } // Teardown using beast::websocket::async_teardown; BOOST_ASSERT(impl.wr_block.is_locked(this)); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read_some")); async_teardown(impl.role, impl.stream(), beast::detail::bind_continuation(std::move(*this))); } BOOST_ASSERT(impl.wr_block.is_locked(this)); if(ec == net::error::eof) { // Rationale: // http://stackoverflow.com/questions/25587403/boost-asio-ssl-async-shutdown-always-finishes-with-an-error ec = {}; } if(! ec) ec = result_; if(ec && ec != error::closed) impl.change_status(status::failed); else impl.change_status(status::closed); impl.close(); upcall: impl.rd_block.try_unlock(this); impl.op_r_close.maybe_invoke(); if(impl.wr_block.try_unlock(this)) impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_ping.maybe_invoke() || impl.op_wr.maybe_invoke(); this->complete(cont, ec, bytes_written_); } } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class Handler, class DynamicBuffer> class stream<NextLayer, deflateSupported>::read_op : public beast::async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; DynamicBuffer& b_; std::size_t limit_; std::size_t bytes_written_ = 0; bool some_; public: template<class Handler_> read_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, DynamicBuffer& b, std::size_t limit, bool some) : async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , b_(b) , limit_(limit ? limit : ( std::numeric_limits<std::size_t>::max)()) , some_(some) { (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { using beast::detail::clamp; auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; bytes_written_ = 0; return this->complete(cont, ec, bytes_written_); } auto& impl = *sp; using mutable_buffers_type = typename DynamicBuffer::mutable_buffers_type; BOOST_ASIO_CORO_REENTER(*this) { do { // VFALCO TODO use boost::beast::bind_continuation BOOST_ASIO_CORO_YIELD { auto mb = beast::detail::dynamic_buffer_prepare(b_, clamp(impl.read_size_hint_db(b_), limit_), ec, error::buffer_overflow); if(impl.check_stop_now(ec)) goto upcall; BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_read")); read_some_op<read_op, mutable_buffers_type>( std::move(*this), sp, *mb); } b_.commit(bytes_transferred); bytes_written_ += bytes_transferred; if(ec) goto upcall; } while(! some_ && ! impl.rd_done); upcall: this->complete(cont, ec, bytes_written_); } } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_read_some_op { template< class ReadHandler, class MutableBufferSequence> void operator()( ReadHandler&& h, boost::shared_ptr<impl_type> const& sp, MutableBufferSequence const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_some_op< typename std::decay<ReadHandler>::type, MutableBufferSequence>( std::forward<ReadHandler>(h), sp, b); } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_read_op { template< class ReadHandler, class DynamicBuffer> void operator()( ReadHandler&& h, boost::shared_ptr<impl_type> const& sp, DynamicBuffer* b, std::size_t limit, bool some) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_op< typename std::decay<ReadHandler>::type, DynamicBuffer>( std::forward<ReadHandler>(h), sp, *b, limit, some); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> std::size_t stream<NextLayer, deflateSupported>:: read(DynamicBuffer& buffer) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); error_code ec; auto const bytes_written = read(buffer, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_written; } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> std::size_t stream<NextLayer, deflateSupported>:: read(DynamicBuffer& buffer, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); std::size_t bytes_written = 0; do { bytes_written += read_some(buffer, 0, ec); if(ec) return bytes_written; } while(! is_message_done()); return bytes_written; } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) stream<NextLayer, deflateSupported>:: async_read(DynamicBuffer& buffer, ReadHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( run_read_op{}, handler, impl_, &buffer, 0, false); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> std::size_t stream<NextLayer, deflateSupported>:: read_some( DynamicBuffer& buffer, std::size_t limit) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); error_code ec; auto const bytes_written = read_some(buffer, limit, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_written; } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> std::size_t stream<NextLayer, deflateSupported>:: read_some( DynamicBuffer& buffer, std::size_t limit, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); using beast::detail::clamp; if(! limit) limit = (std::numeric_limits<std::size_t>::max)(); auto const size = clamp(read_size_hint(buffer), limit); BOOST_ASSERT(size > 0); auto mb = beast::detail::dynamic_buffer_prepare( buffer, size, ec, error::buffer_overflow); if(impl_->check_stop_now(ec)) return 0; auto const bytes_written = read_some(*mb, ec); buffer.commit(bytes_written); return bytes_written; } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) stream<NextLayer, deflateSupported>:: async_read_some( DynamicBuffer& buffer, std::size_t limit, ReadHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( run_read_op{}, handler, impl_, &buffer, limit, true); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class MutableBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: read_some( MutableBufferSequence const& buffers) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); error_code ec; auto const bytes_written = read_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_written; } template<class NextLayer, bool deflateSupported> template<class MutableBufferSequence> std::size_t stream<NextLayer, deflateSupported>:: read_some( MutableBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); using beast::detail::clamp; auto& impl = *impl_; close_code code{}; std::size_t bytes_written = 0; ec = {}; // Make sure the stream is open if(impl.check_stop_now(ec)) return bytes_written; loop: // See if we need to read a frame header. This // condition is structured to give the decompressor // a chance to emit the final empty deflate block // if(impl.rd_remain == 0 && ( ! impl.rd_fh.fin || impl.rd_done)) { // Read frame header error_code result; while(! impl.parse_fh(impl.rd_fh, impl.rd_buf, result)) { if(result) { // _Fail the WebSocket Connection_ if(result == error::message_too_big) code = close_code::too_big; else code = close_code::protocol_error; do_fail(code, result, ec); return bytes_written; } auto const bytes_transferred = impl.stream().read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), ec); impl.rd_buf.commit(bytes_transferred); if(impl.check_stop_now(ec)) return bytes_written; } // Immediately apply the mask to the portion // of the buffer holding payload data. if(impl.rd_fh.len > 0 && impl.rd_fh.mask) detail::mask_inplace(buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()), impl.rd_key); if(detail::is_control(impl.rd_fh.op)) { // Get control frame payload auto const b = buffers_prefix( clamp(impl.rd_fh.len), impl.rd_buf.data()); auto const len = buffer_bytes(b); BOOST_ASSERT(len == impl.rd_fh.len); // Clear this otherwise the next // frame will be considered final. impl.rd_fh.fin = false; // Handle ping frame if(impl.rd_fh.op == detail::opcode::ping) { ping_data payload; detail::read_ping(payload, b); impl.rd_buf.consume(len); if(impl.wr_close) { // Ignore ping when closing goto loop; } if(impl.ctrl_cb) impl.ctrl_cb(frame_type::ping, payload); detail::frame_buffer fb; impl.template write_ping<flat_static_buffer_base>(fb, detail::opcode::pong, payload); net::write(impl.stream(), fb.data(), ec); if(impl.check_stop_now(ec)) return bytes_written; goto loop; } // Handle pong frame if(impl.rd_fh.op == detail::opcode::pong) { ping_data payload; detail::read_ping(payload, b); impl.rd_buf.consume(len); if(impl.ctrl_cb) impl.ctrl_cb(frame_type::pong, payload); goto loop; } // Handle close frame BOOST_ASSERT(impl.rd_fh.op == detail::opcode::close); { BOOST_ASSERT(! impl.rd_close); impl.rd_close = true; close_reason cr; detail::read_close(cr, b, result); if(result) { // _Fail the WebSocket Connection_ do_fail(close_code::protocol_error, result, ec); return bytes_written; } impl.cr = cr; impl.rd_buf.consume(len); if(impl.ctrl_cb) impl.ctrl_cb(frame_type::close, impl.cr.reason); BOOST_ASSERT(! impl.wr_close); // _Start the WebSocket Closing Handshake_ do_fail( cr.code == close_code::none ? close_code::normal : static_cast<close_code>(cr.code), error::closed, ec); return bytes_written; } } if(impl.rd_fh.len == 0 && ! impl.rd_fh.fin) { // Empty non-final frame goto loop; } impl.rd_done = false; } else { ec = {}; } if(! impl.rd_deflated()) { if(impl.rd_remain > 0) { if(impl.rd_buf.size() == 0 && impl.rd_buf.max_size() > (std::min)(clamp(impl.rd_remain), buffer_bytes(buffers))) { // Fill the read buffer first, otherwise we // get fewer bytes at the cost of one I/O. impl.rd_buf.commit(impl.stream().read_some( impl.rd_buf.prepare(read_size(impl.rd_buf, impl.rd_buf.max_size())), ec)); if(impl.check_stop_now(ec)) return bytes_written; if(impl.rd_fh.mask) detail::mask_inplace( buffers_prefix(clamp(impl.rd_remain), impl.rd_buf.data()), impl.rd_key); } if(impl.rd_buf.size() > 0) { // Copy from the read buffer. // The mask was already applied. auto const bytes_transferred = net::buffer_copy( buffers, impl.rd_buf.data(), clamp(impl.rd_remain)); auto const mb = buffers_prefix( bytes_transferred, buffers); impl.rd_remain -= bytes_transferred; if(impl.rd_op == detail::opcode::text) { if(! impl.rd_utf8.write(mb) || (impl.rd_remain == 0 && impl.rd_fh.fin && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ do_fail(close_code::bad_payload, error::bad_frame_payload, ec); return bytes_written; } } bytes_written += bytes_transferred; impl.rd_size += bytes_transferred; impl.rd_buf.consume(bytes_transferred); } else { // Read into caller's buffer BOOST_ASSERT(impl.rd_remain > 0); BOOST_ASSERT(buffer_bytes(buffers) > 0); BOOST_ASSERT(buffer_bytes(buffers_prefix( clamp(impl.rd_remain), buffers)) > 0); auto const bytes_transferred = impl.stream().read_some(buffers_prefix( clamp(impl.rd_remain), buffers), ec); // VFALCO What if some bytes were written? if(impl.check_stop_now(ec)) return bytes_written; BOOST_ASSERT(bytes_transferred > 0); auto const mb = buffers_prefix( bytes_transferred, buffers); impl.rd_remain -= bytes_transferred; if(impl.rd_fh.mask) detail::mask_inplace(mb, impl.rd_key); if(impl.rd_op == detail::opcode::text) { if(! impl.rd_utf8.write(mb) || (impl.rd_remain == 0 && impl.rd_fh.fin && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ do_fail(close_code::bad_payload, error::bad_frame_payload, ec); return bytes_written; } } bytes_written += bytes_transferred; impl.rd_size += bytes_transferred; } } BOOST_ASSERT( ! impl.rd_done ); if( impl.rd_remain == 0 && impl.rd_fh.fin ) impl.rd_done = true; } else { // Read compressed message frame payload: // inflate even if rd_fh_.len == 0, otherwise we // never emit the end-of-stream deflate block. // bool did_read = false; buffers_suffix<MutableBufferSequence> cb(buffers); while(buffer_bytes(cb) > 0) { zlib::z_params zs; { auto const out = beast::buffers_front(cb); zs.next_out = out.data(); zs.avail_out = out.size(); BOOST_ASSERT(zs.avail_out > 0); } if(impl.rd_remain > 0) { if(impl.rd_buf.size() > 0) { // use what's there auto const in = buffers_prefix( clamp(impl.rd_remain), beast::buffers_front( impl.rd_buf.data())); zs.avail_in = in.size(); zs.next_in = in.data(); } else if(! did_read) { // read new auto const bytes_transferred = impl.stream().read_some( impl.rd_buf.prepare(read_size( impl.rd_buf, impl.rd_buf.max_size())), ec); if(impl.check_stop_now(ec)) return bytes_written; BOOST_ASSERT(bytes_transferred > 0); impl.rd_buf.commit(bytes_transferred); if(impl.rd_fh.mask) detail::mask_inplace( buffers_prefix(clamp(impl.rd_remain), impl.rd_buf.data()), impl.rd_key); auto const in = buffers_prefix( clamp(impl.rd_remain), buffers_front( impl.rd_buf.data())); zs.avail_in = in.size(); zs.next_in = in.data(); did_read = true; } else { break; } } else if(impl.rd_fh.fin) { // append the empty block codes static std::uint8_t constexpr empty_block[4] = { 0x00, 0x00, 0xff, 0xff }; zs.next_in = empty_block; zs.avail_in = sizeof(empty_block); impl.inflate(zs, zlib::Flush::sync, ec); if(! ec) { // https://github.com/madler/zlib/issues/280 if(zs.total_out > 0) ec = error::partial_deflate_block; } if(impl.check_stop_now(ec)) return bytes_written; impl.do_context_takeover_read(impl.role); impl.rd_done = true; break; } else { break; } impl.inflate(zs, zlib::Flush::sync, ec); if(impl.check_stop_now(ec)) return bytes_written; if(impl.rd_msg_max && beast::detail::sum_exceeds( impl.rd_size, zs.total_out, impl.rd_msg_max)) { do_fail(close_code::too_big, error::message_too_big, ec); return bytes_written; } cb.consume(zs.total_out); impl.rd_size += zs.total_out; impl.rd_remain -= zs.total_in; impl.rd_buf.consume(zs.total_in); bytes_written += zs.total_out; } if(impl.rd_op == detail::opcode::text) { // check utf8 if(! impl.rd_utf8.write(beast::buffers_prefix( bytes_written, buffers)) || ( impl.rd_done && ! impl.rd_utf8.finish())) { // _Fail the WebSocket Connection_ do_fail(close_code::bad_payload, error::bad_frame_payload, ec); return bytes_written; } } } return bytes_written; } template<class NextLayer, bool deflateSupported> template<class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) stream<NextLayer, deflateSupported>:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( run_read_some_op{}, handler, impl_, buffers); } } // websocket } // beast } // boost #endif PK OP�[.%��Jp Jp websocket/impl/stream_impl.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_STREAM_IMPL_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_STREAM_IMPL_HPP #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/detail/hybi13.hpp> #include <boost/beast/websocket/detail/mask.hpp> #include <boost/beast/websocket/detail/pmd_extension.hpp> #include <boost/beast/websocket/detail/prng.hpp> #include <boost/beast/websocket/detail/service.hpp> #include <boost/beast/websocket/detail/soft_mutex.hpp> #include <boost/beast/websocket/detail/utf8_checker.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/http/write.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/saved_handler.hpp> #include <boost/beast/core/static_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/asio/steady_timer.hpp> #include <boost/core/empty_value.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/shared_ptr.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace websocket { template< class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>::impl_type : boost::empty_value<NextLayer> , detail::service::impl_type , detail::impl_base<deflateSupported> { NextLayer& stream() noexcept { return this->boost::empty_value< NextLayer>::get(); } boost::weak_ptr<impl_type> weak_from_this() { return boost::static_pointer_cast< impl_type>(this->detail::service:: impl_type::shared_from_this()); } boost::shared_ptr<impl_type> shared_this() { return boost::static_pointer_cast< impl_type>(this->detail::service:: impl_type::shared_from_this()); } net::steady_timer timer; // used for timeouts close_reason cr; // set from received close frame control_cb_type ctrl_cb; // control callback std::size_t rd_msg_max /* max message size */ = 16 * 1024 * 1024; std::uint64_t rd_size /* total size of current message so far */ = 0; std::uint64_t rd_remain /* message frame bytes left in current frame */ = 0; detail::frame_header rd_fh; // current frame header detail::prepared_key rd_key; // current stateful mask key detail::frame_buffer rd_fb; // to write control frames (during reads) detail::utf8_checker rd_utf8; // to validate utf8 static_buffer< +tcp_frame_size> rd_buf; // buffer for reads detail::opcode rd_op /* current message binary or text */ = detail::opcode::text; bool rd_cont /* `true` if the next frame is a continuation */ = false; bool rd_done /* set when a message is done */ = true; bool rd_close /* did we read a close frame? */ = false; detail::soft_mutex rd_block; // op currently reading role_type role /* server or client */ = role_type::client; status status_ /* state of the object */ = status::closed; detail::soft_mutex wr_block; // op currently writing bool wr_close /* did we write a close frame? */ = false; bool wr_cont /* next write is a continuation */ = false; bool wr_frag /* autofrag the current message */ = false; bool wr_frag_opt /* autofrag option setting */ = true; bool wr_compress; /* compress current message */ bool wr_compress_opt /* compress message setting */ = true; detail::opcode wr_opcode /* message type */ = detail::opcode::text; std::unique_ptr< std::uint8_t[]> wr_buf; // write buffer std::size_t wr_buf_size /* write buffer size (current message) */ = 0; std::size_t wr_buf_opt /* write buffer size option setting */ = 4096; detail::fh_buffer wr_fb; // header buffer used for writes saved_handler op_rd; // paused read op saved_handler op_wr; // paused write op saved_handler op_ping; // paused ping op saved_handler op_idle_ping; // paused idle ping op saved_handler op_close; // paused close op saved_handler op_r_rd; // paused read op (async read) saved_handler op_r_close; // paused close op (async read) bool idle_pinging = false; bool secure_prng_ = true; bool ec_delivered = false; bool timed_out = false; int idle_counter = 0; detail::decorator decorator_opt; // Decorator for HTTP messages timeout timeout_opt; // Timeout/idle settings template<class... Args> impl_type(Args&&... args) : boost::empty_value<NextLayer>( boost::empty_init_t{}, std::forward<Args>(args)...) , detail::service::impl_type( this->get_context( this->boost::empty_value<NextLayer>::get().get_executor())) , timer(this->boost::empty_value<NextLayer>::get().get_executor()) { timeout_opt.handshake_timeout = none(); timeout_opt.idle_timeout = none(); timeout_opt.keep_alive_pings = false; } void shutdown() override { op_rd.reset(); op_wr.reset(); op_ping.reset(); op_idle_ping.reset(); op_close.reset(); op_r_rd.reset(); op_r_close.reset(); } void open(role_type role_) { // VFALCO TODO analyze and remove dupe code in reset() timer.expires_at(never()); timed_out = false; cr.code = close_code::none; role = role_; status_ = status::open; rd_remain = 0; rd_cont = false; rd_done = true; // Can't clear this because accept uses it //rd_buf.reset(); rd_fh.fin = false; rd_close = false; wr_close = false; // These should not be necessary, because all completion // handlers must be allowed to execute otherwise the // stream exhibits undefined behavior. wr_block.reset(); rd_block.reset(); wr_cont = false; wr_buf_size = 0; this->open_pmd(role); } void close() { timer.cancel(); wr_buf.reset(); this->close_pmd(); } void reset() { BOOST_ASSERT(status_ != status::open); timer.expires_at(never()); cr.code = close_code::none; rd_remain = 0; rd_cont = false; rd_done = true; rd_buf.consume(rd_buf.size()); rd_fh.fin = false; rd_close = false; wr_close = false; wr_cont = false; // These should not be necessary, because all completion // handlers must be allowed to execute otherwise the // stream exhibits undefined behavior. wr_block.reset(); rd_block.reset(); // VFALCO Is this needed? timer.cancel(); } void time_out() { timed_out = true; change_status(status::closed); close_socket(get_lowest_layer(stream())); } // Called just before sending // the first frame of each message void begin_msg() { wr_frag = wr_frag_opt; wr_compress = this->pmd_enabled() && wr_compress_opt; // Maintain the write buffer if( this->pmd_enabled() || role == role_type::client) { if(! wr_buf || wr_buf_size != wr_buf_opt) { wr_buf_size = wr_buf_opt; wr_buf = boost::make_unique_noinit< std::uint8_t[]>(wr_buf_size); } } else { wr_buf_size = wr_buf_opt; wr_buf.reset(); } // } //-------------------------------------------------------------------------- template<class Decorator> request_type build_request( detail::sec_ws_key_type& key, string_view host, string_view target, Decorator const& decorator); void on_response( response_type const& res, detail::sec_ws_key_type const& key, error_code& ec); template<class Body, class Allocator, class Decorator> response_type build_response( http::request<Body, http::basic_fields<Allocator>> const& req, Decorator const& decorator, error_code& result); // Attempt to read a complete frame header. // Returns `false` if more bytes are needed template<class DynamicBuffer> bool parse_fh(detail::frame_header& fh, DynamicBuffer& b, error_code& ec); std::uint32_t create_mask() { auto g = detail::make_prng(secure_prng_); for(;;) if(auto key = g()) return key; } template<class DynamicBuffer> std::size_t read_size_hint_db(DynamicBuffer& buffer) const { auto const initial_size = (std::min)( +tcp_frame_size, buffer.max_size() - buffer.size()); if(initial_size == 0) return 1; // buffer is full return this->read_size_hint_pmd( initial_size, rd_done, rd_remain, rd_fh); } template<class DynamicBuffer> void write_ping(DynamicBuffer& db, detail::opcode code, ping_data const& data); template<class DynamicBuffer> void write_close(DynamicBuffer& db, close_reason const& cr); //-------------------------------------------------------------------------- void set_option(timeout const& opt) { if( opt.handshake_timeout == none() && opt.idle_timeout == none()) { // turn timer off timer.cancel(); timer.expires_at(never()); } timeout_opt = opt; } // Determine if an operation should stop and // deliver an error code to the completion handler. // // This function must be called at the beginning // of every composed operation, and every time a // composed operation receives an intermediate // completion. // bool check_stop_now(error_code& ec) { // Deliver the timeout to the first caller if(timed_out) { timed_out = false; ec = beast::error::timeout; return true; } // If the stream is closed then abort if( status_ == status::closed || status_ == status::failed) { //BOOST_ASSERT(ec_delivered); ec = net::error::operation_aborted; return true; } // If no error then keep going if(! ec) return false; // Is this the first error seen? if(ec_delivered) { // No, so abort ec = net::error::operation_aborted; return true; } // Deliver the error to the completion handler ec_delivered = true; if(status_ != status::closed) status_ = status::failed; return true; } // Change the status of the stream void change_status(status new_status) { switch(new_status) { case status::handshake: break; case status::open: break; case status::closing: //BOOST_ASSERT(status_ == status::open); break; case status::failed: case status::closed: // this->close(); // Is this right? break; default: break; } status_ = new_status; } // Called to disarm the idle timeout counter void reset_idle() { idle_counter = 0; } // Maintain the expiration timer template<class Executor> void update_timer(Executor const& ex) { switch(status_) { case status::handshake: BOOST_ASSERT(idle_counter == 0); if(! is_timer_set() && timeout_opt.handshake_timeout != none()) { timer.expires_after( timeout_opt.handshake_timeout); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::check_stop_now" )); timer.async_wait( timeout_handler<Executor>( ex, this->weak_from_this())); } break; case status::open: if(timeout_opt.idle_timeout != none()) { idle_counter = 0; if(timeout_opt.keep_alive_pings) timer.expires_after( timeout_opt.idle_timeout / 2); else timer.expires_after( timeout_opt.idle_timeout); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::check_stop_now" )); timer.async_wait( timeout_handler<Executor>( ex, this->weak_from_this())); } else { timer.cancel(); timer.expires_at(never()); } break; case status::closing: if(timeout_opt.handshake_timeout != none()) { idle_counter = 0; timer.expires_after( timeout_opt.handshake_timeout); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::check_stop_now" )); timer.async_wait( timeout_handler<Executor>( ex, this->weak_from_this())); } else { // VFALCO This assert goes off when there's also // a pending read with the timer set. The bigger // fix is to give close its own timeout, instead // of using the handshake timeout. // BOOST_ASSERT(! is_timer_set()); } break; case status::failed: case status::closed: // this->close(); // Is this right? timer.cancel(); timer.expires_at(never()); break; } } private: template<class Executor> static net::execution_context& get_context(Executor const& ex, typename std::enable_if< net::execution::is_executor<Executor>::value >::type* = 0) { return net::query(ex, net::execution::context); } template<class Executor> static net::execution_context& get_context(Executor const& ex, typename std::enable_if< !net::execution::is_executor<Executor>::value >::type* = 0) { return ex.context(); } bool is_timer_set() const { return timer.expiry() != never(); } template<class Executor> class timeout_handler : boost::empty_value<Executor> { boost::weak_ptr<impl_type> wp_; public: timeout_handler( Executor const& ex, boost::weak_ptr<impl_type>&& wp) : boost::empty_value<Executor>( boost::empty_init_t{}, ex) , wp_(std::move(wp)) { } using executor_type = Executor; executor_type get_executor() const noexcept { return this->get(); } void operator()(error_code ec) { // timer canceled? if(ec == net::error::operation_aborted) return; BOOST_ASSERT(! ec); // stream destroyed? auto sp = wp_.lock(); if(! sp) return; auto& impl = *sp; switch(impl.status_) { case status::handshake: impl.time_out(); return; case status::open: // timeout was disabled if(impl.timeout_opt.idle_timeout == none()) return; if( impl.timeout_opt.keep_alive_pings && impl.idle_counter < 1) { { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::timeout_handler" )); idle_ping_op<Executor>(sp, get_executor()); } ++impl.idle_counter; impl.timer.expires_after( impl.timeout_opt.idle_timeout / 2); { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::timeout_handler" )); impl.timer.async_wait(std::move(*this)); } return; } impl.time_out(); return; case status::closing: impl.time_out(); return; case status::closed: case status::failed: // nothing to do? return; } } }; }; //-------------------------------------------------------------------------- // // client // //-------------------------------------------------------------------------- template<class NextLayer, bool deflateSupported> template<class Decorator> request_type stream<NextLayer, deflateSupported>::impl_type:: build_request( detail::sec_ws_key_type& key, string_view host, string_view target, Decorator const& decorator) { request_type req; req.target(target); req.version(11); req.method(http::verb::get); req.set(http::field::host, host); req.set(http::field::upgrade, "websocket"); req.set(http::field::connection, "upgrade"); detail::make_sec_ws_key(key); req.set(http::field::sec_websocket_key, key); req.set(http::field::sec_websocket_version, "13"); this->build_request_pmd(req); decorator_opt(req); decorator(req); return req; } // Called when the WebSocket Upgrade response is received template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>::impl_type:: on_response( response_type const& res, detail::sec_ws_key_type const& key, error_code& ec) { auto const err = [&](error e) { ec = e; }; if(res.result() != http::status::switching_protocols) return err(error::upgrade_declined); if(res.version() != 11) return err(error::bad_http_version); { auto const it = res.find(http::field::connection); if(it == res.end()) return err(error::no_connection); if(! http::token_list{it->value()}.exists("upgrade")) return err(error::no_connection_upgrade); } { auto const it = res.find(http::field::upgrade); if(it == res.end()) return err(error::no_upgrade); if(! http::token_list{it->value()}.exists("websocket")) return err(error::no_upgrade_websocket); } { auto const it = res.find( http::field::sec_websocket_accept); if(it == res.end()) return err(error::no_sec_accept); detail::sec_ws_accept_type acc; detail::make_sec_ws_accept(acc, key); if(acc.compare(it->value()) != 0) return err(error::bad_sec_accept); } ec = {}; this->on_response_pmd(res); this->open(role_type::client); } //------------------------------------------------------------------------------ // Attempt to read a complete frame header. // Returns `false` if more bytes are needed template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> bool stream<NextLayer, deflateSupported>::impl_type:: parse_fh( detail::frame_header& fh, DynamicBuffer& b, error_code& ec) { if(buffer_bytes(b.data()) < 2) { // need more bytes ec = {}; return false; } buffers_suffix<typename DynamicBuffer::const_buffers_type> cb{ b.data()}; std::size_t need; { std::uint8_t tmp[2]; cb.consume(net::buffer_copy( net::buffer(tmp), cb)); fh.len = tmp[1] & 0x7f; switch(fh.len) { case 126: need = 2; break; case 127: need = 8; break; default: need = 0; } fh.mask = (tmp[1] & 0x80) != 0; if(fh.mask) need += 4; if(buffer_bytes(cb) < need) { // need more bytes ec = {}; return false; } fh.op = static_cast< detail::opcode>(tmp[0] & 0x0f); fh.fin = (tmp[0] & 0x80) != 0; fh.rsv1 = (tmp[0] & 0x40) != 0; fh.rsv2 = (tmp[0] & 0x20) != 0; fh.rsv3 = (tmp[0] & 0x10) != 0; } switch(fh.op) { case detail::opcode::binary: case detail::opcode::text: if(rd_cont) { // new data frame when continuation expected ec = error::bad_data_frame; return false; } if(fh.rsv2 || fh.rsv3 || ! this->rd_deflated(fh.rsv1)) { // reserved bits not cleared ec = error::bad_reserved_bits; return false; } break; case detail::opcode::cont: if(! rd_cont) { // continuation without an active message ec = error::bad_continuation; return false; } if(fh.rsv1 || fh.rsv2 || fh.rsv3) { // reserved bits not cleared ec = error::bad_reserved_bits; return false; } break; default: if(detail::is_reserved(fh.op)) { // reserved opcode ec = error::bad_opcode; return false; } if(! fh.fin) { // fragmented control message ec = error::bad_control_fragment; return false; } if(fh.len > 125) { // invalid length for control message ec = error::bad_control_size; return false; } if(fh.rsv1 || fh.rsv2 || fh.rsv3) { // reserved bits not cleared ec = error::bad_reserved_bits; return false; } break; } if(role == role_type::server && ! fh.mask) { // unmasked frame from client ec = error::bad_unmasked_frame; return false; } if(role == role_type::client && fh.mask) { // masked frame from server ec = error::bad_masked_frame; return false; } if(detail::is_control(fh.op) && buffer_bytes(cb) < need + fh.len) { // Make the entire control frame payload // get read in before we return `true` return false; } switch(fh.len) { case 126: { std::uint16_t len_be; BOOST_ASSERT(buffer_bytes(cb) >= sizeof(len_be)); cb.consume(net::buffer_copy( net::mutable_buffer(&len_be, sizeof(len_be)), cb)); fh.len = endian::big_to_native(len_be); if(fh.len < 126) { // length not canonical ec = error::bad_size; return false; } break; } case 127: { std::uint64_t len_be; BOOST_ASSERT(buffer_bytes(cb) >= sizeof(len_be)); cb.consume(net::buffer_copy( net::mutable_buffer(&len_be, sizeof(len_be)), cb)); fh.len = endian::big_to_native(len_be); if(fh.len < 65536) { // length not canonical ec = error::bad_size; return false; } break; } } if(fh.mask) { std::uint32_t key_le; BOOST_ASSERT(buffer_bytes(cb) >= sizeof(key_le)); cb.consume(net::buffer_copy( net::mutable_buffer(&key_le, sizeof(key_le)), cb)); fh.key = endian::little_to_native(key_le); detail::prepare_key(rd_key, fh.key); } else { // initialize this otherwise operator== breaks fh.key = 0; } if(! detail::is_control(fh.op)) { if(fh.op != detail::opcode::cont) { rd_size = 0; rd_op = fh.op; } else { if(rd_size > (std::numeric_limits< std::uint64_t>::max)() - fh.len) { // message size exceeds configured limit ec = error::message_too_big; return false; } } if(! this->rd_deflated()) { if(rd_msg_max && beast::detail::sum_exceeds( rd_size, fh.len, rd_msg_max)) { // message size exceeds configured limit ec = error::message_too_big; return false; } } rd_cont = ! fh.fin; rd_remain = fh.len; } b.consume(b.size() - buffer_bytes(cb)); ec = {}; return true; } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> void stream<NextLayer, deflateSupported>::impl_type:: write_ping(DynamicBuffer& db, detail::opcode code, ping_data const& data) { detail::frame_header fh; fh.op = code; fh.fin = true; fh.rsv1 = false; fh.rsv2 = false; fh.rsv3 = false; fh.len = data.size(); fh.mask = role == role_type::client; if(fh.mask) fh.key = create_mask(); detail::write(db, fh); if(data.empty()) return; detail::prepared_key key; if(fh.mask) detail::prepare_key(key, fh.key); auto mb = db.prepare(data.size()); net::buffer_copy(mb, net::const_buffer( data.data(), data.size())); if(fh.mask) detail::mask_inplace(mb, key); db.commit(data.size()); } template<class NextLayer, bool deflateSupported> template<class DynamicBuffer> void stream<NextLayer, deflateSupported>::impl_type:: write_close(DynamicBuffer& db, close_reason const& cr) { using namespace boost::endian; detail::frame_header fh; fh.op = detail::opcode::close; fh.fin = true; fh.rsv1 = false; fh.rsv2 = false; fh.rsv3 = false; fh.len = cr.code == close_code::none ? 0 : 2 + cr.reason.size(); if(role == role_type::client) { fh.mask = true; fh.key = create_mask(); } else { fh.mask = false; } detail::write(db, fh); if(cr.code != close_code::none) { detail::prepared_key key; if(fh.mask) detail::prepare_key(key, fh.key); { auto code_be = endian::native_to_big<std::uint16_t>(cr.code); auto mb = db.prepare(2); net::buffer_copy(mb, net::const_buffer(&code_be, sizeof(code_be))); if(fh.mask) detail::mask_inplace(mb, key); db.commit(2); } if(! cr.reason.empty()) { auto mb = db.prepare(cr.reason.size()); net::buffer_copy(mb, net::const_buffer( cr.reason.data(), cr.reason.size())); if(fh.mask) detail::mask_inplace(mb, key); db.commit(cr.reason.size()); } } } } // websocket } // beast } // boost #endif PK OP�[ \�< - - websocket/impl/handshake.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_HANDSHAKE_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_HANDSHAKE_HPP #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/beast/websocket/detail/type_traits.hpp> #include <boost/beast/http/empty_body.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/http/write.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/flat_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/asio/coroutine.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <memory> namespace boost { namespace beast { namespace websocket { //------------------------------------------------------------------------------ // send the upgrade request and process the response // template<class NextLayer, bool deflateSupported> template<class Handler> class stream<NextLayer, deflateSupported>::handshake_op : public beast::stable_async_base<Handler, beast::executor_type<stream>> , public asio::coroutine { struct data { // VFALCO This really should be two separate // composed operations, to save on memory request_type req; http::response_parser< typename response_type::body_type> p; flat_buffer fb; bool overflow = false; // could be a member of the op explicit data(request_type&& req_) : req(std::move(req_)) { } }; boost::weak_ptr<impl_type> wp_; detail::sec_ws_key_type key_; response_type* res_p_; data& d_; public: template<class Handler_> handshake_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, request_type&& req, detail::sec_ws_key_type key, response_type* res_p) : stable_async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , key_(key) , res_p_(res_p) , d_(beast::allocate_stable<data>( *this, std::move(req))) { sp->reset(); // VFALCO I don't like this (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_used = 0, bool cont = true) { boost::ignore_unused(bytes_used); auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; return this->complete(cont, ec); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { impl.change_status(status::handshake); impl.update_timer(this->get_executor()); // write HTTP request impl.do_pmd_config(d_.req); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_handshake")); http::async_write(impl.stream(), d_.req, std::move(*this)); } if(impl.check_stop_now(ec)) goto upcall; // read HTTP response BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_handshake")); http::async_read(impl.stream(), impl.rd_buf, d_.p, std::move(*this)); } if(ec == http::error::buffer_overflow) { // If the response overflows the internal // read buffer, switch to a dynamically // allocated flat buffer. d_.fb.commit(net::buffer_copy( d_.fb.prepare(impl.rd_buf.size()), impl.rd_buf.data())); impl.rd_buf.clear(); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_handshake")); http::async_read(impl.stream(), d_.fb, d_.p, std::move(*this)); } if(! ec) { // Copy any leftovers back into the read // buffer, since this represents websocket // frame data. if(d_.fb.size() <= impl.rd_buf.capacity()) { impl.rd_buf.commit(net::buffer_copy( impl.rd_buf.prepare(d_.fb.size()), d_.fb.data())); } else { ec = http::error::buffer_overflow; } } // Do this before the upcall d_.fb.clear(); } if(impl.check_stop_now(ec)) goto upcall; // success impl.reset_idle(); impl.on_response(d_.p.get(), key_, ec); if(res_p_) swap(d_.p.get(), *res_p_); upcall: this->complete(cont ,ec); } } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_handshake_op { template<class HandshakeHandler> void operator()( HandshakeHandler&& h, boost::shared_ptr<impl_type> const& sp, request_type&& req, detail::sec_ws_key_type key, response_type* res_p) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<HandshakeHandler, void(error_code)>::value, "HandshakeHandler type requirements not met"); handshake_op< typename std::decay<HandshakeHandler>::type>( std::forward<HandshakeHandler>(h), sp, std::move(req), key, res_p); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class RequestDecorator> void stream<NextLayer, deflateSupported>:: do_handshake( response_type* res_p, string_view host, string_view target, RequestDecorator const& decorator, error_code& ec) { auto& impl = *impl_; impl.change_status(status::handshake); impl.reset(); detail::sec_ws_key_type key; { auto const req = impl.build_request( key, host, target, decorator); impl.do_pmd_config(req); http::write(impl.stream(), req, ec); } if(impl.check_stop_now(ec)) return; http::response_parser< typename response_type::body_type> p; http::read(next_layer(), impl.rd_buf, p, ec); if(ec == http::error::buffer_overflow) { // If the response overflows the internal // read buffer, switch to a dynamically // allocated flat buffer. flat_buffer fb; fb.commit(net::buffer_copy( fb.prepare(impl.rd_buf.size()), impl.rd_buf.data())); impl.rd_buf.clear(); http::read(next_layer(), fb, p, ec);; if(! ec) { // Copy any leftovers back into the read // buffer, since this represents websocket // frame data. if(fb.size() <= impl.rd_buf.capacity()) { impl.rd_buf.commit(net::buffer_copy( impl.rd_buf.prepare(fb.size()), fb.data())); } else { ec = http::error::buffer_overflow; } } } if(impl.check_stop_now(ec)) return; impl.on_response(p.get(), key, ec); if(impl.check_stop_now(ec)) return; if(res_p) *res_p = p.release(); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<BOOST_BEAST_ASYNC_TPARAM1 HandshakeHandler> BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) stream<NextLayer, deflateSupported>:: async_handshake( string_view host, string_view target, HandshakeHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); detail::sec_ws_key_type key; auto req = impl_->build_request( key, host, target, &default_decorate_req); return net::async_initiate< HandshakeHandler, void(error_code)>( run_handshake_op{}, handler, impl_, std::move(req), key, nullptr); } template<class NextLayer, bool deflateSupported> template<BOOST_BEAST_ASYNC_TPARAM1 HandshakeHandler> BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) stream<NextLayer, deflateSupported>:: async_handshake( response_type& res, string_view host, string_view target, HandshakeHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); detail::sec_ws_key_type key; auto req = impl_->build_request( key, host, target, &default_decorate_req); return net::async_initiate< HandshakeHandler, void(error_code)>( run_handshake_op{}, handler, impl_, std::move(req), key, &res); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: handshake(string_view host, string_view target) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); error_code ec; handshake( host, target, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: handshake(response_type& res, string_view host, string_view target) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); error_code ec; handshake(res, host, target, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: handshake(string_view host, string_view target, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); do_handshake(nullptr, host, target, &default_decorate_req, ec); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: handshake(response_type& res, string_view host, string_view target, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); do_handshake(&res, host, target, &default_decorate_req, ec); } } // websocket } // beast } // boost #endif PK OP�[*ϧ+ + websocket/impl/teardown.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_TEARDOWN_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_TEARDOWN_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/bind_continuation.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <memory> namespace boost { namespace beast { namespace websocket { namespace detail { template< class Protocol, class Executor, class Handler> class teardown_tcp_op : public beast::async_base< Handler, beast::executor_type< net::basic_stream_socket< Protocol, Executor>>> , public asio::coroutine { using socket_type = net::basic_stream_socket<Protocol, Executor>; socket_type& s_; role_type role_; bool nb_; public: template<class Handler_> teardown_tcp_op( Handler_&& h, socket_type& s, role_type role) : async_base<Handler, beast::executor_type< net::basic_stream_socket< Protocol, Executor>>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , role_(role) , nb_(false) { (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { BOOST_ASIO_CORO_REENTER(*this) { nb_ = s_.non_blocking(); s_.non_blocking(true, ec); if(ec) goto upcall; if(role_ == role_type::server) s_.shutdown(net::socket_base::shutdown_send, ec); if(ec) goto upcall; for(;;) { { char buf[2048]; s_.read_some(net::buffer(buf), ec); } if(ec == net::error::would_block) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::tcp::async_teardown" )); s_.async_wait( net::socket_base::wait_read, beast::detail::bind_continuation(std::move(*this))); } continue; } if(ec) { if(ec != net::error::eof) goto upcall; ec = {}; break; } if(bytes_transferred == 0) { // happens sometimes // https://github.com/boostorg/beast/issues/1373 break; } } if(role_ == role_type::client) s_.shutdown(net::socket_base::shutdown_send, ec); if(ec) goto upcall; s_.close(ec); upcall: if(! cont) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::tcp::async_teardown" )); net::post(bind_front_handler( std::move(*this), ec)); } } { error_code ignored; s_.non_blocking(nb_, ignored); } this->complete_now(ec); } } }; } // detail //------------------------------------------------------------------------------ template<class Protocol, class Executor> void teardown( role_type role, net::basic_stream_socket< Protocol, Executor>& socket, error_code& ec) { if(role == role_type::server) socket.shutdown( net::socket_base::shutdown_send, ec); if(ec) return; for(;;) { char buf[2048]; auto const bytes_transferred = socket.read_some(net::buffer(buf), ec); if(ec) { if(ec != net::error::eof) return; ec = {}; break; } if(bytes_transferred == 0) { // happens sometimes // https://github.com/boostorg/beast/issues/1373 break; } } if(role == role_type::client) socket.shutdown( net::socket_base::shutdown_send, ec); if(ec) return; socket.close(ec); } template< class Protocol, class Executor, class TeardownHandler> void async_teardown( role_type role, net::basic_stream_socket< Protocol, Executor>& socket, TeardownHandler&& handler) { static_assert(beast::detail::is_invocable< TeardownHandler, void(error_code)>::value, "TeardownHandler type requirements not met"); detail::teardown_tcp_op< Protocol, Executor, typename std::decay<TeardownHandler>::type>( std::forward<TeardownHandler>(handler), socket, role); } } // websocket } // beast } // boost #endif PK OP�[�dj|#H #H websocket/impl/accept.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_ACCEPT_IPP #define BOOST_BEAST_WEBSOCKET_IMPL_ACCEPT_IPP #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/beast/websocket/detail/type_traits.hpp> #include <boost/beast/http/empty_body.hpp> #include <boost/beast/http/parser.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/http/string_body.hpp> #include <boost/beast/http/write.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/version.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <memory> #include <type_traits> namespace boost { namespace beast { namespace websocket { //------------------------------------------------------------------------------ namespace detail { template<class Body, class Allocator> void impl_base<true>:: build_response_pmd( http::response<http::string_body>& res, http::request<Body, http::basic_fields<Allocator>> const& req) { pmd_offer offer; pmd_offer unused; pmd_read(offer, req); pmd_negotiate(res, unused, offer, pmd_opts_); } template<class Body, class Allocator> void impl_base<false>:: build_response_pmd( http::response<http::string_body>&, http::request<Body, http::basic_fields<Allocator>> const&) { } } // detail template<class NextLayer, bool deflateSupported> template<class Body, class Allocator, class Decorator> response_type stream<NextLayer, deflateSupported>::impl_type:: build_response( http::request<Body, http::basic_fields<Allocator>> const& req, Decorator const& decorator, error_code& result) { auto const decorate = [this, &decorator](response_type& res) { decorator_opt(res); decorator(res); if(! res.count(http::field::server)) res.set(http::field::server, string_view(BOOST_BEAST_VERSION_STRING)); }; auto err = [&](error e) { result = e; response_type res; res.version(req.version()); res.result(http::status::bad_request); res.body() = result.message(); res.prepare_payload(); decorate(res); return res; }; if(req.version() != 11) return err(error::bad_http_version); if(req.method() != http::verb::get) return err(error::bad_method); if(! req.count(http::field::host)) return err(error::no_host); { auto const it = req.find(http::field::connection); if(it == req.end()) return err(error::no_connection); if(! http::token_list{it->value()}.exists("upgrade")) return err(error::no_connection_upgrade); } { auto const it = req.find(http::field::upgrade); if(it == req.end()) return err(error::no_upgrade); if(! http::token_list{it->value()}.exists("websocket")) return err(error::no_upgrade_websocket); } string_view key; { auto const it = req.find(http::field::sec_websocket_key); if(it == req.end()) return err(error::no_sec_key); key = it->value(); if(key.size() > detail::sec_ws_key_type::max_size_n) return err(error::bad_sec_key); } { auto const it = req.find(http::field::sec_websocket_version); if(it == req.end()) return err(error::no_sec_version); if(it->value() != "13") { response_type res; res.result(http::status::upgrade_required); res.version(req.version()); res.set(http::field::sec_websocket_version, "13"); result = error::bad_sec_version; res.body() = result.message(); res.prepare_payload(); decorate(res); return res; } } response_type res; res.result(http::status::switching_protocols); res.version(req.version()); res.set(http::field::upgrade, "websocket"); res.set(http::field::connection, "upgrade"); { detail::sec_ws_accept_type acc; detail::make_sec_ws_accept(acc, key); res.set(http::field::sec_websocket_accept, acc); } this->build_response_pmd(res, req); decorate(res); result = {}; return res; } //------------------------------------------------------------------------------ /** Respond to an HTTP request */ template<class NextLayer, bool deflateSupported> template<class Handler> class stream<NextLayer, deflateSupported>::response_op : public beast::stable_async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; error_code result_; // must come before res_ response_type& res_; public: template< class Handler_, class Body, class Allocator, class Decorator> response_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, http::request<Body, http::basic_fields<Allocator>> const& req, Decorator const& decorator, bool cont = false) : stable_async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , res_(beast::allocate_stable<response_type>(*this, sp->build_response(req, decorator, result_))) { (*this)({}, 0, cont); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { boost::ignore_unused(bytes_transferred); auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; return this->complete(cont, ec); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { impl.change_status(status::handshake); impl.update_timer(this->get_executor()); // Send response BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_accept")); http::async_write( impl.stream(), res_, std::move(*this)); } if(impl.check_stop_now(ec)) goto upcall; if(! ec) ec = result_; if(! ec) { impl.do_pmd_config(res_); impl.open(role_type::server); } upcall: this->complete(cont, ec); } } }; //------------------------------------------------------------------------------ // read and respond to an upgrade request // template<class NextLayer, bool deflateSupported> template<class Handler, class Decorator> class stream<NextLayer, deflateSupported>::accept_op : public beast::stable_async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; http::request_parser<http::empty_body>& p_; Decorator d_; public: template<class Handler_, class Buffers> accept_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, Decorator const& decorator, Buffers const& buffers) : stable_async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , p_(beast::allocate_stable< http::request_parser<http::empty_body>>(*this)) , d_(decorator) { auto& impl = *sp; error_code ec; auto const mb = beast::detail::dynamic_buffer_prepare( impl.rd_buf, buffer_bytes(buffers), ec, error::buffer_overflow); if(! ec) impl.rd_buf.commit( net::buffer_copy(*mb, buffers)); (*this)(ec); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { boost::ignore_unused(bytes_transferred); auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; return this->complete(cont, ec); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { impl.change_status(status::handshake); impl.update_timer(this->get_executor()); // The constructor could have set ec if(ec) goto upcall; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_accept")); http::async_read(impl.stream(), impl.rd_buf, p_, std::move(*this)); } if(ec == http::error::end_of_stream) ec = error::closed; if(impl.check_stop_now(ec)) goto upcall; { // Arguments from our state must be // moved to the stack before releasing // the handler. auto const req = p_.release(); auto const decorator = d_; response_op<Handler>( this->release_handler(), sp, req, decorator, true); return; } upcall: this->complete(cont, ec); } } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_response_op { template< class AcceptHandler, class Body, class Allocator, class Decorator> void operator()( AcceptHandler&& h, boost::shared_ptr<impl_type> const& sp, http::request<Body, http::basic_fields<Allocator>> const* m, Decorator const& d) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<AcceptHandler, void(error_code)>::value, "AcceptHandler type requirements not met"); response_op< typename std::decay<AcceptHandler>::type>( std::forward<AcceptHandler>(h), sp, *m, d); } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_accept_op { template< class AcceptHandler, class Decorator, class Buffers> void operator()( AcceptHandler&& h, boost::shared_ptr<impl_type> const& sp, Decorator const& d, Buffers const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<AcceptHandler, void(error_code)>::value, "AcceptHandler type requirements not met"); accept_op< typename std::decay<AcceptHandler>::type, Decorator>( std::forward<AcceptHandler>(h), sp, d, b); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template<class Body, class Allocator, class Decorator> void stream<NextLayer, deflateSupported>:: do_accept( http::request<Body, http::basic_fields<Allocator>> const& req, Decorator const& decorator, error_code& ec) { impl_->change_status(status::handshake); error_code result; auto const res = impl_->build_response(req, decorator, result); http::write(impl_->stream(), res, ec); if(ec) return; ec = result; if(ec) { // VFALCO TODO Respect keep alive setting, perform // teardown if Connection: close. return; } impl_->do_pmd_config(res); impl_->open(role_type::server); } template<class NextLayer, bool deflateSupported> template<class Buffers, class Decorator> void stream<NextLayer, deflateSupported>:: do_accept( Buffers const& buffers, Decorator const& decorator, error_code& ec) { impl_->reset(); auto const mb = beast::detail::dynamic_buffer_prepare( impl_->rd_buf, buffer_bytes(buffers), ec, error::buffer_overflow); if(ec) return; impl_->rd_buf.commit(net::buffer_copy(*mb, buffers)); http::request_parser<http::empty_body> p; http::read(next_layer(), impl_->rd_buf, p, ec); if(ec == http::error::end_of_stream) ec = error::closed; if(ec) return; do_accept(p.get(), decorator, ec); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: accept() { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); error_code ec; accept(ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: accept(error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); do_accept( net::const_buffer{}, &default_decorate_res, ec); } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> typename std::enable_if<! http::detail::is_header< ConstBufferSequence>::value>::type stream<NextLayer, deflateSupported>:: accept(ConstBufferSequence const& buffers) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); error_code ec; accept(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> template<class ConstBufferSequence> typename std::enable_if<! http::detail::is_header< ConstBufferSequence>::value>::type stream<NextLayer, deflateSupported>:: accept( ConstBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); do_accept(buffers, &default_decorate_res, ec); } template<class NextLayer, bool deflateSupported> template<class Body, class Allocator> void stream<NextLayer, deflateSupported>:: accept( http::request<Body, http::basic_fields<Allocator>> const& req) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); error_code ec; accept(req, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> template<class Body, class Allocator> void stream<NextLayer, deflateSupported>:: accept( http::request<Body, http::basic_fields<Allocator>> const& req, error_code& ec) { static_assert(is_sync_stream<next_layer_type>::value, "SyncStream type requirements not met"); impl_->reset(); do_accept(req, &default_decorate_res, ec); } //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> template< BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) stream<NextLayer, deflateSupported>:: async_accept( AcceptHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); impl_->reset(); return net::async_initiate< AcceptHandler, void(error_code)>( run_accept_op{}, handler, impl_, &default_decorate_res, net::const_buffer{}); } template<class NextLayer, bool deflateSupported> template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) stream<NextLayer, deflateSupported>:: async_accept( ConstBufferSequence const& buffers, AcceptHandler&& handler, typename std::enable_if< ! http::detail::is_header< ConstBufferSequence>::value>::type* ) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); impl_->reset(); return net::async_initiate< AcceptHandler, void(error_code)>( run_accept_op{}, handler, impl_, &default_decorate_res, buffers); } template<class NextLayer, bool deflateSupported> template< class Body, class Allocator, BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler> BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) stream<NextLayer, deflateSupported>:: async_accept( http::request<Body, http::basic_fields<Allocator>> const& req, AcceptHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); impl_->reset(); return net::async_initiate< AcceptHandler, void(error_code)>( run_response_op{}, handler, impl_, &req, &default_decorate_res); } } // websocket } // beast } // boost #endif PK OP�[��� � websocket/impl/ssl.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_SSL_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_SSL_HPP #include <utility> #include <boost/beast/websocket/teardown.hpp> #include <boost/asio/compose.hpp> #include <boost/asio/coroutine.hpp> namespace boost { namespace beast { /* See http://stackoverflow.com/questions/32046034/what-is-the-proper-way-to-securely-disconnect-an-asio-ssl-socket/32054476#32054476 Behavior of ssl::stream regarding close_notify If the remote host calls async_shutdown then the local host's async_read will complete with eof. If both hosts call async_shutdown then the calls to async_shutdown will complete with eof. */ template<class AsyncStream> void teardown( role_type role, boost::asio::ssl::stream<AsyncStream>& stream, error_code& ec) { stream.shutdown(ec); using boost::beast::websocket::teardown; error_code ec2; teardown(role, stream.next_layer(), ec ? ec2 : ec); } namespace detail { template<class AsyncStream> struct ssl_shutdown_op : boost::asio::coroutine { ssl_shutdown_op( boost::asio::ssl::stream<AsyncStream>& s, role_type role) : s_(s) , role_(role) { } template<class Self> void operator()(Self& self, error_code ec = {}, std::size_t bytes_transferred = 0) { BOOST_ASIO_CORO_REENTER(*this) { BOOST_ASIO_CORO_YIELD s_.async_shutdown(std::move(self)); ec_ = ec; using boost::beast::websocket::async_teardown; BOOST_ASIO_CORO_YIELD async_teardown(role_, s_.next_layer(), std::move(self)); if (!ec_) ec_ = ec; self.complete(ec_); } } private: boost::asio::ssl::stream<AsyncStream>& s_; role_type role_; error_code ec_; }; } // detail template< class AsyncStream, class TeardownHandler> void async_teardown( role_type role, boost::asio::ssl::stream<AsyncStream>& stream, TeardownHandler&& handler) { return boost::asio::async_compose<TeardownHandler, void(error_code)>( detail::ssl_shutdown_op<AsyncStream>(stream, role), handler, stream); } } // beast } // boost #endif PK OP�[j��) �) websocket/impl/ping.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_IMPL_PING_HPP #define BOOST_BEAST_WEBSOCKET_IMPL_PING_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/bind_continuation.hpp> #include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/impl/stream_impl.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <boost/throw_exception.hpp> #include <memory> namespace boost { namespace beast { namespace websocket { /* This composed operation handles sending ping and pong frames. It only sends the frames it does not make attempts to read any frame data. */ template<class NextLayer, bool deflateSupported> template<class Handler> class stream<NextLayer, deflateSupported>::ping_op : public beast::stable_async_base< Handler, beast::executor_type<stream>> , public asio::coroutine { boost::weak_ptr<impl_type> wp_; detail::frame_buffer& fb_; public: static constexpr int id = 3; // for soft_mutex template<class Handler_> ping_op( Handler_&& h, boost::shared_ptr<impl_type> const& sp, detail::opcode op, ping_data const& payload) : stable_async_base<Handler, beast::executor_type<stream>>( std::forward<Handler_>(h), sp->stream().get_executor()) , wp_(sp) , fb_(beast::allocate_stable< detail::frame_buffer>(*this)) { // Serialize the ping or pong frame sp->template write_ping< flat_static_buffer_base>(fb_, op, payload); (*this)({}, 0, false); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0, bool cont = true) { boost::ignore_unused(bytes_transferred); auto sp = wp_.lock(); if(! sp) { ec = net::error::operation_aborted; return this->complete(cont, ec); } auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { // Acquire the write lock if(! impl.wr_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); impl.op_ping.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); net::post(std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); } if(impl.check_stop_now(ec)) goto upcall; // Send ping frame BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); net::async_write(impl.stream(), fb_.data(), beast::detail::bind_continuation(std::move(*this))); } if(impl.check_stop_now(ec)) goto upcall; upcall: impl.wr_block.unlock(this); impl.op_close.maybe_invoke() || impl.op_idle_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_wr.maybe_invoke(); this->complete(cont, ec); } } }; //------------------------------------------------------------------------------ // sends the idle ping template<class NextLayer, bool deflateSupported> template<class Executor> class stream<NextLayer, deflateSupported>::idle_ping_op : public asio::coroutine , public boost::empty_value<Executor> { boost::weak_ptr<impl_type> wp_; std::unique_ptr<detail::frame_buffer> fb_; public: static constexpr int id = 4; // for soft_mutex using executor_type = Executor; executor_type get_executor() const noexcept { return this->get(); } idle_ping_op( boost::shared_ptr<impl_type> const& sp, Executor const& ex) : boost::empty_value<Executor>( boost::empty_init_t{}, ex) , wp_(sp) , fb_(new detail::frame_buffer) { if(! sp->idle_pinging) { // Create the ping frame ping_data payload; // empty for now sp->template write_ping< flat_static_buffer_base>(*fb_, detail::opcode::ping, payload); sp->idle_pinging = true; (*this)({}, 0); } else { // if we are already in the middle of sending // an idle ping, don't bother sending another. } } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0) { boost::ignore_unused(bytes_transferred); auto sp = wp_.lock(); if(! sp) return; auto& impl = *sp; BOOST_ASIO_CORO_REENTER(*this) { // Acquire the write lock if(! impl.wr_block.try_lock(this)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); impl.op_idle_ping.emplace(std::move(*this)); } impl.wr_block.lock(this); BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); net::post( this->get_executor(), std::move(*this)); } BOOST_ASSERT(impl.wr_block.is_locked(this)); } if(impl.check_stop_now(ec)) goto upcall; // Send ping frame BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "websocket::async_ping")); net::async_write(impl.stream(), fb_->data(), std::move(*this)); } if(impl.check_stop_now(ec)) goto upcall; upcall: BOOST_ASSERT(sp->idle_pinging); sp->idle_pinging = false; impl.wr_block.unlock(this); impl.op_close.maybe_invoke() || impl.op_ping.maybe_invoke() || impl.op_rd.maybe_invoke() || impl.op_wr.maybe_invoke(); } } }; template<class NextLayer, bool deflateSupported> struct stream<NextLayer, deflateSupported>:: run_ping_op { template<class WriteHandler> void operator()( WriteHandler&& h, boost::shared_ptr<impl_type> const& sp, detail::opcode op, ping_data const& p) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code)>::value, "WriteHandler type requirements not met"); ping_op< typename std::decay<WriteHandler>::type>( std::forward<WriteHandler>(h), sp, op, p); } }; //------------------------------------------------------------------------------ template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: ping(ping_data const& payload) { error_code ec; ping(payload, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: ping(ping_data const& payload, error_code& ec) { if(impl_->check_stop_now(ec)) return; detail::frame_buffer fb; impl_->template write_ping<flat_static_buffer_base>( fb, detail::opcode::ping, payload); net::write(impl_->stream(), fb.data(), ec); if(impl_->check_stop_now(ec)) return; } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: pong(ping_data const& payload) { error_code ec; pong(payload, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); } template<class NextLayer, bool deflateSupported> void stream<NextLayer, deflateSupported>:: pong(ping_data const& payload, error_code& ec) { if(impl_->check_stop_now(ec)) return; detail::frame_buffer fb; impl_->template write_ping<flat_static_buffer_base>( fb, detail::opcode::pong, payload); net::write(impl_->stream(), fb.data(), ec); if(impl_->check_stop_now(ec)) return; } template<class NextLayer, bool deflateSupported> template<BOOST_BEAST_ASYNC_TPARAM1 WriteHandler> BOOST_BEAST_ASYNC_RESULT1(WriteHandler) stream<NextLayer, deflateSupported>:: async_ping(ping_data const& payload, WriteHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); return net::async_initiate< WriteHandler, void(error_code)>( run_ping_op{}, handler, impl_, detail::opcode::ping, payload); } template<class NextLayer, bool deflateSupported> template<BOOST_BEAST_ASYNC_TPARAM1 WriteHandler> BOOST_BEAST_ASYNC_RESULT1(WriteHandler) stream<NextLayer, deflateSupported>:: async_pong(ping_data const& payload, WriteHandler&& handler) { static_assert(is_async_stream<next_layer_type>::value, "AsyncStream type requirements not met"); return net::async_initiate< WriteHandler, void(error_code)>( run_ping_op{}, handler, impl_, detail::opcode::pong, payload); } } // websocket } // beast } // boost #endif PK OP�[,$E�� �� websocket/stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_STREAM_HPP #define BOOST_BEAST_WEBSOCKET_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/websocket/error.hpp> #include <boost/beast/websocket/option.hpp> #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/websocket/stream_base.hpp> #include <boost/beast/websocket/stream_fwd.hpp> #include <boost/beast/websocket/detail/hybi13.hpp> #include <boost/beast/websocket/detail/impl_base.hpp> #include <boost/beast/websocket/detail/pmd_extension.hpp> #include <boost/beast/websocket/detail/prng.hpp> #include <boost/beast/core/role.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/http/detail/type_traits.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/error.hpp> #include <boost/shared_ptr.hpp> #include <algorithm> #include <cstdint> #include <functional> #include <limits> #include <memory> #include <type_traits> #include <random> namespace boost { namespace beast { namespace websocket { /** The type of received control frame. Values of this type are passed to the control frame callback set using @ref stream::control_callback. */ enum class frame_type { /// A close frame was received close, /// A ping frame was received ping, /// A pong frame was received pong }; namespace detail { class frame_test; } // detail //-------------------------------------------------------------------- /** Provides message-oriented functionality using WebSocket. The @ref stream class template provides asynchronous and blocking message-oriented functionality necessary for clients and servers to utilize the WebSocket protocol. For asynchronous operations, the application must ensure that they are are all performed within the same implicit or explicit strand. @par Thread Safety @e Distinct @e objects: Safe.@n @e Shared @e objects: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand. @par Example To declare the @ref stream object with a @ref tcp_stream in a multi-threaded asynchronous program using a strand, you may write: @code websocket::stream<tcp_stream> ws{net::make_strand(ioc)}; @endcode Alternatively, for a single-threaded or synchronous application you may write: @code websocket::stream<tcp_stream> ws(ioc); @endcode @tparam NextLayer The type representing the next layer, to which data will be read and written during operations. For synchronous operations, the type must support the <em>SyncStream</em> concept. For asynchronous operations, the type must support the <em>AsyncStream</em> concept. @tparam deflateSupported A `bool` indicating whether or not the stream will be capable of negotiating the permessage-deflate websocket extension. Note that even if this is set to `true`, the permessage deflate options (set by the caller at runtime) must still have the feature enabled for a successful negotiation to occur. @note A stream object must not be moved or destroyed while there are pending asynchronous operations associated with it. @par Concepts @li <em>AsyncStream</em> @li <em>DynamicBuffer</em> @li <em>SyncStream</em> @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc6455#section-7.1.2">Websocket Closing Handshake (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">Websocket Close (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">WebSocket Ping (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">WebSocket Pong (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ template< class NextLayer, bool deflateSupported> class stream #if ! BOOST_BEAST_DOXYGEN : private stream_base #endif { struct impl_type; boost::shared_ptr<impl_type> impl_; using time_point = typename std::chrono::steady_clock::time_point; using control_cb_type = std::function<void(frame_type, string_view)>; friend class close_test; friend class frame_test; friend class ping_test; friend class read2_test; friend class read3_test; friend class stream_test; friend class write_test; /* The read buffer has to be at least as large as the largest possible control frame including the frame header. */ static std::size_t constexpr max_control_frame_size = 2 + 8 + 4 + 125; static std::size_t constexpr tcp_frame_size = 1536; static time_point never() noexcept { return (time_point::max)(); } public: /// Indicates if the permessage-deflate extension is supported using is_deflate_supported = std::integral_constant<bool, deflateSupported>; /// The type of the next layer. using next_layer_type = typename std::remove_reference<NextLayer>::type; /// The type of the executor associated with the object. using executor_type = beast::executor_type<next_layer_type>; /** Destructor Destroys the stream and all associated resources. @note A stream object must not be destroyed while there are pending asynchronous operations associated with it. */ ~stream(); /** Constructor If `NextLayer` is move constructible, this function will move-construct a new stream from the existing stream. After the move, the only valid operation on the moved-from object is destruction. */ stream(stream&&) = default; /// Move assignment (deleted) stream& operator=(stream&&) = delete; /** Constructor This constructor creates a websocket stream and initializes the next layer object. @throws Any exceptions thrown by the NextLayer constructor. @param args The arguments to be passed to initialize the next layer object. The arguments are forwarded to the next layer's constructor. */ template<class... Args> explicit stream(Args&&... args); //-------------------------------------------------------------------------- /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept; /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type& next_layer() noexcept; /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type const& next_layer() const noexcept; //-------------------------------------------------------------------------- // // Observers // //-------------------------------------------------------------------------- /** Returns `true` if the stream is open. The stream is open after a successful handshake, and when no error has occurred. */ bool is_open() const noexcept; /** Returns `true` if the latest message data indicates binary. This function informs the caller of whether the last received message frame represents a message with the binary opcode. If there is no last message frame, the return value is undefined. */ bool got_binary() const noexcept; /** Returns `true` if the latest message data indicates text. This function informs the caller of whether the last received message frame represents a message with the text opcode. If there is no last message frame, the return value is undefined. */ bool got_text() const { return ! got_binary(); } /// Returns `true` if the last completed read finished the current message. bool is_message_done() const noexcept; /** Returns the close reason received from the remote peer. This is only valid after a read completes with error::closed. */ close_reason const& reason() const noexcept; /** Returns a suggested maximum buffer size for the next call to read. This function returns a reasonable upper limit on the number of bytes for the size of the buffer passed in the next call to read. The number is determined by the state of the current frame and whether or not the permessage-deflate extension is enabled. @param initial_size A non-zero size representing the caller's desired buffer size for when there is no information which may be used to calculate a more specific value. For example, when reading the first frame header of a message. */ std::size_t read_size_hint( std::size_t initial_size = +tcp_frame_size) const; /** Returns a suggested maximum buffer size for the next call to read. This function returns a reasonable upper limit on the number of bytes for the size of the buffer passed in the next call to read. The number is determined by the state of the current frame and whether or not the permessage-deflate extension is enabled. @param buffer The buffer which will be used for reading. The implementation will query the buffer to obtain the optimum size of a subsequent call to `buffer.prepare` based on the state of the current frame, if any. */ template<class DynamicBuffer #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< ! std::is_integral<DynamicBuffer>::value>::type #endif > std::size_t read_size_hint( DynamicBuffer& buffer) const; //-------------------------------------------------------------------------- // // Settings // //-------------------------------------------------------------------------- #if BOOST_BEAST_DOXYGEN template<class Option> void get_option(Option& opt); template<class Option> void set_option(Option opt); #else void set_option(decorator opt); void get_option(timeout& opt); void set_option(timeout const& opt); #endif /** Set the permessage-deflate extension options @throws invalid_argument if `deflateSupported == false`, and either `client_enable` or `server_enable` is `true`. */ void set_option(permessage_deflate const& o); /// Get the permessage-deflate extension options void get_option(permessage_deflate& o); /** Set the automatic fragmentation option. Determines if outgoing message payloads are broken up into multiple pieces. When the automatic fragmentation size is turned on, outgoing message payloads are broken up into multiple frames no larger than the write buffer size. The default setting is to fragment messages. @param value A `bool` indicating if auto fragmentation should be on. @par Example Setting the automatic fragmentation option: @code ws.auto_fragment(true); @endcode */ void auto_fragment(bool value); /// Returns `true` if the automatic fragmentation option is set. bool auto_fragment() const; /** Set the binary message write option. This controls whether or not outgoing message opcodes are set to binary or text. The setting is only applied at the start when a caller begins a new message. Changing the opcode after a message is started will only take effect after the current message being sent is complete. The default setting is to send text messages. @param value `true` if outgoing messages should indicate binary, or `false` if they should indicate text. @par Example Setting the message type to binary. @code ws.binary(true); @endcode */ void binary(bool value); /// Returns `true` if the binary message write option is set. bool binary() const; /** Set a callback to be invoked on each incoming control frame. Sets the callback to be invoked whenever a ping, pong, or close control frame is received during a call to one of the following functions: @li @ref beast::websocket::stream::read @li @ref beast::websocket::stream::read_some @li @ref beast::websocket::stream::async_read @li @ref beast::websocket::stream::async_read_some Unlike completion handlers, the callback will be invoked for each control frame during a call to any synchronous or asynchronous read function. The operation is passive, with no associated error code, and triggered by reads. For close frames, the close reason code may be obtained by calling the function @ref reason. @param cb The function object to call, which must be invocable with this equivalent signature: @code void callback( frame_type kind, // The type of frame string_view payload // The payload in the frame ); @endcode The implementation type-erases the callback which may require a dynamic allocation. To prevent the possibility of a dynamic allocation, use `std::ref` to wrap the callback. If the read operation which receives the control frame is an asynchronous operation, the callback will be invoked using the same method as that used to invoke the final handler. @note Incoming ping and close frames are automatically handled. Pings are responded to with pongs, and a close frame is responded to with a close frame leading to the closure of the stream. It is not necessary to manually send pings, pongs, or close frames from inside the control callback. Attempting to manually send a close frame from inside the control callback after receiving a close frame will result in undefined behavior. */ void control_callback(std::function<void(frame_type, string_view)> cb); /** Reset the control frame callback. This function removes any previously set control frame callback. */ void control_callback(); /** Set the maximum incoming message size option. Sets the largest permissible incoming message size. Message frame fields indicating a size that would bring the total message size over this limit will cause a protocol failure. The default setting is 16 megabytes. A value of zero indicates a limit of the maximum value of a `std::uint64_t`. @par Example Setting the maximum read message size. @code ws.read_message_max(65536); @endcode @param amount The limit on the size of incoming messages. */ void read_message_max(std::size_t amount); /// Returns the maximum incoming message size setting. std::size_t read_message_max() const; /** Set whether the PRNG is cryptographically secure This controls whether or not the source of pseudo-random numbers used to produce the masks required by the WebSocket protocol are of cryptographic quality. When the setting is `true`, a strong algorithm is used which cannot be guessed by observing outputs. When the setting is `false`, a much faster algorithm is used. Masking is only performed by streams operating in the client mode. For streams operating in the server mode, this setting has no effect. By default, newly constructed streams use a secure PRNG. If the WebSocket stream is used with an encrypted SSL or TLS next layer, if it is known to the application that intermediate proxies are not vulnerable to cache poisoning, or if the application is designed such that an attacker cannot send arbitrary inputs to the stream interface, then the faster algorithm may be used. For more information please consult the WebSocket protocol RFC. @param value `true` if the PRNG algorithm should be cryptographically secure. */ void secure_prng(bool value); /** Set the write buffer size option. Sets the size of the write buffer used by the implementation to send frames. The write buffer is needed when masking payload data in the client role, compressing frames, or auto-fragmenting message data. Lowering the size of the buffer can decrease the memory requirements for each connection, while increasing the size of the buffer can reduce the number of calls made to the next layer to write data. The default setting is 4096. The minimum value is 8. The write buffer size can only be changed when the stream is not open. Undefined behavior results if the option is modified after a successful WebSocket handshake. @par Example Setting the write buffer size. @code ws.write_buffer_bytes(8192); @endcode @param amount The size of the write buffer in bytes. */ void write_buffer_bytes(std::size_t amount); /// Returns the size of the write buffer. std::size_t write_buffer_bytes() const; /** Set the text message write option. This controls whether or not outgoing message opcodes are set to binary or text. The setting is only applied at the start when a caller begins a new message. Changing the opcode after a message is started will only take effect after the current message being sent is complete. The default setting is to send text messages. @param value `true` if outgoing messages should indicate text, or `false` if they should indicate binary. @par Example Setting the message type to text. @code ws.text(true); @endcode */ void text(bool value); /// Returns `true` if the text message write option is set. bool text() const; /* timer settings * Timer is disabled * Close on timeout - no complete frame received, OR - no complete frame sent * Ping on timeout - ping on no complete frame received * if can't ping? */ //-------------------------------------------------------------------------- // // Handshaking (Client) // //-------------------------------------------------------------------------- /** Perform the WebSocket handshake in the client role. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. @throws system_error Thrown on failure. @par Example @code ws.handshake("localhost", "/"); @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ void handshake( string_view host, string_view target); /** Perform the WebSocket handshake in the client role. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param res The HTTP Upgrade response returned by the remote endpoint. The caller may use the response to access any additional information sent by the server. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. @throws system_error Thrown on failure. @par Example @code response_type res; ws.handshake(res, "localhost", "/"); std::cout << res; @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ void handshake( response_type& res, string_view host, string_view target); /** Perform the WebSocket handshake in the client role. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. @param ec Set to indicate what error occurred, if any. @par Example @code error_code ec; ws.handshake("localhost", "/", ec); @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ void handshake( string_view host, string_view target, error_code& ec); /** Perform the WebSocket handshake in the client role. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param res The HTTP Upgrade response returned by the remote endpoint. The caller may use the response to access any additional information sent by the server. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. @param ec Set to indicate what error occurred, if any. @par Example @code error_code ec; response_type res; ws.handshake(res, "localhost", "/", ec); if(! ec) std::cout << res; @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ void handshake( response_type& res, string_view host, string_view target, error_code& ec); /** Perform the WebSocket handshake asynchronously in the client role. This initiating function is used to asynchronously begin performing the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. No other operation may be performed on the stream until this operation completes. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. The implementation will not access the string data after the initiating function returns. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. The implementation will not access the string data after the initiating function returns. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @par Example @code ws.async_handshake("localhost", "/", [](error_code ec) { if(ec) std::cerr << "Error: " << ec.message() << "\n"; }); @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ template< BOOST_BEAST_ASYNC_TPARAM1 HandshakeHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) async_handshake( string_view host, string_view target, HandshakeHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Perform the WebSocket handshake asynchronously in the client role. This initiating function is used to asynchronously begin performing the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The request is sent and the response is received. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. No other operation may be performed on the stream until this operation completes. The handshake is successful if the received HTTP response indicates the upgrade was accepted by the server, represented by a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols. @param res The HTTP Upgrade response returned by the remote endpoint. The caller may use the response to access any additional information sent by the server. This object will be assigned before the completion handler is invoked. @param host The name of the remote host. This is required by the HTTP protocol to set the "Host" header field. The implementation will not access the string data after the initiating function returns. @param target The request-target, in origin-form. The server may use the target to distinguish different services on the same listening port. The implementation will not access the string data after the initiating function returns. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @par Example @code response_type res; ws.async_handshake(res, "localhost", "/", [&res](error_code ec) { if(ec) std::cerr << "Error: " << ec.message() << "\n"; else std::cout << res; }); @endcode @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.1">Websocket Opening Handshake Client Requirements (RFC6455)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.4">Host field (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-3.1.1">request-target (RFC7230)</a> @li <a href="https://tools.ietf.org/html/rfc7230#section-5.3.1">origin-form (RFC7230)</a> */ template< BOOST_BEAST_ASYNC_TPARAM1 HandshakeHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(HandshakeHandler) async_handshake( response_type& res, string_view host, string_view target, HandshakeHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- // // Handshaking (Server) // //-------------------------------------------------------------------------- /** Perform the WebSocket handshake in the server role. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @throws system_error Thrown on failure. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ void accept(); /** Read and respond to a WebSocket HTTP Upgrade request. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @param ec Set to indicate what error occurred, if any. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ void accept(error_code& ec); /** Read and respond to a WebSocket HTTP Upgrade request. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @param buffers Caller provided data that has already been received on the stream. The implementation will copy the caller provided data before the function returns. @throws system_error Thrown on failure. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template<class ConstBufferSequence> #if BOOST_BEAST_DOXYGEN void #else typename std::enable_if<! http::detail::is_header< ConstBufferSequence>::value>::type #endif accept(ConstBufferSequence const& buffers); /** Read and respond to a WebSocket HTTP Upgrade request. This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @param buffers Caller provided data that has already been received on the stream. The implementation will copy the caller provided data before the function returns. @param ec Set to indicate what error occurred, if any. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template<class ConstBufferSequence> #if BOOST_BEAST_DOXYGEN void #else typename std::enable_if<! http::detail::is_header< ConstBufferSequence>::value>::type #endif accept( ConstBufferSequence const& buffers, error_code& ec); /** Respond to a WebSocket HTTP Upgrade request This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. @param req An object containing the HTTP Upgrade request. Ownership is not transferred, the implementation will not access this object from other threads. @throws system_error Thrown on failure. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template<class Body, class Allocator> void accept(http::request<Body, http::basic_fields<Allocator>> const& req); /** Respond to a WebSocket HTTP Upgrade request This function is used to perform the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. The call blocks until one of the following conditions is true: @li The response is sent. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. @param req An object containing the HTTP Upgrade request. Ownership is not transferred, the implementation will not access this object from other threads. @param ec Set to indicate what error occurred, if any. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template<class Body, class Allocator> void accept(http::request<Body, http::basic_fields<Allocator>> const& req, error_code& ec); /** Perform the WebSocket handshake asynchronously in the server role. This initiating function is used to asynchronously begin performing the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. No other operation may be performed on the stream until this operation completes. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::async_read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template< BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) async_accept( AcceptHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Perform the WebSocket handshake asynchronously in the server role. This initiating function is used to asynchronously begin performing the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. No other operation may be performed on the stream until this operation completes. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. If the request size exceeds the capacity of the stream's internal buffer, the error @ref error::buffer_overflow will be indicated. To handle larger requests, an application should read the HTTP request directly using @ref http::async_read and then pass the request to the appropriate overload of @ref accept or @ref async_accept @param buffers Caller provided data that has already been received on the stream. This may be used for implementations allowing multiple protocols on the same stream. The buffered data will first be applied to the handshake, and then to received WebSocket frames. The implementation will copy the caller provided data before the function returns. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) async_accept( ConstBufferSequence const& buffers, AcceptHandler&& handler = net::default_completion_token_t< executor_type>{} #ifndef BOOST_BEAST_DOXYGEN , typename std::enable_if< ! http::detail::is_header< ConstBufferSequence>::value>::type* = 0 #endif ); /** Perform the WebSocket handshake asynchronously in the server role. This initiating function is used to asynchronously begin performing the <a href="https://en.wikipedia.org/wiki/WebSocket#Protocol_handshake">WebSocket handshake</a>, required before messages can be sent and received. During the handshake, the client sends the Websocket Upgrade HTTP request, and the server replies with an HTTP response indicating the result of the handshake. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The request is received and the response is sent. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. No other operation may be performed on the stream until this operation completes. If a valid upgrade request is received, an HTTP response with a <a href="https://tools.ietf.org/html/rfc7230#section-3.1.2">status-code</a> of @ref beast::http::status::switching_protocols is sent to the peer, otherwise a non-successful error is associated with the operation. @param req An object containing the HTTP Upgrade request. Ownership is not transferred, the implementation will not access this object from other threads. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-4.2">Websocket Opening Handshake Server Requirements (RFC6455)</a> */ template< class Body, class Allocator, BOOST_BEAST_ASYNC_TPARAM1 AcceptHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(AcceptHandler) async_accept( http::request<Body, http::basic_fields<Allocator>> const& req, AcceptHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- // // Close Frames // //-------------------------------------------------------------------------- /** Send a websocket close control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">close frame</a>, which begins the websocket closing handshake. The session ends when both ends of the connection have sent and received a close frame. The call blocks until one of the following conditions is true: @li The close frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. After beginning the closing handshake, the program should not write further message data, pings, or pongs. Instead, the program should continue reading message data until an error occurs. A read returning @ref error::closed indicates a successful connection closure. @param cr The reason for the close. If the close reason specifies a close code other than @ref beast::websocket::close_code::none, the close frame is sent with the close code and optional reason string. Otherwise, the close frame is sent with no payload. @throws system_error Thrown on failure. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-7.1.2">Websocket Closing Handshake (RFC6455)</a> */ void close(close_reason const& cr); /** Send a websocket close control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">close frame</a>, which begins the websocket closing handshake. The session ends when both ends of the connection have sent and received a close frame. The call blocks until one of the following conditions is true: @li The close frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. After beginning the closing handshake, the program should not write further message data, pings, or pongs. Instead, the program should continue reading message data until an error occurs. A read returning @ref error::closed indicates a successful connection closure. @param cr The reason for the close. If the close reason specifies a close code other than @ref beast::websocket::close_code::none, the close frame is sent with the close code and optional reason string. Otherwise, the close frame is sent with no payload. @param ec Set to indicate what error occurred, if any. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-7.1.2">Websocket Closing Handshake (RFC6455)</a> */ void close(close_reason const& cr, error_code& ec); /** Send a websocket close control frame asynchronously. This function is used to asynchronously send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.1">close frame</a>, which begins the websocket closing handshake. The session ends when both ends of the connection have sent and received a close frame. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The close frame finishes sending. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. No other operations except for message reading operations should be initiated on the stream after a close operation is started. After beginning the closing handshake, the program should not write further message data, pings, or pongs. Instead, the program should continue reading message data until an error occurs. A read returning @ref error::closed indicates a successful connection closure. @param cr The reason for the close. If the close reason specifies a close code other than @ref beast::websocket::close_code::none, the close frame is sent with the close code and optional reason string. Otherwise, the close frame is sent with no payload. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see @li <a href="https://tools.ietf.org/html/rfc6455#section-7.1.2">Websocket Closing Handshake (RFC6455)</a> */ template< BOOST_BEAST_ASYNC_TPARAM1 CloseHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(CloseHandler) async_close( close_reason const& cr, CloseHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- // // Ping/Pong Frames // //-------------------------------------------------------------------------- /** Send a websocket ping control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">ping frame</a>, which usually elicits an automatic pong control frame response from the peer. The call blocks until one of the following conditions is true: @li The ping frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. @param payload The payload of the ping message, which may be empty. @throws system_error Thrown on failure. */ void ping(ping_data const& payload); /** Send a websocket ping control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">ping frame</a>, which usually elicits an automatic pong control frame response from the peer. The call blocks until one of the following conditions is true: @li The ping frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. @param payload The payload of the ping message, which may be empty. @param ec Set to indicate what error occurred, if any. */ void ping(ping_data const& payload, error_code& ec); /** Send a websocket ping control frame asynchronously. This function is used to asynchronously send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.2">ping frame</a>, which usually elicits an automatic pong control frame response from the peer. @li The ping frame is written. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. The program must ensure that no other calls to @ref ping, @ref pong, @ref async_ping, or @ref async_pong are performed until this operation completes. If a close frame is sent or received before the ping frame is sent, the error received by this completion handler will be `net::error::operation_aborted`. @param payload The payload of the ping message, which may be empty. The implementation will not access the contents of this object after the initiating function returns. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< BOOST_BEAST_ASYNC_TPARAM1 WriteHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(WriteHandler) async_ping( ping_data const& payload, WriteHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Send a websocket pong control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pong frame</a>, which is usually sent automatically in response to a ping frame from the remote peer. The call blocks until one of the following conditions is true: @li The pong frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. WebSocket allows pong frames to be sent at any time, without first receiving a ping. An unsolicited pong sent in this fashion may indicate to the remote peer that the connection is still active. @param payload The payload of the pong message, which may be empty. @throws system_error Thrown on failure. */ void pong(ping_data const& payload); /** Send a websocket pong control frame. This function is used to send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pong frame</a>, which is usually sent automatically in response to a ping frame from the remote peer. The call blocks until one of the following conditions is true: @li The pong frame is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. WebSocket allows pong frames to be sent at any time, without first receiving a ping. An unsolicited pong sent in this fashion may indicate to the remote peer that the connection is still active. @param payload The payload of the pong message, which may be empty. @param ec Set to indicate what error occurred, if any. */ void pong(ping_data const& payload, error_code& ec); /** Send a websocket pong control frame asynchronously. This function is used to asynchronously send a <a href="https://tools.ietf.org/html/rfc6455#section-5.5.3">pong frame</a>, which is usually sent automatically in response to a ping frame from the remote peer. @li The pong frame is written. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. The program must ensure that no other calls to @ref ping, @ref pong, @ref async_ping, or @ref async_pong are performed until this operation completes. If a close frame is sent or received before the pong frame is sent, the error received by this completion handler will be `net::error::operation_aborted`. WebSocket allows pong frames to be sent at any time, without first receiving a ping. An unsolicited pong sent in this fashion may indicate to the remote peer that the connection is still active. @param payload The payload of the pong message, which may be empty. The implementation will not access the contents of this object after the initiating function returns. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< BOOST_BEAST_ASYNC_TPARAM1 WriteHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(WriteHandler) async_pong( ping_data const& payload, WriteHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- // // Reading // //-------------------------------------------------------------------------- /** Read a complete message. This function is used to read a complete message. The call blocks until one of the following is true: @li A complete message is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffer A dynamic buffer to append message data to. @throws system_error Thrown on failure. */ template<class DynamicBuffer> std::size_t read(DynamicBuffer& buffer); /** Read a complete message. This function is used to read a complete message. The call blocks until one of the following is true: @li A complete message is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffer A dynamic buffer to append message data to. @param ec Set to indicate what error occurred, if any. */ template<class DynamicBuffer> std::size_t read(DynamicBuffer& buffer, error_code& ec); /** Read a complete message asynchronously. This function is used to asynchronously read a complete message. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li A complete message is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. The program must ensure that no other calls to @ref read, @ref read_some, @ref async_read, or @ref async_read_some are performed until this operation completes. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. Until the operation completes, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket close procedure is performed. In this case, when the function returns, the error @ref error::closed will be indicated. Pong frames and close frames sent by the implementation while the read operation is outstanding do not prevent the application from also writing message data, sending pings, sending pongs, or sending close frames. @param buffer A dynamic buffer to append message data to. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation std::size_t bytes_written // Number of bytes appended to buffer ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class DynamicBuffer, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( DynamicBuffer& buffer, ReadHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- /** Read some message data. This function is used to read some message data. The call blocks until one of the following is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. The function @ref is_message_done may be called to determine if the message received by the last read operation is complete. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffer A dynamic buffer to append message data to. @param limit An upper limit on the number of bytes this function will append into the buffer. If this value is zero, then a reasonable size will be chosen automatically. @throws system_error Thrown on failure. */ template<class DynamicBuffer> std::size_t read_some( DynamicBuffer& buffer, std::size_t limit); /** Read some message data. This function is used to read some message data. The call blocks until one of the following is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. The function @ref is_message_done may be called to determine if the message received by the last read operation is complete. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffer A dynamic buffer to append message data to. @param limit An upper limit on the number of bytes this function will append into the buffer. If this value is zero, then a reasonable size will be chosen automatically. @param ec Set to indicate what error occurred, if any. */ template<class DynamicBuffer> std::size_t read_some( DynamicBuffer& buffer, std::size_t limit, error_code& ec); /** Read some message data asynchronously. This function is used to asynchronously read some message data. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. The program must ensure that no other calls to @ref read, @ref read_some, @ref async_read, or @ref async_read_some are performed until this operation completes. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. Until the operation completes, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket close procedure is performed. In this case, when the function returns, the error @ref error::closed will be indicated. Pong frames and close frames sent by the implementation while the read operation is outstanding do not prevent the application from also writing message data, sending pings, sending pongs, or sending close frames. @param buffer A dynamic buffer to append message data to. @param limit An upper limit on the number of bytes this function will append into the buffer. If this value is zero, then a reasonable size will be chosen automatically. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation std::size_t bytes_written // Number of bytes appended to buffer ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class DynamicBuffer, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( DynamicBuffer& buffer, std::size_t limit, ReadHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- /** Read some message data. This function is used to read some message data. The call blocks until one of the following is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. The function @ref is_message_done may be called to determine if the message received by the last read operation is complete. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffers A buffer sequence to write message data into. The previous contents of the buffers will be overwritten, starting from the beginning. @throws system_error Thrown on failure. */ template<class MutableBufferSequence> std::size_t read_some( MutableBufferSequence const& buffers); /** Read some message data. This function is used to read some message data. The call blocks until one of the following is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` and `write_some` functions. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. The function @ref is_message_done may be called to determine if the message received by the last read operation is complete. Until the call returns, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket closing handshake is performed. In this case, when the function returns, the error @ref error::closed will be indicated. @return The number of message payload bytes appended to the buffer. @param buffers A buffer sequence to write message data into. The previous contents of the buffers will be overwritten, starting from the beginning. @param ec Set to indicate what error occurred, if any. */ template<class MutableBufferSequence> std::size_t read_some( MutableBufferSequence const& buffers, error_code& ec); /** Read some message data asynchronously. This function is used to asynchronously read some message data. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li Some message data is received. @li A close frame is received. In this case the error indicated by the function will be @ref error::closed. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` and `async_write_some` functions. The program must ensure that no other calls to @ref read, @ref read_some, @ref async_read, or @ref async_read_some are performed until this operation completes. Received message data is appended to the buffer. The functions @ref got_binary and @ref got_text may be used to query the stream and determine the type of the last received message. Until the operation completes, the implementation will read incoming control frames and handle them automatically as follows: @li The @ref control_callback will be invoked for each control frame. @li For each received ping frame, a pong frame will be automatically sent. @li If a close frame is received, the WebSocket close procedure is performed. In this case, when the function returns, the error @ref error::closed will be indicated. Pong frames and close frames sent by the implementation while the read operation is outstanding do not prevent the application from also writing message data, sending pings, sending pongs, or sending close frames. @param buffers A buffer sequence to write message data into. The previous contents of the buffers will be overwritten, starting from the beginning. The implementation will make copies of this object as needed, but but ownership of the underlying memory is not transferred. The caller is responsible for ensuring that the memory locations pointed to by the buffer sequence remain valid until the completion handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation std::size_t bytes_written // Number of bytes written to the buffers ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler = net::default_completion_token_t< executor_type>{}); //-------------------------------------------------------------------------- // // Writing // //-------------------------------------------------------------------------- /** Write a complete message. This function is used to write a complete message. The call blocks until one of the following is true: @li The message is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. The current setting of the @ref binary option controls whether the message opcode is set to text or binary. If the @ref auto_fragment option is set, the message will be split into one or more frames as necessary. The actual payload contents sent may be transformed as per the WebSocket protocol settings. @param buffers The buffers containing the message to send. @return The number of bytes sent from the buffers. @throws system_error Thrown on failure. */ template<class ConstBufferSequence> std::size_t write(ConstBufferSequence const& buffers); /** Write a complete message. This function is used to write a complete message. The call blocks until one of the following is true: @li The complete message is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. The current setting of the @ref binary option controls whether the message opcode is set to text or binary. If the @ref auto_fragment option is set, the message will be split into one or more frames as necessary. The actual payload contents sent may be transformed as per the WebSocket protocol settings. @param buffers The buffers containing the message to send. @param ec Set to indicate what error occurred, if any. @return The number of bytes sent from the buffers. */ template<class ConstBufferSequence> std::size_t write(ConstBufferSequence const& buffers, error_code& ec); /** Write a complete message asynchronously. This function is used to asynchronously write a complete message. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The complete message is written. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. The program must ensure that no other calls to @ref write, @ref write_some, @ref async_write, or @ref async_write_some are performed until this operation completes. The current setting of the @ref binary option controls whether the message opcode is set to text or binary. If the @ref auto_fragment option is set, the message will be split into one or more frames as necessary. The actual payload contents sent may be transformed as per the WebSocket protocol settings. @param buffers A buffer sequence containing the entire message payload. The implementation will make copies of this object as needed, but ownership of the underlying memory is not transferred. The caller is responsible for ensuring that the memory locations pointed to by buffers remains valid until the completion handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation std::size_t bytes_transferred // Number of bytes sent from the // buffers. If an error occurred, // this will be less than the buffer_size. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Write some message data. This function is used to send part of a message. The call blocks until one of the following is true: @li The message data is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. If this is the beginning of a new message, the message opcode will be set to text or binary based on the current setting of the @ref binary (or @ref text) option. The actual payload sent may be transformed as per the WebSocket protocol settings. @param fin `true` if this is the last part of the message. @param buffers The buffers containing the message part to send. @return The number of bytes sent from the buffers. @throws system_error Thrown on failure. */ template<class ConstBufferSequence> std::size_t write_some(bool fin, ConstBufferSequence const& buffers); /** Write some message data. This function is used to send part of a message. The call blocks until one of the following is true: @li The message data is written. @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `write_some` function. If this is the beginning of a new message, the message opcode will be set to text or binary based on the current setting of the @ref binary (or @ref text) option. The actual payload sent may be transformed as per the WebSocket protocol settings. @param fin `true` if this is the last part of the message. @param buffers The buffers containing the message part to send. @param ec Set to indicate what error occurred, if any. @return The number of bytes sent from the buffers. @return The number of bytes consumed in the input buffers. */ template<class ConstBufferSequence> std::size_t write_some(bool fin, ConstBufferSequence const& buffers, error_code& ec); /** Write some message data asynchronously. This function is used to asynchronously write part of a message. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The message data is written. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. The program must ensure that no other calls to @ref write, @ref write_some, @ref async_write, or @ref async_write_some are performed until this operation completes. If this is the beginning of a new message, the message opcode will be set to text or binary based on the current setting of the @ref binary (or @ref text) option. The actual payload sent may be transformed as per the WebSocket protocol settings. @param fin `true` if this is the last part of the message. @param buffers The buffers containing the message part to send. The implementation will make copies of this object as needed, but ownership of the underlying memory is not transferred. The caller is responsible for ensuring that the memory locations pointed to by buffers remains valid until the completion handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation std::size_t bytes_transferred // Number of bytes sent from the // buffers. If an error occurred, // this will be less than the buffer_size. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( bool fin, ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t< executor_type>{}); private: template<class, class> class accept_op; template<class> class close_op; template<class> class handshake_op; template<class> class ping_op; template<class> class idle_ping_op; template<class, class> class read_some_op; template<class, class> class read_op; template<class> class response_op; template<class, class> class write_some_op; template<class, class> class write_op; struct run_accept_op; struct run_close_op; struct run_handshake_op; struct run_ping_op; struct run_idle_ping_op; struct run_read_some_op; struct run_read_op; struct run_response_op; struct run_write_some_op; struct run_write_op; static void default_decorate_req(request_type&) {} static void default_decorate_res(response_type&) {} // // accept / handshake // template<class Buffers, class Decorator> void do_accept( Buffers const& buffers, Decorator const& decorator, error_code& ec); template< class Body, class Allocator, class Decorator> void do_accept( http::request<Body, http::basic_fields<Allocator>> const& req, Decorator const& decorator, error_code& ec); template<class RequestDecorator> void do_handshake(response_type* res_p, string_view host, string_view target, RequestDecorator const& decorator, error_code& ec); // // fail // void do_fail( std::uint16_t code, error_code ev, error_code& ec); }; /** Manually provide a one-time seed to initialize the PRNG This function invokes the specified seed sequence to produce a seed suitable for use with the pseudo-random number generator used to create masks and perform WebSocket protocol handshakes. If a seed is not manually provided, the implementation will perform a one-time seed generation using `std::random_device`. This function may be used when the application runs in an environment where the random device is unreliable or does not provide sufficient entropy. @par Preconditions This function may not be called after any websocket @ref stream objects have been constructed. @param ss A reference to a `std::seed_seq` which will be used to seed the pseudo-random number generator. The seed sequence should have at least 256 bits of entropy. @see stream::secure_prng */ inline void seed_prng(std::seed_seq& ss) { detail::prng_seed(&ss); } } // websocket } // beast } // boost #include <boost/beast/websocket/impl/stream_impl.hpp> // must be first #include <boost/beast/websocket/impl/accept.hpp> #include <boost/beast/websocket/impl/close.hpp> #include <boost/beast/websocket/impl/handshake.hpp> #include <boost/beast/websocket/impl/ping.hpp> #include <boost/beast/websocket/impl/read.hpp> #include <boost/beast/websocket/impl/stream.hpp> #include <boost/beast/websocket/impl/write.hpp> #endif PK OP�[ �� � websocket/stream_fwd.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_STREAM_FWD_HPP #define BOOST_BEAST_WEBSOCKET_STREAM_FWD_HPP #include <boost/beast/core/detail/config.hpp> //[code_websocket_1h namespace boost { namespace beast { namespace websocket { template< class NextLayer, bool deflateSupported = true> class stream; } // websocket } // beast } // boost //] #endif PK OP�[*���M M websocket/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_ERROR_HPP #define BOOST_BEAST_WEBSOCKET_ERROR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> namespace boost { namespace beast { namespace websocket { /// Error codes returned from @ref beast::websocket::stream operations. enum class error { /** The WebSocket stream was gracefully closed at both endpoints */ closed = 1, /* The error codes error::failed and error::handshake_failed are no longer in use. Please change your code to compare values of type error_code against condition::handshake_failed and condition::protocol_violation instead. Apologies for the inconvenience. - VFALCO */ #if ! BOOST_BEAST_DOXYGEN unused1 = 2, // failed unused2 = 3, // handshake_failed #endif /** The WebSocket operation caused a dynamic buffer overflow */ buffer_overflow, /** The WebSocket stream produced an incomplete deflate block */ partial_deflate_block, /** The WebSocket message exceeded the locally configured limit */ message_too_big, // // Handshake failure errors // // These will compare equal to condition::handshake_failed // /** The WebSocket handshake was not HTTP/1.1 Error codes with this value will compare equal to @ref condition::handshake_failed */ bad_http_version, /** The WebSocket handshake method was not GET Error codes with this value will compare equal to @ref condition::handshake_failed */ bad_method, /** The WebSocket handshake Host field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_host, /** The WebSocket handshake Connection field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_connection, /** The WebSocket handshake Connection field is missing the upgrade token Error codes with this value will compare equal to @ref condition::handshake_failed */ no_connection_upgrade, /** The WebSocket handshake Upgrade field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_upgrade, /** The WebSocket handshake Upgrade field is missing the websocket token Error codes with this value will compare equal to @ref condition::handshake_failed */ no_upgrade_websocket, /** The WebSocket handshake Sec-WebSocket-Key field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_sec_key, /** The WebSocket handshake Sec-WebSocket-Key field is invalid Error codes with this value will compare equal to @ref condition::handshake_failed */ bad_sec_key, /** The WebSocket handshake Sec-WebSocket-Version field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_sec_version, /** The WebSocket handshake Sec-WebSocket-Version field is invalid Error codes with this value will compare equal to @ref condition::handshake_failed */ bad_sec_version, /** The WebSocket handshake Sec-WebSocket-Accept field is missing Error codes with this value will compare equal to @ref condition::handshake_failed */ no_sec_accept, /** The WebSocket handshake Sec-WebSocket-Accept field is invalid Error codes with this value will compare equal to @ref condition::handshake_failed */ bad_sec_accept, /** The WebSocket handshake was declined by the remote peer Error codes with this value will compare equal to @ref condition::handshake_failed */ upgrade_declined, // // Protocol errors // // These will compare equal to condition::protocol_violation // /** The WebSocket frame contained an illegal opcode Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_opcode, /** The WebSocket data frame was unexpected Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_data_frame, /** The WebSocket continuation frame was unexpected Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_continuation, /** The WebSocket frame contained illegal reserved bits Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_reserved_bits, /** The WebSocket control frame was fragmented Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_control_fragment, /** The WebSocket control frame size was invalid Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_control_size, /** The WebSocket frame was unmasked Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_unmasked_frame, /** The WebSocket frame was masked Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_masked_frame, /** The WebSocket frame size was not canonical Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_size, /** The WebSocket frame payload was not valid utf8 Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_frame_payload, /** The WebSocket close frame reason code was invalid Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_close_code, /** The WebSocket close frame payload size was invalid Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_close_size, /** The WebSocket close frame payload was not valid utf8 Error codes with this value will compare equal to @ref condition::protocol_violation */ bad_close_payload }; /// Error conditions corresponding to sets of error codes. enum class condition { /** The WebSocket handshake failed This condition indicates that the WebSocket handshake failed. If the corresponding HTTP response indicates the keep-alive behavior, then the handshake may be reattempted. */ handshake_failed = 1, /** A WebSocket protocol violation occurred This condition indicates that the remote peer on the WebSocket connection sent data which violated the protocol. */ protocol_violation }; } // websocket } // beast } // boost #include <boost/beast/websocket/impl/error.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/impl/error.ipp> #endif #endif PK OP�[�"�� � websocket/detail/type_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_TYPE_TRAITS_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_TYPE_TRAITS_HPP #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/core/detail/is_invocable.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { template<class F> using is_request_decorator = typename beast::detail::is_invocable<F, void(request_type&)>::type; template<class F> using is_response_decorator = typename beast::detail::is_invocable<F, void(response_type&)>::type; } // detail } // websocket } // beast } // boost #endif PK OP�[��[�/ / websocket/detail/frame.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_FRAME_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_FRAME_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/websocket/error.hpp> #include <boost/beast/websocket/rfc6455.hpp> #include <boost/beast/websocket/detail/utf8_checker.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/asio/buffer.hpp> #include <boost/assert.hpp> #include <boost/endian/conversion.hpp> #include <cstdint> namespace boost { namespace beast { namespace websocket { namespace detail { // frame header opcodes enum class opcode : std::uint8_t { cont = 0, text = 1, binary = 2, rsv3 = 3, rsv4 = 4, rsv5 = 5, rsv6 = 6, rsv7 = 7, close = 8, ping = 9, pong = 10, crsvb = 11, crsvc = 12, crsvd = 13, crsve = 14, crsvf = 15 }; // Contents of a WebSocket frame header struct frame_header { std::uint64_t len; std::uint32_t key; opcode op; bool fin : 1; bool mask : 1; bool rsv1 : 1; bool rsv2 : 1; bool rsv3 : 1; }; // holds the largest possible frame header using fh_buffer = flat_static_buffer<14>; // holds the largest possible control frame using frame_buffer = flat_static_buffer< 2 + 8 + 4 + 125 >; inline bool constexpr is_reserved(opcode op) { return (op >= opcode::rsv3 && op <= opcode::rsv7) || (op >= opcode::crsvb && op <= opcode::crsvf); } inline bool constexpr is_valid(opcode op) { return op <= opcode::crsvf; } inline bool constexpr is_control(opcode op) { return op >= opcode::close; } inline bool is_valid_close_code(std::uint16_t v) { switch(v) { case close_code::normal: // 1000 case close_code::going_away: // 1001 case close_code::protocol_error: // 1002 case close_code::unknown_data: // 1003 case close_code::bad_payload: // 1007 case close_code::policy_error: // 1008 case close_code::too_big: // 1009 case close_code::needs_extension: // 1010 case close_code::internal_error: // 1011 case close_code::service_restart: // 1012 case close_code::try_again_later: // 1013 return true; // explicitly reserved case close_code::reserved1: // 1004 case close_code::no_status: // 1005 case close_code::abnormal: // 1006 case close_code::reserved2: // 1014 case close_code::reserved3: // 1015 return false; } // reserved if(v >= 1016 && v <= 2999) return false; // not used if(v <= 999) return false; return true; } //------------------------------------------------------------------------------ // Write frame header to dynamic buffer // template<class DynamicBuffer> void write(DynamicBuffer& db, frame_header const& fh) { std::size_t n; std::uint8_t b[14]; b[0] = (fh.fin ? 0x80 : 0x00) | static_cast<std::uint8_t>(fh.op); if(fh.rsv1) b[0] |= 0x40; if(fh.rsv2) b[0] |= 0x20; if(fh.rsv3) b[0] |= 0x10; b[1] = fh.mask ? 0x80 : 0x00; if(fh.len <= 125) { b[1] |= fh.len; n = 2; } else if(fh.len <= 65535) { b[1] |= 126; auto len_be = endian::native_to_big( static_cast<std::uint16_t>(fh.len)); std::memcpy(&b[2], &len_be, sizeof(len_be)); n = 4; } else { b[1] |= 127; auto len_be = endian::native_to_big( static_cast<std::uint64_t>(fh.len)); std::memcpy(&b[2], &len_be, sizeof(len_be)); n = 10; } if(fh.mask) { auto key_le = endian::native_to_little( static_cast<std::uint32_t>(fh.key)); std::memcpy(&b[n], &key_le, sizeof(key_le)); n += 4; } db.commit(net::buffer_copy( db.prepare(n), net::buffer(b))); } // Read data from buffers // This is for ping and pong payloads // template<class Buffers> void read_ping(ping_data& data, Buffers const& bs) { BOOST_ASSERT(buffer_bytes(bs) <= data.max_size()); data.resize(buffer_bytes(bs)); net::buffer_copy(net::mutable_buffer{ data.data(), data.size()}, bs); } // Read close_reason, return true on success // This is for the close payload // template<class Buffers> void read_close( close_reason& cr, Buffers const& bs, error_code& ec) { auto const n = buffer_bytes(bs); BOOST_ASSERT(n <= 125); if(n == 0) { cr = close_reason{}; ec = {}; return; } if(n == 1) { // invalid payload size == 1 ec = error::bad_close_size; return; } std::uint16_t code_be; cr.reason.resize(n - 2); std::array<net::mutable_buffer, 2> out_bufs{{ net::mutable_buffer(&code_be, sizeof(code_be)), net::mutable_buffer(&cr.reason[0], n - 2)}}; net::buffer_copy(out_bufs, bs); cr.code = endian::big_to_native(code_be); if(! is_valid_close_code(cr.code)) { // invalid close code ec = error::bad_close_code; return; } if(n > 2 && !check_utf8( cr.reason.data(), cr.reason.size())) { // not valid utf-8 ec = error::bad_close_payload; return; } ec = {}; } } // detail } // websocket } // beast } // boost #endif PK OP�[s��� � websocket/detail/soft_mutex.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_SOFT_MUTEX_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_SOFT_MUTEX_HPP #include <boost/assert.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { // used to order reads, writes in websocket streams class soft_mutex { int id_ = 0; public: soft_mutex() = default; soft_mutex(soft_mutex const&) = delete; soft_mutex& operator=(soft_mutex const&) = delete; soft_mutex(soft_mutex&& other) noexcept : id_(boost::exchange(other.id_, 0)) { } soft_mutex& operator=(soft_mutex&& other) noexcept { id_ = other.id_; other.id_ = 0; return *this; } // VFALCO I'm not too happy that this function is needed void reset() { id_ = 0; } bool is_locked() const noexcept { return id_ != 0; } template<class T> bool is_locked(T const*) const noexcept { return id_ == T::id; } template<class T> void lock(T const*) { BOOST_ASSERT(id_ == 0); id_ = T::id; } template<class T> void unlock(T const*) { BOOST_ASSERT(id_ == T::id); id_ = 0; } template<class T> bool try_lock(T const*) { // If this assert goes off it means you are attempting to // simultaneously initiate more than one of same asynchronous // operation, which is not allowed. For example, you must wait // for an async_read to complete before performing another // async_read. // BOOST_ASSERT(id_ != T::id); if(id_ != 0) return false; id_ = T::id; return true; } template<class T> bool try_unlock(T const*) noexcept { if(id_ != T::id) return false; id_ = 0; return true; } }; } // detail } // websocket } // beast } // boost #endif PK OP�[>�q# # websocket/detail/service.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_SERVICE_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_SERVICE_HPP #include <boost/beast/core/detail/service_base.hpp> #include <boost/asio/execution_context.hpp> #include <boost/enable_shared_from_this.hpp> #include <mutex> #include <vector> namespace boost { namespace beast { namespace websocket { namespace detail { class service : public beast::detail::service_base<service> { public: class impl_type : public boost::enable_shared_from_this<impl_type> { service& svc_; std::size_t index_; friend class service; public: virtual ~impl_type() = default; BOOST_BEAST_DECL explicit impl_type(net::execution_context& ctx); BOOST_BEAST_DECL void remove(); virtual void shutdown() = 0; }; private: std::mutex m_; std::vector<impl_type*> v_; BOOST_BEAST_DECL void shutdown() override; public: BOOST_BEAST_DECL explicit service(net::execution_context& ctx) : beast::detail::service_base<service>(ctx) { } }; } // detail } // websocket } // beast } // boost #if BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/service.ipp> #endif #endif PK OP�[l���C1 C1 websocket/detail/impl_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_IMPL_BASE_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_IMPL_BASE_HPP #include <boost/beast/websocket/option.hpp> #include <boost/beast/websocket/detail/frame.hpp> #include <boost/beast/websocket/detail/pmd_extension.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/role.hpp> #include <boost/beast/http/empty_body.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/string_body.hpp> #include <boost/beast/zlib/deflate_stream.hpp> #include <boost/beast/zlib/inflate_stream.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/asio/buffer.hpp> #include <cstdint> #include <memory> #include <stdexcept> namespace boost { namespace beast { namespace websocket { namespace detail { //------------------------------------------------------------------------------ template<bool deflateSupported> struct impl_base; template<> struct impl_base<true> { // State information for the permessage-deflate extension struct pmd_type { // `true` if current read message is compressed bool rd_set = false; zlib::deflate_stream zo; zlib::inflate_stream zi; }; std::unique_ptr<pmd_type> pmd_; // pmd settings or nullptr permessage_deflate pmd_opts_; // local pmd options detail::pmd_offer pmd_config_; // offer (client) or negotiation (server) // return `true` if current message is deflated bool rd_deflated() const { return pmd_ && pmd_->rd_set; } // set whether current message is deflated // returns `false` on protocol violation bool rd_deflated(bool rsv1) { if(pmd_) { pmd_->rd_set = rsv1; return true; } return ! rsv1; // pmd not negotiated } // Compress a buffer sequence // Returns: `true` if more calls are needed // template<class ConstBufferSequence> bool deflate( net::mutable_buffer& out, buffers_suffix<ConstBufferSequence>& cb, bool fin, std::size_t& total_in, error_code& ec) { BOOST_ASSERT(out.size() >= 6); auto& zo = this->pmd_->zo; zlib::z_params zs; zs.avail_in = 0; zs.next_in = nullptr; zs.avail_out = out.size(); zs.next_out = out.data(); for(auto in : beast::buffers_range_ref(cb)) { zs.avail_in = in.size(); if(zs.avail_in == 0) continue; zs.next_in = in.data(); zo.write(zs, zlib::Flush::none, ec); if(ec) { if(ec != zlib::error::need_buffers) return false; BOOST_ASSERT(zs.avail_out == 0); BOOST_ASSERT(zs.total_out == out.size()); ec = {}; break; } if(zs.avail_out == 0) { BOOST_ASSERT(zs.total_out == out.size()); break; } BOOST_ASSERT(zs.avail_in == 0); } total_in = zs.total_in; cb.consume(zs.total_in); if(zs.avail_out > 0 && fin) { auto const remain = buffer_bytes(cb); if(remain == 0) { // Inspired by Mark Adler // https://github.com/madler/zlib/issues/149 // // VFALCO We could do this flush twice depending // on how much space is in the output. zo.write(zs, zlib::Flush::block, ec); BOOST_ASSERT(! ec || ec == zlib::error::need_buffers); if(ec == zlib::error::need_buffers) ec = {}; if(ec) return false; if(zs.avail_out >= 6) { zo.write(zs, zlib::Flush::full, ec); BOOST_ASSERT(! ec); // remove flush marker zs.total_out -= 4; out = net::buffer(out.data(), zs.total_out); return false; } } } ec = {}; out = net::buffer(out.data(), zs.total_out); return true; } void do_context_takeover_write(role_type role) { if((role == role_type::client && this->pmd_config_.client_no_context_takeover) || (role == role_type::server && this->pmd_config_.server_no_context_takeover)) { this->pmd_->zo.reset(); } } void inflate( zlib::z_params& zs, zlib::Flush flush, error_code& ec) { pmd_->zi.write(zs, flush, ec); } void do_context_takeover_read(role_type role) { if((role == role_type::client && pmd_config_.server_no_context_takeover) || (role == role_type::server && pmd_config_.client_no_context_takeover)) { pmd_->zi.clear(); } } template<class Body, class Allocator> void build_response_pmd( http::response<http::string_body>& res, http::request<Body, http::basic_fields<Allocator>> const& req); void on_response_pmd( http::response<http::string_body> const& res) { detail::pmd_offer offer; detail::pmd_read(offer, res); // VFALCO see if offer satisfies pmd_config_, // return an error if not. pmd_config_ = offer; // overwrite for now } template<class Allocator> void do_pmd_config( http::basic_fields<Allocator> const& h) { detail::pmd_read(pmd_config_, h); } void set_option_pmd(permessage_deflate const& o) { if( o.server_max_window_bits > 15 || o.server_max_window_bits < 9) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid server_max_window_bits"}); if( o.client_max_window_bits > 15 || o.client_max_window_bits < 9) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid client_max_window_bits"}); if( o.compLevel < 0 || o.compLevel > 9) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid compLevel"}); if( o.memLevel < 1 || o.memLevel > 9) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid memLevel"}); pmd_opts_ = o; } void get_option_pmd(permessage_deflate& o) { o = pmd_opts_; } void build_request_pmd(http::request<http::empty_body>& req) { if(pmd_opts_.client_enable) { detail::pmd_offer config; config.accept = true; config.server_max_window_bits = pmd_opts_.server_max_window_bits; config.client_max_window_bits = pmd_opts_.client_max_window_bits; config.server_no_context_takeover = pmd_opts_.server_no_context_takeover; config.client_no_context_takeover = pmd_opts_.client_no_context_takeover; detail::pmd_write(req, config); } } void open_pmd(role_type role) { if(((role == role_type::client && pmd_opts_.client_enable) || (role == role_type::server && pmd_opts_.server_enable)) && pmd_config_.accept) { detail::pmd_normalize(pmd_config_); pmd_.reset(::new pmd_type); if(role == role_type::client) { pmd_->zi.reset( pmd_config_.server_max_window_bits); pmd_->zo.reset( pmd_opts_.compLevel, pmd_config_.client_max_window_bits, pmd_opts_.memLevel, zlib::Strategy::normal); } else { pmd_->zi.reset( pmd_config_.client_max_window_bits); pmd_->zo.reset( pmd_opts_.compLevel, pmd_config_.server_max_window_bits, pmd_opts_.memLevel, zlib::Strategy::normal); } } } void close_pmd() { pmd_.reset(); } bool pmd_enabled() const { return pmd_ != nullptr; } std::size_t read_size_hint_pmd( std::size_t initial_size, bool rd_done, std::uint64_t rd_remain, detail::frame_header const& rd_fh) const { using beast::detail::clamp; std::size_t result; BOOST_ASSERT(initial_size > 0); if(! pmd_ || (! rd_done && ! pmd_->rd_set)) { // current message is uncompressed if(rd_done) { // first message frame result = initial_size; goto done; } else if(rd_fh.fin) { // last message frame BOOST_ASSERT(rd_remain > 0); result = clamp(rd_remain); goto done; } } result = (std::max)( initial_size, clamp(rd_remain)); done: BOOST_ASSERT(result != 0); return result; } }; //------------------------------------------------------------------------------ template<> struct impl_base<false> { // These stubs are for avoiding linking in the zlib // code when permessage-deflate is not enabled. bool rd_deflated() const { return false; } bool rd_deflated(bool rsv1) { return ! rsv1; } template<class ConstBufferSequence> bool deflate( net::mutable_buffer&, buffers_suffix<ConstBufferSequence>&, bool, std::size_t&, error_code&) { return false; } void do_context_takeover_write(role_type) { } void inflate( zlib::z_params&, zlib::Flush, error_code&) { } void do_context_takeover_read(role_type) { } template<class Body, class Allocator> void build_response_pmd( http::response<http::string_body>&, http::request<Body, http::basic_fields<Allocator>> const&); void on_response_pmd( http::response<http::string_body> const&) { } template<class Allocator> void do_pmd_config(http::basic_fields<Allocator> const&) { } void set_option_pmd(permessage_deflate const& o) { if(o.client_enable || o.server_enable) { // Can't enable permessage-deflate // when deflateSupported == false. // BOOST_THROW_EXCEPTION(std::invalid_argument{ "deflateSupported == false"}); } } void get_option_pmd(permessage_deflate& o) { o = {}; o.client_enable = false; o.server_enable = false; } void build_request_pmd( http::request<http::empty_body>&) { } void open_pmd(role_type) { } void close_pmd() { } bool pmd_enabled() const { return false; } std::size_t read_size_hint_pmd( std::size_t initial_size, bool rd_done, std::uint64_t rd_remain, frame_header const& rd_fh) const { using beast::detail::clamp; std::size_t result; BOOST_ASSERT(initial_size > 0); // compression is not supported if(rd_done) { // first message frame result = initial_size; } else if(rd_fh.fin) { // last message frame BOOST_ASSERT(rd_remain > 0); result = clamp(rd_remain); } else { result = (std::max)( initial_size, clamp(rd_remain)); } BOOST_ASSERT(result != 0); return result; } }; } // detail } // websocket } // beast } // boost #endif PK OP�[9�� � " websocket/detail/pmd_extension.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_PMD_EXTENSION_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_PMD_EXTENSION_HPP #include <boost/beast/core/error.hpp> #include <boost/beast/websocket/option.hpp> #include <boost/beast/http/rfc7230.hpp> #include <utility> #include <type_traits> namespace boost { namespace beast { namespace websocket { namespace detail { // permessage-deflate offer parameters // // "context takeover" means: // preserve sliding window across messages // struct pmd_offer { bool accept; // 0 = absent, or 8..15 int server_max_window_bits; // -1 = present, 0 = absent, or 8..15 int client_max_window_bits; // `true` if server_no_context_takeover offered bool server_no_context_takeover; // `true` if client_no_context_takeover offered bool client_no_context_takeover; }; BOOST_BEAST_DECL int parse_bits(string_view s); BOOST_BEAST_DECL void pmd_read_impl(pmd_offer& offer, http::ext_list const& list); BOOST_BEAST_DECL static_string<512> pmd_write_impl(pmd_offer const& offer); BOOST_BEAST_DECL static_string<512> pmd_negotiate_impl( pmd_offer& config, pmd_offer const& offer, permessage_deflate const& o); // Parse permessage-deflate request fields // template<class Allocator> void pmd_read(pmd_offer& offer, http::basic_fields<Allocator> const& fields) { http::ext_list list{ fields["Sec-WebSocket-Extensions"]}; detail::pmd_read_impl(offer, list); } // Set permessage-deflate fields for a client offer // template<class Allocator> void pmd_write(http::basic_fields<Allocator>& fields, pmd_offer const& offer) { auto s = detail::pmd_write_impl(offer); fields.set(http::field::sec_websocket_extensions, s); } // Negotiate a permessage-deflate client offer // template<class Allocator> void pmd_negotiate( http::basic_fields<Allocator>& fields, pmd_offer& config, pmd_offer const& offer, permessage_deflate const& o) { if(! (offer.accept && o.server_enable)) { config.accept = false; return; } config.accept = true; auto s = detail::pmd_negotiate_impl(config, offer, o); if(config.accept) fields.set(http::field::sec_websocket_extensions, s); } // Normalize the server's response // BOOST_BEAST_DECL void pmd_normalize(pmd_offer& offer); } // detail } // websocket } // beast } // boost #if BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/pmd_extension.ipp> #endif #endif PK OP�[)5�U� � websocket/detail/mask.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_MASK_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_MASK_IPP #include <boost/beast/websocket/detail/mask.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { void prepare_key(prepared_key& prepared, std::uint32_t key) { prepared[0] = (key >> 0) & 0xff; prepared[1] = (key >> 8) & 0xff; prepared[2] = (key >> 16) & 0xff; prepared[3] = (key >> 24) & 0xff; } inline void rol(prepared_key& v, std::size_t n) { auto v0 = v; for(std::size_t i = 0; i < v.size(); ++i ) v[i] = v0[(i + n) % v.size()]; } // Apply mask in place // void mask_inplace(net::mutable_buffer const& b, prepared_key& key) { auto n = b.size(); auto const mask = key; // avoid aliasing auto p = static_cast<unsigned char*>(b.data()); while(n >= 4) { for(int i = 0; i < 4; ++i) p[i] ^= mask[i]; p += 4; n -= 4; } if(n > 0) { for(std::size_t i = 0; i < n; ++i) p[i] ^= mask[i]; rol(key, n); } } } // detail } // websocket } // beast } // boost #endif PK OP�[_��� � websocket/detail/hybi13.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_HYBI13_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_HYBI13_IPP #include <boost/beast/websocket/detail/hybi13.hpp> #include <boost/beast/core/detail/sha1.hpp> #include <boost/beast/websocket/detail/prng.hpp> #include <boost/assert.hpp> #include <cstdint> #include <string> namespace boost { namespace beast { namespace websocket { namespace detail { void make_sec_ws_key(sec_ws_key_type& key) { auto g = make_prng(true); std::uint32_t a[4]; for (auto& v : a) v = g(); key.resize(key.max_size()); key.resize(beast::detail::base64::encode( key.data(), &a[0], sizeof(a))); } void make_sec_ws_accept( sec_ws_accept_type& accept, string_view key) { BOOST_ASSERT(key.size() <= sec_ws_key_type::max_size_n); using namespace beast::detail::string_literals; auto const guid = "258EAFA5-E914-47DA-95CA-C5AB0DC85B11"_sv; beast::detail::sha1_context ctx; beast::detail::init(ctx); beast::detail::update(ctx, key.data(), key.size()); beast::detail::update(ctx, guid.data(), guid.size()); char digest[beast::detail::sha1_context::digest_size]; beast::detail::finish(ctx, &digest[0]); accept.resize(accept.max_size()); accept.resize(beast::detail::base64::encode( accept.data(), &digest[0], sizeof(digest))); } } // detail } // websocket } // beast } // boost #endif // BOOST_BEAST_WEBSOCKET_DETAIL_HYBI13_IPP PK OP�[�łsP P websocket/detail/hybi13.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_HYBI13_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_HYBI13_HPP #include <boost/beast/core/static_string.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/base64.hpp> #include <cstdint> namespace boost { namespace beast { namespace websocket { namespace detail { using sec_ws_key_type = static_string< beast::detail::base64::encoded_size(16)>; using sec_ws_accept_type = static_string< beast::detail::base64::encoded_size(20)>; BOOST_BEAST_DECL void make_sec_ws_key(sec_ws_key_type& key); BOOST_BEAST_DECL void make_sec_ws_accept( sec_ws_accept_type& accept, string_view key); } // detail } // websocket } // beast } // boost #if BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/hybi13.ipp> #endif #endif PK PP�[t�F�$ $ ! websocket/detail/utf8_checker.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_HPP #include <boost/beast/core/buffers_range.hpp> #include <boost/asio/buffer.hpp> #include <cstdint> namespace boost { namespace beast { namespace websocket { namespace detail { /** A UTF8 validator. This validator can be used to check if a buffer containing UTF8 text is valid. The write function may be called incrementally with segmented UTF8 sequences. The finish function determines if all processed text is valid. */ class utf8_checker { std::size_t need_ = 0; // chars we need to finish the code point std::uint8_t* p_ = cp_; // current position in temp buffer std::uint8_t cp_[4]; // a temp buffer for the code point public: /** Prepare to process text as valid utf8 */ BOOST_BEAST_DECL void reset(); /** Check that all processed text is valid utf8 */ BOOST_BEAST_DECL bool finish(); /** Check if text is valid UTF8 @return `true` if the text is valid utf8 or false otherwise. */ BOOST_BEAST_DECL bool write(std::uint8_t const* in, std::size_t size); /** Check if text is valid UTF8 @return `true` if the text is valid utf8 or false otherwise. */ template<class ConstBufferSequence> bool write(ConstBufferSequence const& bs); }; template<class ConstBufferSequence> bool utf8_checker:: write(ConstBufferSequence const& buffers) { static_assert( net::is_const_buffer_sequence<ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); for(auto b : beast::buffers_range_ref(buffers)) if(! write(static_cast< std::uint8_t const*>(b.data()), b.size())) return false; return true; } BOOST_BEAST_DECL bool check_utf8(char const* p, std::size_t n); } // detail } // websocket } // beast } // boost #if BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/utf8_checker.ipp> #endif #endif PK PP�[�2F� � websocket/detail/prng.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_PRNG_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_PRNG_IPP #include <boost/beast/websocket/detail/prng.hpp> #include <boost/beast/core/detail/chacha.hpp> #include <boost/beast/core/detail/pcg.hpp> #include <atomic> #include <cstdlib> #include <mutex> #include <random> namespace boost { namespace beast { namespace websocket { namespace detail { //------------------------------------------------------------------------------ std::uint32_t const* prng_seed(std::seed_seq* ss) { struct data { std::uint32_t v[8]; explicit data(std::seed_seq* pss) { if(! pss) { std::random_device g; std::seed_seq ss{ g(), g(), g(), g(), g(), g(), g(), g()}; ss.generate(v, v+8); } else { pss->generate(v, v+8); } } }; static data const d(ss); return d.v; } //------------------------------------------------------------------------------ inline std::uint32_t make_nonce() { static std::atomic<std::uint32_t> nonce{0}; return ++nonce; } inline beast::detail::pcg make_pcg() { auto const pv = prng_seed(); return beast::detail::pcg{ ((static_cast<std::uint64_t>(pv[0])<<32)+pv[1]) ^ ((static_cast<std::uint64_t>(pv[2])<<32)+pv[3]) ^ ((static_cast<std::uint64_t>(pv[4])<<32)+pv[5]) ^ ((static_cast<std::uint64_t>(pv[6])<<32)+pv[7]), make_nonce()}; } #ifdef BOOST_NO_CXX11_THREAD_LOCAL inline std::uint32_t secure_generate() { struct generator { std::uint32_t operator()() { std::lock_guard<std::mutex> guard{mtx}; return gen(); } beast::detail::chacha<20> gen; std::mutex mtx; }; static generator gen{beast::detail::chacha<20>{prng_seed(), make_nonce()}}; return gen(); } inline std::uint32_t fast_generate() { struct generator { std::uint32_t operator()() { std::lock_guard<std::mutex> guard{mtx}; return gen(); } beast::detail::pcg gen; std::mutex mtx; }; static generator gen{make_pcg()}; return gen(); } #else inline std::uint32_t secure_generate() { thread_local static beast::detail::chacha<20> gen{prng_seed(), make_nonce()}; return gen(); } inline std::uint32_t fast_generate() { thread_local static beast::detail::pcg gen{make_pcg()}; return gen(); } #endif generator make_prng(bool secure) { if (secure) return &secure_generate; else return &fast_generate; } } // detail } // websocket } // beast } // boost #endif PK PP�[(���% �% ! websocket/detail/utf8_checker.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_IPP #include <boost/beast/websocket/detail/utf8_checker.hpp> #include <boost/assert.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { void utf8_checker:: reset() { need_ = 0; p_ = cp_; } bool utf8_checker:: finish() { auto const success = need_ == 0; reset(); return success; } bool utf8_checker:: write(std::uint8_t const* in, std::size_t size) { auto const valid = [](std::uint8_t const*& p) { if(p[0] < 128) { ++p; return true; } if((p[0] & 0xe0) == 0xc0) { if( (p[1] & 0xc0) != 0x80 || (p[0] & 0x1e) == 0) // overlong return false; p += 2; return true; } if((p[0] & 0xf0) == 0xe0) { if( (p[1] & 0xc0) != 0x80 || (p[2] & 0xc0) != 0x80 || (p[0] == 0xe0 && (p[1] & 0x20) == 0) // overlong || (p[0] == 0xed && (p[1] & 0x20) == 0x20) // surrogate //|| (p[0] == 0xef && p[1] == 0xbf && (p[2] & 0xfe) == 0xbe) // U+FFFE or U+FFFF ) return false; p += 3; return true; } if((p[0] & 0xf8) == 0xf0) { if( (p[0] & 0x07) >= 0x05 // invalid F5...FF characters || (p[1] & 0xc0) != 0x80 || (p[2] & 0xc0) != 0x80 || (p[3] & 0xc0) != 0x80 || (p[0] == 0xf0 && (p[1] & 0x30) == 0) // overlong || (p[0] == 0xf4 && p[1] > 0x8f) || p[0] > 0xf4 // > U+10FFFF ) return false; p += 4; return true; } return false; }; auto const fail_fast = [&]() { if(cp_[0] < 128) { return false; } const auto& p = cp_; // alias, only to keep this code similar to valid() above const auto known_only = p_ - cp_; if (known_only == 1) { if((p[0] & 0xe0) == 0xc0) { return ((p[0] & 0x1e) == 0); // overlong } if((p[0] & 0xf0) == 0xe0) { return false; } if((p[0] & 0xf8) == 0xf0) { return ((p[0] & 0x07) >= 0x05); // invalid F5...FF characters } } else if (known_only == 2) { if((p[0] & 0xe0) == 0xc0) { return ((p[1] & 0xc0) != 0x80 || (p[0] & 0x1e) == 0); // overlong } if((p[0] & 0xf0) == 0xe0) { return ( (p[1] & 0xc0) != 0x80 || (p[0] == 0xe0 && (p[1] & 0x20) == 0) // overlong || (p[0] == 0xed && (p[1] & 0x20) == 0x20)); // surrogate } if((p[0] & 0xf8) == 0xf0) { return ( (p[0] & 0x07) >= 0x05 // invalid F5...FF characters || (p[1] & 0xc0) != 0x80 || (p[0] == 0xf0 && (p[1] & 0x30) == 0) // overlong || (p[0] == 0xf4 && p[1] > 0x8f) || p[0] > 0xf4); // > U+10FFFF } } else if (known_only == 3) { if((p[0] & 0xe0) == 0xc0) { return ( (p[1] & 0xc0) != 0x80 || (p[0] & 0x1e) == 0); // overlong } if((p[0] & 0xf0) == 0xe0) { return ( (p[1] & 0xc0) != 0x80 || (p[2] & 0xc0) != 0x80 || (p[0] == 0xe0 && (p[1] & 0x20) == 0) // overlong || (p[0] == 0xed && (p[1] & 0x20) == 0x20)); // surrogate //|| (p[0] == 0xef && p[1] == 0xbf && (p[2] & 0xfe) == 0xbe) // U+FFFE or U+FFFF } if((p[0] & 0xf8) == 0xf0) { return ( (p[0] & 0x07) >= 0x05 // invalid F5...FF characters || (p[1] & 0xc0) != 0x80 || (p[2] & 0xc0) != 0x80 || (p[0] == 0xf0 && (p[1] & 0x30) == 0) // overlong || (p[0] == 0xf4 && p[1] > 0x8f) || p[0] > 0xf4); // > U+10FFFF } } return true; }; auto const needed = [](std::uint8_t const v) { if(v < 128) return 1; if(v < 192) return 0; if(v < 224) return 2; if(v < 240) return 3; if(v < 248) return 4; return 0; }; auto const end = in + size; // Finish up any incomplete code point if(need_ > 0) { // Calculate what we have auto n = (std::min)(size, need_); size -= n; need_ -= n; // Add characters to the code point while(n--) *p_++ = *in++; BOOST_ASSERT(p_ <= cp_ + 4); // Still incomplete? if(need_ > 0) { // Incomplete code point BOOST_ASSERT(in == end); // Do partial validation on the incomplete // code point, this is called "Fail fast" // in Autobahn|Testsuite parlance. return ! fail_fast(); } // Complete code point, validate it std::uint8_t const* p = &cp_[0]; if(! valid(p)) return false; p_ = cp_; } if(size <= sizeof(std::size_t)) goto slow; // Align `in` to sizeof(std::size_t) boundary { auto const in0 = in; auto last = reinterpret_cast<std::uint8_t const*>( ((reinterpret_cast<std::uintptr_t>(in) + sizeof(std::size_t) - 1) / sizeof(std::size_t)) * sizeof(std::size_t)); // Check one character at a time for low-ASCII while(in < last) { if(*in & 0x80) { // Not low-ASCII so switch to slow loop size = size - (in - in0); goto slow; } ++in; } size = size - (in - in0); } // Fast loop: Process 4 or 8 low-ASCII characters at a time { auto const in0 = in; auto last = in + size - 7; auto constexpr mask = static_cast< std::size_t>(0x8080808080808080 & ~std::size_t{0}); while(in < last) { #if 0 std::size_t temp; std::memcpy(&temp, in, sizeof(temp)); if((temp & mask) != 0) #else // Technically UB but works on all known platforms if((*reinterpret_cast<std::size_t const*>(in) & mask) != 0) #endif { size = size - (in - in0); goto slow; } in += sizeof(std::size_t); } // There's at least one more full code point left last += 4; while(in < last) if(! valid(in)) return false; goto tail; } slow: // Slow loop: Full validation on one code point at a time { auto last = in + size - 3; while(in < last) if(! valid(in)) return false; } tail: // Handle the remaining bytes. The last // characters could split a code point so // we save the partial code point for later. // // On entry to the loop, `in` points to the // beginning of a code point. // for(;;) { // Number of chars left auto n = end - in; if(! n) break; // Chars we need to finish this code point auto const need = needed(*in); if(need == 0) return false; if(need <= n) { // Check a whole code point if(! valid(in)) return false; } else { // Calculate how many chars we need // to finish this partial code point need_ = need - n; // Save the partial code point while(n--) *p_++ = *in++; BOOST_ASSERT(in == end); BOOST_ASSERT(p_ <= cp_ + 4); // Do partial validation on the incomplete // code point, this is called "Fail fast" // in Autobahn|Testsuite parlance. return ! fail_fast(); } } return true; } bool check_utf8(char const* p, std::size_t n) { utf8_checker c; if(! c.write(reinterpret_cast<const uint8_t*>(p), n)) return false; return c.finish(); } } // detail } // websocket } // beast } // boost #endif // BOOST_BEAST_WEBSOCKET_DETAIL_UTF8_CHECKER_IPP PK PP�[8N��% �% " websocket/detail/pmd_extension.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_PMD_EXTENSION_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_PMD_EXTENSION_IPP #include <boost/beast/websocket/detail/pmd_extension.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { int parse_bits(string_view s) { if(s.size() == 0) return -1; if(s.size() > 2) return -1; if(s[0] < '1' || s[0] > '9') return -1; unsigned i = 0; for(auto c : s) { if(c < '0' || c > '9') return -1; auto const i0 = i; i = 10 * i + (c - '0'); if(i < i0) return -1; } return static_cast<int>(i); } // Parse permessage-deflate request fields // void pmd_read_impl(pmd_offer& offer, http::ext_list const& list) { offer.accept = false; offer.server_max_window_bits= 0; offer.client_max_window_bits = 0; offer.server_no_context_takeover = false; offer.client_no_context_takeover = false; for(auto const& ext : list) { if(beast::iequals(ext.first, "permessage-deflate")) { for(auto const& param : ext.second) { if(beast::iequals(param.first, "server_max_window_bits")) { if(offer.server_max_window_bits != 0) { // The negotiation offer contains multiple // extension parameters with the same name. // return; // MUST decline } if(param.second.empty()) { // The negotiation offer extension // parameter is missing the value. // return; // MUST decline } offer.server_max_window_bits = parse_bits(param.second); if( offer.server_max_window_bits < 8 || offer.server_max_window_bits > 15) { // The negotiation offer contains an // extension parameter with an invalid value. // return; // MUST decline } } else if(beast::iequals(param.first, "client_max_window_bits")) { if(offer.client_max_window_bits != 0) { // The negotiation offer contains multiple // extension parameters with the same name. // return; // MUST decline } if(! param.second.empty()) { offer.client_max_window_bits = parse_bits(param.second); if( offer.client_max_window_bits < 8 || offer.client_max_window_bits > 15) { // The negotiation offer contains an // extension parameter with an invalid value. // return; // MUST decline } } else { offer.client_max_window_bits = -1; } } else if(beast::iequals(param.first, "server_no_context_takeover")) { if(offer.server_no_context_takeover) { // The negotiation offer contains multiple // extension parameters with the same name. // return; // MUST decline } if(! param.second.empty()) { // The negotiation offer contains an // extension parameter with an invalid value. // return; // MUST decline } offer.server_no_context_takeover = true; } else if(beast::iequals(param.first, "client_no_context_takeover")) { if(offer.client_no_context_takeover) { // The negotiation offer contains multiple // extension parameters with the same name. // return; // MUST decline } if(! param.second.empty()) { // The negotiation offer contains an // extension parameter with an invalid value. // return; // MUST decline } offer.client_no_context_takeover = true; } else { // The negotiation offer contains an extension // parameter not defined for use in an offer. // return; // MUST decline } } offer.accept = true; return; } } } static_string<512> pmd_write_impl(pmd_offer const& offer) { static_string<512> s = "permessage-deflate"; if(offer.server_max_window_bits != 0) { if(offer.server_max_window_bits != -1) { s += "; server_max_window_bits="; s += to_static_string( offer.server_max_window_bits); } else { s += "; server_max_window_bits"; } } if(offer.client_max_window_bits != 0) { if(offer.client_max_window_bits != -1) { s += "; client_max_window_bits="; s += to_static_string( offer.client_max_window_bits); } else { s += "; client_max_window_bits"; } } if(offer.server_no_context_takeover) { s += "; server_no_context_takeover"; } if(offer.client_no_context_takeover) { s += "; client_no_context_takeover"; } return s; } static_string<512> pmd_negotiate_impl( pmd_offer& config, pmd_offer const& offer, permessage_deflate const& o) { static_string<512> s = "permessage-deflate"; config.server_no_context_takeover = offer.server_no_context_takeover || o.server_no_context_takeover; if(config.server_no_context_takeover) s += "; server_no_context_takeover"; config.client_no_context_takeover = o.client_no_context_takeover || offer.client_no_context_takeover; if(config.client_no_context_takeover) s += "; client_no_context_takeover"; if(offer.server_max_window_bits != 0) config.server_max_window_bits = (std::min)( offer.server_max_window_bits, o.server_max_window_bits); else config.server_max_window_bits = o.server_max_window_bits; if(config.server_max_window_bits < 15) { // ZLib's deflateInit silently treats 8 as // 9 due to a bug, so prevent 8 from being used. // if(config.server_max_window_bits < 9) config.server_max_window_bits = 9; s += "; server_max_window_bits="; s += to_static_string( config.server_max_window_bits); } switch(offer.client_max_window_bits) { case -1: // extension parameter is present with no value config.client_max_window_bits = o.client_max_window_bits; if(config.client_max_window_bits < 15) { s += "; client_max_window_bits="; s += to_static_string( config.client_max_window_bits); } break; case 0: /* extension parameter is absent. If a received extension negotiation offer doesn't have the "client_max_window_bits" extension parameter, the corresponding extension negotiation response to the offer MUST NOT include the "client_max_window_bits" extension parameter. */ if(o.client_max_window_bits == 15) config.client_max_window_bits = 15; else config.accept = false; break; default: // extension parameter has value in [8..15] config.client_max_window_bits = (std::min)( o.client_max_window_bits, offer.client_max_window_bits); s += "; client_max_window_bits="; s += to_static_string( config.client_max_window_bits); break; } return s; } void pmd_normalize(pmd_offer& offer) { if(offer.accept) { if( offer.server_max_window_bits == 0) offer.server_max_window_bits = 15; if( offer.client_max_window_bits == 0 || offer.client_max_window_bits == -1) offer.client_max_window_bits = 15; } } } // detail } // websocket } // beast } // boost #endif // BOOST_BEAST_WEBSOCKET_DETAIL_PMD_EXTENSION_IPP PK PP�[� 7�F F websocket/detail/mask.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_MASK_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_MASK_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/asio/buffer.hpp> #include <array> #include <climits> #include <cstdint> #include <random> #include <type_traits> namespace boost { namespace beast { namespace websocket { namespace detail { using prepared_key = std::array<unsigned char, 4>; BOOST_BEAST_DECL void prepare_key(prepared_key& prepared, std::uint32_t key); // Apply mask in place // BOOST_BEAST_DECL void mask_inplace(net::mutable_buffer const& b, prepared_key& key); // Apply mask in place // template<class MutableBufferSequence> void mask_inplace( MutableBufferSequence const& buffers, prepared_key& key) { for(net::mutable_buffer b : beast::buffers_range_ref(buffers)) detail::mask_inplace(b, key); } } // detail } // websocket } // beast } // boost #if BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/mask.ipp> #endif #endif PK PP�[��, , websocket/detail/service.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_SERVICE_IPP #define BOOST_BEAST_WEBSOCKET_DETAIL_SERVICE_IPP #include <boost/beast/websocket/detail/service.hpp> namespace boost { namespace beast { namespace websocket { namespace detail { service:: impl_type:: impl_type(net::execution_context& ctx) : svc_(net::use_service<service>(ctx)) { std::lock_guard<std::mutex> g(svc_.m_); index_ = svc_.v_.size(); svc_.v_.push_back(this); } void service:: impl_type:: remove() { std::lock_guard<std::mutex> g(svc_.m_); auto& other = *svc_.v_.back(); other.index_ = index_; svc_.v_[index_] = &other; svc_.v_.pop_back(); } //--- void service:: shutdown() { std::vector<boost::weak_ptr<impl_type>> v; { std::lock_guard<std::mutex> g(m_); v.reserve(v_.size()); for(auto p : v_) v.emplace_back(p->weak_from_this()); } for(auto wp : v) if(auto sp = wp.lock()) sp->shutdown(); } } // detail } // websocket } // beast } // boost #endif PK PP�[x�� � websocket/detail/prng.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_PRNG_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_PRNG_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/config.hpp> #include <cstdint> #include <random> namespace boost { namespace beast { namespace websocket { namespace detail { using generator = std::uint32_t(*)(); //------------------------------------------------------------------------------ // Manually seed the prngs, must be called // before acquiring a prng for the first time. // BOOST_BEAST_DECL std::uint32_t const* prng_seed(std::seed_seq* ss = nullptr); // Acquire a PRNG using the TLS implementation if it // is available, otherwise using the no-TLS implementation. // BOOST_BEAST_DECL generator make_prng(bool secure); } // detail } // websocket } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/websocket/detail/prng.ipp> #endif #endif PK PP�[n�]�7 7 websocket/detail/decorator.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_DETAIL_DECORATOR_HPP #define BOOST_BEAST_WEBSOCKET_DETAIL_DECORATOR_HPP #include <boost/beast/websocket/rfc6455.hpp> #include <boost/core/exchange.hpp> #include <boost/type_traits/make_void.hpp> #include <algorithm> #include <memory> #include <new> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace websocket { namespace detail { // VFALCO NOTE: When this is two traits, one for // request and one for response, // Visual Studio 2015 fails. template<class T, class U, class = void> struct can_invoke_with : std::false_type { }; template<class T, class U> struct can_invoke_with<T, U, boost::void_t<decltype( std::declval<T&>()(std::declval<U&>()))>> : std::true_type { }; template<class T> using is_decorator = std::integral_constant<bool, can_invoke_with<T, request_type>::value || can_invoke_with<T, response_type>::value>; class decorator { friend class decorator_test; struct incomplete; struct exemplar { void (incomplete::*mf)(); std::shared_ptr<incomplete> sp; void* param; }; union storage { void* p_; void (*fn_)(); typename std::aligned_storage< sizeof(exemplar), alignof(exemplar)>::type buf_; }; struct vtable { void (*move)( storage& dst, storage& src) noexcept; void (*destroy)(storage& dst) noexcept; void (*invoke_req)( storage& dst, request_type& req); void (*invoke_res)( storage& dst, response_type& req); static void move_fn( storage&, storage&) noexcept { } static void destroy_fn( storage&) noexcept { } static void invoke_req_fn( storage&, request_type&) { } static void invoke_res_fn( storage&, response_type&) { } static vtable const* get_default() { static const vtable impl{ &move_fn, &destroy_fn, &invoke_req_fn, &invoke_res_fn }; return &impl; } }; template<class F, bool Inline = (sizeof(F) <= sizeof(storage) && alignof(F) <= alignof(storage) && std::is_nothrow_move_constructible<F>::value)> struct vtable_impl; storage storage_; vtable const* vtable_ = vtable::get_default(); // VFALCO NOTE: When this is two traits, one for // request and one for response, // Visual Studio 2015 fails. template<class T, class U, class = void> struct maybe_invoke { void operator()(T&, U&) { } }; template<class T, class U> struct maybe_invoke<T, U, boost::void_t<decltype( std::declval<T&>()(std::declval<U&>()))>> { void operator()(T& t, U& u) { t(u); } }; public: decorator() = default; decorator(decorator const&) = delete; decorator& operator=(decorator const&) = delete; ~decorator() { vtable_->destroy(storage_); } decorator(decorator&& other) noexcept : vtable_(boost::exchange( other.vtable_, vtable::get_default())) { vtable_->move( storage_, other.storage_); } template<class F, class = typename std::enable_if< ! std::is_convertible< F, decorator>::value>::type> explicit decorator(F&& f) : vtable_(vtable_impl< typename std::decay<F>::type>:: construct(storage_, std::forward<F>(f))) { } decorator& operator=(decorator&& other) noexcept { vtable_->destroy(storage_); vtable_ = boost::exchange( other.vtable_, vtable::get_default()); vtable_->move(storage_, other.storage_); return *this; } void operator()(request_type& req) { vtable_->invoke_req(storage_, req); } void operator()(response_type& res) { vtable_->invoke_res(storage_, res); } }; template<class F> struct decorator::vtable_impl<F, true> { template<class Arg> static vtable const* construct(storage& dst, Arg&& arg) { ::new (static_cast<void*>(&dst.buf_)) F( std::forward<Arg>(arg)); return get(); } static void move(storage& dst, storage& src) noexcept { auto& f = *beast::detail::launder_cast<F*>(&src.buf_); ::new (&dst.buf_) F(std::move(f)); } static void destroy(storage& dst) noexcept { beast::detail::launder_cast<F*>(&dst.buf_)->~F(); } static void invoke_req(storage& dst, request_type& req) { maybe_invoke<F, request_type>{}( *beast::detail::launder_cast<F*>(&dst.buf_), req); } static void invoke_res(storage& dst, response_type& res) { maybe_invoke<F, response_type>{}( *beast::detail::launder_cast<F*>(&dst.buf_), res); } static vtable const* get() { static constexpr vtable impl{ &move, &destroy, &invoke_req, &invoke_res}; return &impl; } }; template<class F> struct decorator::vtable_impl<F, false> { template<class Arg> static vtable const* construct(storage& dst, Arg&& arg) { dst.p_ = new F(std::forward<Arg>(arg)); return get(); } static void move(storage& dst, storage& src) noexcept { dst.p_ = src.p_; } static void destroy(storage& dst) noexcept { delete static_cast<F*>(dst.p_); } static void invoke_req( storage& dst, request_type& req) { maybe_invoke<F, request_type>{}( *static_cast<F*>(dst.p_), req); } static void invoke_res( storage& dst, response_type& res) { maybe_invoke<F, response_type>{}( *static_cast<F*>(dst.p_), res); } static vtable const* get() { static constexpr vtable impl{&move, &destroy, &invoke_req, &invoke_res}; return &impl; } }; } // detail } // websocket } // beast } // boost #endif PK PP�[���s s websocket/rfc6455.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_RFC6455_HPP #define BOOST_BEAST_WEBSOCKET_RFC6455_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/static_string.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/http/empty_body.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/string_body.hpp> #include <array> #include <cstdint> namespace boost { namespace beast { namespace websocket { /// The type of object holding HTTP Upgrade requests using request_type = http::request<http::empty_body>; /// The type of object holding HTTP Upgrade responses using response_type = http::response<http::string_body>; /** Returns `true` if the specified HTTP request is a WebSocket Upgrade. This function returns `true` when the passed HTTP Request indicates a WebSocket Upgrade. It does not validate the contents of the fields: it just trivially accepts requests which could only possibly be a valid or invalid WebSocket Upgrade message. Callers who wish to manually read HTTP requests in their server implementation can use this function to determine if the request should be routed to an instance of @ref websocket::stream. @par Example @code void handle_connection(net::ip::tcp::socket& sock) { boost::beast::flat_buffer buffer; boost::beast::http::request<boost::beast::http::string_body> req; boost::beast::http::read(sock, buffer, req); if(boost::beast::websocket::is_upgrade(req)) { boost::beast::websocket::stream<decltype(sock)> ws{std::move(sock)}; ws.accept(req); } } @endcode @param req The HTTP Request object to check. @return `true` if the request is a WebSocket Upgrade. */ template<class Allocator> bool is_upgrade(beast::http::header<true, http::basic_fields<Allocator>> const& req); /** Close status codes. These codes accompany close frames. @see <a href="https://tools.ietf.org/html/rfc6455#section-7.4.1">RFC 6455 7.4.1 Defined Status Codes</a> */ enum close_code : std::uint16_t { /// Normal closure; the connection successfully completed whatever purpose for which it was created. normal = 1000, /// The endpoint is going away, either because of a server failure or because the browser is navigating away from the page that opened the connection. going_away = 1001, /// The endpoint is terminating the connection due to a protocol error. protocol_error = 1002, /// The connection is being terminated because the endpoint received data of a type it cannot accept (for example, a text-only endpoint received binary data). unknown_data = 1003, /// The endpoint is terminating the connection because a message was received that contained inconsistent data (e.g., non-UTF-8 data within a text message). bad_payload = 1007, /// The endpoint is terminating the connection because it received a message that violates its policy. This is a generic status code, used when codes 1003 and 1009 are not suitable. policy_error = 1008, /// The endpoint is terminating the connection because a data frame was received that is too large. too_big = 1009, /// The client is terminating the connection because it expected the server to negotiate one or more extension, but the server didn't. needs_extension = 1010, /// The server is terminating the connection because it encountered an unexpected condition that prevented it from fulfilling the request. internal_error = 1011, /// The server is terminating the connection because it is restarting. service_restart = 1012, /// The server is terminating the connection due to a temporary condition, e.g. it is overloaded and is casting off some of its clients. try_again_later = 1013, //---- // // The following are illegal on the wire // /** Used internally to mean "no error" This code is reserved and may not be sent. */ none = 0, /** Reserved for future use by the WebSocket standard. This code is reserved and may not be sent. */ reserved1 = 1004, /** No status code was provided even though one was expected. This code is reserved and may not be sent. */ no_status = 1005, /** Connection was closed without receiving a close frame This code is reserved and may not be sent. */ abnormal = 1006, /** Reserved for future use by the WebSocket standard. This code is reserved and may not be sent. */ reserved2 = 1014, /** Reserved for future use by the WebSocket standard. This code is reserved and may not be sent. */ reserved3 = 1015 // //---- //last = 5000 // satisfy warnings }; /// The type representing the reason string in a close frame. using reason_string = static_string<123, char>; /// The type representing the payload of ping and pong messages. using ping_data = static_string<125, char>; /** Description of the close reason. This object stores the close code (if any) and the optional utf-8 encoded implementation defined reason string. */ struct close_reason { /// The close code. std::uint16_t code = close_code::none; /// The optional utf8-encoded reason string. reason_string reason; /** Default constructor. The code will be none. Default constructed objects will explicitly convert to bool as `false`. */ close_reason() = default; /// Construct from a code. close_reason(std::uint16_t code_) : code(code_) { } /// Construct from a reason string. code is @ref close_code::normal. close_reason(string_view s) : code(close_code::normal) , reason(s) { } /// Construct from a reason string literal. code is @ref close_code::normal. close_reason(char const* s) : code(close_code::normal) , reason(s) { } /// Construct from a close code and reason string. close_reason(close_code code_, string_view s) : code(code_) , reason(s) { } /// Returns `true` if a code was specified operator bool() const { return code != close_code::none; } }; } // websocket } // beast } // boost #include <boost/beast/websocket/impl/rfc6455.hpp> #endif PK PP�[��"�d d websocket/option.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_OPTION_HPP #define BOOST_BEAST_WEBSOCKET_OPTION_HPP #include <boost/beast/core/detail/config.hpp> namespace boost { namespace beast { namespace websocket { /** permessage-deflate extension options. These settings control the permessage-deflate extension, which allows messages to be compressed. @note Objects of this type are used with @ref beast::websocket::stream::set_option. */ struct permessage_deflate { /// `true` to offer the extension in the server role bool server_enable = false; /// `true` to offer the extension in the client role bool client_enable = false; /** Maximum server window bits to offer @note Due to a bug in ZLib, this value must be greater than 8. */ int server_max_window_bits = 15; /** Maximum client window bits to offer @note Due to a bug in ZLib, this value must be greater than 8. */ int client_max_window_bits = 15; /// `true` if server_no_context_takeover desired bool server_no_context_takeover = false; /// `true` if client_no_context_takeover desired bool client_no_context_takeover = false; /// Deflate compression level 0..9 int compLevel = 8; /// Deflate memory level, 1..9 int memLevel = 4; }; } // websocket } // beast } // boost #endif PK PP�[�g websocket/stream_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_STREAM_BASE_HPP #define BOOST_BEAST_WEBSOCKET_STREAM_BASE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/websocket/detail/decorator.hpp> #include <boost/beast/core/role.hpp> #include <chrono> #include <type_traits> namespace boost { namespace beast { namespace websocket { /** This class is used as a base for the @ref websocket::stream class template to group common types and constants. */ struct stream_base { /// The type used to represent durations using duration = std::chrono::steady_clock::duration; /// The type used to represent time points using time_point = std::chrono::steady_clock::time_point; /// Returns the special time_point value meaning "never" static time_point never() noexcept { return (time_point::max)(); } /// Returns the special duration value meaning "none" static duration none() noexcept { return (duration::max)(); } /** Stream option used to adjust HTTP fields of WebSocket upgrade request and responses. */ class decorator { detail::decorator d_; template<class, bool> friend class stream; public: // Move Constructor decorator(decorator&&) = default; /** Construct a decorator option. @param f An invocable function object. Ownership of the function object is transferred by decay-copy. */ template<class Decorator #ifndef BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< detail::is_decorator< Decorator>::value>::type #endif > explicit decorator(Decorator&& f) : d_(std::forward<Decorator>(f)) { } }; /** Stream option to control the behavior of websocket timeouts. Timeout features are available for asynchronous operations only. */ struct timeout { /** Time limit on handshake, accept, and close operations: This value whether or not there is a time limit, and the duration of that time limit, for asynchronous handshake, accept, and close operations. If this is equal to the value @ref none then there will be no time limit. Otherwise, if any of the applicable operations takes longer than this amount of time, the operation will be canceled and a timeout error delivered to the completion handler. */ duration handshake_timeout; /** The time limit after which a connection is considered idle. */ duration idle_timeout; /** Automatic ping setting. If the idle interval is set, this setting affects the behavior of the stream when no data is received for the timeout interval as follows: @li When `keep_alive_pings` is `true`, an idle ping will be sent automatically. If another timeout interval elapses with no received data then the connection will be closed. An outstanding read operation must be pending, which will complete immediately the error @ref beast::error::timeout. @li When `keep_alive_pings` is `false`, the connection will be closed. An outstanding read operation must be pending, which will complete immediately the error @ref beast::error::timeout. */ bool keep_alive_pings; /** Construct timeout settings with suggested values for a role. This constructs the timeout settings with a predefined set of values which varies depending on the desired role. The values are selected upon construction, regardless of the current or actual role in use on the stream. @par Example This statement sets the timeout settings of the stream to the suggested values for the server role: @code @endcode @param role The role of the websocket stream (@ref role_type::client or @ref role_type::server). */ static timeout suggested(role_type role) noexcept { timeout opt{}; switch(role) { case role_type::client: opt.handshake_timeout = std::chrono::seconds(30); opt.idle_timeout = none(); opt.keep_alive_pings = false; break; case role_type::server: opt.handshake_timeout = std::chrono::seconds(30); opt.idle_timeout = std::chrono::seconds(300); opt.keep_alive_pings = true; break; } return opt; } }; protected: enum class status { //none, handshake, open, closing, closed, failed // VFALCO Is this needed? }; }; } // websocket } // beast } // boost #endif PK PP�[6�f�' ' websocket/teardown.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_TEARDOWN_HPP #define BOOST_BEAST_WEBSOCKET_TEARDOWN_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/role.hpp> #include <boost/asio/basic_stream_socket.hpp> #include <type_traits> namespace boost { namespace beast { namespace websocket { /** Tear down a connection. This tears down a connection. The implementation will call the overload of this function based on the `Socket` parameter used to consruct the socket. When `Socket` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param socket The socket to tear down. @param ec Set to the error if any occurred. */ template<class Socket> void teardown( role_type role, Socket& socket, error_code& ec) { boost::ignore_unused(role, socket, ec); /* If you are trying to use OpenSSL and this goes off, you need to add an include for <boost/beast/websocket/ssl.hpp>. If you are creating an instance of beast::websocket::stream with your own user defined type, you must provide an overload of teardown with the corresponding signature (including the role_type). */ static_assert(sizeof(Socket)==-1, "Unknown Socket type in teardown."); } /** Start tearing down a connection. This begins tearing down a connection asynchronously. The implementation will call the overload of this function based on the `Socket` parameter used to consruct the socket. When `Stream` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param socket The socket to tear down. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class Socket, class TeardownHandler> void async_teardown( role_type role, Socket& socket, TeardownHandler&& handler) { boost::ignore_unused(role, socket, handler); /* If you are trying to use OpenSSL and this goes off, you need to add an include for <boost/beast/websocket/ssl.hpp>. If you are creating an instance of beast::websocket::stream with your own user defined type, you must provide an overload of teardown with the corresponding signature (including the role_type). */ static_assert(sizeof(Socket)==-1, "Unknown Socket type in async_teardown."); } } // websocket //------------------------------------------------------------------------------ namespace websocket { /** Tear down a `net::ip::tcp::socket`. This tears down a connection. The implementation will call the overload of this function based on the `Stream` parameter used to consruct the socket. When `Stream` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param socket The socket to tear down. @param ec Set to the error if any occurred. */ template<class Protocol, class Executor> void teardown( role_type role, net::basic_stream_socket< Protocol, Executor>& socket, error_code& ec); /** Start tearing down a `net::ip::tcp::socket`. This begins tearing down a connection asynchronously. The implementation will call the overload of this function based on the `Stream` parameter used to consruct the socket. When `Stream` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param socket The socket to tear down. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class Protocol, class Executor, class TeardownHandler> void async_teardown( role_type role, net::basic_stream_socket< Protocol, Executor>& socket, TeardownHandler&& handler); } // websocket } // beast } // boost #include <boost/beast/websocket/impl/teardown.hpp> #endif PK PP�[��\ websocket/ssl.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WEBSOCKET_SSL_HPP #define BOOST_BEAST_WEBSOCKET_SSL_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/websocket/teardown.hpp> #include <boost/asio/ip/tcp.hpp> #include <boost/asio/ssl/stream.hpp> namespace boost { namespace beast { /** Tear down a `net::ssl::stream`. This tears down a connection. The implementation will call the overload of this function based on the `Stream` parameter used to consruct the socket. When `Stream` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param stream The stream to tear down. @param ec Set to the error if any occurred. */ template<class SyncStream> void teardown( role_type role, net::ssl::stream<SyncStream>& stream, error_code& ec); /** Start tearing down a `net::ssl::stream`. This begins tearing down a connection asynchronously. The implementation will call the overload of this function based on the `Stream` parameter used to consruct the socket. When `Stream` is a user defined type, and not a `net::ip::tcp::socket` or any `net::ssl::stream`, callers are responsible for providing a suitable overload of this function. @param role The role of the local endpoint @param stream The stream to tear down. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error // result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template<class AsyncStream, class TeardownHandler> void async_teardown( role_type role, net::ssl::stream<AsyncStream>& stream, TeardownHandler&& handler); } // beast } // boost #include <boost/beast/websocket/impl/ssl.hpp> #endif PK PP�[�)��� � ssl.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_SSL_HPP #define BOOST_BEAST_SSL_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/ssl/ssl_stream.hpp> #endif PK PP�[�#W.� .� core/basic_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_BASIC_STREAM_HPP #define BOOST_BEAST_CORE_BASIC_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/stream_base.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/rate_policy.hpp> #include <boost/beast/core/role.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/basic_stream_socket.hpp> #include <boost/asio/connect.hpp> #include <boost/asio/executor.hpp> #include <boost/asio/is_executor.hpp> #include <boost/core/empty_value.hpp> #include <boost/config/workaround.hpp> #include <boost/enable_shared_from_this.hpp> #include <boost/shared_ptr.hpp> #include <chrono> #include <limits> #include <memory> #if ! BOOST_BEAST_DOXYGEN namespace boost { namespace asio { namespace ssl { template<typename> class stream; } // ssl } // asio } // boost #endif namespace boost { namespace beast { /** A stream socket wrapper with timeouts, an executor, and a rate limit policy. This stream wraps a `net::basic_stream_socket` to provide the following features: @li An <em>Executor</em> may be associated with the stream, which will be used to invoke any completion handlers which do not already have an associated executor. This achieves support for <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1322r0.html">[P1322R0] Networking TS enhancement to enable custom I/O executors</a>. @li Timeouts may be specified for each logical asynchronous operation performing any reading, writing, or connecting. @li A <em>RatePolicy</em> may be associated with the stream, to implement rate limiting through the policy's interface. Although the stream supports multiple concurrent outstanding asynchronous operations, the stream object is not thread-safe. The caller is responsible for ensuring that the stream is accessed from only one thread at a time. This includes the times when the stream, and its underlying socket, are accessed by the networking implementation. To meet this thread safety requirement, all asynchronous operations must be performed by the stream within the same implicit strand (only one thread `net::io_context::run`) or within the same explicit strand, such as an instance of `net::strand`. Completion handlers with explicit associated executors (such as those arising from use of `net::bind_executor`) will be invoked by the stream using the associated executor. Otherwise, the completion handler will be invoked by the executor associated with the stream upon construction. The type of executor used with this stream must meet the following requirements: @li Function objects submitted to the executor shall never run concurrently with each other. The executor type `net::strand` meets these requirements. Use of a strand as the executor in the stream class template offers an additional notational convenience: the strand does not need to be specified in each individual initiating function call. Unlike other stream wrappers, the underlying socket is accessed through the @ref socket member function instead of `next_layer`. This causes the @ref basic_stream to be returned in calls to @ref get_lowest_layer. @par Usage To use this stream declare an instance of the class. Then, before each logical operation for which a timeout is desired, call @ref expires_after with a duration, or call @ref expires_at with a time point. Alternatively, call @ref expires_never to disable the timeout for subsequent logical operations. A logical operation is any series of one or more direct or indirect calls to the timeout stream's asynchronous read, asynchronous write, or asynchronous connect functions. When a timeout is set and a mixed operation is performed (one that includes both reads and writes, for example) the timeout applies to all of the intermediate asynchronous operations used in the enclosing operation. This allows timeouts to be applied to stream algorithms which were not written specifically to allow for timeouts, when those algorithms are passed a timeout stream with a timeout set. When a timeout occurs the socket will be closed, canceling any pending I/O operations. The completion handlers for these canceled operations will be invoked with the error @ref beast::error::timeout. @par Examples This function reads an HTTP request with a timeout, then sends the HTTP response with a different timeout. @code void process_http_1 (tcp_stream& stream, net::yield_context yield) { flat_buffer buffer; http::request<http::empty_body> req; // Read the request, with a 15 second timeout stream.expires_after(std::chrono::seconds(15)); http::async_read(stream, buffer, req, yield); // Calculate the response http::response<http::string_body> res = make_response(req); // Send the response, with a 30 second timeout. stream.expires_after (std::chrono::seconds(30)); http::async_write (stream, res, yield); } @endcode The example above could be expressed using a single timeout with a simple modification. The function that follows first reads an HTTP request then sends the HTTP response, with a single timeout that applies to the entire combined operation of reading and writing: @code void process_http_2 (tcp_stream& stream, net::yield_context yield) { flat_buffer buffer; http::request<http::empty_body> req; // Require that the read and write combined take no longer than 30 seconds stream.expires_after(std::chrono::seconds(30)); http::async_read(stream, buffer, req, yield); http::response<http::string_body> res = make_response(req); http::async_write (stream, res, yield); } @endcode Some stream algorithms, such as `ssl::stream::async_handshake` perform both reads and writes. A timeout set before calling the initiating function of such composite stream algorithms will apply to the entire composite operation. For example, a timeout may be set on performing the SSL handshake thusly: @code void do_ssl_handshake (net::ssl::stream<tcp_stream>& stream, net::yield_context yield) { // Require that the SSL handshake take no longer than 10 seconds stream.expires_after(std::chrono::seconds(10)); stream.async_handshake(net::ssl::stream_base::client, yield); } @endcode @par Blocking I/O Synchronous functions behave identically as that of the wrapped `net::basic_stream_socket`. Timeouts are not available when performing blocking calls. @tparam Protocol A type meeting the requirements of <em>Protocol</em> representing the protocol the protocol to use for the basic stream socket. A common choice is `net::ip::tcp`. @tparam Executor A type meeting the requirements of <em>Executor</em> to be used for submitting all completion handlers which do not already have an associated executor. If this type is omitted, the default of `net::any_io_executor` will be used. @par Thread Safety <em>Distinct objects</em>: Safe.@n <em>Shared objects</em>: Unsafe. The application must also ensure that all asynchronous operations are performed within the same implicit or explicit strand. @see @li <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1322r0.html">[P1322R0] Networking TS enhancement to enable custom I/O executors</a>. */ template< class Protocol, class Executor = net::any_io_executor, class RatePolicy = unlimited_rate_policy > class basic_stream #if ! BOOST_BEAST_DOXYGEN : private detail::stream_base #endif { public: /// The type of the underlying socket. using socket_type = net::basic_stream_socket<Protocol, Executor>; /** The type of the executor associated with the stream. This will be the type of executor used to invoke completion handlers which do not have an explicit associated executor. */ using executor_type = beast::executor_type<socket_type>; /// Rebinds the stream type to another executor. template<class Executor1> struct rebind_executor { /// The stream type when rebound to the specified executor. using other = basic_stream< Protocol, Executor1, RatePolicy>; }; /// The protocol type. using protocol_type = Protocol; /// The endpoint type. using endpoint_type = typename Protocol::endpoint; private: static_assert( net::is_executor<Executor>::value || net::execution::is_executor<Executor>::value, "Executor type requirements not met"); struct impl_type : boost::enable_shared_from_this<impl_type> , boost::empty_value<RatePolicy> { // must come first net::basic_stream_socket< Protocol, Executor> socket; op_state read; op_state write; #if 0 net::basic_waitable_timer< std::chrono::steady_clock, net::wait_traits< std::chrono::steady_clock>, Executor> timer; // rate timer; #else net::steady_timer timer; #endif int waiting = 0; impl_type(impl_type&&) = default; template<class... Args> explicit impl_type(std::false_type, Args&&...); template<class RatePolicy_, class... Args> explicit impl_type(std::true_type, RatePolicy_&& policy, Args&&...); impl_type& operator=(impl_type&&) = delete; beast::executor_type<socket_type> ex() noexcept { return this->socket.get_executor(); } RatePolicy& policy() noexcept { return this->boost::empty_value<RatePolicy>::get(); } RatePolicy const& policy() const noexcept { return this->boost::empty_value<RatePolicy>::get(); } template<class Executor2> void on_timer(Executor2 const& ex2); void reset(); // set timeouts to never void close() noexcept; // cancel everything }; // We use shared ownership for the state so it can // outlive the destruction of the stream_socket object, // in the case where there is no outstanding read or write // but the implementation is still waiting on a timer. boost::shared_ptr<impl_type> impl_; template<class Executor2> struct timeout_handler; struct ops; #if ! BOOST_BEAST_DOXYGEN // boost::asio::ssl::stream needs these // DEPRECATED template<class> friend class boost::asio::ssl::stream; // DEPRECATED using lowest_layer_type = socket_type; // DEPRECATED lowest_layer_type& lowest_layer() noexcept { return impl_->socket; } // DEPRECATED lowest_layer_type const& lowest_layer() const noexcept { return impl_->socket; } #endif public: /** Destructor This function destroys the stream, cancelling any outstanding asynchronous operations associated with the socket as if by calling cancel. */ ~basic_stream(); /** Constructor This constructor creates the stream by forwarding all arguments to the underlying socket. The socket then needs to be open and connected or accepted before data can be sent or received on it. @param args A list of parameters forwarded to the constructor of the underlying socket. */ #if BOOST_BEAST_DOXYGEN template<class... Args> explicit basic_stream(Args&&... args); #else template<class Arg0, class... Args, class = typename std::enable_if< ! std::is_constructible<RatePolicy, Arg0>::value>::type> explicit basic_stream(Arg0&& argo, Args&&... args); #endif /** Constructor This constructor creates the stream with the specified rate policy, and forwards all remaining arguments to the underlying socket. The socket then needs to be open and connected or accepted before data can be sent or received on it. @param policy The rate policy object to use. The stream will take ownership of this object by decay-copy. @param args A list of parameters forwarded to the constructor of the underlying socket. */ #if BOOST_BEAST_DOXYGEN template<class RatePolicy_, class... Args> explicit basic_stream(RatePolicy_&& policy, Args&&... args); #else template<class RatePolicy_, class Arg0, class... Args, class = typename std::enable_if< std::is_constructible< RatePolicy, RatePolicy_>::value>::type> basic_stream( RatePolicy_&& policy, Arg0&& arg, Args&&... args); #endif /** Move constructor @param other The other object from which the move will occur. @note Following the move, the moved-from object is in the same state as if newly constructed. */ basic_stream(basic_stream&& other); /// Move assignment (deleted). basic_stream& operator=(basic_stream&&) = delete; /// Return a reference to the underlying socket socket_type& socket() noexcept { return impl_->socket; } /// Return a reference to the underlying socket socket_type const& socket() const noexcept { return impl_->socket; } /** Release ownership of the underlying socket. This function causes all outstanding asynchronous connect, read, and write operations to be canceled as if by a call to @ref cancel. Ownership of the underlying socket is then transferred to the caller. */ socket_type release_socket(); //-------------------------------------------------------------------------- /// Returns the rate policy associated with the object RatePolicy& rate_policy() noexcept { return impl_->policy(); } /// Returns the rate policy associated with the object RatePolicy const& rate_policy() const noexcept { return impl_->policy(); } /** Set the timeout for the next logical operation. This sets either the read timer, the write timer, or both timers to expire after the specified amount of time has elapsed. If a timer expires when the corresponding asynchronous operation is outstanding, the stream will be closed and any outstanding operations will complete with the error @ref beast::error::timeout. Otherwise, if the timer expires while no operations are outstanding, and the expiraton is not set again, the next operation will time out immediately. The timer applies collectively to any asynchronous reads or writes initiated after the expiration is set, until the expiration is set again. A call to @ref async_connect counts as both a read and a write. @param expiry_time The amount of time after which a logical operation should be considered timed out. */ void expires_after( net::steady_timer::duration expiry_time); /** Set the timeout for the next logical operation. This sets either the read timer, the write timer, or both timers to expire at the specified time point. If a timer expires when the corresponding asynchronous operation is outstanding, the stream will be closed and any outstanding operations will complete with the error @ref beast::error::timeout. Otherwise, if the timer expires while no operations are outstanding, and the expiraton is not set again, the next operation will time out immediately. The timer applies collectively to any asynchronous reads or writes initiated after the expiration is set, until the expiration is set again. A call to @ref async_connect counts as both a read and a write. @param expiry_time The time point after which a logical operation should be considered timed out. */ void expires_at(net::steady_timer::time_point expiry_time); /// Disable the timeout for the next logical operation. void expires_never(); /** Cancel all asynchronous operations associated with the socket. This function causes all outstanding asynchronous connect, read, and write operations to finish immediately. Completion handlers for cancelled operations will receive the error `net::error::operation_aborted`. Completion handlers not yet invoked whose operations have completed, will receive the error corresponding to the result of the operation (which may indicate success). */ void cancel(); /** Close the timed stream. This cancels all of the outstanding asynchronous operations as if by calling @ref cancel, and closes the underlying socket. */ void close(); //-------------------------------------------------------------------------- /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch completion handlers without an assocaited executor. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept { return impl_->ex(); } /** Connect the stream to the specified endpoint. This function is used to connect the underlying socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. @param ep The remote endpoint to connect to. @throws system_error Thrown on failure. @see connect */ void connect(endpoint_type const& ep) { socket().connect(ep); } /** Connect the stream to the specified endpoint. This function is used to connect the underlying socket to the specified remote endpoint. The function call will block until the connection is successfully made or an error occurs. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. @param ep The remote endpoint to connect to. @param ec Set to indicate what error occurred, if any. @see connect */ void connect(endpoint_type const& ep, error_code& ec) { socket().connect(ep, ec); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param endpoints A sequence of endpoints. @returns The successfully connected endpoint. @throws system_error Thrown on failure. If the sequence is empty, the associated error code is `net::error::not_found`. Otherwise, contains the error from the last connection attempt. */ template<class EndpointSequence #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > typename Protocol::endpoint connect(EndpointSequence const& endpoints) { return net::connect(socket(), endpoints); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param endpoints A sequence of endpoints. @param ec Set to indicate what error occurred, if any. If the sequence is empty, set to `net::error::not_found`. Otherwise, contains the error from the last connection attempt. @returns On success, the successfully connected endpoint. Otherwise, a default-constructed endpoint. */ template<class EndpointSequence #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > typename Protocol::endpoint connect( EndpointSequence const& endpoints, error_code& ec ) { return net::connect(socket(), endpoints, ec); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @returns An iterator denoting the successfully connected endpoint. @throws system_error Thrown on failure. If the sequence is empty, the associated error code is `net::error::not_found`. Otherwise, contains the error from the last connection attempt. */ template<class Iterator> Iterator connect( Iterator begin, Iterator end) { return net::connect(socket(), begin, end); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @param ec Set to indicate what error occurred, if any. If the sequence is empty, set to boost::asio::error::not_found. Otherwise, contains the error from the last connection attempt. @returns On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator. */ template<class Iterator> Iterator connect( Iterator begin, Iterator end, error_code& ec) { return net::connect(socket(), begin, end, ec); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param endpoints A sequence of endpoints. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode The @c ec parameter contains the result from the most recent connect operation. Before the first connection attempt, @c ec is always set to indicate success. The @c next parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped. @returns The successfully connected endpoint. @throws boost::system::system_error Thrown on failure. If the sequence is empty, the associated error code is `net::error::not_found`. Otherwise, contains the error from the last connection attempt. */ template< class EndpointSequence, class ConnectCondition #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > typename Protocol::endpoint connect( EndpointSequence const& endpoints, ConnectCondition connect_condition ) { return net::connect(socket(), endpoints, connect_condition); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param endpoints A sequence of endpoints. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode The @c ec parameter contains the result from the most recent connect operation. Before the first connection attempt, @c ec is always set to indicate success. The @c next parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped. @param ec Set to indicate what error occurred, if any. If the sequence is empty, set to `net::error::not_found`. Otherwise, contains the error from the last connection attempt. @returns On success, the successfully connected endpoint. Otherwise, a default-constructed endpoint. */ template< class EndpointSequence, class ConnectCondition #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > typename Protocol::endpoint connect( EndpointSequence const& endpoints, ConnectCondition connect_condition, error_code& ec) { return net::connect(socket(), endpoints, connect_condition, ec); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode The @c ec parameter contains the result from the most recent connect operation. Before the first connection attempt, @c ec is always set to indicate success. The @c next parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped. @returns An iterator denoting the successfully connected endpoint. @throws boost::system::system_error Thrown on failure. If the sequence is empty, the associated @c error_code is `net::error::not_found`. Otherwise, contains the error from the last connection attempt. */ template< class Iterator, class ConnectCondition> Iterator connect( Iterator begin, Iterator end, ConnectCondition connect_condition) { return net::connect(socket(), begin, end, connect_condition); } /** Establishes a connection by trying each endpoint in a sequence. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the underlying socket's `connect` function. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode The @c ec parameter contains the result from the most recent connect operation. Before the first connection attempt, @c ec is always set to indicate success. The @c next parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped. @param ec Set to indicate what error occurred, if any. If the sequence is empty, set to `net::error::not_found`. Otherwise, contains the error from the last connection attempt. @returns On success, an iterator denoting the successfully connected endpoint. Otherwise, the end iterator. */ template< class Iterator, class ConnectCondition> Iterator connect( Iterator begin, Iterator end, ConnectCondition connect_condition, error_code& ec) { return net::connect(socket(), begin, end, connect_condition, ec); } /** Connect the stream to the specified endpoint asynchronously. This function is used to asynchronously connect the underlying socket to the specified remote endpoint. The function call always returns immediately. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. If the timeout timer expires while the operation is outstanding, the operation will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param ep The remote endpoint to which the underlying socket will be connected. Copies will be made of the endpoint object as required. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code ec // Result of operation ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see async_connect */ template< BOOST_BEAST_ASYNC_TPARAM1 ConnectHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT1(ConnectHandler) async_connect( endpoint_type const& ep, ConnectHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Establishes a connection by trying each endpoint in a sequence asynchronously. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the underlying socket's `async_connect` function. If the timeout timer expires while the operation is outstanding, the current connection attempt will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param endpoints A sequence of endpoints. This this object must meet the requirements of <em>EndpointSequence</em>. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( // Result of operation. if the sequence is empty, set to // net::error::not_found. Otherwise, contains the // error from the last connection attempt. error_code const& error, // On success, the successfully connected endpoint. // Otherwise, a default-constructed endpoint. typename Protocol::endpoint const& endpoint ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class EndpointSequence, BOOST_ASIO_COMPLETION_TOKEN_FOR( void(error_code, typename Protocol::endpoint)) RangeConnectHandler = net::default_completion_token_t<executor_type> #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > BOOST_ASIO_INITFN_RESULT_TYPE( RangeConnectHandler, void(error_code, typename Protocol::endpoint)) async_connect( EndpointSequence const& endpoints, RangeConnectHandler&& handler = net::default_completion_token_t<executor_type>{}); /** Establishes a connection by trying each endpoint in a sequence asynchronously. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the underlying socket's `async_connect` function. If the timeout timer expires while the operation is outstanding, the current connection attempt will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param endpoints A sequence of endpoints. This this object must meet the requirements of <em>EndpointSequence</em>. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode The @c ec parameter contains the result from the most recent connect operation. Before the first connection attempt, @c ec is always set to indicate success. The @c next parameter is the next endpoint to be tried. The function object should return true if the next endpoint should be tried, and false if it should be skipped. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( // Result of operation. if the sequence is empty, set to // net::error::not_found. Otherwise, contains the // error from the last connection attempt. error_code const& error, // On success, the successfully connected endpoint. // Otherwise, a default-constructed endpoint. typename Protocol::endpoint const& endpoint ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @par Example The following connect condition function object can be used to output information about the individual connection attempts: @code struct my_connect_condition { bool operator()( error_code const& ec, net::ip::tcp::endpoint const& next) { if (ec) std::cout << "Error: " << ec.message() << std::endl; std::cout << "Trying: " << next << std::endl; return true; } }; @endcode */ template< class EndpointSequence, class ConnectCondition, BOOST_ASIO_COMPLETION_TOKEN_FOR( void(error_code, typename Protocol::endpoint)) RangeConnectHandler = net::default_completion_token_t<executor_type> #if ! BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< net::is_endpoint_sequence< EndpointSequence>::value>::type #endif > BOOST_ASIO_INITFN_RESULT_TYPE( RangeConnectHandler, void(error_code, typename Protocol::endpoint)) async_connect( EndpointSequence const& endpoints, ConnectCondition connect_condition, RangeConnectHandler&& handler = net::default_completion_token_t< executor_type>{}); /** Establishes a connection by trying each endpoint in a sequence asynchronously. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The underlying socket is automatically opened if needed. An automatically opened socket is not returned to the closed state upon failure. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the underlying socket's `async_connect` function. If the timeout timer expires while the operation is outstanding, the current connection attempt will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( // Result of operation. if the sequence is empty, set to // net::error::not_found. Otherwise, contains the // error from the last connection attempt. error_code const& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class Iterator, BOOST_ASIO_COMPLETION_TOKEN_FOR( void(error_code, Iterator)) IteratorConnectHandler = net::default_completion_token_t<executor_type>> BOOST_ASIO_INITFN_RESULT_TYPE( IteratorConnectHandler, void(error_code, Iterator)) async_connect( Iterator begin, Iterator end, IteratorConnectHandler&& handler = net::default_completion_token_t<executor_type>{}); /** Establishes a connection by trying each endpoint in a sequence asynchronously. This function attempts to connect the stream to one of a sequence of endpoints by trying each endpoint until a connection is successfully established. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the underlying socket's `async_connect` function. If the timeout timer expires while the operation is outstanding, the current connection attempt will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param begin An iterator pointing to the start of a sequence of endpoints. @param end An iterator pointing to the end of a sequence of endpoints. @param connect_condition A function object that is called prior to each connection attempt. The signature of the function object must be: @code bool connect_condition( error_code const& ec, typename Protocol::endpoint const& next); @endcode @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( // Result of operation. if the sequence is empty, set to // net::error::not_found. Otherwise, contains the // error from the last connection attempt. error_code const& error, // On success, an iterator denoting the successfully // connected endpoint. Otherwise, the end iterator. Iterator iterator ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class Iterator, class ConnectCondition, BOOST_ASIO_COMPLETION_TOKEN_FOR( void(error_code, Iterator)) IteratorConnectHandler = net::default_completion_token_t<executor_type>> BOOST_ASIO_INITFN_RESULT_TYPE( IteratorConnectHandler, void(error_code, Iterator)) async_connect( Iterator begin, Iterator end, ConnectCondition connect_condition, IteratorConnectHandler&& handler = net::default_completion_token_t<executor_type>{}); //-------------------------------------------------------------------------- /** Read some data. This function is used to read some data from the stream. The call blocks until one of the following is true: @li One or more bytes are read from the stream. @li An error occurs. @param buffers The buffers into which the data will be read. If the size of the buffers is zero bytes, the call always returns immediately with no error. @returns The number of bytes read. @throws system_error Thrown on failure. @note The `read_some` operation may not receive all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers) { return impl_->socket.read_some(buffers); } /** Read some data. This function is used to read some data from the underlying socket. The call blocks until one of the following is true: @li One or more bytes are read from the stream. @li An error occurs. @param buffers The buffers into which the data will be read. If the size of the buffers is zero bytes, the call always returns immediately with no error. @param ec Set to indicate what error occurred, if any. @returns The number of bytes read. @note The `read_some` operation may not receive all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some( MutableBufferSequence const& buffers, error_code& ec) { return impl_->socket.read_some(buffers, ec); } /** Read some data asynchronously. This function is used to asynchronously read data from the stream. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li One or more bytes are read from the stream. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` function. The program must ensure that no other calls to @ref read_some or @ref async_read_some are performed until this operation completes. If the timeout timer expires while the operation is outstanding, the operation will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param buffers The buffers into which the data will be read. If the size of the buffers is zero bytes, the operation always completes immediately with no error. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_read_some` operation may not receive all of the requested number of bytes. Consider using the function `net::async_read` if you need to ensure that the requested amount of data is read before the asynchronous operation completes. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t<executor_type> > BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler = net::default_completion_token_t<executor_type>{} ); /** Write some data. This function is used to write some data to the stream. The call blocks until one of the following is true: @li One or more bytes are written to the stream. @li An error occurs. @param buffers The buffers from which the data will be written. If the size of the buffers is zero bytes, the call always returns immediately with no error. @returns The number of bytes written. @throws system_error Thrown on failure. @note The `write_some` operation may not transmit all of the requested number of bytes. Consider using the function `net::write` if you need to ensure that the requested amount of data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers) { return impl_->socket.write_some(buffers); } /** Write some data. This function is used to write some data to the stream. The call blocks until one of the following is true: @li One or more bytes are written to the stream. @li An error occurs. @param buffers The buffers from which the data will be written. If the size of the buffers is zero bytes, the call always returns immediately with no error. @param ec Set to indicate what error occurred, if any. @returns The number of bytes written. @throws system_error Thrown on failure. @note The `write_some` operation may not transmit all of the requested number of bytes. Consider using the function `net::write` if you need to ensure that the requested amount of data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some( ConstBufferSequence const& buffers, error_code& ec) { return impl_->socket.write_some(buffers, ec); } /** Write some data asynchronously. This function is used to asynchronously write data to the underlying socket. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li One or more bytes are written to the stream. @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_write_some` function. The program must ensure that no other calls to @ref async_write_some are performed until this operation completes. If the timeout timer expires while the operation is outstanding, the operation will be canceled and the completion handler will be invoked with the error @ref error::timeout. @param buffers The buffers from which the data will be written. If the size of the buffers is zero bytes, the operation always completes immediately with no error. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code error, // Result of operation. std::size_t bytes_transferred // Number of bytes written. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_write_some` operation may not transmit all of the requested number of bytes. Consider using the function `net::async_write` if you need to ensure that the requested amount of data is sent before the asynchronous operation completes. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t<Executor> > BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t<Executor>{}); }; } // beast } // boost #include <boost/beast/core/impl/basic_stream.hpp> #endif PK PP�[�y��L L core/bind_handler.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BIND_HANDLER_HPP #define BOOST_BEAST_BIND_HANDLER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/bind_handler.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { /** Bind parameters to a completion handler, creating a new handler. This function creates a new handler which, when invoked, calls the original handler with the list of bound arguments. Any parameters passed in the invocation will be substituted for placeholders present in the list of bound arguments. Parameters which are not matched to placeholders are silently discarded. The passed handler and arguments are forwarded into the returned handler, whose associated allocator and associated executor will will be the same as those of the original handler. @par Example This function posts the invocation of the specified completion handler with bound arguments: @code template <class AsyncReadStream, class ReadHandler> void signal_aborted (AsyncReadStream& stream, ReadHandler&& handler) { net::post( stream.get_executor(), bind_handler (std::forward <ReadHandler> (handler), net::error::operation_aborted, 0)); } @endcode @param handler The handler to wrap. The implementation takes ownership of the handler by performing a decay-copy. @param args A list of arguments to bind to the handler. The arguments are forwarded into the returned object. These arguments may include placeholders, which will operate in a fashion identical to a call to `std::bind`. */ template<class Handler, class... Args> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else detail::bind_wrapper< typename std::decay<Handler>::type, typename std::decay<Args>::type...> #endif bind_handler(Handler&& handler, Args&&... args) { return detail::bind_wrapper< typename std::decay<Handler>::type, typename std::decay<Args>::type...>( std::forward<Handler>(handler), std::forward<Args>(args)...); } /** Bind parameters to a completion handler, creating a new handler. This function creates a new handler which, when invoked, calls the original handler with the list of bound arguments. Any parameters passed in the invocation will be forwarded in the parameter list after the bound arguments. The passed handler and arguments are forwarded into the returned handler, whose associated allocator and associated executor will will be the same as those of the original handler. @par Example This function posts the invocation of the specified completion handler with bound arguments: @code template <class AsyncReadStream, class ReadHandler> void signal_eof (AsyncReadStream& stream, ReadHandler&& handler) { net::post( stream.get_executor(), bind_front_handler (std::forward<ReadHandler> (handler), net::error::eof, 0)); } @endcode @param handler The handler to wrap. The implementation takes ownership of the handler by performing a decay-copy. @param args A list of arguments to bind to the handler. The arguments are forwarded into the returned object. */ template<class Handler, class... Args> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else auto #endif bind_front_handler( Handler&& handler, Args&&... args) -> detail::bind_front_wrapper< typename std::decay<Handler>::type, typename std::decay<Args>::type...> { return detail::bind_front_wrapper< typename std::decay<Handler>::type, typename std::decay<Args>::type...>( std::forward<Handler>(handler), std::forward<Args>(args)...); } } // beast } // boost #endif PK PP�[�t끘 � core/file_win32.hppnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FILE_WIN32_HPP #define BOOST_BEAST_CORE_FILE_WIN32_HPP #include <boost/beast/core/detail/config.hpp> #if ! defined(BOOST_BEAST_USE_WIN32_FILE) # ifdef BOOST_MSVC # define BOOST_BEAST_USE_WIN32_FILE 1 # else # define BOOST_BEAST_USE_WIN32_FILE 0 # endif #endif #if BOOST_BEAST_USE_WIN32_FILE #include <boost/beast/core/error.hpp> #include <boost/beast/core/file_base.hpp> #include <boost/winapi/basic_types.hpp> #include <boost/winapi/handles.hpp> #include <cstdio> #include <cstdint> namespace boost { namespace beast { /** An implementation of File for Win32. This class implements a <em>File</em> using Win32 native interfaces. */ class file_win32 { boost::winapi::HANDLE_ h_ = boost::winapi::INVALID_HANDLE_VALUE_; public: /** The type of the underlying file handle. This is platform-specific. */ #if BOOST_BEAST_DOXYGEN using native_handle_type = HANDLE; #else using native_handle_type = boost::winapi::HANDLE_; #endif /** Destructor If the file is open it is first closed. */ BOOST_BEAST_DECL ~file_win32(); /** Constructor There is no open file initially. */ file_win32() = default; /** Constructor The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_win32(file_win32&& other); /** Assignment The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_win32& operator=(file_win32&& other); /// Returns the native handle associated with the file. native_handle_type native_handle() { return h_; } /** Set the native handle associated with the file. If the file is open it is first closed. @param h The native file handle to assign. */ BOOST_BEAST_DECL void native_handle(native_handle_type h); /// Returns `true` if the file is open bool is_open() const { return h_ != boost::winapi::INVALID_HANDLE_VALUE_; } /** Close the file if open @param ec Set to the error, if any occurred. */ BOOST_BEAST_DECL void close(error_code& ec); /** Open a file at the given path with the specified mode @param path The utf-8 encoded path to the file @param mode The file mode to use @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void open(char const* path, file_mode mode, error_code& ec); /** Return the size of the open file @param ec Set to the error, if any occurred @return The size in bytes */ BOOST_BEAST_DECL std::uint64_t size(error_code& ec) const; /** Return the current position in the open file @param ec Set to the error, if any occurred @return The offset in bytes from the beginning of the file */ BOOST_BEAST_DECL std::uint64_t pos(error_code& ec); /** Adjust the current position in the open file @param offset The offset in bytes from the beginning of the file @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void seek(std::uint64_t offset, error_code& ec); /** Read from the open file @param buffer The buffer for storing the result of the read @param n The number of bytes to read @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t read(void* buffer, std::size_t n, error_code& ec); /** Write to the open file @param buffer The buffer holding the data to write @param n The number of bytes to write @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t write(void const* buffer, std::size_t n, error_code& ec); }; } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/file_win32.ipp> #endif #endif #endif PK PP�[�a�^�r �r core/impl/basic_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_BASIC_STREAM_HPP #define BOOST_BEAST_CORE_IMPL_BASIC_STREAM_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/websocket/teardown.hpp> #include <boost/asio/coroutine.hpp> #include <boost/assert.hpp> #include <boost/make_shared.hpp> #include <boost/core/exchange.hpp> #include <cstdlib> #include <type_traits> #include <utility> namespace boost { namespace beast { //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> template<class... Args> basic_stream<Protocol, Executor, RatePolicy>:: impl_type:: impl_type(std::false_type, Args&&... args) : socket(std::forward<Args>(args)...) , read(ex()) , write(ex()) , timer(ex()) { reset(); } template<class Protocol, class Executor, class RatePolicy> template<class RatePolicy_, class... Args> basic_stream<Protocol, Executor, RatePolicy>:: impl_type:: impl_type(std::true_type, RatePolicy_&& policy, Args&&... args) : boost::empty_value<RatePolicy>( boost::empty_init_t{}, std::forward<RatePolicy_>(policy)) , socket(std::forward<Args>(args)...) , read(ex()) , write(ex()) , timer(ex()) { reset(); } template<class Protocol, class Executor, class RatePolicy> template<class Executor2> void basic_stream<Protocol, Executor, RatePolicy>:: impl_type:: on_timer(Executor2 const& ex2) { BOOST_ASSERT(waiting > 0); // the last waiter starts the new slice if(--waiting > 0) return; // update the expiration time BOOST_VERIFY(timer.expires_after( std::chrono::seconds(1)) == 0); rate_policy_access::on_timer(policy()); struct handler : boost::empty_value<Executor2> { boost::weak_ptr<impl_type> wp; using executor_type = Executor2; executor_type get_executor() const noexcept { return this->get(); } handler( Executor2 const& ex2, boost::shared_ptr<impl_type> const& sp) : boost::empty_value<Executor2>( boost::empty_init_t{}, ex2) , wp(sp) { } void operator()(error_code ec) { auto sp = wp.lock(); if(! sp) return; if(ec == net::error::operation_aborted) return; BOOST_ASSERT(! ec); if(ec) return; sp->on_timer(this->get()); } }; // wait on the timer again ++waiting; timer.async_wait(handler(ex2, this->shared_from_this())); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: impl_type:: reset() { // If assert goes off, it means that there are // already read or write (or connect) operations // outstanding, so there is nothing to apply // the expiration time to! // BOOST_ASSERT(! read.pending || ! write.pending); if(! read.pending) BOOST_VERIFY( read.timer.expires_at(never()) == 0); if(! write.pending) BOOST_VERIFY( write.timer.expires_at(never()) == 0); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: impl_type:: close() noexcept { { error_code ec; socket.close(ec); } try { timer.cancel(); } catch(...) { } } //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> template<class Executor2> struct basic_stream<Protocol, Executor, RatePolicy>:: timeout_handler { using executor_type = Executor2; op_state& state; boost::weak_ptr<impl_type> wp; tick_type tick; executor_type ex; executor_type get_executor() const noexcept { return ex; } void operator()(error_code ec) { // timer canceled if(ec == net::error::operation_aborted) return; BOOST_ASSERT(! ec); auto sp = wp.lock(); // stream destroyed if(! sp) return; // stale timer if(tick < state.tick) return; BOOST_ASSERT(tick == state.tick); // timeout BOOST_ASSERT(! state.timeout); sp->close(); state.timeout = true; } }; //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> struct basic_stream<Protocol, Executor, RatePolicy>::ops { template<bool isRead, class Buffers, class Handler> class transfer_op : public async_base<Handler, Executor> , public boost::asio::coroutine { boost::shared_ptr<impl_type> impl_; pending_guard pg_; Buffers b_; using is_read = std::integral_constant<bool, isRead>; op_state& state() { if (isRead) return impl_->read; else return impl_->write; } std::size_t available_bytes() { if (isRead) return rate_policy_access:: available_read_bytes(impl_->policy()); else return rate_policy_access:: available_write_bytes(impl_->policy()); } void transfer_bytes(std::size_t n) { if (isRead) rate_policy_access:: transfer_read_bytes(impl_->policy(), n); else rate_policy_access:: transfer_write_bytes(impl_->policy(), n); } void async_perform( std::size_t amount, std::true_type) { impl_->socket.async_read_some( beast::buffers_prefix(amount, b_), std::move(*this)); } void async_perform( std::size_t amount, std::false_type) { impl_->socket.async_write_some( beast::buffers_prefix(amount, b_), std::move(*this)); } static bool never_pending_; public: template<class Handler_> transfer_op( Handler_&& h, basic_stream& s, Buffers const& b) : async_base<Handler, Executor>( std::forward<Handler_>(h), s.get_executor()) , impl_(s.impl_) , pg_() , b_(b) { if (buffer_bytes(b_) == 0 && state().pending) { // Workaround: // Corner case discovered in https://github.com/boostorg/beast/issues/2065 // Enclosing SSL stream wishes to complete a 0-length write early by // executing a 0-length read against the underlying stream. // This can occur even if an existing async_read is in progress. // In this specific case, we will complete the async op with no error // in order to prevent assertions and/or internal corruption of the basic_stream this->complete(false, error_code(), 0); } else { pg_.assign(state().pending); (*this)({}); } } void operator()( error_code ec, std::size_t bytes_transferred = 0) { BOOST_ASIO_CORO_REENTER(*this) { // handle empty buffers if(detail::buffers_empty(b_)) { // make sure we perform the no-op BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, (isRead ? "basic_stream::async_read_some" : "basic_stream::async_write_some"))); async_perform(0, is_read{}); } // apply the timeout manually, otherwise // behavior varies across platforms. if(state().timer.expiry() <= clock_type::now()) { impl_->close(); ec = beast::error::timeout; } goto upcall; } // if a timeout is active, wait on the timer if(state().timer.expiry() != never()) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, (isRead ? "basic_stream::async_read_some" : "basic_stream::async_write_some"))); state().timer.async_wait( timeout_handler<decltype(this->get_executor())>{ state(), impl_, state().tick, this->get_executor()}); } // check rate limit, maybe wait std::size_t amount; amount = available_bytes(); if(amount == 0) { ++impl_->waiting; BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, (isRead ? "basic_stream::async_read_some" : "basic_stream::async_write_some"))); impl_->timer.async_wait(std::move(*this)); } if(ec) { // socket was closed, or a timeout BOOST_ASSERT(ec == net::error::operation_aborted); // timeout handler invoked? if(state().timeout) { // yes, socket already closed ec = beast::error::timeout; state().timeout = false; } goto upcall; } impl_->on_timer(this->get_executor()); // Allow at least one byte, otherwise // bytes_transferred could be 0. amount = std::max<std::size_t>( available_bytes(), 1); } BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, (isRead ? "basic_stream::async_read_some" : "basic_stream::async_write_some"))); async_perform(amount, is_read{}); } if(state().timer.expiry() != never()) { ++state().tick; // try cancelling timer auto const n = state().timer.cancel(); if(n == 0) { // timeout handler invoked? if(state().timeout) { // yes, socket already closed ec = beast::error::timeout; state().timeout = false; } } else { BOOST_ASSERT(n == 1); BOOST_ASSERT(! state().timeout); } } upcall: pg_.reset(); transfer_bytes(bytes_transferred); this->complete_now(ec, bytes_transferred); } } }; template<class Handler> class connect_op : public async_base<Handler, Executor> { boost::shared_ptr<impl_type> impl_; pending_guard pg0_; pending_guard pg1_; op_state& state() noexcept { return impl_->write; } public: template<class Handler_> connect_op( Handler_&& h, basic_stream& s, endpoint_type ep) : async_base<Handler, Executor>( std::forward<Handler_>(h), s.get_executor()) , impl_(s.impl_) , pg0_(impl_->read.pending) , pg1_(impl_->write.pending) { if(state().timer.expiry() != stream_base::never()) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); impl_->write.timer.async_wait( timeout_handler<decltype(this->get_executor())>{ state(), impl_, state().tick, this->get_executor()}); } BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); impl_->socket.async_connect( ep, std::move(*this)); // *this is now moved-from } template< class Endpoints, class Condition, class Handler_> connect_op( Handler_&& h, basic_stream& s, Endpoints const& eps, Condition const& cond) : async_base<Handler, Executor>( std::forward<Handler_>(h), s.get_executor()) , impl_(s.impl_) , pg0_(impl_->read.pending) , pg1_(impl_->write.pending) { if(state().timer.expiry() != stream_base::never()) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); impl_->write.timer.async_wait( timeout_handler<decltype(this->get_executor())>{ state(), impl_, state().tick, this->get_executor()}); } BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); net::async_connect(impl_->socket, eps, cond, std::move(*this)); // *this is now moved-from } template< class Iterator, class Condition, class Handler_> connect_op( Handler_&& h, basic_stream& s, Iterator begin, Iterator end, Condition const& cond) : async_base<Handler, Executor>( std::forward<Handler_>(h), s.get_executor()) , impl_(s.impl_) , pg0_(impl_->read.pending) , pg1_(impl_->write.pending) { if(state().timer.expiry() != stream_base::never()) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); impl_->write.timer.async_wait( timeout_handler<decltype(this->get_executor())>{ state(), impl_, state().tick, this->get_executor()}); } BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "basic_stream::async_connect")); net::async_connect(impl_->socket, begin, end, cond, std::move(*this)); // *this is now moved-from } template<class... Args> void operator()(error_code ec, Args&&... args) { if(state().timer.expiry() != stream_base::never()) { ++state().tick; // try cancelling timer auto const n = impl_->write.timer.cancel(); if(n == 0) { // timeout handler invoked? if(state().timeout) { // yes, socket already closed ec = beast::error::timeout; state().timeout = false; } } else { BOOST_ASSERT(n == 1); BOOST_ASSERT(! state().timeout); } } pg0_.reset(); pg1_.reset(); this->complete_now(ec, std::forward<Args>(args)...); } }; struct run_read_op { template<class ReadHandler, class Buffers> void operator()( ReadHandler&& h, basic_stream* s, Buffers const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); transfer_op< true, Buffers, typename std::decay<ReadHandler>::type>( std::forward<ReadHandler>(h), *s, b); } }; struct run_write_op { template<class WriteHandler, class Buffers> void operator()( WriteHandler&& h, basic_stream* s, Buffers const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); transfer_op< false, Buffers, typename std::decay<WriteHandler>::type>( std::forward<WriteHandler>(h), *s, b); } }; struct run_connect_op { template<class ConnectHandler> void operator()( ConnectHandler&& h, basic_stream* s, endpoint_type const& ep) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( detail::is_invocable<ConnectHandler, void(error_code)>::value, "ConnectHandler type requirements not met"); connect_op<typename std::decay<ConnectHandler>::type>( std::forward<ConnectHandler>(h), *s, ep); } }; struct run_connect_range_op { template< class RangeConnectHandler, class EndpointSequence, class Condition> void operator()( RangeConnectHandler&& h, basic_stream* s, EndpointSequence const& eps, Condition const& cond) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( detail::is_invocable<RangeConnectHandler, void(error_code, typename Protocol::endpoint)>::value, "RangeConnectHandler type requirements not met"); connect_op<typename std::decay<RangeConnectHandler>::type>( std::forward<RangeConnectHandler>(h), *s, eps, cond); } }; struct run_connect_iter_op { template< class IteratorConnectHandler, class Iterator, class Condition> void operator()( IteratorConnectHandler&& h, basic_stream* s, Iterator begin, Iterator end, Condition const& cond) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( detail::is_invocable<IteratorConnectHandler, void(error_code, Iterator)>::value, "IteratorConnectHandler type requirements not met"); connect_op<typename std::decay<IteratorConnectHandler>::type>( std::forward<IteratorConnectHandler>(h), *s, begin, end, cond); } }; }; //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> basic_stream<Protocol, Executor, RatePolicy>:: ~basic_stream() { // the shared object can outlive *this, // cancel any operations so the shared // object is destroyed as soon as possible. impl_->close(); } template<class Protocol, class Executor, class RatePolicy> template<class Arg0, class... Args, class> basic_stream<Protocol, Executor, RatePolicy>:: basic_stream(Arg0&& arg0, Args&&... args) : impl_(boost::make_shared<impl_type>( std::false_type{}, std::forward<Arg0>(arg0), std::forward<Args>(args)...)) { } template<class Protocol, class Executor, class RatePolicy> template<class RatePolicy_, class Arg0, class... Args, class> basic_stream<Protocol, Executor, RatePolicy>:: basic_stream( RatePolicy_&& policy, Arg0&& arg0, Args&&... args) : impl_(boost::make_shared<impl_type>( std::true_type{}, std::forward<RatePolicy_>(policy), std::forward<Arg0>(arg0), std::forward<Args>(args)...)) { } template<class Protocol, class Executor, class RatePolicy> basic_stream<Protocol, Executor, RatePolicy>:: basic_stream(basic_stream&& other) : impl_(boost::make_shared<impl_type>( std::move(*other.impl_))) { // Explainer: Asio's sockets provide the guarantee that a moved-from socket // will be in a state as-if newly created. i.e.: // * having the same (valid) executor // * the socket shall not be open // We provide the same guarantee by moving the impl rather than the pointer // controlling its lifetime. } //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> auto basic_stream<Protocol, Executor, RatePolicy>:: release_socket() -> socket_type { this->cancel(); return std::move(impl_->socket); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: expires_after(net::steady_timer::duration expiry_time) { // If assert goes off, it means that there are // already read or write (or connect) operations // outstanding, so there is nothing to apply // the expiration time to! // BOOST_ASSERT( ! impl_->read.pending || ! impl_->write.pending); if(! impl_->read.pending) BOOST_VERIFY( impl_->read.timer.expires_after( expiry_time) == 0); if(! impl_->write.pending) BOOST_VERIFY( impl_->write.timer.expires_after( expiry_time) == 0); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: expires_at( net::steady_timer::time_point expiry_time) { // If assert goes off, it means that there are // already read or write (or connect) operations // outstanding, so there is nothing to apply // the expiration time to! // BOOST_ASSERT( ! impl_->read.pending || ! impl_->write.pending); if(! impl_->read.pending) BOOST_VERIFY( impl_->read.timer.expires_at( expiry_time) == 0); if(! impl_->write.pending) BOOST_VERIFY( impl_->write.timer.expires_at( expiry_time) == 0); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: expires_never() { impl_->reset(); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: cancel() { error_code ec; impl_->socket.cancel(ec); impl_->timer.cancel(); } template<class Protocol, class Executor, class RatePolicy> void basic_stream<Protocol, Executor, RatePolicy>:: close() { impl_->close(); } //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> template<BOOST_BEAST_ASYNC_TPARAM1 ConnectHandler> BOOST_BEAST_ASYNC_RESULT1(ConnectHandler) basic_stream<Protocol, Executor, RatePolicy>:: async_connect( endpoint_type const& ep, ConnectHandler&& handler) { return net::async_initiate< ConnectHandler, void(error_code)>( typename ops::run_connect_op{}, handler, this, ep); } template<class Protocol, class Executor, class RatePolicy> template< class EndpointSequence, BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, typename Protocol::endpoint)) RangeConnectHandler, class> BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,void(error_code, typename Protocol::endpoint)) basic_stream<Protocol, Executor, RatePolicy>:: async_connect( EndpointSequence const& endpoints, RangeConnectHandler&& handler) { return net::async_initiate< RangeConnectHandler, void(error_code, typename Protocol::endpoint)>( typename ops::run_connect_range_op{}, handler, this, endpoints, detail::any_endpoint{}); } template<class Protocol, class Executor, class RatePolicy> template< class EndpointSequence, class ConnectCondition, BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, typename Protocol::endpoint)) RangeConnectHandler, class> BOOST_ASIO_INITFN_RESULT_TYPE(RangeConnectHandler,void (error_code, typename Protocol::endpoint)) basic_stream<Protocol, Executor, RatePolicy>:: async_connect( EndpointSequence const& endpoints, ConnectCondition connect_condition, RangeConnectHandler&& handler) { return net::async_initiate< RangeConnectHandler, void(error_code, typename Protocol::endpoint)>( typename ops::run_connect_range_op{}, handler, this, endpoints, connect_condition); } template<class Protocol, class Executor, class RatePolicy> template< class Iterator, BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, Iterator)) IteratorConnectHandler> BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,void (error_code, Iterator)) basic_stream<Protocol, Executor, RatePolicy>:: async_connect( Iterator begin, Iterator end, IteratorConnectHandler&& handler) { return net::async_initiate< IteratorConnectHandler, void(error_code, Iterator)>( typename ops::run_connect_iter_op{}, handler, this, begin, end, detail::any_endpoint{}); } template<class Protocol, class Executor, class RatePolicy> template< class Iterator, class ConnectCondition, BOOST_ASIO_COMPLETION_TOKEN_FOR(void(error_code, Iterator)) IteratorConnectHandler> BOOST_ASIO_INITFN_RESULT_TYPE(IteratorConnectHandler,void (error_code, Iterator)) basic_stream<Protocol, Executor, RatePolicy>:: async_connect( Iterator begin, Iterator end, ConnectCondition connect_condition, IteratorConnectHandler&& handler) { return net::async_initiate< IteratorConnectHandler, void(error_code, Iterator)>( typename ops::run_connect_iter_op{}, handler, this, begin, end, connect_condition); } //------------------------------------------------------------------------------ template<class Protocol, class Executor, class RatePolicy> template<class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) basic_stream<Protocol, Executor, RatePolicy>:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( typename ops::run_read_op{}, handler, this, buffers); } template<class Protocol, class Executor, class RatePolicy> template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) basic_stream<Protocol, Executor, RatePolicy>:: async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( typename ops::run_write_op{}, handler, this, buffers); } //------------------------------------------------------------------------------ // // Customization points // #if ! BOOST_BEAST_DOXYGEN template< class Protocol, class Executor, class RatePolicy> void beast_close_socket( basic_stream<Protocol, Executor, RatePolicy>& stream) { error_code ec; stream.socket().close(ec); } template< class Protocol, class Executor, class RatePolicy> void teardown( role_type role, basic_stream<Protocol, Executor, RatePolicy>& stream, error_code& ec) { using beast::websocket::teardown; teardown(role, stream.socket(), ec); } template< class Protocol, class Executor, class RatePolicy, class TeardownHandler> void async_teardown( role_type role, basic_stream<Protocol, Executor, RatePolicy>& stream, TeardownHandler&& handler) { using beast::websocket::async_teardown; async_teardown(role, stream.socket(), std::forward<TeardownHandler>(handler)); } #endif } // beast } // boost #endif PK PP�[�t� � core/impl/string.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_STRING_IPP #define BOOST_BEAST_IMPL_STRING_IPP #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/string.hpp> #include <algorithm> namespace boost { namespace beast { bool iequals( beast::string_view lhs, beast::string_view rhs) { auto n = lhs.size(); if(rhs.size() != n) return false; auto p1 = lhs.data(); auto p2 = rhs.data(); char a, b; // fast loop while(n--) { a = *p1++; b = *p2++; if(a != b) goto slow; } return true; slow: do { if( detail::ascii_tolower(a) != detail::ascii_tolower(b)) return false; a = *p1++; b = *p2++; } while(n--); return true; } bool iless::operator()( string_view lhs, string_view rhs) const { using std::begin; using std::end; return std::lexicographical_compare( begin(lhs), end(lhs), begin(rhs), end(rhs), [](char c1, char c2) { return detail::ascii_tolower(c1) < detail::ascii_tolower(c2); } ); } } // beast } // boost #endif PK PP�[�� 2� � core/impl/error.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_ERROR_IPP #define BOOST_BEAST_IMPL_ERROR_IPP #include <boost/beast/core/error.hpp> namespace boost { namespace beast { namespace detail { class error_codes : public error_category { public: const char* name() const noexcept override { return "boost.beast"; } BOOST_BEAST_DECL std::string message(int ev) const override { switch(static_cast<error>(ev)) { default: case error::timeout: return "The socket was closed due to a timeout"; } } BOOST_BEAST_DECL error_condition default_error_condition(int ev) const noexcept override { switch(static_cast<error>(ev)) { default: // return {ev, *this}; case error::timeout: return condition::timeout; } } }; class error_conditions : public error_category { public: BOOST_BEAST_DECL const char* name() const noexcept override { return "boost.beast"; } BOOST_BEAST_DECL std::string message(int cv) const override { switch(static_cast<condition>(cv)) { default: case condition::timeout: return "The operation timed out"; } } }; } // detail error_code make_error_code(error e) { static detail::error_codes const cat{}; return error_code{static_cast< std::underlying_type<error>::type>(e), cat}; } error_condition make_error_condition(condition c) { static detail::error_conditions const cat{}; return error_condition{static_cast< std::underlying_type<condition>::type>(c), cat}; } } // beast } // boost #endif PK PP�[���k� � core/impl/static_buffer.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_STATIC_BUFFER_IPP #define BOOST_BEAST_IMPL_STATIC_BUFFER_IPP #include <boost/beast/core/static_buffer.hpp> #include <boost/asio/buffer.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace beast { static_buffer_base:: static_buffer_base( void* p, std::size_t size) noexcept : begin_(static_cast<char*>(p)) , capacity_(size) { } void static_buffer_base:: clear() noexcept { in_off_ = 0; in_size_ = 0; out_size_ = 0; } auto static_buffer_base:: data() const noexcept -> const_buffers_type { if(in_off_ + in_size_ <= capacity_) return { net::const_buffer{ begin_ + in_off_, in_size_}, net::const_buffer{ begin_, 0}}; return { net::const_buffer{ begin_ + in_off_, capacity_ - in_off_}, net::const_buffer{ begin_, in_size_ - (capacity_ - in_off_)}}; } auto static_buffer_base:: data() noexcept -> mutable_buffers_type { if(in_off_ + in_size_ <= capacity_) return { net::mutable_buffer{ begin_ + in_off_, in_size_}, net::mutable_buffer{ begin_, 0}}; return { net::mutable_buffer{ begin_ + in_off_, capacity_ - in_off_}, net::mutable_buffer{ begin_, in_size_ - (capacity_ - in_off_)}}; } auto static_buffer_base:: prepare(std::size_t n) -> mutable_buffers_type { using net::mutable_buffer; if(n > capacity_ - in_size_) BOOST_THROW_EXCEPTION(std::length_error{ "static_buffer overflow"}); out_size_ = n; auto const out_off = (in_off_ + in_size_) % capacity_; if(out_off + out_size_ <= capacity_ ) return { net::mutable_buffer{ begin_ + out_off, out_size_}, net::mutable_buffer{ begin_, 0}}; return { net::mutable_buffer{ begin_ + out_off, capacity_ - out_off}, net::mutable_buffer{ begin_, out_size_ - (capacity_ - out_off)}}; } void static_buffer_base:: commit(std::size_t n) noexcept { in_size_ += (std::min)(n, out_size_); out_size_ = 0; } void static_buffer_base:: consume(std::size_t n) noexcept { if(n < in_size_) { in_off_ = (in_off_ + n) % capacity_; in_size_ -= n; } else { // rewind the offset, so the next call to prepare // can have a longer contiguous segment. this helps // algorithms optimized for larger buffers. in_off_ = 0; in_size_ = 0; } } } // beast } // boost #endif PK PP�[2I'�� � core/impl/saved_handler.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_SAVED_HANDLER_HPP #define BOOST_BEAST_CORE_IMPL_SAVED_HANDLER_HPP #include <boost/beast/core/detail/allocator.hpp> #include <boost/asio/associated_allocator.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/executor_work_guard.hpp> #include <boost/assert.hpp> #include <boost/core/empty_value.hpp> #include <boost/core/exchange.hpp> #include <utility> namespace boost { namespace beast { //------------------------------------------------------------------------------ class saved_handler::base { protected: ~base() = default; public: base() = default; virtual void destroy() = 0; virtual void invoke() = 0; }; //------------------------------------------------------------------------------ template<class Handler, class Alloc> class saved_handler::impl final : public base { using alloc_type = typename beast::detail::allocator_traits< Alloc>::template rebind_alloc<impl>; using alloc_traits = beast::detail::allocator_traits<alloc_type>; struct ebo_pair : boost::empty_value<alloc_type> { Handler h; template<class Handler_> ebo_pair( alloc_type const& a, Handler_&& h_) : boost::empty_value<alloc_type>( boost::empty_init_t{}, a) , h(std::forward<Handler_>(h_)) { } }; ebo_pair v_; #if defined(BOOST_ASIO_NO_TS_EXECUTORS) typename std::decay<decltype(net::prefer(std::declval< net::associated_executor_t<Handler>>(), net::execution::outstanding_work.tracked))>::type wg2_; #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) net::executor_work_guard< net::associated_executor_t<Handler>> wg2_; #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) public: template<class Handler_> impl(alloc_type const& a, Handler_&& h) : v_(a, std::forward<Handler_>(h)) #if defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg2_(net::prefer( net::get_associated_executor(v_.h), net::execution::outstanding_work.tracked)) #else // defined(BOOST_ASIO_NO_TS_EXECUTORS) , wg2_(net::get_associated_executor(v_.h)) #endif // defined(BOOST_ASIO_NO_TS_EXECUTORS) { } void destroy() override { auto v = std::move(v_); alloc_traits::destroy(v.get(), this); alloc_traits::deallocate(v.get(), this, 1); } void invoke() override { auto v = std::move(v_); alloc_traits::destroy(v.get(), this); alloc_traits::deallocate(v.get(), this, 1); v.h(); } }; //------------------------------------------------------------------------------ template<class Handler, class Allocator> void saved_handler:: emplace(Handler&& handler, Allocator const& alloc) { // Can't delete a handler before invoking BOOST_ASSERT(! has_value()); using handler_type = typename std::decay<Handler>::type; using alloc_type = typename detail::allocator_traits<Allocator>:: template rebind_alloc<impl< handler_type, Allocator>>; using alloc_traits = beast::detail::allocator_traits<alloc_type>; struct storage { alloc_type a; impl<Handler, Allocator>* p; explicit storage(Allocator const& a_) : a(a_) , p(alloc_traits::allocate(a, 1)) { } ~storage() { if(p) alloc_traits::deallocate(a, p, 1); } }; storage s(alloc); alloc_traits::construct(s.a, s.p, s.a, std::forward<Handler>(handler)); p_ = boost::exchange(s.p, nullptr); } template<class Handler> void saved_handler:: emplace(Handler&& handler) { // Can't delete a handler before invoking BOOST_ASSERT(! has_value()); emplace( std::forward<Handler>(handler), net::get_associated_allocator(handler)); } } // beast } // boost #endif PK PP�[~2 |. |. core/impl/flat_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_FLAT_BUFFER_HPP #define BOOST_BEAST_IMPL_FLAT_BUFFER_HPP #include <boost/core/exchange.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <memory> #include <stdexcept> namespace boost { namespace beast { /* Layout: begin_ in_ out_ last_ end_ |<------->|<---------->|<---------->|<------->| | readable | writable | */ template<class Allocator> basic_flat_buffer<Allocator>:: ~basic_flat_buffer() { if(! begin_) return; alloc_traits::deallocate( this->get(), begin_, capacity()); } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer() noexcept(default_nothrow) : begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(alloc_traits::max_size( this->get())) { } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer( std::size_t limit) noexcept(default_nothrow) : begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(limit) { } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer(Allocator const& alloc) noexcept : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, alloc) , begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(alloc_traits::max_size( this->get())) { } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer( std::size_t limit, Allocator const& alloc) noexcept : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, alloc) , begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(limit) { } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer(basic_flat_buffer&& other) noexcept : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, std::move(other.get())) , begin_(boost::exchange(other.begin_, nullptr)) , in_(boost::exchange(other.in_, nullptr)) , out_(boost::exchange(other.out_, nullptr)) , last_(boost::exchange(other.last_, nullptr)) , end_(boost::exchange(other.end_, nullptr)) , max_(other.max_) { } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer( basic_flat_buffer&& other, Allocator const& alloc) : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, alloc) { if(this->get() != other.get()) { begin_ = nullptr; in_ = nullptr; out_ = nullptr; last_ = nullptr; end_ = nullptr; max_ = other.max_; copy_from(other); return; } begin_ = other.begin_; in_ = other.in_; out_ = other.out_; last_ = other.out_; // invalidate end_ = other.end_; max_ = other.max_; BOOST_ASSERT( alloc_traits::max_size(this->get()) == alloc_traits::max_size(other.get())); other.begin_ = nullptr; other.in_ = nullptr; other.out_ = nullptr; other.last_ = nullptr; other.end_ = nullptr; } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer(basic_flat_buffer const& other) : boost::empty_value<base_alloc_type>(boost::empty_init_t{}, alloc_traits::select_on_container_copy_construction( other.get())) , begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(other.max_) { copy_from(other); } template<class Allocator> basic_flat_buffer<Allocator>:: basic_flat_buffer( basic_flat_buffer const& other, Allocator const& alloc) : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, alloc) , begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(other.max_) { copy_from(other); } template<class Allocator> template<class OtherAlloc> basic_flat_buffer<Allocator>:: basic_flat_buffer( basic_flat_buffer<OtherAlloc> const& other) noexcept(default_nothrow) : begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(other.max_) { copy_from(other); } template<class Allocator> template<class OtherAlloc> basic_flat_buffer<Allocator>:: basic_flat_buffer( basic_flat_buffer<OtherAlloc> const& other, Allocator const& alloc) : boost::empty_value<base_alloc_type>( boost::empty_init_t{}, alloc) , begin_(nullptr) , in_(nullptr) , out_(nullptr) , last_(nullptr) , end_(nullptr) , max_(other.max_) { copy_from(other); } template<class Allocator> auto basic_flat_buffer<Allocator>:: operator=(basic_flat_buffer&& other) noexcept -> basic_flat_buffer& { if(this == &other) return *this; move_assign(other, pocma{}); return *this; } template<class Allocator> auto basic_flat_buffer<Allocator>:: operator=(basic_flat_buffer const& other) -> basic_flat_buffer& { if(this == &other) return *this; copy_assign(other, pocca{}); return *this; } template<class Allocator> template<class OtherAlloc> auto basic_flat_buffer<Allocator>:: operator=( basic_flat_buffer<OtherAlloc> const& other) -> basic_flat_buffer& { copy_from(other); return *this; } template<class Allocator> void basic_flat_buffer<Allocator>:: reserve(std::size_t n) { if(max_ < n) max_ = n; if(n > capacity()) prepare(n - size()); } template<class Allocator> void basic_flat_buffer<Allocator>:: shrink_to_fit() noexcept { auto const len = size(); if(len == capacity()) return; char* p; if(len > 0) { BOOST_ASSERT(begin_); BOOST_ASSERT(in_); #ifndef BOOST_NO_EXCEPTIONS try { #endif p = alloc(len); #ifndef BOOST_NO_EXCEPTIONS } catch(std::exception const&) { // request could not be fulfilled, // squelch the exception return; } #endif std::memcpy(p, in_, len); } else { p = nullptr; } alloc_traits::deallocate( this->get(), begin_, this->capacity()); begin_ = p; in_ = begin_; out_ = begin_ + len; last_ = out_; end_ = out_; } template<class Allocator> void basic_flat_buffer<Allocator>:: clear() noexcept { in_ = begin_; out_ = begin_; last_ = begin_; } //------------------------------------------------------------------------------ template<class Allocator> auto basic_flat_buffer<Allocator>:: prepare(std::size_t n) -> mutable_buffers_type { auto const len = size(); if(len > max_ || n > (max_ - len)) BOOST_THROW_EXCEPTION(std::length_error{ "basic_flat_buffer too long"}); if(n <= dist(out_, end_)) { // existing capacity is sufficient last_ = out_ + n; return{out_, n}; } if(n <= capacity() - len) { // after a memmove, // existing capacity is sufficient if(len > 0) { BOOST_ASSERT(begin_); BOOST_ASSERT(in_); std::memmove(begin_, in_, len); } in_ = begin_; out_ = in_ + len; last_ = out_ + n; return {out_, n}; } // allocate a new buffer auto const new_size = (std::min<std::size_t>)( max_, (std::max<std::size_t>)(2 * len, len + n)); auto const p = alloc(new_size); if(begin_) { BOOST_ASSERT(p); BOOST_ASSERT(in_); std::memcpy(p, in_, len); alloc_traits::deallocate( this->get(), begin_, capacity()); } begin_ = p; in_ = begin_; out_ = in_ + len; last_ = out_ + n; end_ = begin_ + new_size; return {out_, n}; } template<class Allocator> void basic_flat_buffer<Allocator>:: consume(std::size_t n) noexcept { if(n >= dist(in_, out_)) { in_ = begin_; out_ = begin_; return; } in_ += n; } //------------------------------------------------------------------------------ template<class Allocator> template<class OtherAlloc> void basic_flat_buffer<Allocator>:: copy_from( basic_flat_buffer<OtherAlloc> const& other) { std::size_t const n = other.size(); if(n == 0 || n > capacity()) { if(begin_ != nullptr) { alloc_traits::deallocate( this->get(), begin_, this->capacity()); begin_ = nullptr; in_ = nullptr; out_ = nullptr; last_ = nullptr; end_ = nullptr; } if(n == 0) return; begin_ = alloc(n); in_ = begin_; out_ = begin_ + n; last_ = begin_ + n; end_ = begin_ + n; } in_ = begin_; out_ = begin_ + n; last_ = begin_ + n; if(begin_) { BOOST_ASSERT(other.begin_); std::memcpy(begin_, other.in_, n); } } template<class Allocator> void basic_flat_buffer<Allocator>:: move_assign(basic_flat_buffer& other, std::true_type) { clear(); shrink_to_fit(); this->get() = std::move(other.get()); begin_ = other.begin_; in_ = other.in_; out_ = other.out_; last_ = out_; end_ = other.end_; max_ = other.max_; other.begin_ = nullptr; other.in_ = nullptr; other.out_ = nullptr; other.last_ = nullptr; other.end_ = nullptr; } template<class Allocator> void basic_flat_buffer<Allocator>:: move_assign(basic_flat_buffer& other, std::false_type) { if(this->get() != other.get()) { copy_from(other); } else { move_assign(other, std::true_type{}); } } template<class Allocator> void basic_flat_buffer<Allocator>:: copy_assign(basic_flat_buffer const& other, std::true_type) { max_ = other.max_; this->get() = other.get(); copy_from(other); } template<class Allocator> void basic_flat_buffer<Allocator>:: copy_assign(basic_flat_buffer const& other, std::false_type) { clear(); shrink_to_fit(); max_ = other.max_; copy_from(other); } template<class Allocator> void basic_flat_buffer<Allocator>:: swap(basic_flat_buffer& other) { swap(other, typename alloc_traits::propagate_on_container_swap{}); } template<class Allocator> void basic_flat_buffer<Allocator>:: swap(basic_flat_buffer& other, std::true_type) { using std::swap; swap(this->get(), other.get()); swap(max_, other.max_); swap(begin_, other.begin_); swap(in_, other.in_); swap(out_, other.out_); last_ = this->out_; other.last_ = other.out_; swap(end_, other.end_); } template<class Allocator> void basic_flat_buffer<Allocator>:: swap(basic_flat_buffer& other, std::false_type) { BOOST_ASSERT(this->get() == other.get()); using std::swap; swap(max_, other.max_); swap(begin_, other.begin_); swap(in_, other.in_); swap(out_, other.out_); last_ = this->out_; other.last_ = other.out_; swap(end_, other.end_); } template<class Allocator> void swap( basic_flat_buffer<Allocator>& lhs, basic_flat_buffer<Allocator>& rhs) { lhs.swap(rhs); } template<class Allocator> char* basic_flat_buffer<Allocator>:: alloc(std::size_t n) { if(n > alloc_traits::max_size(this->get())) BOOST_THROW_EXCEPTION(std::length_error( "A basic_flat_buffer exceeded the allocator's maximum size")); return alloc_traits::allocate(this->get(), n); } } // beast } // boost #endif PK PP�[�v��z) z) core/impl/buffers_cat.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_BUFFERS_CAT_HPP #define BOOST_BEAST_IMPL_BUFFERS_CAT_HPP #include <boost/beast/core/detail/tuple.hpp> #include <boost/beast/core/detail/variant.hpp> #include <boost/asio/buffer.hpp> #include <cstdint> #include <iterator> #include <new> #include <stdexcept> #include <utility> namespace boost { namespace beast { template<class Buffer> class buffers_cat_view<Buffer> { Buffer buffer_; public: using value_type = buffers_type<Buffer>; using const_iterator = buffers_iterator_type<Buffer>; explicit buffers_cat_view(Buffer const& buffer) : buffer_(buffer) { } const_iterator begin() const { return net::buffer_sequence_begin(buffer_); } const_iterator end() const { return net::buffer_sequence_end(buffer_); } }; #if defined(_MSC_VER) && ! defined(__clang__) # define BOOST_BEAST_UNREACHABLE() __assume(false) # define BOOST_BEAST_UNREACHABLE_RETURN(v) return v #else # define BOOST_BEAST_UNREACHABLE() __builtin_unreachable() # define BOOST_BEAST_UNREACHABLE_RETURN(v) \ do { __builtin_unreachable(); return v; } while(false) #endif #ifdef BOOST_BEAST_TESTS #define BOOST_BEAST_LOGIC_ERROR(s) \ do { \ BOOST_THROW_EXCEPTION(std::logic_error((s))); \ BOOST_BEAST_UNREACHABLE(); \ } while(false) #define BOOST_BEAST_LOGIC_ERROR_RETURN(v, s) \ do { \ BOOST_THROW_EXCEPTION(std::logic_error(s)); \ BOOST_BEAST_UNREACHABLE_RETURN(v); \ } while(false) #else #define BOOST_BEAST_LOGIC_ERROR(s) \ do { \ BOOST_ASSERT_MSG(false, s); \ BOOST_BEAST_UNREACHABLE(); \ } while(false) #define BOOST_BEAST_LOGIC_ERROR_RETURN(v, s) \ do { \ BOOST_ASSERT_MSG(false, (s)); \ BOOST_BEAST_UNREACHABLE_RETURN(v); \ } while(false) #endif namespace detail { struct buffers_cat_view_iterator_base { struct past_end { char unused = 0; // make g++8 happy net::mutable_buffer operator*() const { BOOST_BEAST_LOGIC_ERROR_RETURN({}, "Dereferencing a one-past-the-end iterator"); } operator bool() const noexcept { return true; } }; }; } // detail template<class... Bn> class buffers_cat_view<Bn...>::const_iterator : private detail::buffers_cat_view_iterator_base { // VFALCO The logic to skip empty sequences fails // if there is just one buffer in the list. static_assert(sizeof...(Bn) >= 2, "A minimum of two sequences are required"); detail::tuple<Bn...> const* bn_ = nullptr; detail::variant< buffers_iterator_type<Bn>..., past_end> it_{}; friend class buffers_cat_view<Bn...>; template<std::size_t I> using C = std::integral_constant<std::size_t, I>; public: using value_type = typename buffers_cat_view<Bn...>::value_type; using pointer = value_type const*; using reference = value_type; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; const_iterator() = default; const_iterator(const_iterator const& other) = default; const_iterator& operator=( const_iterator const& other) = default; bool operator==(const_iterator const& other) const; bool operator!=(const_iterator const& other) const { return ! (*this == other); } reference operator*() const; pointer operator->() const = delete; const_iterator& operator++(); const_iterator operator++(int); const_iterator& operator--(); const_iterator operator--(int); private: const_iterator( detail::tuple<Bn...> const& bn, std::true_type); const_iterator( detail::tuple<Bn...> const& bn, std::false_type); struct dereference { const_iterator const& self; reference operator()(mp11::mp_size_t<0>) { BOOST_BEAST_LOGIC_ERROR_RETURN({}, "Dereferencing a default-constructed iterator"); } template<class I> reference operator()(I) { return *self.it_.template get<I::value>(); } }; struct increment { const_iterator& self; void operator()(mp11::mp_size_t<0>) { BOOST_BEAST_LOGIC_ERROR( "Incrementing a default-constructed iterator"); } template<std::size_t I> void operator()(mp11::mp_size_t<I>) { ++self.it_.template get<I>(); next(mp11::mp_size_t<I>{}); } template<std::size_t I> void next(mp11::mp_size_t<I>) { auto& it = self.it_.template get<I>(); for(;;) { if (it == net::buffer_sequence_end( detail::get<I-1>(*self.bn_))) break; if(net::const_buffer(*it).size() > 0) return; ++it; } self.it_.template emplace<I+1>( net::buffer_sequence_begin( detail::get<I>(*self.bn_))); next(mp11::mp_size_t<I+1>{}); } void operator()(mp11::mp_size_t<sizeof...(Bn)>) { auto constexpr I = sizeof...(Bn); ++self.it_.template get<I>(); next(mp11::mp_size_t<I>{}); } void next(mp11::mp_size_t<sizeof...(Bn)>) { auto constexpr I = sizeof...(Bn); auto& it = self.it_.template get<I>(); for(;;) { if (it == net::buffer_sequence_end( detail::get<I-1>(*self.bn_))) break; if(net::const_buffer(*it).size() > 0) return; ++it; } // end self.it_.template emplace<I+1>(); } void operator()(mp11::mp_size_t<sizeof...(Bn)+1>) { BOOST_BEAST_LOGIC_ERROR( "Incrementing a one-past-the-end iterator"); } }; struct decrement { const_iterator& self; void operator()(mp11::mp_size_t<0>) { BOOST_BEAST_LOGIC_ERROR( "Decrementing a default-constructed iterator"); } void operator()(mp11::mp_size_t<1>) { auto constexpr I = 1; auto& it = self.it_.template get<I>(); for(;;) { if(it == net::buffer_sequence_begin( detail::get<I-1>(*self.bn_))) { BOOST_BEAST_LOGIC_ERROR( "Decrementing an iterator to the beginning"); } --it; if(net::const_buffer(*it).size() > 0) return; } } template<std::size_t I> void operator()(mp11::mp_size_t<I>) { auto& it = self.it_.template get<I>(); for(;;) { if(it == net::buffer_sequence_begin( detail::get<I-1>(*self.bn_))) break; --it; if(net::const_buffer(*it).size() > 0) return; } self.it_.template emplace<I-1>( net::buffer_sequence_end( detail::get<I-2>(*self.bn_))); (*this)(mp11::mp_size_t<I-1>{}); } void operator()(mp11::mp_size_t<sizeof...(Bn)+1>) { auto constexpr I = sizeof...(Bn)+1; self.it_.template emplace<I-1>( net::buffer_sequence_end( detail::get<I-2>(*self.bn_))); (*this)(mp11::mp_size_t<I-1>{}); } }; }; //------------------------------------------------------------------------------ template<class... Bn> buffers_cat_view<Bn...>:: const_iterator:: const_iterator( detail::tuple<Bn...> const& bn, std::true_type) : bn_(&bn) { // one past the end it_.template emplace<sizeof...(Bn)+1>(); } template<class... Bn> buffers_cat_view<Bn...>:: const_iterator:: const_iterator( detail::tuple<Bn...> const& bn, std::false_type) : bn_(&bn) { it_.template emplace<1>( net::buffer_sequence_begin( detail::get<0>(*bn_))); increment{*this}.next( mp11::mp_size_t<1>{}); } template<class... Bn> bool buffers_cat_view<Bn...>:: const_iterator:: operator==(const_iterator const& other) const { return bn_ == other.bn_ && it_ == other.it_; } template<class... Bn> auto buffers_cat_view<Bn...>:: const_iterator:: operator*() const -> reference { return mp11::mp_with_index< sizeof...(Bn) + 2>( it_.index(), dereference{*this}); } template<class... Bn> auto buffers_cat_view<Bn...>:: const_iterator:: operator++() -> const_iterator& { mp11::mp_with_index< sizeof...(Bn) + 2>( it_.index(), increment{*this}); return *this; } template<class... Bn> auto buffers_cat_view<Bn...>:: const_iterator:: operator++(int) -> const_iterator { auto temp = *this; ++(*this); return temp; } template<class... Bn> auto buffers_cat_view<Bn...>:: const_iterator:: operator--() -> const_iterator& { mp11::mp_with_index< sizeof...(Bn) + 2>( it_.index(), decrement{*this}); return *this; } template<class... Bn> auto buffers_cat_view<Bn...>:: const_iterator:: operator--(int) -> const_iterator { auto temp = *this; --(*this); return temp; } //------------------------------------------------------------------------------ template<class... Bn> buffers_cat_view<Bn...>:: buffers_cat_view(Bn const&... bn) : bn_(bn...) { } template<class... Bn> auto buffers_cat_view<Bn...>::begin() const -> const_iterator { return const_iterator{bn_, std::false_type{}}; } template<class... Bn> auto buffers_cat_view<Bn...>::end() const-> const_iterator { return const_iterator{bn_, std::true_type{}}; } } // beast } // boost #endif PK PP�[Y�.o� � core/impl/flat_static_buffer.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_FLAT_STATIC_BUFFER_IPP #define BOOST_BEAST_IMPL_FLAT_STATIC_BUFFER_IPP #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <cstring> #include <iterator> #include <memory> #include <stdexcept> namespace boost { namespace beast { /* Layout: begin_ in_ out_ last_ end_ |<------->|<---------->|<---------->|<------->| | readable | writable | */ void flat_static_buffer_base:: clear() noexcept { in_ = begin_; out_ = begin_; last_ = begin_; } auto flat_static_buffer_base:: prepare(std::size_t n) -> mutable_buffers_type { if(n <= dist(out_, end_)) { last_ = out_ + n; return {out_, n}; } auto const len = size(); if(n > capacity() - len) BOOST_THROW_EXCEPTION(std::length_error{ "buffer overflow"}); if(len > 0) std::memmove(begin_, in_, len); in_ = begin_; out_ = in_ + len; last_ = out_ + n; return {out_, n}; } void flat_static_buffer_base:: consume(std::size_t n) noexcept { if(n >= size()) { in_ = begin_; out_ = in_; return; } in_ += n; } void flat_static_buffer_base:: reset(void* p, std::size_t n) noexcept { begin_ = static_cast<char*>(p); in_ = begin_; out_ = begin_; last_ = begin_; end_ = begin_ + n; } } // beast } // boost #endifPK PP�[Tn�U5 5 core/impl/async_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_ASYNC_BASE_HPP #define BOOST_BEAST_CORE_IMPL_ASYNC_BASE_HPP #include <boost/core/exchange.hpp> namespace boost { namespace beast { namespace detail { template<class State, class Allocator> struct allocate_stable_state final : stable_base , boost::empty_value<Allocator> { State value; template<class... Args> explicit allocate_stable_state( Allocator const& alloc, Args&&... args) : boost::empty_value<Allocator>( boost::empty_init_t{}, alloc) , value{std::forward<Args>(args)...} { } void destroy() override { using A = typename allocator_traits< Allocator>::template rebind_alloc< allocate_stable_state>; A a(this->get()); auto* p = this; p->~allocate_stable_state(); a.deallocate(p, 1); } }; } // detail template< class Handler, class Executor1, class Allocator, class Function> boost::asio::asio_handler_invoke_is_deprecated asio_handler_invoke( Function&& f, async_base<Handler, Executor1, Allocator>* p) { using boost::asio::asio_handler_invoke; return asio_handler_invoke(f, p->get_legacy_handler_pointer()); } template< class Handler, class Executor1, class Allocator> boost::asio::asio_handler_allocate_is_deprecated asio_handler_allocate( std::size_t size, async_base<Handler, Executor1, Allocator>* p) { using boost::asio::asio_handler_allocate; return asio_handler_allocate(size, p->get_legacy_handler_pointer()); } template< class Handler, class Executor1, class Allocator> boost::asio::asio_handler_deallocate_is_deprecated asio_handler_deallocate( void* mem, std::size_t size, async_base<Handler, Executor1, Allocator>* p) { using boost::asio::asio_handler_deallocate; return asio_handler_deallocate(mem, size, p->get_legacy_handler_pointer()); } template< class Handler, class Executor1, class Allocator> bool asio_handler_is_continuation( async_base<Handler, Executor1, Allocator>* p) { using boost::asio::asio_handler_is_continuation; return asio_handler_is_continuation( p->get_legacy_handler_pointer()); } template< class State, class Handler, class Executor1, class Allocator, class... Args> State& allocate_stable( stable_async_base< Handler, Executor1, Allocator>& base, Args&&... args) { using allocator_type = typename stable_async_base< Handler, Executor1, Allocator>::allocator_type; using state = detail::allocate_stable_state< State, allocator_type>; using A = typename detail::allocator_traits< allocator_type>::template rebind_alloc<state>; struct deleter { allocator_type alloc; state* ptr; ~deleter() { if(ptr) { A a(alloc); a.deallocate(ptr, 1); } } }; A a(base.get_allocator()); deleter d{base.get_allocator(), a.allocate(1)}; ::new(static_cast<void*>(d.ptr)) state(d.alloc, std::forward<Args>(args)...); d.ptr->next_ = base.list_; base.list_ = d.ptr; return boost::exchange(d.ptr, nullptr)->value; } } // beast } // boost #endif PK PP�[�F'Z Z core/impl/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_ERROR_HPP #define BOOST_BEAST_IMPL_ERROR_HPP #include <type_traits> namespace boost { namespace system { template<> struct is_error_code_enum<::boost::beast::error> { static bool const value = true; }; template<> struct is_error_condition_enum<::boost::beast::condition> { static bool const value = true; }; } // system } // boost namespace boost { namespace beast { BOOST_BEAST_DECL error_code make_error_code(error e); BOOST_BEAST_DECL error_condition make_error_condition(condition c); } // beast } // boost #endif PK PP�[���*�& �& core/impl/file_win32.ippnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_FILE_WIN32_IPP #define BOOST_BEAST_CORE_IMPL_FILE_WIN32_IPP #include <boost/beast/core/file_win32.hpp> #if BOOST_BEAST_USE_WIN32_FILE #include <boost/beast/core/detail/win32_unicode_path.hpp> #include <boost/core/exchange.hpp> #include <boost/winapi/access_rights.hpp> #include <boost/winapi/error_codes.hpp> #include <boost/winapi/get_last_error.hpp> #include <limits> #include <utility> namespace boost { namespace beast { namespace detail { // VFALCO Can't seem to get boost/detail/winapi to work with // this so use the non-Ex version for now. BOOST_BEAST_DECL boost::winapi::BOOL_ set_file_pointer_ex( boost::winapi::HANDLE_ hFile, boost::winapi::LARGE_INTEGER_ lpDistanceToMove, boost::winapi::PLARGE_INTEGER_ lpNewFilePointer, boost::winapi::DWORD_ dwMoveMethod) { auto dwHighPart = lpDistanceToMove.u.HighPart; auto dwLowPart = boost::winapi::SetFilePointer( hFile, lpDistanceToMove.u.LowPart, &dwHighPart, dwMoveMethod); if(dwLowPart == boost::winapi::INVALID_SET_FILE_POINTER_) return 0; if(lpNewFilePointer) { lpNewFilePointer->u.LowPart = dwLowPart; lpNewFilePointer->u.HighPart = dwHighPart; } return 1; } } // detail file_win32:: ~file_win32() { if(h_ != boost::winapi::INVALID_HANDLE_VALUE_) boost::winapi::CloseHandle(h_); } file_win32:: file_win32(file_win32&& other) : h_(boost::exchange(other.h_, boost::winapi::INVALID_HANDLE_VALUE_)) { } file_win32& file_win32:: operator=(file_win32&& other) { if(&other == this) return *this; if(h_) boost::winapi::CloseHandle(h_); h_ = other.h_; other.h_ = boost::winapi::INVALID_HANDLE_VALUE_; return *this; } void file_win32:: native_handle(native_handle_type h) { if(h_ != boost::winapi::INVALID_HANDLE_VALUE_) boost::winapi::CloseHandle(h_); h_ = h; } void file_win32:: close(error_code& ec) { if(h_ != boost::winapi::INVALID_HANDLE_VALUE_) { if(! boost::winapi::CloseHandle(h_)) ec.assign(boost::winapi::GetLastError(), system_category()); else ec = {}; h_ = boost::winapi::INVALID_HANDLE_VALUE_; } else { ec = {}; } } void file_win32:: open(char const* path, file_mode mode, error_code& ec) { if(h_ != boost::winapi::INVALID_HANDLE_VALUE_) { boost::winapi::CloseHandle(h_); h_ = boost::winapi::INVALID_HANDLE_VALUE_; } boost::winapi::DWORD_ share_mode = 0; boost::winapi::DWORD_ desired_access = 0; boost::winapi::DWORD_ creation_disposition = 0; boost::winapi::DWORD_ flags_and_attributes = 0; /* | When the file... This argument: | Exists Does not exist -------------------------+------------------------------------------------------ CREATE_ALWAYS | Truncates Creates CREATE_NEW +-----------+ Fails Creates OPEN_ALWAYS ===| does this |===> Opens Creates OPEN_EXISTING +-----------+ Opens Fails TRUNCATE_EXISTING | Truncates Fails */ switch(mode) { default: case file_mode::read: desired_access = boost::winapi::GENERIC_READ_; share_mode = boost::winapi::FILE_SHARE_READ_; creation_disposition = boost::winapi::OPEN_EXISTING_; flags_and_attributes = 0x10000000; // FILE_FLAG_RANDOM_ACCESS break; case file_mode::scan: desired_access = boost::winapi::GENERIC_READ_; share_mode = boost::winapi::FILE_SHARE_READ_; creation_disposition = boost::winapi::OPEN_EXISTING_; flags_and_attributes = 0x08000000; // FILE_FLAG_SEQUENTIAL_SCAN break; case file_mode::write: desired_access = boost::winapi::GENERIC_READ_ | boost::winapi::GENERIC_WRITE_; creation_disposition = boost::winapi::CREATE_ALWAYS_; flags_and_attributes = 0x10000000; // FILE_FLAG_RANDOM_ACCESS break; case file_mode::write_new: desired_access = boost::winapi::GENERIC_READ_ | boost::winapi::GENERIC_WRITE_; creation_disposition = boost::winapi::CREATE_NEW_; flags_and_attributes = 0x10000000; // FILE_FLAG_RANDOM_ACCESS break; case file_mode::write_existing: desired_access = boost::winapi::GENERIC_READ_ | boost::winapi::GENERIC_WRITE_; creation_disposition = boost::winapi::OPEN_EXISTING_; flags_and_attributes = 0x10000000; // FILE_FLAG_RANDOM_ACCESS break; case file_mode::append: desired_access = boost::winapi::GENERIC_READ_ | boost::winapi::GENERIC_WRITE_; creation_disposition = boost::winapi::CREATE_ALWAYS_; flags_and_attributes = 0x08000000; // FILE_FLAG_SEQUENTIAL_SCAN break; case file_mode::append_existing: desired_access = boost::winapi::GENERIC_READ_ | boost::winapi::GENERIC_WRITE_; creation_disposition = boost::winapi::OPEN_EXISTING_; flags_and_attributes = 0x08000000; // FILE_FLAG_SEQUENTIAL_SCAN break; } detail::win32_unicode_path unicode_path(path, ec); if (ec) return; h_ = ::CreateFileW( unicode_path.c_str(), desired_access, share_mode, NULL, creation_disposition, flags_and_attributes, NULL); if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) ec.assign(boost::winapi::GetLastError(), system_category()); else ec = {}; } std::uint64_t file_win32:: size(error_code& ec) const { if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } boost::winapi::LARGE_INTEGER_ fileSize; if(! boost::winapi::GetFileSizeEx(h_, &fileSize)) { ec.assign(boost::winapi::GetLastError(), system_category()); return 0; } ec = {}; return fileSize.QuadPart; } std::uint64_t file_win32:: pos(error_code& ec) { if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } boost::winapi::LARGE_INTEGER_ in; boost::winapi::LARGE_INTEGER_ out; in.QuadPart = 0; if(! detail::set_file_pointer_ex(h_, in, &out, boost::winapi::FILE_CURRENT_)) { ec.assign(boost::winapi::GetLastError(), system_category()); return 0; } ec = {}; return out.QuadPart; } void file_win32:: seek(std::uint64_t offset, error_code& ec) { if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) { ec = make_error_code(errc::bad_file_descriptor); return; } boost::winapi::LARGE_INTEGER_ in; in.QuadPart = offset; if(! detail::set_file_pointer_ex(h_, in, 0, boost::winapi::FILE_BEGIN_)) { ec.assign(boost::winapi::GetLastError(), system_category()); return; } ec = {}; } std::size_t file_win32:: read(void* buffer, std::size_t n, error_code& ec) { if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } std::size_t nread = 0; while(n > 0) { boost::winapi::DWORD_ amount; if(n > (std::numeric_limits< boost::winapi::DWORD_>::max)()) amount = (std::numeric_limits< boost::winapi::DWORD_>::max)(); else amount = static_cast< boost::winapi::DWORD_>(n); boost::winapi::DWORD_ bytesRead; if(! ::ReadFile(h_, buffer, amount, &bytesRead, 0)) { auto const dwError = boost::winapi::GetLastError(); if(dwError != boost::winapi::ERROR_HANDLE_EOF_) ec.assign(dwError, system_category()); else ec = {}; return nread; } if(bytesRead == 0) return nread; n -= bytesRead; nread += bytesRead; buffer = static_cast<char*>(buffer) + bytesRead; } ec = {}; return nread; } std::size_t file_win32:: write(void const* buffer, std::size_t n, error_code& ec) { if(h_ == boost::winapi::INVALID_HANDLE_VALUE_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } std::size_t nwritten = 0; while(n > 0) { boost::winapi::DWORD_ amount; if(n > (std::numeric_limits< boost::winapi::DWORD_>::max)()) amount = (std::numeric_limits< boost::winapi::DWORD_>::max)(); else amount = static_cast< boost::winapi::DWORD_>(n); boost::winapi::DWORD_ bytesWritten; if(! ::WriteFile(h_, buffer, amount, &bytesWritten, 0)) { auto const dwError = boost::winapi::GetLastError(); if(dwError != boost::winapi::ERROR_HANDLE_EOF_) ec.assign(dwError, system_category()); else ec = {}; return nwritten; } if(bytesWritten == 0) return nwritten; n -= bytesWritten; nwritten += bytesWritten; buffer = static_cast<char const*>(buffer) + bytesWritten; } ec = {}; return nwritten; } } // beast } // boost #endif #endif PK PP�[TvLxi i core/impl/buffers_suffix.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_BUFFERS_SUFFIX_HPP #define BOOST_BEAST_IMPL_BUFFERS_SUFFIX_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/type_traits.hpp> #include <algorithm> #include <cstdint> #include <iterator> #include <type_traits> #include <utility> namespace boost { namespace beast { template<class Buffers> class buffers_suffix<Buffers>::const_iterator { friend class buffers_suffix<Buffers>; using iter_type = buffers_iterator_type<Buffers>; iter_type it_{}; buffers_suffix const* b_ = nullptr; public: #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) using value_type = typename std::conditional< boost::is_convertible<typename std::iterator_traits<iter_type>::value_type, net::mutable_buffer>::value, net::mutable_buffer, net::const_buffer>::type; #else using value_type = buffers_type<Buffers>; #endif using pointer = value_type const*; using reference = value_type; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; const_iterator() = default; const_iterator( const_iterator const& other) = default; const_iterator& operator=( const_iterator const& other) = default; bool operator==(const_iterator const& other) const { return b_ == other.b_ && it_ == other.it_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { if(it_ == b_->begin_) return value_type(*it_) + b_->skip_; return value_type(*it_); } pointer operator->() const = delete; const_iterator& operator++() { ++it_; return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } const_iterator& operator--() { --it_; return *this; } const_iterator operator--(int) { auto temp = *this; --(*this); return temp; } private: const_iterator( buffers_suffix const& b, iter_type it) : it_(it) , b_(&b) { } }; //------------------------------------------------------------------------------ template<class Buffers> buffers_suffix<Buffers>:: buffers_suffix() : begin_(net::buffer_sequence_begin(bs_)) { } template<class Buffers> buffers_suffix<Buffers>:: buffers_suffix(buffers_suffix const& other) : buffers_suffix(other, std::distance<iter_type>( net::buffer_sequence_begin( other.bs_), other.begin_)) { } template<class Buffers> buffers_suffix<Buffers>:: buffers_suffix(Buffers const& bs) : bs_(bs) , begin_(net::buffer_sequence_begin(bs_)) { static_assert( net::is_const_buffer_sequence<Buffers>::value || net::is_mutable_buffer_sequence<Buffers>::value, "BufferSequence type requirements not met"); } template<class Buffers> template<class... Args> buffers_suffix<Buffers>:: buffers_suffix(boost::in_place_init_t, Args&&... args) : bs_(std::forward<Args>(args)...) , begin_(net::buffer_sequence_begin(bs_)) { static_assert(sizeof...(Args) > 0, "Missing constructor arguments"); static_assert( std::is_constructible<Buffers, Args...>::value, "Buffers not constructible from arguments"); } template<class Buffers> auto buffers_suffix<Buffers>:: operator=(buffers_suffix const& other) -> buffers_suffix& { auto const dist = std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.begin_); bs_ = other.bs_; begin_ = std::next( net::buffer_sequence_begin(bs_), dist); skip_ = other.skip_; return *this; } template<class Buffers> auto buffers_suffix<Buffers>:: begin() const -> const_iterator { return const_iterator{*this, begin_}; } template<class Buffers> auto buffers_suffix<Buffers>:: end() const -> const_iterator { return const_iterator{*this, net::buffer_sequence_end(bs_)}; } template<class Buffers> void buffers_suffix<Buffers>:: consume(std::size_t amount) { auto const end = net::buffer_sequence_end(bs_); for(;amount > 0 && begin_ != end; ++begin_) { auto const len = buffer_bytes(*begin_) - skip_; if(amount < len) { skip_ += amount; break; } amount -= len; skip_ = 0; } } } // beast } // boost #endif PK PP�[:Y��� � core/impl/flat_static_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_FLAT_STATIC_BUFFER_HPP #define BOOST_BEAST_IMPL_FLAT_STATIC_BUFFER_HPP namespace boost { namespace beast { template<std::size_t N> flat_static_buffer<N>:: flat_static_buffer( flat_static_buffer const& other) : flat_static_buffer_base(buf_, N) { this->commit(net::buffer_copy( this->prepare(other.size()), other.data())); } template<std::size_t N> auto flat_static_buffer<N>:: operator=(flat_static_buffer const& other) -> flat_static_buffer<N>& { if(this == &other) return *this; this->consume(this->size()); this->commit(net::buffer_copy( this->prepare(other.size()), other.data())); return *this; } } // beast } // boost #endifPK PP�[Gm!�o o core/impl/saved_handler.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_SAVED_HANDLER_IPP #define BOOST_BEAST_CORE_IMPL_SAVED_HANDLER_IPP #include <boost/beast/core/saved_handler.hpp> #include <boost/core/exchange.hpp> namespace boost { namespace beast { saved_handler:: ~saved_handler() { if(p_) p_->destroy(); } saved_handler:: saved_handler(saved_handler&& other) noexcept : p_(boost::exchange(other.p_, nullptr)) { } saved_handler& saved_handler:: operator=(saved_handler&& other) noexcept { // Can't delete a handler before invoking BOOST_ASSERT(! has_value()); p_ = boost::exchange(other.p_, nullptr); return *this; } bool saved_handler:: reset() noexcept { if(! p_) return false; boost::exchange(p_, nullptr)->destroy(); return true; } void saved_handler:: invoke() { // Can't invoke without a value BOOST_ASSERT(has_value()); boost::exchange( p_, nullptr)->invoke(); } bool saved_handler:: maybe_invoke() { if(! p_) return false; boost::exchange( p_, nullptr)->invoke(); return true; } } // beast } // boost #endif PK PP�[���� core/impl/static_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_STATIC_BUFFER_HPP #define BOOST_BEAST_IMPL_STATIC_BUFFER_HPP #include <boost/asio/buffer.hpp> #include <stdexcept> namespace boost { namespace beast { template<std::size_t N> static_buffer<N>:: static_buffer(static_buffer const& other) noexcept : static_buffer_base(buf_, N) { this->commit(net::buffer_copy( this->prepare(other.size()), other.data())); } template<std::size_t N> auto static_buffer<N>:: operator=(static_buffer const& other) noexcept -> static_buffer<N>& { if(this == &other) return *this; this->consume(this->size()); this->commit(net::buffer_copy( this->prepare(other.size()), other.data())); return *this; } } // beast } // boost #endif PK PP�[#�;�> > core/impl/buffers_adaptor.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_BUFFERS_ADAPTOR_HPP #define BOOST_BEAST_IMPL_BUFFERS_ADAPTOR_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffers_adaptor.hpp> #include <boost/asio/buffer.hpp> #include <boost/config/workaround.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <cstring> #include <iterator> #include <stdexcept> #include <type_traits> #include <utility> namespace boost { namespace beast { //------------------------------------------------------------------------------ #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (push) # pragma warning (disable: 4521) // multiple copy constructors specified # pragma warning (disable: 4522) // multiple assignment operators specified #endif template<class MutableBufferSequence> template<bool isMutable> class buffers_adaptor<MutableBufferSequence>::subrange { public: using value_type = typename std::conditional< isMutable, net::mutable_buffer, net::const_buffer>::type; struct iterator; // construct from two iterators plus optionally subrange definition subrange( iter_type first, // iterator to first buffer in storage iter_type last, // iterator to last buffer in storage std::size_t pos = 0, // the offset in bytes from the beginning of the storage std::size_t n = // the total length of the subrange (std::numeric_limits<std::size_t>::max)()); #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) subrange( subrange const& other) : first_(other.first_) , last_(other.last_) , first_offset_(other.first_offset_) , last_size_(other.last_size_) { } subrange& operator=( subrange const& other) { first_ = other.first_; last_ = other.last_; first_offset_ = other.first_offset_; last_size_ = other.last_size_; return *this; } #else subrange( subrange const&) = default; subrange& operator=( subrange const&) = default; #endif // allow conversion from mutable to const template<bool isMutable_ = isMutable, typename std::enable_if<!isMutable_>::type * = nullptr> subrange(subrange<true> const &other) : first_(other.first_) , last_(other.last_) , first_offset_(other.first_offset_) , last_size_(other.last_size_) { } iterator begin() const; iterator end() const; private: friend subrange<!isMutable>; void adjust( std::size_t pos, std::size_t n); private: // points to the first buffer in the sequence iter_type first_; // Points to one past the end of the underlying buffer sequence iter_type last_; // The initial offset into the first buffer std::size_t first_offset_; // how many bytes in the penultimate buffer are used (if any) std::size_t last_size_; }; #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (pop) #endif //------------------------------------------------------------------------------ template<class MutableBufferSequence> template<bool isMutable> struct buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator { using iterator_category = std::bidirectional_iterator_tag; using value_type = typename buffers_adaptor<MutableBufferSequence>:: template subrange<isMutable>:: value_type; using reference = value_type&; using pointer = value_type*; using difference_type = std::ptrdiff_t; iterator( subrange<isMutable> const *parent, iter_type it); iterator(); value_type operator*() const; pointer operator->() const = delete; iterator & operator++(); iterator operator++(int); iterator & operator--(); iterator operator--(int); bool operator==(iterator const &b) const; bool operator!=(iterator const &b) const; private: subrange<isMutable> const *parent_; iter_type it_; }; //------------------------------------------------------------------------------ template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: end_impl() const -> iter_type { return out_ == end_ ? end_ : std::next(out_); } template<class MutableBufferSequence> buffers_adaptor<MutableBufferSequence>:: buffers_adaptor( buffers_adaptor const& other, std::size_t nbegin, std::size_t nout, std::size_t nend) : bs_(other.bs_) , begin_(std::next(bs_.begin(), nbegin)) , out_(std::next(bs_.begin(), nout)) , end_(std::next(bs_.begin(), nend)) , max_size_(other.max_size_) , in_pos_(other.in_pos_) , in_size_(other.in_size_) , out_pos_(other.out_pos_) , out_end_(other.out_end_) { } template<class MutableBufferSequence> buffers_adaptor<MutableBufferSequence>:: buffers_adaptor(MutableBufferSequence const& bs) : bs_(bs) , begin_(net::buffer_sequence_begin(bs_)) , out_ (net::buffer_sequence_begin(bs_)) , end_ (net::buffer_sequence_begin(bs_)) , max_size_( [&bs] { return buffer_bytes(bs); }()) { } template<class MutableBufferSequence> template<class... Args> buffers_adaptor<MutableBufferSequence>:: buffers_adaptor( boost::in_place_init_t, Args&&... args) : bs_{std::forward<Args>(args)...} , begin_(net::buffer_sequence_begin(bs_)) , out_ (net::buffer_sequence_begin(bs_)) , end_ (net::buffer_sequence_begin(bs_)) , max_size_( [&] { return buffer_bytes(bs_); }()) { } template<class MutableBufferSequence> buffers_adaptor<MutableBufferSequence>:: buffers_adaptor(buffers_adaptor const& other) : buffers_adaptor( other, std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.begin_), std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.out_), std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.end_)) { } template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: operator=(buffers_adaptor const& other) -> buffers_adaptor& { if(this == &other) return *this; auto const nbegin = std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.begin_); auto const nout = std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.out_); auto const nend = std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.end_); bs_ = other.bs_; begin_ = std::next( net::buffer_sequence_begin(bs_), nbegin); out_ = std::next( net::buffer_sequence_begin(bs_), nout); end_ = std::next( net::buffer_sequence_begin(bs_), nend); max_size_ = other.max_size_; in_pos_ = other.in_pos_; in_size_ = other.in_size_; out_pos_ = other.out_pos_; out_end_ = other.out_end_; return *this; } // template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: data() const noexcept -> const_buffers_type { return const_buffers_type( begin_, end_, in_pos_, in_size_); } template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: data() noexcept -> mutable_buffers_type { return mutable_buffers_type( begin_, end_, in_pos_, in_size_); } template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: prepare(std::size_t n) -> mutable_buffers_type { auto prepared = n; end_ = out_; if(end_ != net::buffer_sequence_end(bs_)) { auto size = buffer_bytes(*end_) - out_pos_; if(n > size) { n -= size; while(++end_ != net::buffer_sequence_end(bs_)) { size = buffer_bytes(*end_); if(n < size) { out_end_ = n; n = 0; ++end_; break; } n -= size; out_end_ = size; } } else { ++end_; out_end_ = out_pos_ + n; n = 0; } } if(n > 0) BOOST_THROW_EXCEPTION(std::length_error{ "buffers_adaptor too long"}); return mutable_buffers_type(out_, end_, out_pos_, prepared); } template<class MutableBufferSequence> void buffers_adaptor<MutableBufferSequence>:: commit(std::size_t n) noexcept { if(out_ == end_) return; auto const last = std::prev(end_); while(out_ != last) { auto const avail = buffer_bytes(*out_) - out_pos_; if(n < avail) { out_pos_ += n; in_size_ += n; return; } ++out_; n -= avail; out_pos_ = 0; in_size_ += avail; } n = std::min<std::size_t>( n, out_end_ - out_pos_); out_pos_ += n; in_size_ += n; if(out_pos_ == buffer_bytes(*out_)) { ++out_; out_pos_ = 0; out_end_ = 0; } } template<class MutableBufferSequence> void buffers_adaptor<MutableBufferSequence>:: consume(std::size_t n) noexcept { while(begin_ != out_) { auto const avail = buffer_bytes(*begin_) - in_pos_; if(n < avail) { in_size_ -= n; in_pos_ += n; return; } n -= avail; in_size_ -= avail; in_pos_ = 0; ++begin_; } auto const avail = out_pos_ - in_pos_; if(n < avail) { in_size_ -= n; in_pos_ += n; } else { in_size_ -= avail; in_pos_ = out_pos_; } } template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: make_subrange(std::size_t pos, std::size_t n) -> subrange<true> { return subrange<true>( begin_, net::buffer_sequence_end(bs_), in_pos_ + pos, n); } template<class MutableBufferSequence> auto buffers_adaptor<MutableBufferSequence>:: make_subrange(std::size_t pos, std::size_t n) const -> subrange<false> { return subrange<false>( begin_, net::buffer_sequence_end(bs_), in_pos_ + pos, n); } // ------------------------------------------------------------------------- // subrange template<class MutableBufferSequence> template<bool isMutable> buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: subrange( iter_type first, // iterator to first buffer in storage iter_type last, // iterator to last buffer in storage std::size_t pos, // the offset in bytes from the beginning of the storage std::size_t n) // the total length of the subrange : first_(first) , last_(last) , first_offset_(0) , last_size_((std::numeric_limits<std::size_t>::max)()) { adjust(pos, n); } template<class MutableBufferSequence> template<bool isMutable> void buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: adjust( std::size_t pos, std::size_t n) { if (n == 0) last_ = first_; if (first_ == last_) { first_offset_ = 0; last_size_ = 0; return; } auto is_last = [this](iter_type iter) { return std::next(iter) == last_; }; pos += first_offset_; while (pos) { auto adjust = (std::min)(pos, first_->size()); if (adjust >= first_->size()) { ++first_; first_offset_ = 0; pos -= adjust; } else { first_offset_ = adjust; pos = 0; break; } } auto current = first_; auto max_elem = current->size() - first_offset_; if (is_last(current)) { // both first and last element last_size_ = (std::min)(max_elem, n); last_ = std::next(current); return; } else if (max_elem >= n) { last_ = std::next(current); last_size_ = n; } else { n -= max_elem; ++current; } for (;;) { max_elem = current->size(); if (is_last(current)) { last_size_ = (std::min)(n, last_size_); return; } else if (max_elem < n) { n -= max_elem; ++current; } else { last_size_ = n; last_ = std::next(current); return; } } } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: begin() const -> iterator { return iterator(this, first_); } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: end() const -> iterator { return iterator(this, last_); } // ------------------------------------------------------------------------- // buffers_adaptor::subrange::iterator template<class MutableBufferSequence> template<bool isMutable> buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: iterator() : parent_(nullptr) , it_() { } template<class MutableBufferSequence> template<bool isMutable> buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: iterator(subrange<isMutable> const *parent, iter_type it) : parent_(parent) , it_(it) { } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator*() const -> value_type { value_type result = *it_; if (it_ == parent_->first_) result += parent_->first_offset_; if (std::next(it_) == parent_->last_) { result = value_type( result.data(), (std::min)( parent_->last_size_, result.size())); } return result; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator++() -> iterator & { ++it_; return *this; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator++(int) -> iterator { auto result = *this; ++it_; return result; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator--() -> iterator & { --it_; return *this; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator--(int) -> iterator { auto result = *this; --it_; return result; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator==(iterator const &b) const -> bool { return it_ == b.it_; } template<class MutableBufferSequence> template<bool isMutable> auto buffers_adaptor<MutableBufferSequence>:: subrange<isMutable>:: iterator:: operator!=(iterator const &b) const -> bool { return !(*this == b); } } // beast } // boost #endif PK PP�[�/ / core/impl/buffers_prefix.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_BUFFERS_PREFIX_HPP #define BOOST_BEAST_IMPL_BUFFERS_PREFIX_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/config/workaround.hpp> #include <algorithm> #include <cstdint> #include <iterator> #include <stdexcept> #include <type_traits> #include <utility> namespace boost { namespace beast { template<class Buffers> class buffers_prefix_view<Buffers>::const_iterator { friend class buffers_prefix_view<Buffers>; buffers_prefix_view const* b_ = nullptr; std::size_t remain_ = 0; iter_type it_{}; public: #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) using value_type = typename std::conditional< boost::is_convertible<typename std::iterator_traits<iter_type>::value_type, net::mutable_buffer>::value, net::mutable_buffer, net::const_buffer>::type; #else using value_type = buffers_type<Buffers>; #endif BOOST_STATIC_ASSERT(std::is_same< typename const_iterator::value_type, typename buffers_prefix_view::value_type>::value); using pointer = value_type const*; using reference = value_type; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; const_iterator() = default; const_iterator( const_iterator const& other) = default; const_iterator& operator=( const_iterator const& other) = default; bool operator==(const_iterator const& other) const { return b_ == other.b_ && it_ == other.it_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { value_type v(*it_); if(remain_ < v.size()) return {v.data(), remain_}; return v; } pointer operator->() const = delete; const_iterator& operator++() { value_type const v = *it_++; remain_ -= v.size(); return *this; } const_iterator operator++(int) { auto temp = *this; value_type const v = *it_++; remain_ -= v.size(); return temp; } const_iterator& operator--() { value_type const v = *--it_; remain_ += v.size(); return *this; } const_iterator operator--(int) { auto temp = *this; value_type const v = *--it_; remain_ += v.size(); return temp; } private: const_iterator( buffers_prefix_view const& b, std::true_type) : b_(&b) , remain_(b.remain_) , it_(b_->end_) { } const_iterator( buffers_prefix_view const& b, std::false_type) : b_(&b) , remain_(b_->size_) , it_(net::buffer_sequence_begin(b_->bs_)) { } }; //------------------------------------------------------------------------------ template<class Buffers> void buffers_prefix_view<Buffers>:: setup(std::size_t size) { size_ = 0; remain_ = 0; end_ = net::buffer_sequence_begin(bs_); auto const last = bs_.end(); while(end_ != last) { auto const len = buffer_bytes(*end_++); if(len >= size) { size_ += size; // by design, this subtraction can wrap BOOST_STATIC_ASSERT(std::is_unsigned< decltype(remain_)>::value); remain_ = size - len; break; } size -= len; size_ += len; } } template<class Buffers> buffers_prefix_view<Buffers>:: buffers_prefix_view( buffers_prefix_view const& other, std::size_t dist) : bs_(other.bs_) , size_(other.size_) , remain_(other.remain_) , end_(std::next(bs_.begin(), dist)) { } template<class Buffers> buffers_prefix_view<Buffers>:: buffers_prefix_view(buffers_prefix_view const& other) : buffers_prefix_view(other, std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.end_)) { } template<class Buffers> auto buffers_prefix_view<Buffers>:: operator=(buffers_prefix_view const& other) -> buffers_prefix_view& { auto const dist = std::distance<iter_type>( net::buffer_sequence_begin(other.bs_), other.end_); bs_ = other.bs_; size_ = other.size_; remain_ = other.remain_; end_ = std::next( net::buffer_sequence_begin(bs_), dist); return *this; } template<class Buffers> buffers_prefix_view<Buffers>:: buffers_prefix_view( std::size_t size, Buffers const& bs) : bs_(bs) { setup(size); } template<class Buffers> template<class... Args> buffers_prefix_view<Buffers>:: buffers_prefix_view( std::size_t size, boost::in_place_init_t, Args&&... args) : bs_(std::forward<Args>(args)...) { setup(size); } template<class Buffers> auto buffers_prefix_view<Buffers>:: begin() const -> const_iterator { return const_iterator{ *this, std::false_type{}}; } template<class Buffers> auto buffers_prefix_view<Buffers>:: end() const -> const_iterator { return const_iterator{ *this, std::true_type{}}; } //------------------------------------------------------------------------------ template<> class buffers_prefix_view<net::const_buffer> : public net::const_buffer { public: using net::const_buffer::const_buffer; buffers_prefix_view(buffers_prefix_view const&) = default; buffers_prefix_view& operator=(buffers_prefix_view const&) = default; buffers_prefix_view( std::size_t size, net::const_buffer buffer) : net::const_buffer( buffer.data(), std::min<std::size_t>(size, buffer.size()) #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , buffer.get_debug_check() #endif ) { } template<class... Args> buffers_prefix_view( std::size_t size, boost::in_place_init_t, Args&&... args) : buffers_prefix_view(size, net::const_buffer( std::forward<Args>(args)...)) { } }; //------------------------------------------------------------------------------ template<> class buffers_prefix_view<net::mutable_buffer> : public net::mutable_buffer { public: using net::mutable_buffer::mutable_buffer; buffers_prefix_view(buffers_prefix_view const&) = default; buffers_prefix_view& operator=(buffers_prefix_view const&) = default; buffers_prefix_view( std::size_t size, net::mutable_buffer buffer) : net::mutable_buffer( buffer.data(), std::min<std::size_t>(size, buffer.size()) #if defined(BOOST_ASIO_ENABLE_BUFFER_DEBUGGING) , buffer.get_debug_check() #endif ) { } template<class... Args> buffers_prefix_view( std::size_t size, boost::in_place_init_t, Args&&... args) : buffers_prefix_view(size, net::mutable_buffer( std::forward<Args>(args)...)) { } }; } // beast } // boost #endif PK PP�[�B��� � core/impl/file_posix.ippnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_FILE_POSIX_IPP #define BOOST_BEAST_CORE_IMPL_FILE_POSIX_IPP #include <boost/beast/core/file_posix.hpp> #if BOOST_BEAST_USE_POSIX_FILE #include <boost/core/exchange.hpp> #include <limits> #include <fcntl.h> #include <sys/types.h> #include <sys/uio.h> #include <sys/stat.h> #include <unistd.h> #include <limits.h> #if ! defined(BOOST_BEAST_NO_POSIX_FADVISE) # if defined(__APPLE__) || (defined(__ANDROID__) && (__ANDROID_API__ < 21)) # define BOOST_BEAST_NO_POSIX_FADVISE # endif #endif #if ! defined(BOOST_BEAST_USE_POSIX_FADVISE) # if ! defined(BOOST_BEAST_NO_POSIX_FADVISE) # define BOOST_BEAST_USE_POSIX_FADVISE 1 # else # define BOOST_BEAST_USE_POSIX_FADVISE 0 # endif #endif namespace boost { namespace beast { int file_posix:: native_close(native_handle_type& fd) { /* https://github.com/boostorg/beast/issues/1445 This function is tuned for Linux / Mac OS: * only calls close() once * returns the error directly to the caller * does not loop on EINTR If this is incorrect for the platform, then the caller will need to implement their own type meeting the File requirements and use the correct behavior. See: http://man7.org/linux/man-pages/man2/close.2.html */ int ev = 0; if(fd != -1) { if(::close(fd) != 0) ev = errno; fd = -1; } return ev; } file_posix:: ~file_posix() { native_close(fd_); } file_posix:: file_posix(file_posix&& other) : fd_(boost::exchange(other.fd_, -1)) { } file_posix& file_posix:: operator=(file_posix&& other) { if(&other == this) return *this; native_close(fd_); fd_ = other.fd_; other.fd_ = -1; return *this; } void file_posix:: native_handle(native_handle_type fd) { native_close(fd_); fd_ = fd; } void file_posix:: close(error_code& ec) { auto const ev = native_close(fd_); if(ev) ec.assign(ev, system_category()); else ec = {}; } void file_posix:: open(char const* path, file_mode mode, error_code& ec) { auto const ev = native_close(fd_); if(ev) ec.assign(ev, system_category()); else ec = {}; int f = 0; #if BOOST_BEAST_USE_POSIX_FADVISE int advise = 0; #endif switch(mode) { default: case file_mode::read: f = O_RDONLY; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_RANDOM; #endif break; case file_mode::scan: f = O_RDONLY; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_SEQUENTIAL; #endif break; case file_mode::write: f = O_RDWR | O_CREAT | O_TRUNC; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_RANDOM; #endif break; case file_mode::write_new: f = O_RDWR | O_CREAT | O_EXCL; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_RANDOM; #endif break; case file_mode::write_existing: f = O_RDWR | O_EXCL; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_RANDOM; #endif break; case file_mode::append: f = O_WRONLY | O_CREAT | O_TRUNC; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_SEQUENTIAL; #endif break; case file_mode::append_existing: f = O_WRONLY | O_APPEND; #if BOOST_BEAST_USE_POSIX_FADVISE advise = POSIX_FADV_SEQUENTIAL; #endif break; } for(;;) { fd_ = ::open(path, f, 0644); if(fd_ != -1) break; auto const ev = errno; if(ev != EINTR) { ec.assign(ev, system_category()); return; } } #if BOOST_BEAST_USE_POSIX_FADVISE if(::posix_fadvise(fd_, 0, 0, advise)) { auto const ev = errno; native_close(fd_); ec.assign(ev, system_category()); return; } #endif ec = {}; } std::uint64_t file_posix:: size(error_code& ec) const { if(fd_ == -1) { ec = make_error_code(errc::bad_file_descriptor); return 0; } struct stat st; if(::fstat(fd_, &st) != 0) { ec.assign(errno, system_category()); return 0; } ec = {}; return st.st_size; } std::uint64_t file_posix:: pos(error_code& ec) const { if(fd_ == -1) { ec = make_error_code(errc::bad_file_descriptor); return 0; } auto const result = ::lseek(fd_, 0, SEEK_CUR); if(result == (off_t)-1) { ec.assign(errno, system_category()); return 0; } ec = {}; return result; } void file_posix:: seek(std::uint64_t offset, error_code& ec) { if(fd_ == -1) { ec = make_error_code(errc::bad_file_descriptor); return; } auto const result = ::lseek(fd_, offset, SEEK_SET); if(result == static_cast<off_t>(-1)) { ec.assign(errno, system_category()); return; } ec = {}; } std::size_t file_posix:: read(void* buffer, std::size_t n, error_code& ec) const { if(fd_ == -1) { ec = make_error_code(errc::bad_file_descriptor); return 0; } std::size_t nread = 0; while(n > 0) { auto const amount = static_cast<ssize_t>((std::min)( n, static_cast<std::size_t>(SSIZE_MAX))); auto const result = ::read(fd_, buffer, amount); if(result == -1) { auto const ev = errno; if(ev == EINTR) continue; ec.assign(ev, system_category()); return nread; } if(result == 0) { // short read return nread; } n -= result; nread += result; buffer = static_cast<char*>(buffer) + result; } return nread; } std::size_t file_posix:: write(void const* buffer, std::size_t n, error_code& ec) { if(fd_ == -1) { ec = make_error_code(errc::bad_file_descriptor); return 0; } std::size_t nwritten = 0; while(n > 0) { auto const amount = static_cast<ssize_t>((std::min)( n, static_cast<std::size_t>(SSIZE_MAX))); auto const result = ::write(fd_, buffer, amount); if(result == -1) { auto const ev = errno; if(ev == EINTR) continue; ec.assign(ev, system_category()); return nwritten; } n -= result; nwritten += result; buffer = static_cast<char const*>(buffer) + result; } return nwritten; } } // beast } // boost #endif #endif PK PP�[�8�� " core/impl/buffered_read_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_BUFFERED_READ_STREAM_HPP #define BOOST_BEAST_IMPL_BUFFERED_READ_STREAM_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/read_size.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/post.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { template<class Stream, class DynamicBuffer> struct buffered_read_stream<Stream, DynamicBuffer>::ops { template<class MutableBufferSequence, class Handler> class read_op : public async_base<Handler, beast::executor_type<buffered_read_stream>> { buffered_read_stream& s_; MutableBufferSequence b_; int step_ = 0; public: read_op(read_op&&) = default; read_op(read_op const&) = delete; template<class Handler_> read_op( Handler_&& h, buffered_read_stream& s, MutableBufferSequence const& b) : async_base< Handler, beast::executor_type<buffered_read_stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , b_(b) { (*this)({}, 0); } void operator()( error_code ec, std::size_t bytes_transferred) { // VFALCO TODO Rewrite this using reenter/yield switch(step_) { case 0: if(s_.buffer_.size() == 0) { if(s_.capacity_ == 0) { // read (unbuffered) step_ = 1; return s_.next_layer_.async_read_some( b_, std::move(*this)); } // read step_ = 2; return s_.next_layer_.async_read_some( s_.buffer_.prepare(read_size( s_.buffer_, s_.capacity_)), std::move(*this)); } step_ = 3; return net::post( s_.get_executor(), beast::bind_front_handler( std::move(*this), ec, 0)); case 1: // upcall break; case 2: s_.buffer_.commit(bytes_transferred); BOOST_FALLTHROUGH; case 3: bytes_transferred = net::buffer_copy(b_, s_.buffer_.data()); s_.buffer_.consume(bytes_transferred); break; } this->complete_now(ec, bytes_transferred); } }; struct run_read_op { template<class ReadHandler, class Buffers> void operator()( ReadHandler&& h, buffered_read_stream* s, Buffers const* b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_op< Buffers, typename std::decay<ReadHandler>::type>( std::forward<ReadHandler>(h), *s, *b); } }; }; //------------------------------------------------------------------------------ template<class Stream, class DynamicBuffer> template<class... Args> buffered_read_stream<Stream, DynamicBuffer>:: buffered_read_stream(Args&&... args) : next_layer_(std::forward<Args>(args)...) { } template<class Stream, class DynamicBuffer> template<class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) buffered_read_stream<Stream, DynamicBuffer>:: async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler) { static_assert(is_async_write_stream<next_layer_type>::value, "AsyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); static_assert(detail::is_completion_token_for<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); return next_layer_.async_write_some(buffers, std::forward<WriteHandler>(handler)); } template<class Stream, class DynamicBuffer> template<class MutableBufferSequence> std::size_t buffered_read_stream<Stream, DynamicBuffer>:: read_some( MutableBufferSequence const& buffers) { static_assert(is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); error_code ec; auto n = read_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return n; } template<class Stream, class DynamicBuffer> template<class MutableBufferSequence> std::size_t buffered_read_stream<Stream, DynamicBuffer>:: read_some(MutableBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); if(buffer_.size() == 0) { if(capacity_ == 0) return next_layer_.read_some(buffers, ec); buffer_.commit(next_layer_.read_some( buffer_.prepare(read_size(buffer_, capacity_)), ec)); if(ec) return 0; } else { ec = {}; } auto bytes_transferred = net::buffer_copy(buffers, buffer_.data()); buffer_.consume(bytes_transferred); return bytes_transferred; } template<class Stream, class DynamicBuffer> template<class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) buffered_read_stream<Stream, DynamicBuffer>:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(is_async_read_stream<next_layer_type>::value, "AsyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); if(buffer_.size() == 0 && capacity_ == 0) return next_layer_.async_read_some(buffers, std::forward<ReadHandler>(handler)); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( typename ops::run_read_op{}, handler, this, &buffers); } } // beast } // boost #endif PK PP�[e�Rv�w �w core/impl/multi_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_MULTI_BUFFER_HPP #define BOOST_BEAST_IMPL_MULTI_BUFFER_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/config/workaround.hpp> #include <boost/core/exchange.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <algorithm> #include <exception> #include <iterator> #include <sstream> #include <string> #include <type_traits> #include <utility> namespace boost { namespace beast { /* These diagrams illustrate the layout and state variables. 1 Input and output contained entirely in one element: 0 out_ |<------+-----------+--------------------------------+----->| in_pos_ out_pos_ out_end_ 2 Output contained in first and second elements: out_ |<------+-----------+------>| |<-------------------+----->| in_pos_ out_pos_ out_end_ 3 Output contained in the second element: out_ |<------+------------------>| |<----+--------------+----->| in_pos_ out_pos_ out_end_ 4 Output contained in second and third elements: out_ |<------+------->| |<-------+------>| |<---------+----->| in_pos_ out_pos_ out_end_ 5 Input sequence is empty: out_ |<------+------------------>| |<-------------------+----->| out_pos_ out_end_ in_pos_ 6 Output sequence is empty: out_ |<------+------------------>| |<------+------------------>| in_pos_ out_pos_ out_end_ 7 The end of output can point to the end of an element. But out_pos_ should never point to the end: out_ |<------+------------------>| |<------+------------------>| in_pos_ out_pos_ out_end_ 8 When the input sequence entirely fills the last element and the output sequence is empty, out_ will point to the end of the list of buffers, and out_pos_ and out_end_ will be 0: |<------+------------------>| out_ == list_.end() in_pos_ out_pos_ == 0 out_end_ == 0 */ //------------------------------------------------------------------------------ #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (push) # pragma warning (disable: 4521) // multiple copy constructors specified # pragma warning (disable: 4522) // multiple assignment operators specified #endif template<class Allocator> template<bool isMutable> class basic_multi_buffer<Allocator>::subrange { basic_multi_buffer const* b_; const_iter begin_; const_iter end_; size_type begin_pos_; // offset in begin_ size_type last_pos_; // offset in std::prev(end_) friend class basic_multi_buffer; subrange( basic_multi_buffer const& b, size_type pos, size_type n) noexcept : b_(&b) { auto const set_empty = [&] { begin_ = b_->list_.end(); end_ = b_->list_.end(); begin_pos_ = 0; last_pos_ = 0; }; // VFALCO Handle this trivial case of // pos larger than total size, otherwise // the addition to pos can overflow. //if(pos >= b_->in_size_) // skip unused prefix pos = pos + b_->in_pos_; // iterate the buffers auto it = b_->list_.begin(); // is the list empty? if(it == b_->list_.end()) { set_empty(); return; } // is the requested size zero? if(n == 0) { set_empty(); return; } // get last buffer and its size auto const last = std::prev(b_->list_.end()); auto const last_end = [&] { if(b_->out_end_ == 0) return last->size(); return b_->out_end_; }(); // only one buffer in list? if(it == last) { if(pos >= last_end) { set_empty(); return; } begin_ = it; begin_pos_ = pos; end_ = std::next(it); if(n > last_end - pos) last_pos_ = last_end; else last_pos_ = pos + n; return; } for(;;) { // is pos in this buffer? if(pos < it->size()) { begin_ = it; begin_pos_ = pos; // does this buffer satisfy n? auto const avail = it->size() - pos; if(n <= avail) { end_ = ++it; last_pos_ = pos + n; return; } n -= avail; ++it; break; } pos -= it->size(); ++it; // did we reach the last buffer? if(it == last) { // is pos past the end? if(pos >= last_end) { set_empty(); return; } // satisfy the request begin_ = it; begin_pos_ = pos; end_ = std::next(it); if(n < last_end - pos) last_pos_ = pos + n; else last_pos_ = last_end; return; } } // find pos+n for(;;) { if(it == last) { end_ = ++it; if(n >= last_end) last_pos_ = last_end; else last_pos_ = n; return; } if(n <= it->size()) { end_ = ++it; last_pos_ = n; return; } n -= it->size(); ++it; } } public: using value_type = typename std::conditional< isMutable, net::mutable_buffer, net::const_buffer>::type; class const_iterator; subrange() = delete; #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) subrange(subrange const& other) : b_(other.b_) , begin_(other.begin_) , end_(other.end_) , begin_pos_(other.begin_pos_) , last_pos_(other.last_pos_) { } subrange& operator=(subrange const& other) { b_ = other.b_; begin_ = other.begin_; end_ = other.end_; begin_pos_ = other.begin_pos_; last_pos_ = other.last_pos_; return *this; } #else subrange(subrange const&) = default; subrange& operator=(subrange const&) = default; #endif template< bool isMutable_ = isMutable, class = typename std::enable_if<! isMutable_>::type> subrange( subrange<true> const& other) noexcept : b_(other.b_) , begin_(other.begin_) , end_(other.end_) , begin_pos_(other.begin_pos_) , last_pos_(other.last_pos_) { } template< bool isMutable_ = isMutable, class = typename std::enable_if<! isMutable_>::type> subrange& operator=( subrange<true> const& other) noexcept { b_ = other.b_; begin_ = other.begin_; end_ = other.end_; begin_pos_ = other.begin_pos_; last_pos_ = other.last_pos_; return *this; } const_iterator begin() const noexcept; const_iterator end() const noexcept; std::size_t buffer_bytes() const noexcept { return b_->size(); } }; #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (pop) #endif //------------------------------------------------------------------------------ template<class Allocator> template<bool isMutable> class basic_multi_buffer<Allocator>:: subrange<isMutable>:: const_iterator { friend class subrange; subrange const* sr_ = nullptr; typename list_type::const_iterator it_; const_iterator( subrange const& sr, typename list_type::const_iterator const& it) noexcept : sr_(&sr) , it_(it) { } public: using value_type = typename subrange::value_type; using pointer = value_type const*; using reference = value_type; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; const_iterator() = default; const_iterator( const_iterator const& other) = default; const_iterator& operator=( const_iterator const& other) = default; bool operator==( const_iterator const& other) const noexcept { return sr_ == other.sr_ && it_ == other.it_; } bool operator!=( const_iterator const& other) const noexcept { return !(*this == other); } reference operator*() const noexcept { value_type result; BOOST_ASSERT(sr_->last_pos_ != 0); if(it_ == std::prev(sr_->end_)) result = { it_->data(), sr_->last_pos_ }; else result = { it_->data(), it_->size() }; if(it_ == sr_->begin_) result += sr_->begin_pos_; return result; } pointer operator->() const = delete; const_iterator& operator++() noexcept { ++it_; return *this; } const_iterator operator++(int) noexcept { auto temp = *this; ++(*this); return temp; } const_iterator& operator--() noexcept { --it_; return *this; } const_iterator operator--(int) noexcept { auto temp = *this; --(*this); return temp; } }; //------------------------------------------------------------------------------ template<class Allocator> template<bool isMutable> auto basic_multi_buffer<Allocator>:: subrange<isMutable>:: begin() const noexcept -> const_iterator { return const_iterator( *this, begin_); } template<class Allocator> template<bool isMutable> auto basic_multi_buffer<Allocator>:: subrange<isMutable>:: end() const noexcept -> const_iterator { return const_iterator( *this, end_); } //------------------------------------------------------------------------------ template<class Allocator> basic_multi_buffer<Allocator>:: ~basic_multi_buffer() { destroy(list_); } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer() noexcept(default_nothrow) : max_(alloc_traits::max_size(this->get())) , out_(list_.end()) { } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( std::size_t limit) noexcept(default_nothrow) : max_(limit) , out_(list_.end()) { } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( Allocator const& alloc) noexcept : boost::empty_value<Allocator>( boost::empty_init_t(), alloc) , max_(alloc_traits::max_size(this->get())) , out_(list_.end()) { } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( std::size_t limit, Allocator const& alloc) noexcept : boost::empty_value<Allocator>( boost::empty_init_t(), alloc) , max_(limit) , out_(list_.end()) { } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer&& other) noexcept : boost::empty_value<Allocator>( boost::empty_init_t(), std::move(other.get())) , max_(other.max_) , in_size_(boost::exchange(other.in_size_, 0)) , in_pos_(boost::exchange(other.in_pos_, 0)) , out_pos_(boost::exchange(other.out_pos_, 0)) , out_end_(boost::exchange(other.out_end_, 0)) { auto const at_end = other.out_ == other.list_.end(); list_ = std::move(other.list_); out_ = at_end ? list_.end() : other.out_; other.out_ = other.list_.end(); } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer&& other, Allocator const& alloc) : boost::empty_value<Allocator>( boost::empty_init_t(), alloc) , max_(other.max_) { if(this->get() != other.get()) { out_ = list_.end(); copy_from(other); return; } auto const at_end = other.out_ == other.list_.end(); list_ = std::move(other.list_); out_ = at_end ? list_.end() : other.out_; in_size_ = other.in_size_; in_pos_ = other.in_pos_; out_pos_ = other.out_pos_; out_end_ = other.out_end_; other.in_size_ = 0; other.out_ = other.list_.end(); other.in_pos_ = 0; other.out_pos_ = 0; other.out_end_ = 0; } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer const& other) : boost::empty_value<Allocator>( boost::empty_init_t(), alloc_traits:: select_on_container_copy_construction( other.get())) , max_(other.max_) , out_(list_.end()) { copy_from(other); } template<class Allocator> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer const& other, Allocator const& alloc) : boost::empty_value<Allocator>( boost::empty_init_t(), alloc) , max_(other.max_) , out_(list_.end()) { copy_from(other); } template<class Allocator> template<class OtherAlloc> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer<OtherAlloc> const& other) : out_(list_.end()) { copy_from(other); } template<class Allocator> template<class OtherAlloc> basic_multi_buffer<Allocator>:: basic_multi_buffer( basic_multi_buffer<OtherAlloc> const& other, allocator_type const& alloc) : boost::empty_value<Allocator>( boost::empty_init_t(), alloc) , max_(other.max_) , out_(list_.end()) { copy_from(other); } template<class Allocator> auto basic_multi_buffer<Allocator>:: operator=(basic_multi_buffer&& other) -> basic_multi_buffer& { if(this == &other) return *this; clear(); max_ = other.max_; move_assign(other, pocma{}); return *this; } template<class Allocator> auto basic_multi_buffer<Allocator>:: operator=(basic_multi_buffer const& other) -> basic_multi_buffer& { if(this == &other) return *this; copy_assign(other, pocca{}); return *this; } template<class Allocator> template<class OtherAlloc> auto basic_multi_buffer<Allocator>:: operator=( basic_multi_buffer<OtherAlloc> const& other) -> basic_multi_buffer& { copy_from(other); return *this; } //------------------------------------------------------------------------------ template<class Allocator> std::size_t basic_multi_buffer<Allocator>:: capacity() const noexcept { auto pos = out_; if(pos == list_.end()) return in_size_; auto n = pos->size() - out_pos_; while(++pos != list_.end()) n += pos->size(); return in_size_ + n; } template<class Allocator> auto basic_multi_buffer<Allocator>:: data() const noexcept -> const_buffers_type { return const_buffers_type( *this, 0, in_size_); } template<class Allocator> auto basic_multi_buffer<Allocator>:: data() noexcept -> mutable_buffers_type { return mutable_buffers_type( *this, 0, in_size_); } template<class Allocator> void basic_multi_buffer<Allocator>:: reserve(std::size_t n) { // VFALCO The amount needs to be adjusted for // the sizeof(element) plus padding if(n > alloc_traits::max_size(this->get())) BOOST_THROW_EXCEPTION(std::length_error( "A basic_multi_buffer exceeded the allocator's maximum size")); std::size_t total = in_size_; if(n <= total) return; if(out_ != list_.end()) { total += out_->size() - out_pos_; if(n <= total) return; for(auto it = out_;;) { if(++it == list_.end()) break; total += it->size(); if(n <= total) return; } } BOOST_ASSERT(n > total); (void)prepare(n - size()); } template<class Allocator> void basic_multi_buffer<Allocator>:: shrink_to_fit() { // empty list if(list_.empty()) return; // zero readable bytes if(in_size_ == 0) { destroy(list_); list_.clear(); out_ = list_.end(); in_size_ = 0; in_pos_ = 0; out_pos_ = 0; out_end_ = 0; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif return; } // one or more unused output buffers if(out_ != list_.end()) { if(out_ != list_.iterator_to(list_.back())) { // unused list list_type extra; extra.splice( extra.end(), list_, std::next(out_), list_.end()); destroy(extra); #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } // unused out_ BOOST_ASSERT(out_ == list_.iterator_to(list_.back())); if(out_pos_ == 0) { BOOST_ASSERT(out_ != list_.begin()); auto& e = *out_; list_.erase(out_); out_ = list_.end(); destroy(e); out_end_ = 0; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } } auto const replace = [&](iter pos, element& e) { auto it = list_.insert(pos, e); auto& e0 = *pos; list_.erase(pos); destroy(e0); return it; }; // partial last buffer if(list_.size() > 1 && out_ != list_.end()) { BOOST_ASSERT(out_ == list_.iterator_to(list_.back())); BOOST_ASSERT(out_pos_ != 0); auto& e = alloc(out_pos_); std::memcpy( e.data(), out_->data(), out_pos_); replace(out_, e); out_ = list_.end(); out_pos_ = 0; out_end_ = 0; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } // partial first buffer if(in_pos_ != 0) { if(out_ != list_.begin()) { auto const n = list_.front().size() - in_pos_; auto& e = alloc(n); std::memcpy( e.data(), list_.front().data() + in_pos_, n); replace(list_.begin(), e); in_pos_ = 0; } else { BOOST_ASSERT(list_.size() == 1); BOOST_ASSERT(out_pos_ > in_pos_); auto const n = out_pos_ - in_pos_; auto& e = alloc(n); std::memcpy( e.data(), list_.front().data() + in_pos_, n); replace(list_.begin(), e); in_pos_ = 0; out_ = list_.end(); } #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } } template<class Allocator> void basic_multi_buffer<Allocator>:: clear() noexcept { out_ = list_.begin(); in_size_ = 0; in_pos_ = 0; out_pos_ = 0; out_end_ = 0; } template<class Allocator> auto basic_multi_buffer<Allocator>:: prepare(size_type n) -> mutable_buffers_type { auto const n0 = n; if(in_size_ > max_ || n > (max_ - in_size_)) BOOST_THROW_EXCEPTION(std::length_error{ "basic_multi_buffer too long"}); list_type reuse; std::size_t total = in_size_; // put all empty buffers on reuse list if(out_ != list_.end()) { total += out_->size() - out_pos_; if(out_ != list_.iterator_to(list_.back())) { out_end_ = out_->size(); reuse.splice(reuse.end(), list_, std::next(out_), list_.end()); #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } auto const avail = out_->size() - out_pos_; if(n > avail) { out_end_ = out_->size(); n -= avail; } else { out_end_ = out_pos_ + n; n = 0; } #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } // get space from reuse buffers while(n > 0 && ! reuse.empty()) { auto& e = reuse.front(); reuse.erase(reuse.iterator_to(e)); list_.push_back(e); total += e.size(); if(n > e.size()) { out_end_ = e.size(); n -= e.size(); } else { out_end_ = n; n = 0; } #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } BOOST_ASSERT(total <= max_); if(! reuse.empty() || n > 0) { destroy(reuse); if(n > 0) { auto const growth_factor = 2.0f; auto const size = (std::min<std::size_t>)( max_ - total, (std::max<std::size_t>)({ static_cast<std::size_t>( in_size_ * growth_factor - in_size_), 512, n})); auto& e = alloc(size); list_.push_back(e); if(out_ == list_.end()) out_ = list_.iterator_to(e); out_end_ = n; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } } auto const result = mutable_buffers_type( *this, in_size_, n0); BOOST_ASSERT( net::buffer_size(result) == n0); return result; } template<class Allocator> void basic_multi_buffer<Allocator>:: commit(size_type n) noexcept { if(list_.empty()) return; if(out_ == list_.end()) return; auto const back = list_.iterator_to(list_.back()); while(out_ != back) { auto const avail = out_->size() - out_pos_; if(n < avail) { out_pos_ += n; in_size_ += n; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif return; } ++out_; n -= avail; out_pos_ = 0; in_size_ += avail; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } n = (std::min)(n, out_end_ - out_pos_); out_pos_ += n; in_size_ += n; if(out_pos_ == out_->size()) { ++out_; out_pos_ = 0; out_end_ = 0; } #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } template<class Allocator> void basic_multi_buffer<Allocator>:: consume(size_type n) noexcept { if(list_.empty()) return; for(;;) { if(list_.begin() != out_) { auto const avail = list_.front().size() - in_pos_; if(n < avail) { in_size_ -= n; in_pos_ += n; #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif break; } n -= avail; in_size_ -= avail; in_pos_ = 0; auto& e = list_.front(); list_.erase(list_.iterator_to(e)); destroy(e); #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif } else { auto const avail = out_pos_ - in_pos_; if(n < avail) { in_size_ -= n; in_pos_ += n; } else { in_size_ = 0; if(out_ != list_.iterator_to(list_.back()) || out_pos_ != out_end_) { in_pos_ = out_pos_; } else { // Input and output sequences are empty, reuse buffer. // Alternatively we could deallocate it. in_pos_ = 0; out_pos_ = 0; out_end_ = 0; } } #if BOOST_BEAST_MULTI_BUFFER_DEBUG_CHECK debug_check(); #endif break; } } } template<class Allocator> template<class OtherAlloc> void basic_multi_buffer<Allocator>:: copy_from(basic_multi_buffer<OtherAlloc> const& other) { clear(); max_ = other.max_; if(other.size() == 0) return; commit(net::buffer_copy( prepare(other.size()), other.data())); } template<class Allocator> void basic_multi_buffer<Allocator>:: move_assign(basic_multi_buffer& other, std::true_type) noexcept { this->get() = std::move(other.get()); auto const at_end = other.out_ == other.list_.end(); list_ = std::move(other.list_); out_ = at_end ? list_.end() : other.out_; in_size_ = other.in_size_; in_pos_ = other.in_pos_; out_pos_ = other.out_pos_; out_end_ = other.out_end_; max_ = other.max_; other.in_size_ = 0; other.out_ = other.list_.end(); other.in_pos_ = 0; other.out_pos_ = 0; other.out_end_ = 0; } template<class Allocator> void basic_multi_buffer<Allocator>:: move_assign(basic_multi_buffer& other, std::false_type) { if(this->get() != other.get()) { copy_from(other); } else { move_assign(other, std::true_type{}); } } template<class Allocator> void basic_multi_buffer<Allocator>:: copy_assign( basic_multi_buffer const& other, std::false_type) { copy_from(other); } template<class Allocator> void basic_multi_buffer<Allocator>:: copy_assign( basic_multi_buffer const& other, std::true_type) { clear(); this->get() = other.get(); copy_from(other); } template<class Allocator> void basic_multi_buffer<Allocator>:: swap(basic_multi_buffer& other) noexcept { swap(other, typename alloc_traits::propagate_on_container_swap{}); } template<class Allocator> void basic_multi_buffer<Allocator>:: swap(basic_multi_buffer& other, std::true_type) noexcept { using std::swap; auto const at_end0 = out_ == list_.end(); auto const at_end1 = other.out_ == other.list_.end(); swap(this->get(), other.get()); swap(list_, other.list_); swap(out_, other.out_); if(at_end1) out_ = list_.end(); if(at_end0) other.out_ = other.list_.end(); swap(in_size_, other.in_size_); swap(in_pos_, other.in_pos_); swap(out_pos_, other.out_pos_); swap(out_end_, other.out_end_); } template<class Allocator> void basic_multi_buffer<Allocator>:: swap(basic_multi_buffer& other, std::false_type) noexcept { BOOST_ASSERT(this->get() == other.get()); using std::swap; auto const at_end0 = out_ == list_.end(); auto const at_end1 = other.out_ == other.list_.end(); swap(list_, other.list_); swap(out_, other.out_); if(at_end1) out_ = list_.end(); if(at_end0) other.out_ = other.list_.end(); swap(in_size_, other.in_size_); swap(in_pos_, other.in_pos_); swap(out_pos_, other.out_pos_); swap(out_end_, other.out_end_); } template<class Allocator> void swap( basic_multi_buffer<Allocator>& lhs, basic_multi_buffer<Allocator>& rhs) noexcept { lhs.swap(rhs); } template<class Allocator> void basic_multi_buffer<Allocator>:: destroy(list_type& list) noexcept { for(auto it = list.begin(); it != list.end();) destroy(*it++); } template<class Allocator> void basic_multi_buffer<Allocator>:: destroy(const_iter it) { auto& e = list_.erase(it); destroy(e); } template<class Allocator> void basic_multi_buffer<Allocator>:: destroy(element& e) { auto a = rebind_type{this->get()}; auto const n = (sizeof(element) + e.size() + sizeof(align_type) - 1) / sizeof(align_type); e.~element(); alloc_traits::deallocate(a, reinterpret_cast<align_type*>(&e), n); } template<class Allocator> auto basic_multi_buffer<Allocator>:: alloc(std::size_t size) -> element& { if(size > alloc_traits::max_size(this->get())) BOOST_THROW_EXCEPTION(std::length_error( "A basic_multi_buffer exceeded the allocator's maximum size")); auto a = rebind_type{this->get()}; auto const p = alloc_traits::allocate(a, (sizeof(element) + size + sizeof(align_type) - 1) / sizeof(align_type)); return *(::new(p) element(size)); } template<class Allocator> void basic_multi_buffer<Allocator>:: debug_check() const { #ifndef NDEBUG BOOST_ASSERT(buffer_bytes(data()) == in_size_); if(list_.empty()) { BOOST_ASSERT(in_pos_ == 0); BOOST_ASSERT(in_size_ == 0); BOOST_ASSERT(out_pos_ == 0); BOOST_ASSERT(out_end_ == 0); BOOST_ASSERT(out_ == list_.end()); return; } auto const& front = list_.front(); BOOST_ASSERT(in_pos_ < front.size()); if(out_ == list_.end()) { BOOST_ASSERT(out_pos_ == 0); BOOST_ASSERT(out_end_ == 0); } else { auto const& out = *out_; auto const& back = list_.back(); BOOST_ASSERT(out_end_ <= back.size()); BOOST_ASSERT(out_pos_ < out.size()); BOOST_ASSERT(&out != &front || out_pos_ >= in_pos_); BOOST_ASSERT(&out != &front || out_pos_ - in_pos_ == in_size_); BOOST_ASSERT(&out != &back || out_pos_ <= out_end_); } #endif } } // beast } // boost #endif PK PP�[2�-��7 �7 core/impl/static_string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_STATIC_STRING_HPP #define BOOST_BEAST_IMPL_STATIC_STRING_HPP #include <boost/beast/core/detail/static_string.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { // // (constructor) // template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string() { n_ = 0; term(); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(size_type count, CharT ch) { assign(count, ch); } template<std::size_t N, class CharT, class Traits> template<std::size_t M> static_string<N, CharT, Traits>:: static_string(static_string<M, CharT, Traits> const& other, size_type pos) { assign(other, pos); } template<std::size_t N, class CharT, class Traits> template<std::size_t M> static_string<N, CharT, Traits>:: static_string(static_string<M, CharT, Traits> const& other, size_type pos, size_type count) { assign(other, pos, count); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(CharT const* s, size_type count) { assign(s, count); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(CharT const* s) { auto const count = Traits::length(s); if(count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "count > max_size()"}); n_ = count; Traits::copy(&s_[0], s, n_ + 1); } template<std::size_t N, class CharT, class Traits> template<class InputIt> static_string<N, CharT, Traits>:: static_string(InputIt first, InputIt last) { assign(first, last); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(static_string const& s) { assign(s); } template<std::size_t N, class CharT, class Traits> template<std::size_t M> static_string<N, CharT, Traits>:: static_string(static_string<M, CharT, Traits> const& s) { assign(s); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(std::initializer_list<CharT> init) { assign(init.begin(), init.end()); } template<std::size_t N, class CharT, class Traits> static_string<N, CharT, Traits>:: static_string(string_view_type sv) { assign(sv); } template<std::size_t N, class CharT, class Traits> template<class T, class> static_string<N, CharT, Traits>:: static_string(T const& t, size_type pos, size_type n) { assign(t, pos, n); } // // (assignment) // template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: operator=(CharT const* s) -> static_string& { auto const count = Traits::length(s); if(count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "count > max_size()"}); n_ = count; Traits::copy(&s_[0], s, n_ + 1); return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: assign(size_type count, CharT ch) -> static_string& { if(count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "count > max_size()"}); n_ = count; Traits::assign(&s_[0], n_, ch); term(); return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: assign(static_string const& str) -> static_string& { n_ = str.n_; auto const n = n_ + 1; BOOST_BEAST_ASSUME(n != 0); Traits::copy(&s_[0], &str.s_[0], n); return *this; } template<std::size_t N, class CharT, class Traits> template<std::size_t M> auto static_string<N, CharT, Traits>:: assign(static_string<M, CharT, Traits> const& str, size_type pos, size_type count) -> static_string& { auto const ss = str.substr(pos, count); return assign(ss.data(), ss.size()); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: assign(CharT const* s, size_type count) -> static_string& { if(count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "count > max_size()"}); n_ = count; Traits::copy(&s_[0], s, n_); term(); return *this; } template<std::size_t N, class CharT, class Traits> template<class InputIt> auto static_string<N, CharT, Traits>:: assign(InputIt first, InputIt last) -> static_string& { std::size_t const n = std::distance(first, last); if(n > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "n > max_size()"}); n_ = n; for(auto it = &s_[0]; first != last; ++it, ++first) Traits::assign(*it, *first); term(); return *this; } template<std::size_t N, class CharT, class Traits> template<class T> auto static_string<N, CharT, Traits>:: assign(T const& t, size_type pos, size_type count) -> typename std::enable_if<std::is_convertible<T, string_view_type>::value, static_string&>::type { auto const sv = string_view_type(t).substr(pos, count); if(sv.size() > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "sv.size() > max_size()"}); n_ = sv.size(); Traits::copy(&s_[0], &sv[0], n_); term(); return *this; } // // Element access // template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: at(size_type pos) -> reference { if(pos >= size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "pos >= size()"}); return s_[pos]; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: at(size_type pos) const -> const_reference { if(pos >= size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "pos >= size()"}); return s_[pos]; } // // Capacity // template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: reserve(std::size_t n) { if(n > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "n > max_size()"}); } // // Operations // template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: clear() { n_ = 0; term(); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: insert(size_type index, size_type count, CharT ch) -> static_string& { if(index > size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "index > size()"}); insert(begin() + index, count, ch); return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: insert(size_type index, CharT const* s, size_type count) -> static_string& { if(index > size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "index > size()"}); if(size() + count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "size() + count > max_size()"}); Traits::move( &s_[index + count], &s_[index], size() - index); n_ += count; Traits::copy(&s_[index], s, count); term(); return *this; } template<std::size_t N, class CharT, class Traits> template<std::size_t M> auto static_string<N, CharT, Traits>:: insert(size_type index, static_string<M, CharT, Traits> const& str, size_type index_str, size_type count) -> static_string& { auto const ss = str.substr(index_str, count); return insert(index, ss.data(), ss.size()); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: insert(const_iterator pos, size_type count, CharT ch) -> iterator { if(size() + count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "size() + count() > max_size()"}); auto const index = pos - &s_[0]; Traits::move( &s_[index + count], &s_[index], size() - index); n_ += count; Traits::assign(&s_[index], count, ch); term(); return &s_[index]; } template<std::size_t N, class CharT, class Traits> template<class InputIt> auto static_string<N, CharT, Traits>:: insert(const_iterator pos, InputIt first, InputIt last) -> typename std::enable_if< detail::is_input_iterator<InputIt>::value, iterator>::type { std::size_t const count = std::distance(first, last); if(size() + count > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "size() + count > max_size()"}); std::size_t const index = pos - begin(); Traits::move( &s_[index + count], &s_[index], size() - index); n_ += count; for(auto it = begin() + index; first != last; ++it, ++first) Traits::assign(*it, *first); term(); return begin() + index; } template<std::size_t N, class CharT, class Traits> template<class T> auto static_string<N, CharT, Traits>:: insert(size_type index, const T& t, size_type index_str, size_type count) -> typename std::enable_if<std::is_convertible< T const&, string_view_type>::value && ! std::is_convertible<T const&, CharT const*>::value, static_string&>::type { auto const str = string_view_type(t).substr(index_str, count); return insert(index, str.data(), str.size()); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: erase(size_type index, size_type count) -> static_string& { if(index > size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "index > size()"}); auto const n = (std::min)(count, size() - index); Traits::move( &s_[index], &s_[index + n], size() - (index + n) + 1); n_ -= n; return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: erase(const_iterator pos) -> iterator { erase(pos - begin(), 1); return begin() + (pos - begin()); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: erase(const_iterator first, const_iterator last) -> iterator { erase(first - begin(), std::distance(first, last)); return begin() + (first - begin()); } template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: push_back(CharT ch) { if(size() >= max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "size() >= max_size()"}); Traits::assign(s_[n_++], ch); term(); } template<std::size_t N, class CharT, class Traits> template<std::size_t M> auto static_string<N, CharT, Traits>:: append(static_string<M, CharT, Traits> const& str, size_type pos, size_type count) -> static_string& { // Valid range is [0, size) if(pos >= str.size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "pos > str.size()"}); string_view_type const ss{&str.s_[pos], (std::min)(count, str.size() - pos)}; insert(size(), ss.data(), ss.size()); return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: substr(size_type pos, size_type count) const -> string_view_type { if(pos > size()) BOOST_THROW_EXCEPTION(std::out_of_range{ "pos > size()"}); return{&s_[pos], (std::min)(count, size() - pos)}; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: copy(CharT* dest, size_type count, size_type pos) const -> size_type { auto const str = substr(pos, count); Traits::copy(dest, str.data(), str.size()); return str.size(); } template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: resize(std::size_t n) { if(n > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "n > max_size()"}); if(n > n_) Traits::assign(&s_[n_], n - n_, CharT{}); n_ = n; term(); } template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: resize(std::size_t n, CharT c) { if(n > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "n > max_size()"}); if(n > n_) Traits::assign(&s_[n_], n - n_, c); n_ = n; term(); } template<std::size_t N, class CharT, class Traits> void static_string<N, CharT, Traits>:: swap(static_string& str) { static_string tmp(str); str.n_ = n_; Traits::copy(&str.s_[0], &s_[0], n_ + 1); n_ = tmp.n_; Traits::copy(&s_[0], &tmp.s_[0], n_ + 1); } template<std::size_t N, class CharT, class Traits> template<std::size_t M> void static_string<N, CharT, Traits>:: swap(static_string<M, CharT, Traits>& str) { if(size() > str.max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "size() > str.max_size()"}); if(str.size() > max_size()) BOOST_THROW_EXCEPTION(std::length_error{ "str.size() > max_size()"}); static_string tmp(str); str.n_ = n_; Traits::copy(&str.s_[0], &s_[0], n_ + 1); n_ = tmp.n_; Traits::copy(&s_[0], &tmp.s_[0], n_ + 1); } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: assign_char(CharT ch, std::true_type) -> static_string& { n_ = 1; Traits::assign(s_[0], ch); term(); return *this; } template<std::size_t N, class CharT, class Traits> auto static_string<N, CharT, Traits>:: assign_char(CharT, std::false_type) -> static_string& { BOOST_THROW_EXCEPTION(std::length_error{ "max_size() == 0"}); } template<class Integer, class> static_string<detail::max_digits(sizeof(Integer))> to_static_string(Integer x) { using CharT = char; using Traits = std::char_traits<CharT>; BOOST_STATIC_ASSERT(std::is_integral<Integer>::value); char buf[detail::max_digits(sizeof(Integer))]; auto last = buf + sizeof(buf); auto it = detail::raw_to_string< CharT, Integer, Traits>(last, sizeof(buf), x); static_string<detail::max_digits(sizeof(Integer))> s; s.resize(static_cast<std::size_t>(last - it)); auto p = s.data(); while(it < last) Traits::assign(*p++, *it++); return s; } } // beast } // boost #endif PK PP�[D��¿ � core/impl/file_stdio.ippnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_FILE_STDIO_IPP #define BOOST_BEAST_CORE_IMPL_FILE_STDIO_IPP #include <boost/beast/core/file_stdio.hpp> #include <boost/beast/core/detail/win32_unicode_path.hpp> #include <boost/config/workaround.hpp> #include <boost/core/exchange.hpp> #include <limits> namespace boost { namespace beast { file_stdio:: ~file_stdio() { if(f_) fclose(f_); } file_stdio:: file_stdio(file_stdio&& other) : f_(boost::exchange(other.f_, nullptr)) { } file_stdio& file_stdio:: operator=(file_stdio&& other) { if(&other == this) return *this; if(f_) fclose(f_); f_ = other.f_; other.f_ = nullptr; return *this; } void file_stdio:: native_handle(std::FILE* f) { if(f_) fclose(f_); f_ = f; } void file_stdio:: close(error_code& ec) { if(f_) { int failed = fclose(f_); f_ = nullptr; if(failed) { ec.assign(errno, generic_category()); return; } } ec = {}; } void file_stdio:: open(char const* path, file_mode mode, error_code& ec) { if(f_) { fclose(f_); f_ = nullptr; } ec = {}; #ifdef BOOST_MSVC boost::winapi::WCHAR_ const* s; detail::win32_unicode_path unicode_path(path, ec); if (ec) return; #else char const* s; #endif switch(mode) { default: case file_mode::read: #ifdef BOOST_MSVC s = L"rb"; #else s = "rb"; #endif break; case file_mode::scan: #ifdef BOOST_MSVC s = L"rbS"; #else s = "rb"; #endif break; case file_mode::write: #ifdef BOOST_MSVC s = L"wb+"; #else s = "wb+"; #endif break; case file_mode::write_new: { #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) std::FILE* f0; auto const ev = ::_wfopen_s(&f0, unicode_path.c_str(), L"rb"); if(! ev) { std::fclose(f0); ec = make_error_code(errc::file_exists); return; } else if(ev != errc::no_such_file_or_directory) { ec.assign(ev, generic_category()); return; } s = L"wb"; #elif defined(BOOST_MSVC) s = L"wbx"; #else s = "wbx"; #endif break; } case file_mode::write_existing: #ifdef BOOST_MSVC s = L"rb+"; #else s = "rb+"; #endif break; case file_mode::append: #ifdef BOOST_MSVC s = L"ab"; #else s = "ab"; #endif break; case file_mode::append_existing: { #ifdef BOOST_MSVC std::FILE* f0; auto const ev = ::_wfopen_s(&f0, unicode_path.c_str(), L"rb+"); if(ev) { ec.assign(ev, generic_category()); return; } #else auto const f0 = std::fopen(path, "rb+"); if(! f0) { ec.assign(errno, generic_category()); return; } #endif std::fclose(f0); #ifdef BOOST_MSVC s = L"ab"; #else s = "ab"; #endif break; } } #ifdef BOOST_MSVC auto const ev = ::_wfopen_s(&f_, unicode_path.c_str(), s); if(ev) { f_ = nullptr; ec.assign(ev, generic_category()); return; } #else f_ = std::fopen(path, s); if(! f_) { ec.assign(errno, generic_category()); return; } #endif } std::uint64_t file_stdio:: size(error_code& ec) const { if(! f_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } long pos = std::ftell(f_); if(pos == -1L) { ec.assign(errno, generic_category()); return 0; } int result = std::fseek(f_, 0, SEEK_END); if(result != 0) { ec.assign(errno, generic_category()); return 0; } long size = std::ftell(f_); if(size == -1L) { ec.assign(errno, generic_category()); std::fseek(f_, pos, SEEK_SET); return 0; } result = std::fseek(f_, pos, SEEK_SET); if(result != 0) ec.assign(errno, generic_category()); else ec = {}; return size; } std::uint64_t file_stdio:: pos(error_code& ec) const { if(! f_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } long pos = std::ftell(f_); if(pos == -1L) { ec.assign(errno, generic_category()); return 0; } ec = {}; return pos; } void file_stdio:: seek(std::uint64_t offset, error_code& ec) { if(! f_) { ec = make_error_code(errc::bad_file_descriptor); return; } if(offset > static_cast<std::uint64_t>((std::numeric_limits<long>::max)())) { ec = make_error_code(errc::invalid_seek); return; } int result = std::fseek(f_, static_cast<long>(offset), SEEK_SET); if(result != 0) ec.assign(errno, generic_category()); else ec = {}; } std::size_t file_stdio:: read(void* buffer, std::size_t n, error_code& ec) const { if(! f_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } auto nread = std::fread(buffer, 1, n, f_); if(std::ferror(f_)) { ec.assign(errno, generic_category()); return 0; } return nread; } std::size_t file_stdio:: write(void const* buffer, std::size_t n, error_code& ec) { if(! f_) { ec = make_error_code(errc::bad_file_descriptor); return 0; } auto nwritten = std::fwrite(buffer, 1, n, f_); if(std::ferror(f_)) { ec.assign(errno, generic_category()); return 0; } return nwritten; } } // beast } // boost #endif PK PP�[��%vv v core/impl/flat_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP #define BOOST_BEAST_CORE_IMPL_FLAT_STREAM_HPP #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/static_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/websocket/teardown.hpp> #include <boost/asio/buffer.hpp> #include <memory> namespace boost { namespace beast { template<class NextLayer> struct flat_stream<NextLayer>::ops { template<class Handler> class write_op : public async_base<Handler, beast::executor_type<flat_stream>> { public: template< class ConstBufferSequence, class Handler_> write_op( Handler_&& h, flat_stream<NextLayer>& s, ConstBufferSequence const& b) : async_base<Handler, beast::executor_type<flat_stream>>( std::forward<Handler_>(h), s.get_executor()) { auto const result = flatten(b, max_size); if(result.flatten) { s.buffer_.clear(); s.buffer_.commit(net::buffer_copy( s.buffer_.prepare(result.size), b, result.size)); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "flat_stream::async_write_some")); s.stream_.async_write_some( s.buffer_.data(), std::move(*this)); } else { s.buffer_.clear(); s.buffer_.shrink_to_fit(); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "flat_stream::async_write_some")); s.stream_.async_write_some( beast::buffers_prefix( result.size, b), std::move(*this)); } } void operator()( boost::system::error_code ec, std::size_t bytes_transferred) { this->complete_now(ec, bytes_transferred); } }; struct run_write_op { template<class WriteHandler, class Buffers> void operator()( WriteHandler&& h, flat_stream* s, Buffers const& b) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_op< typename std::decay<WriteHandler>::type>( std::forward<WriteHandler>(h), *s, b); } }; }; //------------------------------------------------------------------------------ template<class NextLayer> template<class... Args> flat_stream<NextLayer>:: flat_stream(Args&&... args) : stream_(std::forward<Args>(args)...) { } template<class NextLayer> template<class MutableBufferSequence> std::size_t flat_stream<NextLayer>:: read_some(MutableBufferSequence const& buffers) { static_assert(boost::beast::is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); error_code ec; auto n = read_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(boost::system::system_error{ec}); return n; } template<class NextLayer> template<class MutableBufferSequence> std::size_t flat_stream<NextLayer>:: read_some(MutableBufferSequence const& buffers, error_code& ec) { static_assert(boost::beast::is_sync_read_stream<next_layer_type>::value, "SyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); return stream_.read_some(buffers, ec); } template<class NextLayer> template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) flat_stream<NextLayer>:: async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler) { static_assert(boost::beast::is_async_read_stream<next_layer_type>::value, "AsyncReadStream type requirements not met"); static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence >::value, "MutableBufferSequence type requirements not met"); return stream_.async_read_some( buffers, std::forward<ReadHandler>(handler)); } template<class NextLayer> template<class ConstBufferSequence> std::size_t flat_stream<NextLayer>:: write_some(ConstBufferSequence const& buffers) { static_assert(boost::beast::is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); error_code ec; auto n = write_some(buffers, ec); if(ec) BOOST_THROW_EXCEPTION(boost::system::system_error{ec}); return n; } template<class NextLayer> template<class ConstBufferSequence> std::size_t flat_stream<NextLayer>:: stack_write_some( std::size_t size, ConstBufferSequence const& buffers, error_code& ec) { static_buffer<max_stack> b; b.commit(net::buffer_copy( b.prepare(size), buffers)); return stream_.write_some(b.data(), ec); } template<class NextLayer> template<class ConstBufferSequence> std::size_t flat_stream<NextLayer>:: write_some(ConstBufferSequence const& buffers, error_code& ec) { static_assert(boost::beast::is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); auto const result = flatten(buffers, max_size); if(result.flatten) { if(result.size <= max_stack) return stack_write_some(result.size, buffers, ec); buffer_.clear(); buffer_.commit(net::buffer_copy( buffer_.prepare(result.size), buffers)); return stream_.write_some(buffer_.data(), ec); } buffer_.clear(); buffer_.shrink_to_fit(); return stream_.write_some( boost::beast::buffers_prefix(result.size, buffers), ec); } template<class NextLayer> template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) flat_stream<NextLayer>:: async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler) { static_assert(boost::beast::is_async_write_stream<next_layer_type>::value, "AsyncWriteStream type requirements not met"); static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( typename ops::run_write_op{}, handler, this, buffers); } template<class NextLayer> void teardown( boost::beast::role_type role, flat_stream<NextLayer>& s, error_code& ec) { using boost::beast::websocket::teardown; teardown(role, s.next_layer(), ec); } template<class NextLayer, class TeardownHandler> void async_teardown( boost::beast::role_type role, flat_stream<NextLayer>& s, TeardownHandler&& handler) { using boost::beast::websocket::async_teardown; async_teardown(role, s.next_layer(), std::move(handler)); } } // beast } // boost #endif PK PP�[#t�� � core/impl/read_size.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_READ_SIZE_HPP #define BOOST_BEAST_IMPL_READ_SIZE_HPP #include <boost/asio/buffer.hpp> #include <boost/assert.hpp> #include <stdexcept> #include <type_traits> namespace boost { namespace beast { namespace detail { template<class T, class = void> struct has_read_size_helper : std::false_type {}; template<class T> struct has_read_size_helper<T, decltype( read_size_helper(std::declval<T&>(), 512), (void)0)> : std::true_type { }; template<class DynamicBuffer> std::size_t read_size(DynamicBuffer& buffer, std::size_t max_size, std::true_type) { return read_size_helper(buffer, max_size); } template<class DynamicBuffer> std::size_t read_size(DynamicBuffer& buffer, std::size_t max_size, std::false_type) { static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); auto const size = buffer.size(); auto const limit = buffer.max_size() - size; BOOST_ASSERT(size <= buffer.max_size()); return std::min<std::size_t>( std::max<std::size_t>(512, buffer.capacity() - size), std::min<std::size_t>(max_size, limit)); } } // detail template<class DynamicBuffer> std::size_t read_size( DynamicBuffer& buffer, std::size_t max_size) { return detail::read_size(buffer, max_size, detail::has_read_size_helper<DynamicBuffer>{}); } template<class DynamicBuffer> std::size_t read_size_or_throw( DynamicBuffer& buffer, std::size_t max_size) { auto const n = read_size(buffer, max_size); if(n == 0) BOOST_THROW_EXCEPTION(std::length_error{ "buffer overflow"}); return n; } } // beast } // boost #endif PK PP�[2��Hf f core/impl/string_param.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_IMPL_STRING_PARAM_HPP #define BOOST_BEAST_IMPL_STRING_PARAM_HPP namespace boost { namespace beast { template<class T> typename std::enable_if< std::is_integral<T>::value>::type string_param:: print(T const& t) { auto const last = buf_ + sizeof(buf_); auto const it = detail::raw_to_string< char, T, std::char_traits<char>>( last, sizeof(buf_), t); sv_ = {it, static_cast<std::size_t>( last - it)}; } template<class T> typename std::enable_if< ! std::is_integral<T>::value && ! std::is_convertible<T, string_view>::value >::type string_param:: print(T const& t) { os_.emplace(buf_, sizeof(buf_)); *os_ << t; os_->flush(); sv_ = os_->str(); } inline void string_param:: print(string_view sv) { sv_ = sv; } template<class T> typename std::enable_if< std::is_integral<T>::value>::type string_param:: print_1(T const& t) { char buf[detail::max_digits(sizeof(T))]; auto const last = buf + sizeof(buf); auto const it = detail::raw_to_string< char, T, std::char_traits<char>>( last, sizeof(buf), t); *os_ << string_view{it, static_cast<std::size_t>(last - it)}; } template<class T> typename std::enable_if< ! std::is_integral<T>::value>::type string_param:: print_1(T const& t) { *os_ << t; } template<class T0, class... TN> void string_param:: print_n(T0 const& t0, TN const&... tn) { print_1(t0); print_n(tn...); } template<class T0, class T1, class... TN> void string_param:: print(T0 const& t0, T1 const& t1, TN const&... tn) { os_.emplace(buf_, sizeof(buf_)); print_1(t0); print_1(t1); print_n(tn...); os_->flush(); sv_ = os_->str(); } template<class... Args> string_param:: string_param(Args const&... args) { print(args...); } } // beast } // boost #endif PK PP�[�# � � core/ostream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_WRITE_OSTREAM_HPP #define BOOST_BEAST_WRITE_OSTREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/ostream.hpp> #include <type_traits> #include <streambuf> #include <utility> #ifdef BOOST_BEAST_ALLOW_DEPRECATED #include <boost/beast/core/make_printable.hpp> #endif namespace boost { namespace beast { /** Return an output stream that formats values into a <em>DynamicBuffer</em>. This function wraps the caller provided <em>DynamicBuffer</em> into a `std::ostream` derived class, to allow `operator<<` stream style formatting operations. @par Example @code ostream(buffer) << "Hello, world!" << std::endl; @endcode @note Calling members of the underlying buffer before the output stream is destroyed results in undefined behavior. @param buffer An object meeting the requirements of <em>DynamicBuffer</em> into which the formatted output will be placed. @return An object derived from `std::ostream` which redirects output The wrapped dynamic buffer is not modified, a copy is made instead. Ownership of the underlying memory is not transferred, the application is still responsible for managing its lifetime. The caller is responsible for ensuring the dynamic buffer is not destroyed for the lifetime of the output stream. */ template<class DynamicBuffer> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else detail::ostream_helper< DynamicBuffer, char, std::char_traits<char>, detail::basic_streambuf_movable::value> #endif ostream(DynamicBuffer& buffer) { static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); return detail::ostream_helper< DynamicBuffer, char, std::char_traits<char>, detail::basic_streambuf_movable::value>{buffer}; } //------------------------------------------------------------------------------ #ifdef BOOST_BEAST_ALLOW_DEPRECATED template<class T> detail::make_printable_adaptor<T> buffers(T const& t) { return make_printable(t); } #else template<class T> void buffers(T const&) { static_assert(sizeof(T) == 0, "The function buffers() is deprecated, use make_printable() instead, " "or define BOOST_BEAST_ALLOW_DEPRECATED to silence this error."); } #endif } // beast } // boost #endif PK PP�[f�9K� � core/saved_handler.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_SAVED_HANDLER_HPP #define BOOST_BEAST_CORE_SAVED_HANDLER_HPP #include <boost/beast/core/detail/config.hpp> namespace boost { namespace beast { /** An invocable, nullary function object which holds a completion handler. This container can hold a type-erased instance of any completion handler, or it can be empty. When the container holds a value, the implementation maintains an instance of `net::executor_work_guard` for the handler's associated executor. Memory is dynamically allocated to store the completion handler, and the allocator may optionally be specified. Otherwise, the implementation uses the handler's associated allocator. */ class saved_handler { class base; template<class, class> class impl; base* p_ = nullptr; public: /// Default Constructor saved_handler() = default; /// Copy Constructor (deleted) saved_handler(saved_handler const&) = delete; /// Copy Assignment (deleted) saved_handler& operator=(saved_handler const&) = delete; /// Destructor BOOST_BEAST_DECL ~saved_handler(); /// Move Constructor BOOST_BEAST_DECL saved_handler(saved_handler&& other) noexcept; /// Move Assignment BOOST_BEAST_DECL saved_handler& operator=(saved_handler&& other) noexcept; /// Returns `true` if `*this` contains a completion handler. bool has_value() const noexcept { return p_ != nullptr; } /** Store a completion handler in the container. Requires `this->has_value() == false`. @param handler The completion handler to store. The implementation takes ownership of the handler by performing a decay-copy. @param alloc The allocator to use. */ template<class Handler, class Allocator> void emplace(Handler&& handler, Allocator const& alloc); /** Store a completion handler in the container. Requires `this->has_value() == false`. The implementation will use the handler's associated allocator to obtian storage. @param handler The completion handler to store. The implementation takes ownership of the handler by performing a decay-copy. */ template<class Handler> void emplace(Handler&& handler); /** Discard the saved handler, if one exists. If `*this` contains an object, it is destroyed. @returns `true` if an object was destroyed. */ BOOST_BEAST_DECL bool reset() noexcept; /** Unconditionally invoke the stored completion handler. Requires `this->has_value() == true`. Any dynamic memory used is deallocated before the stored completion handler is invoked. The executor work guard is also reset before the invocation. */ BOOST_BEAST_DECL void invoke(); /** Conditionally invoke the stored completion handler. Invokes the stored completion handler if `this->has_value() == true`, otherwise does nothing. Any dynamic memory used is deallocated before the stored completion handler is invoked. The executor work guard is also reset before the invocation. @return `true` if the invocation took place. */ BOOST_BEAST_DECL bool maybe_invoke(); }; } // beast } // boost #include <boost/beast/core/impl/saved_handler.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/saved_handler.ipp> #endif #endif PK PP�[� <vC< C< core/flat_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_FLAT_BUFFER_HPP #define BOOST_BEAST_FLAT_BUFFER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/allocator.hpp> #include <boost/asio/buffer.hpp> #include <boost/core/empty_value.hpp> #include <limits> #include <memory> #include <type_traits> namespace boost { namespace beast { /** A dynamic buffer providing buffer sequences of length one. A dynamic buffer encapsulates memory storage that may be automatically resized as required, where the memory is divided into two regions: readable bytes followed by writable bytes. These memory regions are internal to the dynamic buffer, but direct access to the elements is provided to permit them to be efficiently used with I/O operations. Objects of this type meet the requirements of <em>DynamicBuffer</em> and have the following additional properties: @li A mutable buffer sequence representing the readable bytes is returned by @ref data when `this` is non-const. @li A configurable maximum buffer size may be set upon construction. Attempts to exceed the buffer size will throw `std::length_error`. @li Buffer sequences representing the readable and writable bytes, returned by @ref data and @ref prepare, will have length one. Upon construction, a maximum size for the buffer may be specified. If this limit is exceeded, the `std::length_error` exception will be thrown. @note This class is designed for use with algorithms that take dynamic buffers as parameters, and are optimized for the case where the input sequence or output sequence is stored in a single contiguous buffer. */ template<class Allocator> class basic_flat_buffer #if ! BOOST_BEAST_DOXYGEN : private boost::empty_value< typename detail::allocator_traits<Allocator>:: template rebind_alloc<char>> #endif { template<class OtherAlloc> friend class basic_flat_buffer; using base_alloc_type = typename detail::allocator_traits<Allocator>:: template rebind_alloc<char>; static bool constexpr default_nothrow = std::is_nothrow_default_constructible<Allocator>::value; using alloc_traits = beast::detail::allocator_traits<base_alloc_type>; using pocma = typename alloc_traits::propagate_on_container_move_assignment; using pocca = typename alloc_traits::propagate_on_container_copy_assignment; static std::size_t dist(char const* first, char const* last) noexcept { return static_cast<std::size_t>(last - first); } char* begin_; char* in_; char* out_; char* last_; char* end_; std::size_t max_; public: /// The type of allocator used. using allocator_type = Allocator; /// Destructor ~basic_flat_buffer(); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the largest value which may be passed to the allocator's `allocate` function. */ basic_flat_buffer() noexcept(default_nothrow); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the specified value of `limit`. @param limit The desired maximum size. */ explicit basic_flat_buffer( std::size_t limit) noexcept(default_nothrow); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the largest value which may be passed to the allocator's `allocate` function. @param alloc The allocator to use for the object. @esafe No-throw guarantee. */ explicit basic_flat_buffer(Allocator const& alloc) noexcept; /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the specified value of `limit`. @param limit The desired maximum size. @param alloc The allocator to use for the object. @esafe No-throw guarantee. */ basic_flat_buffer( std::size_t limit, Allocator const& alloc) noexcept; /** Move Constructor The container is constructed with the contents of `other` using move semantics. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare remain valid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. @esafe No-throw guarantee. */ basic_flat_buffer(basic_flat_buffer&& other) noexcept; /** Move Constructor Using `alloc` as the allocator for the new container, the contents of `other` are moved. If `alloc != other.get_allocator()`, this results in a copy. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare become invalid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ basic_flat_buffer( basic_flat_buffer&& other, Allocator const& alloc); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ basic_flat_buffer(basic_flat_buffer const& other); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics and the specified allocator. The maximum size will be the same as the copied object. @param other The object to copy from. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ basic_flat_buffer( basic_flat_buffer const& other, Allocator const& alloc); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ template<class OtherAlloc> basic_flat_buffer( basic_flat_buffer<OtherAlloc> const& other) noexcept(default_nothrow); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ template<class OtherAlloc> basic_flat_buffer( basic_flat_buffer<OtherAlloc> const& other, Allocator const& alloc); /** Move Assignment The container is assigned with the contents of `other` using move semantics. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare remain valid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. @esafe No-throw guarantee. */ basic_flat_buffer& operator=(basic_flat_buffer&& other) noexcept; /** Copy Assignment The container is assigned with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. After the copy, `this` will have zero writable bytes. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ basic_flat_buffer& operator=(basic_flat_buffer const& other); /** Copy assignment The container is assigned with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. After the copy, `this` will have zero writable bytes. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ template<class OtherAlloc> basic_flat_buffer& operator=(basic_flat_buffer<OtherAlloc> const& other); /// Returns a copy of the allocator used. allocator_type get_allocator() const { return this->get(); } /** Set the maximum allowed capacity This function changes the currently configured upper limit on capacity to the specified value. @param n The maximum number of bytes ever allowed for capacity. @esafe No-throw guarantee. */ void max_size(std::size_t n) noexcept { max_ = n; } /** Guarantee a minimum capacity This function adjusts the internal storage (if necessary) to guarantee space for at least `n` bytes. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @param n The minimum number of byte for the new capacity. If this value is greater than the maximum size, then the maximum size will be adjusted upwards to this value. @esafe Basic guarantee. @throws std::length_error if n is larger than the maximum allocation size of the allocator. */ void reserve(std::size_t n); /** Request the removal of unused capacity. This function attempts to reduce @ref capacity() to @ref size(), which may not succeed. @esafe No-throw guarantee. */ void shrink_to_fit() noexcept; /** Set the size of the readable and writable bytes to zero. This clears the buffer without changing capacity. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @esafe No-throw guarantee. */ void clear() noexcept; /// Exchange two dynamic buffers template<class Alloc> friend void swap( basic_flat_buffer<Alloc>&, basic_flat_buffer<Alloc>&); //-------------------------------------------------------------------------- /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = net::const_buffer; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = net::mutable_buffer; /// Returns the number of readable bytes. std::size_t size() const noexcept { return dist(in_, out_); } /// Return the maximum number of bytes, both readable and writable, that can ever be held. std::size_t max_size() const noexcept { return max_; } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept { return dist(begin_, end_); } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type data() const noexcept { return {in_, dist(in_, out_)}; } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type cdata() const noexcept { return data(); } /// Returns a mutable buffer sequence representing the readable bytes mutable_buffers_type data() noexcept { return {in_, dist(in_, out_)}; } /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. Memory may be reallocated as needed. All buffers sequences previously obtained using @ref data or @ref prepare become invalid. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds either `max_size()` or the allocator's maximum allocation size. @esafe Strong guarantee. */ mutable_buffers_type prepare(std::size_t n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare become invalid. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ void commit(std::size_t n) noexcept { out_ += (std::min)(n, dist(out_, last_)); } /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare become invalid. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ void consume(std::size_t n) noexcept; private: template<class OtherAlloc> void copy_from(basic_flat_buffer<OtherAlloc> const& other); void move_assign(basic_flat_buffer&, std::true_type); void move_assign(basic_flat_buffer&, std::false_type); void copy_assign(basic_flat_buffer const&, std::true_type); void copy_assign(basic_flat_buffer const&, std::false_type); void swap(basic_flat_buffer&); void swap(basic_flat_buffer&, std::true_type); void swap(basic_flat_buffer&, std::false_type); char* alloc(std::size_t n); }; /// A flat buffer which uses the default allocator. using flat_buffer = basic_flat_buffer<std::allocator<char>>; } // beast } // boost #include <boost/beast/core/impl/flat_buffer.hpp> #endif PK PP�[��P�7 7 core/buffers_cat.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_CAT_HPP #define BOOST_BEAST_BUFFERS_CAT_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/tuple.hpp> #include <boost/beast/core/detail/type_traits.hpp> namespace boost { namespace beast { /** A buffer sequence representing a concatenation of buffer sequences. @see buffers_cat */ template<class... Buffers> class buffers_cat_view { detail::tuple<Buffers...> bn_; public: /** The type of buffer returned when dereferencing an iterator. If every buffer sequence in the view is a <em>MutableBufferSequence</em>, then `value_type` will be `net::mutable_buffer`. Otherwise, `value_type` will be `net::const_buffer`. */ #if BOOST_BEAST_DOXYGEN using value_type = __see_below__; #else using value_type = buffers_type<Buffers...>; #endif /// The type of iterator used by the concatenated sequence class const_iterator; /// Copy Constructor buffers_cat_view(buffers_cat_view const&) = default; /// Copy Assignment buffers_cat_view& operator=(buffers_cat_view const&) = default; /** Constructor @param buffers The list of buffer sequences to concatenate. Copies of the arguments will be maintained for the lifetime of the concatenated sequence; however, the ownership of the memory buffers themselves is not transferred. */ explicit buffers_cat_view(Buffers const&... buffers); /// Returns an iterator to the first buffer in the sequence const_iterator begin() const; /// Returns an iterator to one past the last buffer in the sequence const_iterator end() const; }; /** Concatenate 1 or more buffer sequences. This function returns a constant or mutable buffer sequence which, when iterated, efficiently concatenates the input buffer sequences. Copies of the arguments passed will be made; however, the returned object does not take ownership of the underlying memory. The application is still responsible for managing the lifetime of the referenced memory. @param buffers The list of buffer sequences to concatenate. @return A new buffer sequence that represents the concatenation of the input buffer sequences. This buffer sequence will be a <em>MutableBufferSequence</em> if each of the passed buffer sequences is also a <em>MutableBufferSequence</em>; otherwise the returned buffer sequence will be a <em>ConstBufferSequence</em>. @see buffers_cat_view */ #if BOOST_BEAST_DOXYGEN template<class... BufferSequence> buffers_cat_view<BufferSequence...> buffers_cat(BufferSequence const&... buffers) #else template<class B1, class... Bn> buffers_cat_view<B1, Bn...> buffers_cat(B1 const& b1, Bn const&... bn) #endif { static_assert( is_const_buffer_sequence<B1, Bn...>::value, "BufferSequence type requirements not met"); return buffers_cat_view<B1, Bn...>{b1, bn...}; } } // beast } // boost #include <boost/beast/core/impl/buffers_cat.hpp> #endif PK PP�[ag�U U core/tcp_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_TCP_STREAM_HPP #define BOOST_BEAST_CORE_TCP_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/basic_stream.hpp> #include <boost/beast/core/rate_policy.hpp> #include <boost/asio/executor.hpp> #include <boost/asio/ip/tcp.hpp> namespace boost { namespace beast { /** A TCP/IP stream socket with timeouts and a polymorphic executor. @see basic_stream */ using tcp_stream = basic_stream< net::ip::tcp, net::any_io_executor, unlimited_rate_policy>; } // beast } // boost #endif PK PP�[�� �s s core/buffers_range.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_RANGE_HPP #define BOOST_BEAST_BUFFERS_RANGE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/buffers_range_adaptor.hpp> namespace boost { namespace beast { /** Returns an iterable range representing a buffer sequence. This function returns an iterable range representing the passed buffer sequence. The values obtained when iterating the range will be `net::const_buffer`, unless the underlying buffer sequence is a <em>MutableBufferSequence</em>, in which case the value obtained when iterating will be a `net::mutable_buffer`. @par Example The following function returns the total number of bytes in the specified buffer sequence. A copy of the buffer sequence is maintained for the lifetime of the range object: @code template <class BufferSequence> std::size_t buffer_sequence_size (BufferSequence const& buffers) { std::size_t size = 0; for (auto const buffer : buffers_range (buffers)) size += buffer.size(); return size; } @endcode @param buffers The buffer sequence to adapt into a range. The range object returned from this function will contain a copy of the passed buffer sequence. @return An object of unspecified type which meets the requirements of <em>ConstBufferSequence</em>. If `buffers` is a mutable buffer sequence, the returned object will also meet the requirements of <em>MutableBufferSequence</em>. @see buffers_range_ref */ template<class BufferSequence> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else detail::buffers_range_adaptor<BufferSequence> #endif buffers_range(BufferSequence const& buffers) { static_assert( is_const_buffer_sequence<BufferSequence>::value, "BufferSequence type requirements not met"); return detail::buffers_range_adaptor< BufferSequence>(buffers); } /** Returns an iterable range representing a buffer sequence. This function returns an iterable range representing the passed buffer sequence. The values obtained when iterating the range will be `net::const_buffer`, unless the underlying buffer sequence is a <em>MutableBufferSequence</em>, in which case the value obtained when iterating will be a `net::mutable_buffer`. @par Example The following function returns the total number of bytes in the specified buffer sequence. A reference to the original buffers is maintained for the lifetime of the range object: @code template <class BufferSequence> std::size_t buffer_sequence_size_ref (BufferSequence const& buffers) { std::size_t size = 0; for (auto const buffer : buffers_range_ref (buffers)) size += buffer.size(); return size; } @endcode @param buffers The buffer sequence to adapt into a range. The range returned from this function will maintain a reference to these buffers. The application is responsible for ensuring that the lifetime of the referenced buffers extends until the range object is destroyed. @return An object of unspecified type which meets the requirements of <em>ConstBufferSequence</em>. If `buffers` is a mutable buffer sequence, the returned object will also meet the requirements of <em>MutableBufferSequence</em>. @see buffers_range */ template<class BufferSequence> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else detail::buffers_range_adaptor<BufferSequence const&> #endif buffers_range_ref(BufferSequence const& buffers) { static_assert( is_const_buffer_sequence<BufferSequence>::value, "BufferSequence type requirements not met"); return detail::buffers_range_adaptor< BufferSequence const&>(buffers); } /** @} */ } // beast } // boost #endif PK PP�[-x�@ @ core/stream_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STREAM_TRAITS_HPP #define BOOST_BEAST_STREAM_TRAITS_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/static_const.hpp> #include <boost/beast/core/detail/stream_traits.hpp> #include <boost/asio/basic_socket.hpp> namespace boost { namespace beast { /** A trait to determine the lowest layer type of a stack of stream layers. If `t.next_layer()` is well-defined for an object `t` of type `T`, then `lowest_layer_type<T>` will be an alias for `lowest_layer_type<decltype(t.next_layer())>`, otherwise it will be the type `std::remove_reference<T>`. @param T The type to determine the lowest layer type of. @return The type of the lowest layer. */ template<class T> #if BOOST_BEAST_DOXYGEN using lowest_layer_type = __see_below__; #else using lowest_layer_type = detail::lowest_layer_type<T>; #endif /** Return the lowest layer in a stack of stream layers. If `t.next_layer()` is well-defined, returns `get_lowest_layer(t.next_layer())`. Otherwise, it returns `t`. A stream layer is an object of class type which wraps another object through composition, and meets some or all of the named requirements of the wrapped type while optionally changing behavior. Examples of stream layers include `net::ssl::stream` or @ref beast::websocket::stream. The owner of a stream layer can interact directly with the wrapper, by passing it to stream algorithms. Or, the owner can obtain a reference to the wrapped object by calling `next_layer()` and accessing its members. This is necessary when it is desired to access functionality in the next layer which is not available in the wrapper. For example, @ref websocket::stream permits reading and writing, but in order to establish the underlying connection, members of the wrapped stream (such as `connect`) must be invoked directly. Usually the last object in the chain of composition is the concrete socket object (for example, a `net::basic_socket` or a class derived from it). The function @ref get_lowest_layer exists to easily obtain the concrete socket when it is desired to perform an action that is not prescribed by a named requirement, such as changing a socket option, cancelling all pending asynchronous I/O, or closing the socket (perhaps by using @ref close_socket). @par Example @code // Set non-blocking mode on a stack of stream // layers with a regular socket at the lowest layer. template <class Stream> void set_non_blocking (Stream& stream) { error_code ec; // A compile error here means your lowest layer is not the right type! get_lowest_layer(stream).non_blocking(true, ec); if(ec) throw system_error{ec}; } @endcode @param t The layer in a stack of layered objects for which the lowest layer is returned. @see close_socket, lowest_layer_type */ template<class T> lowest_layer_type<T>& get_lowest_layer(T& t) noexcept { return detail::get_lowest_layer_impl( t, detail::has_next_layer<T>{}); } //------------------------------------------------------------------------------ /** A trait to determine the return type of get_executor. This type alias will be the type of values returned by by calling member `get_exector` on an object of type `T&`. @param T The type to query @return The type of values returned from `get_executor`. */ // Workaround for ICE on gcc 4.8 #if BOOST_BEAST_DOXYGEN template<class T> using executor_type = __see_below__; #elif BOOST_WORKAROUND(BOOST_GCC, < 40900) template<class T> using executor_type = typename std::decay<T>::type::executor_type; #else template<class T> using executor_type = decltype(std::declval<T&>().get_executor()); #endif /** Determine if `T` has the `get_executor` member function. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` has the member function with the correct signature, else type will be `std::false_type`. @par Example Use with tag dispatching: @code template<class T> void maybe_hello(T const& t, std::true_type) { net::post( t.get_executor(), [] { std::cout << "Hello, world!" << std::endl; }); } template<class T> void maybe_hello(T const&, std::false_type) { // T does not have get_executor } template<class T> void maybe_hello(T const& t) { maybe_hello(t, has_get_executor<T>{}); } @endcode Use with `static_assert`: @code struct stream { using executor_type = net::io_context::executor_type; executor_type get_executor() noexcept; }; static_assert(has_get_executor<stream>::value, "Missing get_executor member"); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using has_get_executor = __see_below__; #else template<class T, class = void> struct has_get_executor : std::false_type {}; template<class T> struct has_get_executor<T, boost::void_t<decltype( std::declval<T&>().get_executor())>> : std::true_type {}; #endif //------------------------------------------------------------------------------ /** Determine if at type meets the requirements of <em>SyncReadStream</em>. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class SyncReadStream> void f(SyncReadStream& stream) { static_assert(is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class SyncReadStream> typename std::enable_if<is_sync_read_stream<SyncReadStream>::value>::type f(SyncReadStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_sync_read_stream = __see_below__; #else template<class T, class = void> struct is_sync_read_stream : std::false_type {}; template<class T> struct is_sync_read_stream<T, boost::void_t<decltype( std::declval<std::size_t&>() = std::declval<T&>().read_some( std::declval<detail::MutableBufferSequence>()), std::declval<std::size_t&>() = std::declval<T&>().read_some( std::declval<detail::MutableBufferSequence>(), std::declval<boost::system::error_code&>()) )>> : std::true_type {}; #endif /** Determine if `T` meets the requirements of <em>SyncWriteStream</em>. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class SyncReadStream> void f(SyncReadStream& stream) { static_assert(is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class SyncReadStream> typename std::enable_if<is_sync_read_stream<SyncReadStream>::value>::type f(SyncReadStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_sync_write_stream = __see_below__; #else template<class T, class = void> struct is_sync_write_stream : std::false_type {}; template<class T> struct is_sync_write_stream<T, boost::void_t<decltype( ( std::declval<std::size_t&>() = std::declval<T&>().write_some( std::declval<detail::ConstBufferSequence>())) ,std::declval<std::size_t&>() = std::declval<T&>().write_some( std::declval<detail::ConstBufferSequence>(), std::declval<boost::system::error_code&>()) )>> : std::true_type {}; #endif /** Determine if `T` meets the requirements of @b SyncStream. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class SyncStream> void f(SyncStream& stream) { static_assert(is_sync_stream<SyncStream>::value, "SyncStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class SyncStream> typename std::enable_if<is_sync_stream<SyncStream>::value>::type f(SyncStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_sync_stream = __see_below__; #else template<class T> using is_sync_stream = std::integral_constant<bool, is_sync_read_stream<T>::value && is_sync_write_stream<T>::value>; #endif //------------------------------------------------------------------------------ /** Determine if `T` meets the requirements of <em>AsyncReadStream</em>. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class AsyncReadStream> void f(AsyncReadStream& stream) { static_assert(is_async_read_stream<AsyncReadStream>::value, "AsyncReadStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class AsyncReadStream> typename std::enable_if<is_async_read_stream<AsyncReadStream>::value>::type f(AsyncReadStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_async_read_stream = __see_below__; #else template<class T, class = void> struct is_async_read_stream : std::false_type {}; template<class T> struct is_async_read_stream<T, boost::void_t<decltype( std::declval<T&>().async_read_some( std::declval<detail::MutableBufferSequence>(), std::declval<detail::ReadHandler>()) )>> : std::integral_constant<bool, has_get_executor<T>::value > {}; #endif /** Determine if `T` meets the requirements of <em>AsyncWriteStream</em>. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class AsyncWriteStream> void f(AsyncWriteStream& stream) { static_assert(is_async_write_stream<AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class AsyncWriteStream> typename std::enable_if<is_async_write_stream<AsyncWriteStream>::value>::type f(AsyncWriteStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_async_write_stream = __see_below__; #else template<class T, class = void> struct is_async_write_stream : std::false_type {}; template<class T> struct is_async_write_stream<T, boost::void_t<decltype( std::declval<T&>().async_write_some( std::declval<detail::ConstBufferSequence>(), std::declval<detail::WriteHandler>()) )>> : std::integral_constant<bool, has_get_executor<T>::value > {}; #endif /** Determine if `T` meets the requirements of @b AsyncStream. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class AsyncStream> void f(AsyncStream& stream) { static_assert(is_async_stream<AsyncStream>::value, "AsyncStream type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class AsyncStream> typename std::enable_if<is_async_stream<AsyncStream>::value>::type f(AsyncStream& stream); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_async_stream = __see_below__; #else template<class T> using is_async_stream = std::integral_constant<bool, is_async_read_stream<T>::value && is_async_write_stream<T>::value>; #endif //------------------------------------------------------------------------------ /** Default socket close function. This function is not meant to be called directly. Instead, it is called automatically when using @ref close_socket. To enable closure of user-defined types or classes derived from a particular user-defined type, this function should be overloaded in the corresponding namespace for the type in question. @see close_socket */ template< class Protocol, class Executor> void beast_close_socket( net::basic_socket< Protocol, Executor>& sock) { boost::system::error_code ec; sock.close(ec); } namespace detail { struct close_socket_impl { template<class T> void operator()(T& t) const { using beast::beast_close_socket; beast_close_socket(t); } }; } // detail /** Close a socket or socket-like object. This function attempts to close an object representing a socket. In this context, a socket is an object for which an unqualified call to the function `void beast_close_socket(Socket&)` is well-defined. The function `beast_close_socket` is a <em>customization point</em>, allowing user-defined types to provide an algorithm for performing the close operation by overloading this function for the type in question. Since the customization point is a function call, the normal rules for finding the correct overload are applied including the rules for argument-dependent lookup ("ADL"). This permits classes derived from a type for which a customization is provided to inherit the customization point. An overload for the networking class template `net::basic_socket` is provided, which implements the close algorithm for all socket-like objects (hence the name of this customization point). When used in conjunction with @ref get_lowest_layer, a generic algorithm operating on a layered stream can perform a closure of the underlying socket without knowing the exact list of concrete types. @par Example 1 The following generic function synchronously sends a message on the stream, then closes the socket. @code template <class WriteStream> void hello_and_close (WriteStream& stream) { net::write(stream, net::const_buffer("Hello, world!", 13)); close_socket(get_lowest_layer(stream)); } @endcode To enable closure of user defined types, it is necessary to provide an overload of the function `beast_close_socket` for the type. @par Example 2 The following code declares a user-defined type which contains a private socket, and provides an overload of the customization point which closes the private socket. @code class my_socket { net::ip::tcp::socket sock_; public: my_socket(net::io_context& ioc) : sock_(ioc) { } friend void beast_close_socket(my_socket& s) { error_code ec; s.sock_.close(ec); // ignore the error } }; @endcode @param sock The socket to close. If the customization point is not defined for the type of this object, or one of its base classes, then a compiler error results. @see beast_close_socket */ #if BOOST_BEAST_DOXYGEN template<class Socket> void close_socket(Socket& sock); #else BOOST_BEAST_INLINE_VARIABLE(close_socket, detail::close_socket_impl) #endif } // beast } // boost #endif PK PP�[�=�d]g ]g core/async_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_ASYNC_BASE_HPP #define BOOST_BEAST_CORE_ASYNC_BASE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/detail/allocator.hpp> #include <boost/beast/core/detail/async_base.hpp> #include <boost/beast/core/detail/work_guard.hpp> #include <boost/asio/associated_allocator.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/bind_executor.hpp> #include <boost/asio/handler_alloc_hook.hpp> #include <boost/asio/handler_continuation_hook.hpp> #include <boost/asio/handler_invoke_hook.hpp> #include <boost/asio/post.hpp> #include <boost/core/exchange.hpp> #include <boost/core/empty_value.hpp> #include <utility> namespace boost { namespace beast { /** Base class to assist writing composed operations. A function object submitted to intermediate initiating functions during a composed operation may derive from this type to inherit all of the boilerplate to forward the executor, allocator, and legacy customization points associated with the completion handler invoked at the end of the composed operation. The composed operation must be typical; that is, associated with one executor of an I/O object, and invoking a caller-provided completion handler when the operation is finished. Classes derived from @ref async_base will acquire these properties: @li Ownership of the final completion handler provided upon construction. @li If the final handler has an associated allocator, this allocator will be propagated to the composed operation subclass. Otherwise, the associated allocator will be the type specified in the allocator template parameter, or the default of `std::allocator<void>` if the parameter is omitted. @li If the final handler has an associated executor, then it will be used as the executor associated with the composed operation. Otherwise, the specified `Executor1` will be the type of executor associated with the composed operation. @li An instance of `net::executor_work_guard` for the instance of `Executor1` shall be maintained until either the final handler is invoked, or the operation base is destroyed, whichever comes first. @li Calls to the legacy customization points `asio_handler_invoke`, `asio_handler_allocate`, `asio_handler_deallocate`, and `asio_handler_is_continuation`, which use argument-dependent lookup, will be forwarded to the legacy customization points associated with the handler. @par Example The following code demonstrates how @ref async_base may be be used to assist authoring an asynchronous initiating function, by providing all of the boilerplate to manage the final completion handler in a way that maintains the allocator and executor associations: @code // Asynchronously read into a buffer until the buffer is full, or an error occurs template<class AsyncReadStream, class ReadHandler> typename net::async_result<ReadHandler, void(error_code, std::size_t)>::return_type async_read(AsyncReadStream& stream, net::mutable_buffer buffer, ReadHandler&& handler) { using handler_type = BOOST_ASIO_HANDLER_TYPE(ReadHandler, void(error_code, std::size_t)); using base_type = async_base<handler_type, typename AsyncReadStream::executor_type>; struct op : base_type { AsyncReadStream& stream_; net::mutable_buffer buffer_; std::size_t total_bytes_transferred_; op( AsyncReadStream& stream, net::mutable_buffer buffer, handler_type& handler) : base_type(std::move(handler), stream.get_executor()) , stream_(stream) , buffer_(buffer) , total_bytes_transferred_(0) { (*this)({}, 0, false); // start the operation } void operator()(error_code ec, std::size_t bytes_transferred, bool is_continuation = true) { // Adjust the count of bytes and advance our buffer total_bytes_transferred_ += bytes_transferred; buffer_ = buffer_ + bytes_transferred; // Keep reading until buffer is full or an error occurs if(! ec && buffer_.size() > 0) return stream_.async_read_some(buffer_, std::move(*this)); // Call the completion handler with the result. If `is_continuation` is // false, which happens on the first time through this function, then // `net::post` will be used to call the completion handler, otherwise // the completion handler will be invoked directly. this->complete(is_continuation, ec, total_bytes_transferred_); } }; net::async_completion<ReadHandler, void(error_code, std::size_t)> init{handler}; op(stream, buffer, init.completion_handler); return init.result.get(); } @endcode Data members of composed operations implemented as completion handlers do not have stable addresses, as the composed operation object is move constructed upon each call to an initiating function. For most operations this is not a problem. For complex operations requiring stable temporary storage, the class @ref stable_async_base is provided which offers additional functionality: @li The free function @ref allocate_stable may be used to allocate one or more temporary objects associated with the composed operation. @li Memory for stable temporary objects is allocated using the allocator associated with the composed operation. @li Stable temporary objects are automatically destroyed, and the memory freed using the associated allocator, either before the final completion handler is invoked (a Networking requirement) or when the composed operation is destroyed, whichever occurs first. @par Temporary Storage Example The following example demonstrates how a composed operation may store a temporary object. @code @endcode @tparam Handler The type of the completion handler to store. This type must meet the requirements of <em>CompletionHandler</em>. @tparam Executor1 The type of the executor used when the handler has no associated executor. An instance of this type must be provided upon construction. The implementation will maintain an executor work guard and a copy of this instance. @tparam Allocator The allocator type to use if the handler does not have an associated allocator. If this parameter is omitted, then `std::allocator<void>` will be used. If the specified allocator is not default constructible, an instance of the type must be provided upon construction. @see stable_async_base */ template< class Handler, class Executor1, class Allocator = std::allocator<void> > class async_base #if ! BOOST_BEAST_DOXYGEN : private boost::empty_value<Allocator> #endif { static_assert( net::is_executor<Executor1>::value || net::execution::is_executor<Executor1>::value, "Executor type requirements not met"); Handler h_; detail::select_work_guard_t<Executor1> wg1_; public: /** The type of executor associated with this object. If a class derived from @ref async_base is a completion handler, then the associated executor of the derived class will be this type. */ using executor_type = #if BOOST_BEAST_DOXYGEN __implementation_defined__; #else typename net::associated_executor< Handler, typename detail::select_work_guard_t<Executor1>::executor_type >::type; #endif private: virtual void before_invoke_hook() { } public: /** Constructor @param handler The final completion handler. The type of this object must meet the requirements of <em>CompletionHandler</em>. The implementation takes ownership of the handler by performing a decay-copy. @param ex1 The executor associated with the implied I/O object target of the operation. The implementation shall maintain an executor work guard for the lifetime of the operation, or until the final completion handler is invoked, whichever is shorter. @param alloc The allocator to be associated with objects derived from this class. If `Allocator` is default-constructible, this parameter is optional and may be omitted. */ #if BOOST_BEAST_DOXYGEN template<class Handler_> async_base( Handler&& handler, Executor1 const& ex1, Allocator const& alloc = Allocator()); #else template< class Handler_, class = typename std::enable_if< ! std::is_same<typename std::decay<Handler_>::type, async_base >::value>::type > async_base( Handler_&& handler, Executor1 const& ex1) : h_(std::forward<Handler_>(handler)) , wg1_(detail::make_work_guard(ex1)) { } template<class Handler_> async_base( Handler_&& handler, Executor1 const& ex1, Allocator const& alloc) : boost::empty_value<Allocator>( boost::empty_init_t{}, alloc) , h_(std::forward<Handler_>(handler)) , wg1_(ex1) { } #endif /// Move Constructor async_base(async_base&& other) = default; virtual ~async_base() = default; async_base(async_base const&) = delete; async_base& operator=(async_base const&) = delete; /** The type of allocator associated with this object. If a class derived from @ref async_base is a completion handler, then the associated allocator of the derived class will be this type. */ using allocator_type = net::associated_allocator_t<Handler, Allocator>; /** Returns the allocator associated with this object. If a class derived from @ref async_base is a completion handler, then the object returned from this function will be used as the associated allocator of the derived class. */ allocator_type get_allocator() const noexcept { return net::get_associated_allocator(h_, boost::empty_value<Allocator>::get()); } /** Returns the executor associated with this object. If a class derived from @ref async_base is a completion handler, then the object returned from this function will be used as the associated executor of the derived class. */ executor_type get_executor() const noexcept { return net::get_associated_executor( h_, wg1_.get_executor()); } /// Returns the handler associated with this object Handler const& handler() const noexcept { return h_; } /** Returns ownership of the handler associated with this object This function is used to transfer ownership of the handler to the caller, by move-construction. After the move, the only valid operations on the base object are move construction and destruction. */ Handler release_handler() { return std::move(h_); } /** Invoke the final completion handler, maybe using post. This invokes the final completion handler with the specified arguments forwarded. It is undefined to call either of @ref complete or @ref complete_now more than once. Any temporary objects allocated with @ref beast::allocate_stable will be automatically destroyed before the final completion handler is invoked. @param is_continuation If this value is `false`, then the handler will be submitted to the executor using `net::post`. Otherwise the handler will be invoked as if by calling @ref complete_now. @param args A list of optional parameters to invoke the handler with. The completion handler must be invocable with the parameter list, or else a compilation error will result. */ template<class... Args> void complete(bool is_continuation, Args&&... args) { this->before_invoke_hook(); if(! is_continuation) { auto const ex = get_executor(); net::post(net::bind_executor( ex, beast::bind_front_handler( std::move(h_), std::forward<Args>(args)...))); wg1_.reset(); } else { wg1_.reset(); h_(std::forward<Args>(args)...); } } /** Invoke the final completion handler. This invokes the final completion handler with the specified arguments forwarded. It is undefined to call either of @ref complete or @ref complete_now more than once. Any temporary objects allocated with @ref beast::allocate_stable will be automatically destroyed before the final completion handler is invoked. @param args A list of optional parameters to invoke the handler with. The completion handler must be invocable with the parameter list, or else a compilation error will result. */ template<class... Args> void complete_now(Args&&... args) { this->before_invoke_hook(); wg1_.reset(); h_(std::forward<Args>(args)...); } #if ! BOOST_BEAST_DOXYGEN Handler* get_legacy_handler_pointer() noexcept { return std::addressof(h_); } #endif }; //------------------------------------------------------------------------------ /** Base class to provide completion handler boilerplate for composed operations. A function object submitted to intermediate initiating functions during a composed operation may derive from this type to inherit all of the boilerplate to forward the executor, allocator, and legacy customization points associated with the completion handler invoked at the end of the composed operation. The composed operation must be typical; that is, associated with one executor of an I/O object, and invoking a caller-provided completion handler when the operation is finished. Classes derived from @ref async_base will acquire these properties: @li Ownership of the final completion handler provided upon construction. @li If the final handler has an associated allocator, this allocator will be propagated to the composed operation subclass. Otherwise, the associated allocator will be the type specified in the allocator template parameter, or the default of `std::allocator<void>` if the parameter is omitted. @li If the final handler has an associated executor, then it will be used as the executor associated with the composed operation. Otherwise, the specified `Executor1` will be the type of executor associated with the composed operation. @li An instance of `net::executor_work_guard` for the instance of `Executor1` shall be maintained until either the final handler is invoked, or the operation base is destroyed, whichever comes first. @li Calls to the legacy customization points `asio_handler_invoke`, `asio_handler_allocate`, `asio_handler_deallocate`, and `asio_handler_is_continuation`, which use argument-dependent lookup, will be forwarded to the legacy customization points associated with the handler. Data members of composed operations implemented as completion handlers do not have stable addresses, as the composed operation object is move constructed upon each call to an initiating function. For most operations this is not a problem. For complex operations requiring stable temporary storage, the class @ref stable_async_base is provided which offers additional functionality: @li The free function @ref beast::allocate_stable may be used to allocate one or more temporary objects associated with the composed operation. @li Memory for stable temporary objects is allocated using the allocator associated with the composed operation. @li Stable temporary objects are automatically destroyed, and the memory freed using the associated allocator, either before the final completion handler is invoked (a Networking requirement) or when the composed operation is destroyed, whichever occurs first. @par Example The following code demonstrates how @ref stable_async_base may be be used to assist authoring an asynchronous initiating function, by providing all of the boilerplate to manage the final completion handler in a way that maintains the allocator and executor associations. Furthermore, the operation shown allocates temporary memory using @ref beast::allocate_stable for the timer and message, whose addresses must not change between intermediate operations: @code // Asynchronously send a message multiple times, once per second template <class AsyncWriteStream, class T, class WriteHandler> auto async_write_messages( AsyncWriteStream& stream, T const& message, std::size_t repeat_count, WriteHandler&& handler) -> typename net::async_result< typename std::decay<WriteHandler>::type, void(error_code)>::return_type { using handler_type = typename net::async_completion<WriteHandler, void(error_code)>::completion_handler_type; using base_type = stable_async_base<handler_type, typename AsyncWriteStream::executor_type>; struct op : base_type, boost::asio::coroutine { // This object must have a stable address struct temporary_data { // Although std::string is in theory movable, most implementations // use a "small buffer optimization" which means that we might // be submitting a buffer to the write operation and then // moving the string, invalidating the buffer. To prevent // undefined behavior we store the string object itself at // a stable location. std::string const message; net::steady_timer timer; temporary_data(std::string message_, net::io_context& ctx) : message(std::move(message_)) , timer(ctx) { } }; AsyncWriteStream& stream_; std::size_t repeats_; temporary_data& data_; op(AsyncWriteStream& stream, std::size_t repeats, std::string message, handler_type& handler) : base_type(std::move(handler), stream.get_executor()) , stream_(stream) , repeats_(repeats) , data_(allocate_stable<temporary_data>(*this, std::move(message), stream.get_executor().context())) { (*this)(); // start the operation } // Including this file provides the keywords for macro-based coroutines #include <boost/asio/yield.hpp> void operator()(error_code ec = {}, std::size_t = 0) { reenter(*this) { // If repeats starts at 0 then we must complete immediately. But // we can't call the final handler from inside the initiating // function, so we post our intermediate handler first. We use // net::async_write with an empty buffer instead of calling // net::post to avoid an extra function template instantiation, to // keep compile times lower and make the resulting executable smaller. yield net::async_write(stream_, net::const_buffer{}, std::move(*this)); while(! ec && repeats_-- > 0) { // Send the string. We construct a `const_buffer` here to guarantee // that we do not create an additional function template instantation // of net::async_write, since we already instantiated it above for // net::const_buffer. yield net::async_write(stream_, net::const_buffer(net::buffer(data_.message)), std::move(*this)); if(ec) break; // Set the timer and wait data_.timer.expires_after(std::chrono::seconds(1)); yield data_.timer.async_wait(std::move(*this)); } } // The base class destroys the temporary data automatically, // before invoking the final completion handler this->complete_now(ec); } // Including this file undefines the macros for the coroutines #include <boost/asio/unyield.hpp> }; net::async_completion<WriteHandler, void(error_code)> completion(handler); std::ostringstream os; os << message; op(stream, repeat_count, os.str(), completion.completion_handler); return completion.result.get(); } @endcode @tparam Handler The type of the completion handler to store. This type must meet the requirements of <em>CompletionHandler</em>. @tparam Executor1 The type of the executor used when the handler has no associated executor. An instance of this type must be provided upon construction. The implementation will maintain an executor work guard and a copy of this instance. @tparam Allocator The allocator type to use if the handler does not have an associated allocator. If this parameter is omitted, then `std::allocator<void>` will be used. If the specified allocator is not default constructible, an instance of the type must be provided upon construction. @see allocate_stable, async_base */ template< class Handler, class Executor1, class Allocator = std::allocator<void> > class stable_async_base : public async_base< Handler, Executor1, Allocator> { detail::stable_base* list_ = nullptr; void before_invoke_hook() override { detail::stable_base::destroy_list(list_); } public: /** Constructor @param handler The final completion handler. The type of this object must meet the requirements of <em>CompletionHandler</em>. The implementation takes ownership of the handler by performing a decay-copy. @param ex1 The executor associated with the implied I/O object target of the operation. The implementation shall maintain an executor work guard for the lifetime of the operation, or until the final completion handler is invoked, whichever is shorter. @param alloc The allocator to be associated with objects derived from this class. If `Allocator` is default-constructible, this parameter is optional and may be omitted. */ #if BOOST_BEAST_DOXYGEN template<class Handler> stable_async_base( Handler&& handler, Executor1 const& ex1, Allocator const& alloc = Allocator()); #else template< class Handler_, class = typename std::enable_if< ! std::is_same<typename std::decay<Handler_>::type, stable_async_base >::value>::type > stable_async_base( Handler_&& handler, Executor1 const& ex1) : async_base< Handler, Executor1, Allocator>( std::forward<Handler_>(handler), ex1) { } template<class Handler_> stable_async_base( Handler_&& handler, Executor1 const& ex1, Allocator const& alloc) : async_base< Handler, Executor1, Allocator>( std::forward<Handler_>(handler), ex1, alloc) { } #endif /// Move Constructor stable_async_base(stable_async_base&& other) : async_base<Handler, Executor1, Allocator>( std::move(other)) , list_(boost::exchange(other.list_, nullptr)) { } /** Destructor If the completion handler was not invoked, then any state objects allocated with @ref allocate_stable will be destroyed here. */ ~stable_async_base() { detail::stable_base::destroy_list(list_); } /** Allocate a temporary object to hold operation state. The object will be destroyed just before the completion handler is invoked, or when the operation base is destroyed. */ template< class State, class Handler_, class Executor1_, class Allocator_, class... Args> friend State& allocate_stable( stable_async_base< Handler_, Executor1_, Allocator_>& base, Args&&... args); }; /** Allocate a temporary object to hold stable asynchronous operation state. The object will be destroyed just before the completion handler is invoked, or when the base is destroyed. @tparam State The type of object to allocate. @param base The helper to allocate from. @param args An optional list of parameters to forward to the constructor of the object being allocated. @see stable_async_base */ template< class State, class Handler, class Executor1, class Allocator, class... Args> State& allocate_stable( stable_async_base< Handler, Executor1, Allocator>& base, Args&&... args); } // beast } // boost #include <boost/beast/core/impl/async_base.hpp> #endif PK PP�[(D\b� � core/string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STRING_HPP #define BOOST_BEAST_STRING_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string_type.hpp> namespace boost { namespace beast { /** Returns `true` if two strings are equal, using a case-insensitive comparison. The case-comparison operation is defined only for low-ASCII characters. @param lhs The string on the left side of the equality @param rhs The string on the right side of the equality */ BOOST_BEAST_DECL bool iequals( beast::string_view lhs, beast::string_view rhs); /** A case-insensitive less predicate for strings. The case-comparison operation is defined only for low-ASCII characters. As of C++14, containers using this class as the `Compare` type will take part in heterogeneous lookup if the search term is implicitly convertible to @ref string_view. */ struct iless { BOOST_BEAST_DECL bool operator()( string_view lhs, string_view rhs) const; using is_transparent = void; }; /** A case-insensitive equality predicate for strings. The case-comparison operation is defined only for low-ASCII characters. As of C++14, containers using this class as the `Compare` type will take part in heterogeneous lookup if the search term is implicitly convertible to @ref string_view. */ struct iequal { bool operator()( string_view lhs, string_view rhs) const { return iequals(lhs, rhs); } using is_transparent = void; }; } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/string.ipp> #endif #endif PK PP�[<�XnY nY core/detect_ssl.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETECT_SSL_HPP #define BOOST_BEAST_CORE_DETECT_SSL_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/read_size.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/logic/tribool.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/coroutine.hpp> #include <type_traits> namespace boost { namespace beast { //------------------------------------------------------------------------------ // // Example: Detect TLS client_hello // // This is an example and also a public interface. It implements // an algorithm for determining if a "TLS client_hello" message // is received. It can be used to implement a listening port that // can handle both plain and TLS encrypted connections. // //------------------------------------------------------------------------------ //[example_core_detect_ssl_1 // By convention, the "detail" namespace means "not-public." // Identifiers in a detail namespace are not visible in the documentation, // and users should not directly use those identifiers in programs, otherwise // their program may break in the future. // // Using a detail namespace gives the library writer the freedom to change // the interface or behavior later, and maintain backward-compatibility. namespace detail { /** Return `true` if the buffer contains a TLS Protocol client_hello message. This function analyzes the bytes at the beginning of the buffer and compares it to a valid client_hello message. This is the message required to be sent by a client at the beginning of any TLS (encrypted communication) session, including when resuming a session. The return value will be: @li `true` if the contents of the buffer unambiguously define contain a client_hello message, @li `false` if the contents of the buffer cannot possibly be a valid client_hello message, or @li `boost::indeterminate` if the buffer contains an insufficient number of bytes to determine the result. In this case the caller should read more data from the relevant stream, append it to the buffers, and call this function again. @param buffers The buffer sequence to inspect. This type must meet the requirements of <em>ConstBufferSequence</em>. @return `boost::tribool` indicating whether the buffer contains a TLS client handshake, does not contain a handshake, or needs additional bytes to determine an outcome. @see <a href="https://tools.ietf.org/html/rfc2246#section-7.4">7.4. Handshake protocol</a> (RFC2246: The TLS Protocol) */ template <class ConstBufferSequence> boost::tribool is_tls_client_hello (ConstBufferSequence const& buffers); } // detail //] //[example_core_detect_ssl_2 namespace detail { template <class ConstBufferSequence> boost::tribool is_tls_client_hello (ConstBufferSequence const& buffers) { // Make sure buffers meets the requirements static_assert( net::is_const_buffer_sequence<ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); /* The first message on a TLS connection must be the client_hello, which is a type of handshake record, and it cannot be compressed or encrypted. A plaintext record has this format: 0 byte record_type // 0x16 = handshake 1 byte major // major protocol version 2 byte minor // minor protocol version 3-4 uint16 length // size of the payload 5 byte handshake_type // 0x01 = client_hello 6 uint24 length // size of the ClientHello 9 byte major // major protocol version 10 byte minor // minor protocol version 11 uint32 gmt_unix_time 15 byte random_bytes[28] ... */ // Flatten the input buffers into a single contiguous range // of bytes on the stack to make it easier to work with the data. unsigned char buf[9]; auto const n = net::buffer_copy( net::mutable_buffer(buf, sizeof(buf)), buffers); // Can't do much without any bytes if(n < 1) return boost::indeterminate; // Require the first byte to be 0x16, indicating a TLS handshake record if(buf[0] != 0x16) return false; // We need at least 5 bytes to know the record payload size if(n < 5) return boost::indeterminate; // Calculate the record payload size std::uint32_t const length = (buf[3] << 8) + buf[4]; // A ClientHello message payload is at least 34 bytes. // There can be multiple handshake messages in the same record. if(length < 34) return false; // We need at least 6 bytes to know the handshake type if(n < 6) return boost::indeterminate; // The handshake_type must be 0x01 == client_hello if(buf[5] != 0x01) return false; // We need at least 9 bytes to know the payload size if(n < 9) return boost::indeterminate; // Calculate the message payload size std::uint32_t const size = (buf[6] << 16) + (buf[7] << 8) + buf[8]; // The message payload can't be bigger than the enclosing record if(size + 4 > length) return false; // This can only be a TLS client_hello message return true; } } // detail //] //[example_core_detect_ssl_3 /** Detect a TLS client handshake on a stream. This function reads from a stream to determine if a client handshake message is being received. The call blocks until one of the following is true: @li A TLS client opening handshake is detected, @li The received data is invalid for a TLS client handshake, or @li An error occurs. The algorithm, known as a <em>composed operation</em>, is implemented in terms of calls to the next layer's `read_some` function. Bytes read from the stream will be stored in the passed dynamic buffer, which may be used to perform the TLS handshake if the detector returns true, or be otherwise consumed by the caller based on the expected protocol. @param stream The stream to read from. This type must meet the requirements of <em>SyncReadStream</em>. @param buffer The dynamic buffer to use. This type must meet the requirements of <em>DynamicBuffer</em>. @param ec Set to the error if any occurred. @return `true` if the buffer contains a TLS client handshake and no error occurred, otherwise `false`. */ template< class SyncReadStream, class DynamicBuffer> bool detect_ssl( SyncReadStream& stream, DynamicBuffer& buffer, error_code& ec) { namespace beast = boost::beast; // Make sure arguments meet the requirements static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); // Loop until an error occurs or we get a definitive answer for(;;) { // There could already be data in the buffer // so we do this first, before reading from the stream. auto const result = detail::is_tls_client_hello(buffer.data()); // If we got an answer, return it if(! boost::indeterminate(result)) { // A definite answer is a success ec = {}; return static_cast<bool>(result); } // Try to fill our buffer by reading from the stream. // The function read_size calculates a reasonable size for the // amount to read next, using existing capacity if possible to // avoid allocating memory, up to the limit of 1536 bytes which // is the size of a normal TCP frame. std::size_t const bytes_transferred = stream.read_some( buffer.prepare(beast::read_size(buffer, 1536)), ec); // Commit what we read into the buffer's input area. buffer.commit(bytes_transferred); // Check for an error if(ec) break; } // error return false; } //] //[example_core_detect_ssl_4 /** Detect a TLS/SSL handshake asynchronously on a stream. This function reads asynchronously from a stream to determine if a client handshake message is being received. This call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li A TLS client opening handshake is detected, @li The received data is invalid for a TLS client handshake, or @li An error occurs. The algorithm, known as a <em>composed asynchronous operation</em>, is implemented in terms of calls to the next layer's `async_read_some` function. The program must ensure that no other calls to `async_read_some` are performed until this operation completes. Bytes read from the stream will be stored in the passed dynamic buffer, which may be used to perform the TLS handshake if the detector returns true, or be otherwise consumed by the caller based on the expected protocol. @param stream The stream to read from. This type must meet the requirements of <em>AsyncReadStream</em>. @param buffer The dynamic buffer to use. This type must meet the requirements of <em>DynamicBuffer</em>. @param token The completion token used to determine the method used to provide the result of the asynchronous operation. If this is a completion handler, the implementation takes ownership of the handler by performing a decay-copy, and the equivalent function signature of the handler must be: @code void handler( error_code const& error, // Set to the error, if any bool result // The result of the detector ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class AsyncReadStream, class DynamicBuffer, class CompletionToken = net::default_completion_token_t<beast::executor_type<AsyncReadStream>> > #if BOOST_BEAST_DOXYGEN BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void(error_code, bool)) #else auto #endif async_detect_ssl( AsyncReadStream& stream, DynamicBuffer& buffer, CompletionToken&& token = net::default_completion_token_t< beast::executor_type<AsyncReadStream>>{}) -> typename net::async_result< typename std::decay<CompletionToken>::type, /*< `async_result` customizes the return value based on the completion token >*/ void(error_code, bool)>::return_type; /*< This is the signature for the completion handler >*/ //] //[example_core_detect_ssl_5 // These implementation details don't need to be public namespace detail { // The composed operation object template< class DetectHandler, class AsyncReadStream, class DynamicBuffer> class detect_ssl_op; // This is a function object which `net::async_initiate` can use to launch // our composed operation. This is a relatively new feature in networking // which allows the asynchronous operation to be "lazily" executed (meaning // that it is launched later). Users don't need to worry about this, but // authors of composed operations need to write it this way to get the // very best performance, for example when using Coroutines TS (`co_await`). struct run_detect_ssl_op { // The implementation of `net::async_initiate` captures the // arguments of the initiating function, and then calls this // function object later with the captured arguments in order // to launch the composed operation. All we need to do here // is take those arguments and construct our composed operation // object. // // `async_initiate` takes care of transforming the completion // token into the "real handler" which must have the correct // signature, in this case `void(error_code, boost::tri_bool)`. template< class DetectHandler, class AsyncReadStream, class DynamicBuffer> void operator()( DetectHandler&& h, AsyncReadStream* s, // references are passed as pointers DynamicBuffer* b) { detect_ssl_op< typename std::decay<DetectHandler>::type, AsyncReadStream, DynamicBuffer>( std::forward<DetectHandler>(h), *s, *b); } }; } // detail //] //[example_core_detect_ssl_6 // Here is the implementation of the asynchronous initiation function template< class AsyncReadStream, class DynamicBuffer, class CompletionToken> #if BOOST_BEAST_DOXYGEN BOOST_ASIO_INITFN_RESULT_TYPE(CompletionToken, void(error_code, bool)) #else auto #endif async_detect_ssl( AsyncReadStream& stream, DynamicBuffer& buffer, CompletionToken&& token) -> typename net::async_result< typename std::decay<CompletionToken>::type, void(error_code, bool)>::return_type { // Make sure arguments meet the type requirements static_assert( is_async_read_stream<AsyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); // The function `net::async_initate` uses customization points // to allow one asynchronous initiating function to work with // all sorts of notification systems, such as callbacks but also // fibers, futures, coroutines, and user-defined types. // // It works by capturing all of the arguments using perfect // forwarding, and then depending on the specialization of // `net::async_result` for the type of `CompletionToken`, // the `initiation` object will be invoked with the saved // parameters and the actual completion handler. Our // initiating object is `run_detect_ssl_op`. // // Non-const references need to be passed as pointers, // since we don't want a decay-copy. return net::async_initiate< CompletionToken, void(error_code, bool)>( detail::run_detect_ssl_op{}, token, &stream, // pass the reference by pointer &buffer); } //] //[example_core_detect_ssl_7 namespace detail { // Read from a stream, calling is_tls_client_hello on the data // data to determine if the TLS client handshake is present. // // This will be implemented using Asio's "stackless coroutines" // which are based on macros forming a switch statement. The // operation is derived from `coroutine` for this reason. // // The library type `async_base` takes care of all of the // boilerplate for writing composed operations, including: // // * Storing the user's completion handler // * Maintaining the work guard for the handler's associated executor // * Propagating the associated allocator of the handler // * Propagating the associated executor of the handler // * Deallocating temporary storage before invoking the handler // * Posting the handler to the executor on an immediate completion // // `async_base` needs to know the type of the handler, as well // as the executor of the I/O object being used. The metafunction // `executor_type` returns the type of executor used by an // I/O object. // template< class DetectHandler, class AsyncReadStream, class DynamicBuffer> class detect_ssl_op : public boost::asio::coroutine , public async_base< DetectHandler, executor_type<AsyncReadStream>> { // This composed operation has trivial state, // so it is just kept inside the class and can // be cheaply copied as needed by the implementation. AsyncReadStream& stream_; // The callers buffer is used to hold all received data DynamicBuffer& buffer_; // We're going to need this in case we have to post the handler error_code ec_; boost::tribool result_ = false; public: // Completion handlers must be MoveConstructible. detect_ssl_op(detect_ssl_op&&) = default; // Construct the operation. The handler is deduced through // the template type `DetectHandler_`, this lets the same constructor // work properly for both lvalues and rvalues. // template<class DetectHandler_> detect_ssl_op( DetectHandler_&& handler, AsyncReadStream& stream, DynamicBuffer& buffer) : beast::async_base< DetectHandler, beast::executor_type<AsyncReadStream>>( std::forward<DetectHandler_>(handler), stream.get_executor()) , stream_(stream) , buffer_(buffer) { // This starts the operation. We pass `false` to tell the // algorithm that it needs to use net::post if it wants to // complete immediately. This is required by Networking, // as initiating functions are not allowed to invoke the // completion handler on the caller's thread before // returning. (*this)({}, 0, false); } // Our main entry point. This will get called as our // intermediate operations complete. Definition below. // // The parameter `cont` indicates if we are being called subsequently // from the original invocation // void operator()( error_code ec, std::size_t bytes_transferred, bool cont = true); }; } // detail //] //[example_core_detect_ssl_8 namespace detail { // This example uses the Asio's stackless "fauxroutines", implemented // using a macro-based solution. It makes the code easier to write and // easier to read. This include file defines the necessary macros and types. #include <boost/asio/yield.hpp> // detect_ssl_op is callable with the signature void(error_code, bytes_transferred), // allowing `*this` to be used as a ReadHandler // template< class AsyncStream, class DynamicBuffer, class Handler> void detect_ssl_op<AsyncStream, DynamicBuffer, Handler>:: operator()(error_code ec, std::size_t bytes_transferred, bool cont) { namespace beast = boost::beast; // This introduces the scope of the stackless coroutine reenter(*this) { // Loop until an error occurs or we get a definitive answer for(;;) { // There could already be a hello in the buffer so check first result_ = is_tls_client_hello(buffer_.data()); // If we got an answer, then the operation is complete if(! boost::indeterminate(result_)) break; // Try to fill our buffer by reading from the stream. // The function read_size calculates a reasonable size for the // amount to read next, using existing capacity if possible to // avoid allocating memory, up to the limit of 1536 bytes which // is the size of a normal TCP frame. // // `async_read_some` expects a ReadHandler as the completion // handler. The signature of a read handler is void(error_code, size_t), // and this function matches that signature (the `cont` parameter has // a default of true). We pass `std::move(*this)` as the completion // handler for the read operation. This transfers ownership of this // entire state machine back into the `async_read_some` operation. // Care must be taken with this idiom, to ensure that parameters // passed to the initiating function which could be invalidated // by the move, are first moved to the stack before calling the // initiating function. yield { // This macro facilitates asynchrnous handler tracking and // debugging when the preprocessor macro // BOOST_ASIO_CUSTOM_HANDLER_TRACKING is defined. BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "async_detect_ssl")); stream_.async_read_some(buffer_.prepare( read_size(buffer_, 1536)), std::move(*this)); } // Commit what we read into the buffer's input area. buffer_.commit(bytes_transferred); // Check for an error if(ec) break; } // If `cont` is true, the handler will be invoked directly. // // Otherwise, the handler cannot be invoked directly, because // initiating functions are not allowed to call the handler // before returning. Instead, the handler must be posted to // the I/O context. We issue a zero-byte read using the same // type of buffers used in the ordinary read above, to prevent // the compiler from creating an extra instantiation of the // function template. This reduces compile times and the size // of the program executable. if(! cont) { // Save the error, otherwise it will be overwritten with // a successful error code when this read completes // immediately. ec_ = ec; // Zero-byte reads and writes are guaranteed to complete // immediately with succcess. The type of buffers and the // type of handler passed here need to exactly match the types // used in the call to async_read_some above, to avoid // instantiating another version of the function template. yield { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "async_detect_ssl")); stream_.async_read_some(buffer_.prepare(0), std::move(*this)); } // Restore the saved error code ec = ec_; } // Invoke the final handler. // At this point, we are guaranteed that the original initiating // function is no longer on our stack frame. this->complete_now(ec, static_cast<bool>(result_)); } } // Including this file undefines the macros used by the stackless fauxroutines. #include <boost/asio/unyield.hpp> } // detail //] } // beast } // boost #endif PK PP�[tx��� � core/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_ERROR_HPP #define BOOST_BEAST_ERROR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/system/error_code.hpp> #include <boost/system/system_error.hpp> namespace boost { namespace beast { /// The type of error code used by the library using error_code = boost::system::error_code; /// The type of system error thrown by the library using system_error = boost::system::system_error; /// The type of error category used by the library using error_category = boost::system::error_category; /// A function to return the generic error category used by the library #if BOOST_BEAST_DOXYGEN error_category const& generic_category(); #else using boost::system::generic_category; #endif /// A function to return the system error category used by the library #if BOOST_BEAST_DOXYGEN error_category const& system_category(); #else using boost::system::system_category; #endif /// The type of error condition used by the library using error_condition = boost::system::error_condition; /// The set of constants used for cross-platform error codes #if BOOST_BEAST_DOXYGEN enum errc{}; #else namespace errc = boost::system::errc; #endif //------------------------------------------------------------------------------ /// Error codes returned from library operations enum class error { /** The socket was closed due to a timeout This error indicates that a socket was closed due to a a timeout detected during an operation. Error codes with this value will compare equal to @ref condition::timeout. */ timeout = 1 }; /// Error conditions corresponding to sets of library error codes. enum class condition { /** The operation timed out This error indicates that an operation took took too long. */ timeout = 1 }; } // beast } // boost #include <boost/beast/core/impl/error.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/error.ipp> #endif #endif PK PP�[ܕ�]� � core/buffers_suffix.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_SUFFIX_HPP #define BOOST_BEAST_BUFFERS_SUFFIX_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/optional.hpp> #include <cstdint> #include <iterator> #include <utility> namespace boost { namespace beast { /** Adaptor to progressively trim the front of a <em>BufferSequence</em>. This adaptor wraps a buffer sequence to create a new sequence which may be incrementally consumed. Bytes consumed are removed from the front of the buffer. The underlying memory is not changed, instead the adaptor efficiently iterates through a subset of the buffers wrapped. The wrapped buffer is not modified, a copy is made instead. Ownership of the underlying memory is not transferred, the application is still responsible for managing its lifetime. @tparam BufferSequence The buffer sequence to wrap. @par Example This function writes the entire contents of a buffer sequence to the specified stream. @code template<class SyncWriteStream, class ConstBufferSequence> void send(SyncWriteStream& stream, ConstBufferSequence const& buffers) { buffers_suffix<ConstBufferSequence> bs{buffers}; while(buffer_bytes(bs) > 0) bs.consume(stream.write_some(bs)); } @endcode */ template<class BufferSequence> class buffers_suffix { using iter_type = buffers_iterator_type<BufferSequence>; BufferSequence bs_; iter_type begin_{}; std::size_t skip_ = 0; template<class Deduced> buffers_suffix(Deduced&& other, std::size_t dist) : bs_(std::forward<Deduced>(other).bs_) , begin_(std::next( net::buffer_sequence_begin(bs_), dist)) , skip_(other.skip_) { } public: /** The type for each element in the list of buffers. If <em>BufferSequence</em> meets the requirements of <em>MutableBufferSequence</em>, then this type will be `net::mutable_buffer`, otherwise this type will be `net::const_buffer`. */ #if BOOST_BEAST_DOXYGEN using value_type = __see_below__; #else using value_type = buffers_type<BufferSequence>; #endif #if BOOST_BEAST_DOXYGEN /// A bidirectional iterator type that may be used to read elements. using const_iterator = __implementation_defined__; #else class const_iterator; #endif /// Constructor buffers_suffix(); /// Copy Constructor buffers_suffix(buffers_suffix const&); /** Constructor A copy of the buffer sequence is made. Ownership of the underlying memory is not transferred or copied. */ explicit buffers_suffix(BufferSequence const& buffers); /** Constructor This constructs the buffer sequence in-place from a list of arguments. @param args Arguments forwarded to the buffers constructor. */ template<class... Args> explicit buffers_suffix(boost::in_place_init_t, Args&&... args); /// Copy Assignment buffers_suffix& operator=(buffers_suffix const&); /// Get a bidirectional iterator to the first element. const_iterator begin() const; /// Get a bidirectional iterator to one past the last element. const_iterator end() const; /** Remove bytes from the beginning of the sequence. @param amount The number of bytes to remove. If this is larger than the number of bytes remaining, all the bytes remaining are removed. */ void consume(std::size_t amount); }; } // beast } // boost #include <boost/beast/core/impl/buffers_suffix.hpp> #endif PK PP�[kQv} } core/buffer_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFER_TRAITS_HPP #define BOOST_BEAST_BUFFER_TRAITS_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/buffer_traits.hpp> #include <boost/beast/core/detail/static_const.hpp> #include <boost/asio/buffer.hpp> #include <boost/config/workaround.hpp> #include <boost/mp11/function.hpp> #include <type_traits> namespace boost { namespace beast { /** Determine if a list of types satisfy the <em>ConstBufferSequence</em> requirements. This metafunction is used to determine if all of the specified types meet the requirements for constant buffer sequences. This type alias will be `std::true_type` if each specified type meets the requirements, otherwise, this type alias will be `std::false_type`. @tparam BufferSequence A list of zero or more types to check. If this list is empty, the resulting type alias will be `std::true_type`. */ template<class... BufferSequence> #if BOOST_BEAST_DOXYGEN using is_const_buffer_sequence = __see_below__; #else using is_const_buffer_sequence = mp11::mp_all< net::is_const_buffer_sequence< typename std::decay<BufferSequence>::type>...>; #endif /** Determine if a list of types satisfy the <em>MutableBufferSequence</em> requirements. This metafunction is used to determine if all of the specified types meet the requirements for mutable buffer sequences. This type alias will be `std::true_type` if each specified type meets the requirements, otherwise, this type alias will be `std::false_type`. @tparam BufferSequence A list of zero or more types to check. If this list is empty, the resulting type alias will be `std::true_type`. */ template<class... BufferSequence> #if BOOST_BEAST_DOXYGEN using is_mutable_buffer_sequence = __see_below__; #else using is_mutable_buffer_sequence = mp11::mp_all< net::is_mutable_buffer_sequence< typename std::decay<BufferSequence>::type>...>; #endif /** Type alias for the underlying buffer type of a list of buffer sequence types. This metafunction is used to determine the underlying buffer type for a list of buffer sequence. The equivalent type of the alias will vary depending on the template type argument: @li If every type in the list is a <em>MutableBufferSequence</em>, the resulting type alias will be `net::mutable_buffer`, otherwise @li The resulting type alias will be `net::const_buffer`. @par Example The following code returns the first buffer in a buffer sequence, or generates a compilation error if the argument is not a buffer sequence: @code template <class BufferSequence> buffers_type <BufferSequence> buffers_front (BufferSequence const& buffers) { static_assert( net::is_const_buffer_sequence<BufferSequence>::value, "BufferSequence type requirements not met"); auto const first = net::buffer_sequence_begin (buffers); if (first == net::buffer_sequence_end (buffers)) return {}; return *first; } @endcode @tparam BufferSequence A list of zero or more types to check. If this list is empty, the resulting type alias will be `net::mutable_buffer`. */ template<class... BufferSequence> #if BOOST_BEAST_DOXYGEN using buffers_type = __see_below__; #else using buffers_type = typename std::conditional< is_mutable_buffer_sequence<BufferSequence...>::value, net::mutable_buffer, net::const_buffer>::type; #endif /** Type alias for the iterator type of a buffer sequence type. This metafunction is used to determine the type of iterator used by a particular buffer sequence. @tparam T The buffer sequence type to use. The resulting type alias will be equal to the iterator type used by the buffer sequence. */ template <class BufferSequence> #if BOOST_BEAST_DOXYGEN using buffers_iterator_type = __see_below__; #elif BOOST_WORKAROUND(BOOST_MSVC, < 1910) using buffers_iterator_type = typename detail::buffers_iterator_type_helper< typename std::decay<BufferSequence>::type>::type; #else using buffers_iterator_type = decltype(net::buffer_sequence_begin( std::declval<BufferSequence const&>())); #endif /** Return the total number of bytes in a buffer or buffer sequence This function returns the total number of bytes in a buffer, buffer sequence, or object convertible to a buffer. Specifically it may be passed: @li A <em>ConstBufferSequence</em> or <em>MutableBufferSequence</em> @li A `net::const_buffer` or `net::mutable_buffer` @li An object convertible to `net::const_buffer` This function is designed as an easier-to-use replacement for `net::buffer_size`. It recognizes customization points found through argument-dependent lookup. The call `beast::buffer_bytes(b)` is equivalent to performing: @code using net::buffer_size; return buffer_size(b); @endcode In addition this handles types which are convertible to `net::const_buffer`; these are not handled by `net::buffer_size`. @param buffers The buffer or buffer sequence to calculate the size of. @return The total number of bytes in the buffer or sequence. */ #if BOOST_BEAST_DOXYGEN template<class BufferSequence> std::size_t buffer_bytes(BufferSequence const& buffers); #else BOOST_BEAST_INLINE_VARIABLE(buffer_bytes, detail::buffer_bytes_impl) #endif } // beast } // boost #endif PK PP�[�P��� � core/buffers_to_string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_TO_STRING_HPP #define BOOST_BEAST_BUFFERS_TO_STRING_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/asio/buffer.hpp> #include <string> namespace boost { namespace beast { /** Return a string representing the contents of a buffer sequence. This function returns a string representing an entire buffer sequence. Nulls and unprintable characters in the buffer sequence are inserted to the resulting string as-is. No character conversions are performed. @param buffers The buffer sequence to convert @par Example This function writes a buffer sequence converted to a string to `std::cout`. @code template<class ConstBufferSequence> void print(ConstBufferSequence const& buffers) { std::cout << buffers_to_string(buffers) << std::endl; } @endcode */ template<class ConstBufferSequence> std::string buffers_to_string(ConstBufferSequence const& buffers) { static_assert( net::is_const_buffer_sequence<ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); std::string result; result.reserve(buffer_bytes(buffers)); for(auto const buffer : buffers_range_ref(buffers)) result.append(static_cast<char const*>( buffer.data()), buffer.size()); return result; } } // beast } // boost #endif PK PP�[݊��D D core/string_type.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STRING_TYPE_HPP #define BOOST_BEAST_STRING_TYPE_HPP #include <boost/beast/core/detail/config.hpp> #if defined(BOOST_BEAST_USE_STD_STRING_VIEW) #include <string_view> #else #include <boost/utility/string_view.hpp> #endif namespace boost { namespace beast { #if BOOST_BEAST_DOXYGEN || ! defined(BOOST_BEAST_USE_STD_STRING_VIEW) /// The type of string view used by the library using string_view = boost::string_view; /// The type of `basic_string_view` used by the library template<class CharT, class Traits> using basic_string_view = boost::basic_string_view<CharT, Traits>; #else using string_view = std::string_view; template<class CharT, class Traits> using basic_string_view = std::basic_string_view<CharT, Traits>; #endif } // beast } // boost #endif PK PP�[�b��" " core/flat_static_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_FLAT_STATIC_BUFFER_HPP #define BOOST_BEAST_FLAT_STATIC_BUFFER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/asio/buffer.hpp> #include <algorithm> #include <cstddef> #include <cstring> namespace boost { namespace beast { /** A dynamic buffer using a fixed size internal buffer. A dynamic buffer encapsulates memory storage that may be automatically resized as required, where the memory is divided into two regions: readable bytes followed by writable bytes. These memory regions are internal to the dynamic buffer, but direct access to the elements is provided to permit them to be efficiently used with I/O operations. Objects of this type meet the requirements of <em>DynamicBuffer</em> and have the following additional properties: @li A mutable buffer sequence representing the readable bytes is returned by @ref data when `this` is non-const. @li Buffer sequences representing the readable and writable bytes, returned by @ref data and @ref prepare, will have length one. @li Ownership of the underlying storage belongs to the derived class. @note Variables are usually declared using the template class @ref flat_static_buffer; however, to reduce the number of template instantiations, objects should be passed `flat_static_buffer_base&`. @see flat_static_buffer */ class flat_static_buffer_base { char* begin_; char* in_; char* out_; char* last_; char* end_; flat_static_buffer_base( flat_static_buffer_base const& other) = delete; flat_static_buffer_base& operator=( flat_static_buffer_base const&) = delete; public: /** Constructor This creates a dynamic buffer using the provided storage area. @param p A pointer to valid storage of at least `n` bytes. @param n The number of valid bytes pointed to by `p`. */ flat_static_buffer_base( void* p, std::size_t n) noexcept { reset(p, n); } /** Clear the readable and writable bytes to zero. This function causes the readable and writable bytes to become empty. The capacity is not changed. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void clear() noexcept; //-------------------------------------------------------------------------- /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = net::const_buffer; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = net::mutable_buffer; /// Returns the number of readable bytes. std::size_t size() const noexcept { return out_ - in_; } /// Return the maximum number of bytes, both readable and writable, that can ever be held. std::size_t max_size() const noexcept { return dist(begin_, end_); } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept { return max_size(); } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type data() const noexcept { return {in_, dist(in_, out_)}; } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type cdata() const noexcept { return data(); } /// Returns a mutable buffer sequence representing the readable bytes mutable_buffers_type data() noexcept { return {in_, dist(in_, out_)}; } /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds `max_size()`. @esafe Strong guarantee. */ BOOST_BEAST_DECL mutable_buffers_type prepare(std::size_t n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ void commit(std::size_t n) noexcept { out_ += (std::min<std::size_t>)(n, last_ - out_); } /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void consume(std::size_t n) noexcept; protected: /** Constructor The buffer will be in an undefined state. It is necessary for the derived class to call @ref reset with a pointer and size in order to initialize the object. */ flat_static_buffer_base() = default; /** Reset the pointed-to buffer. This function resets the internal state to the buffer provided. All input and output sequences are invalidated. This function allows the derived class to construct its members before initializing the static buffer. @param p A pointer to valid storage of at least `n` bytes. @param n The number of valid bytes pointed to by `p`. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void reset(void* p, std::size_t n) noexcept; private: static std::size_t dist(char const* first, char const* last) noexcept { return static_cast<std::size_t>(last - first); } }; //------------------------------------------------------------------------------ /** A <em>DynamicBuffer</em> with a fixed size internal buffer. Buffer sequences returned by @ref data and @ref prepare will always be of length one. This implements a dynamic buffer using no memory allocations. @tparam N The number of bytes in the internal buffer. @note To reduce the number of template instantiations when passing objects of this type in a deduced context, the signature of the receiving function should use @ref flat_static_buffer_base instead. @see flat_static_buffer_base */ template<std::size_t N> class flat_static_buffer : public flat_static_buffer_base { char buf_[N]; public: /// Constructor flat_static_buffer(flat_static_buffer const&); /// Constructor flat_static_buffer() : flat_static_buffer_base(buf_, N) { } /// Assignment flat_static_buffer& operator=(flat_static_buffer const&); /// Returns the @ref flat_static_buffer_base portion of this object flat_static_buffer_base& base() { return *this; } /// Returns the @ref flat_static_buffer_base portion of this object flat_static_buffer_base const& base() const { return *this; } /// Return the maximum sum of the input and output sequence sizes. std::size_t constexpr max_size() const { return N; } /// Return the maximum sum of input and output sizes that can be held without an allocation. std::size_t constexpr capacity() const { return N; } }; } // beast } // boost #include <boost/beast/core/impl/flat_static_buffer.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/flat_static_buffer.ipp> #endif #endifPK PP�[��9� � core/make_printable.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_MAKE_PRINTABLE_HPP #define BOOST_BEAST_MAKE_PRINTABLE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/asio/buffer.hpp> #include <ostream> namespace boost { namespace beast { namespace detail { template<class Buffers> class make_printable_adaptor { Buffers b_; public: explicit make_printable_adaptor(Buffers const& b) : b_(b) { } template<class B> friend std::ostream& operator<<(std::ostream& os, make_printable_adaptor<B> const& v); }; template<class Buffers> std::ostream& operator<<(std::ostream& os, make_printable_adaptor<Buffers> const& v) { for( auto it = net::buffer_sequence_begin(v.b_), end = net::buffer_sequence_end(v.b_); it != end; ++it) { net::const_buffer cb = *it; os.write(static_cast<char const*>( cb.data()), cb.size()); } return os; } } // detail /** Helper to permit a buffer sequence to be printed to a std::ostream This function is used to wrap a buffer sequence to allow it to be interpreted as characters and written to a `std::ostream` such as `std::cout`. No character translation is performed; unprintable and null characters will be transferred as-is to the output stream. @par Example This function prints the size and contents of a buffer sequence to standard output: @code template <class ConstBufferSequence> void print (ConstBufferSequence const& buffers) { std::cout << "Buffer size: " << buffer_bytes(buffers) << " bytes\n" "Buffer data: '" << make_printable(buffers) << "'\n"; } @endcode @param buffers An object meeting the requirements of <em>ConstBufferSequence</em> to be streamed. The implementation will make a copy of this object. Ownership of the underlying memory is not transferred, the application is still responsible for managing its lifetime. */ template<class ConstBufferSequence> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else detail::make_printable_adaptor<ConstBufferSequence> #endif make_printable(ConstBufferSequence const& buffers) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); return detail::make_printable_adaptor< ConstBufferSequence>{buffers}; } } // beast } // boost #endif PK PP�[�h�pC! C! core/static_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STATIC_BUFFER_HPP #define BOOST_BEAST_STATIC_BUFFER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/buffers_pair.hpp> #include <boost/asio/buffer.hpp> #include <cstddef> namespace boost { namespace beast { /** A dynamic buffer providing a fixed size, circular buffer. A dynamic buffer encapsulates memory storage that may be automatically resized as required, where the memory is divided into two regions: readable bytes followed by writable bytes. These memory regions are internal to the dynamic buffer, but direct access to the elements is provided to permit them to be efficiently used with I/O operations. Objects of this type meet the requirements of <em>DynamicBuffer</em> and have the following additional properties: @li A mutable buffer sequence representing the readable bytes is returned by @ref data when `this` is non-const. @li Buffer sequences representing the readable and writable bytes, returned by @ref data and @ref prepare, may have length up to two. @li All operations execute in constant time. @li Ownership of the underlying storage belongs to the derived class. @note Variables are usually declared using the template class @ref static_buffer; however, to reduce the number of template instantiations, objects should be passed `static_buffer_base&`. @see static_buffer */ class static_buffer_base { char* begin_; std::size_t in_off_ = 0; std::size_t in_size_ = 0; std::size_t out_size_ = 0; std::size_t capacity_; static_buffer_base(static_buffer_base const& other) = delete; static_buffer_base& operator=(static_buffer_base const&) = delete; public: /** Constructor This creates a dynamic buffer using the provided storage area. @param p A pointer to valid storage of at least `n` bytes. @param size The number of valid bytes pointed to by `p`. */ BOOST_BEAST_DECL static_buffer_base(void* p, std::size_t size) noexcept; /** Clear the readable and writable bytes to zero. This function causes the readable and writable bytes to become empty. The capacity is not changed. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void clear() noexcept; //-------------------------------------------------------------------------- #if BOOST_BEAST_DOXYGEN /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = __implementation_defined__; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = __implementation_defined__; #else using const_buffers_type = detail::buffers_pair<false>; using mutable_buffers_type = detail::buffers_pair<true>; #endif /// Returns the number of readable bytes. std::size_t size() const noexcept { return in_size_; } /// Return the maximum number of bytes, both readable and writable, that can ever be held. std::size_t max_size() const noexcept { return capacity_; } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept { return capacity_; } /// Returns a constant buffer sequence representing the readable bytes BOOST_BEAST_DECL const_buffers_type data() const noexcept; /// Returns a constant buffer sequence representing the readable bytes const_buffers_type cdata() const noexcept { return data(); } /// Returns a mutable buffer sequence representing the readable bytes BOOST_BEAST_DECL mutable_buffers_type data() noexcept; /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. Memory may be reallocated as needed. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds `max_size()`. @esafe Strong guarantee. */ BOOST_BEAST_DECL mutable_buffers_type prepare(std::size_t n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void commit(std::size_t n) noexcept; /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ BOOST_BEAST_DECL void consume(std::size_t n) noexcept; }; //------------------------------------------------------------------------------ /** A dynamic buffer providing a fixed size, circular buffer. A dynamic buffer encapsulates memory storage that may be automatically resized as required, where the memory is divided into two regions: readable bytes followed by writable bytes. These memory regions are internal to the dynamic buffer, but direct access to the elements is provided to permit them to be efficiently used with I/O operations. Objects of this type meet the requirements of <em>DynamicBuffer</em> and have the following additional properties: @li A mutable buffer sequence representing the readable bytes is returned by @ref data when `this` is non-const. @li Buffer sequences representing the readable and writable bytes, returned by @ref data and @ref prepare, may have length up to two. @li All operations execute in constant time. @tparam N The number of bytes in the internal buffer. @note To reduce the number of template instantiations when passing objects of this type in a deduced context, the signature of the receiving function should use @ref static_buffer_base instead. @see static_buffer_base */ template<std::size_t N> class static_buffer : public static_buffer_base { char buf_[N]; public: /// Constructor static_buffer() noexcept : static_buffer_base(buf_, N) { } /// Constructor static_buffer(static_buffer const&) noexcept; /// Assignment static_buffer& operator=(static_buffer const&) noexcept; /// Returns the @ref static_buffer_base portion of this object static_buffer_base& base() noexcept { return *this; } /// Returns the @ref static_buffer_base portion of this object static_buffer_base const& base() const noexcept { return *this; } /// Return the maximum sum of the input and output sequence sizes. std::size_t constexpr max_size() const noexcept { return N; } /// Return the maximum sum of input and output sizes that can be held without an allocation. std::size_t constexpr capacity() const noexcept { return N; } }; } // beast } // boost #include <boost/beast/core/impl/static_buffer.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/static_buffer.ipp> #endif #endif PK PP�[�9��! ! core/detail/buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_BUFFER_HPP #define BOOST_BEAST_CORE_DETAIL_BUFFER_HPP #include <boost/beast/core/error.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> #include <stdexcept> namespace boost { namespace beast { namespace detail { template< class DynamicBuffer, class ErrorValue> auto dynamic_buffer_prepare_noexcept( DynamicBuffer& buffer, std::size_t size, error_code& ec, ErrorValue ev) -> boost::optional<typename DynamicBuffer::mutable_buffers_type> { if(buffer.max_size() - buffer.size() < size) { // length error ec = ev; return boost::none; } boost::optional<typename DynamicBuffer::mutable_buffers_type> result; result.emplace(buffer.prepare(size)); ec = {}; return result; } template< class DynamicBuffer, class ErrorValue> auto dynamic_buffer_prepare( DynamicBuffer& buffer, std::size_t size, error_code& ec, ErrorValue ev) -> boost::optional<typename DynamicBuffer::mutable_buffers_type> { #ifndef BOOST_NO_EXCEPTIONS try { boost::optional<typename DynamicBuffer::mutable_buffers_type> result; result.emplace(buffer.prepare(size)); ec = {}; return result; } catch(std::length_error const&) { ec = ev; } return boost::none; #else return dynamic_buffer_prepare_noexcept( buffer, size, ec, ev); #endif } } // detail } // beast } // boost #endif PK PP�[R�꒱ � core/detail/allocator.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_ALLOCATOR_HPP #define BOOST_BEAST_DETAIL_ALLOCATOR_HPP #include <boost/config.hpp> #ifdef BOOST_NO_CXX11_ALLOCATOR #include <boost/container/allocator_traits.hpp> #else #include <memory> #endif namespace boost { namespace beast { namespace detail { // This is a workaround for allocator_traits // implementations which falsely claim C++11 // compatibility. #ifdef BOOST_NO_CXX11_ALLOCATOR template<class Alloc> using allocator_traits = boost::container::allocator_traits<Alloc>; #else template<class Alloc> using allocator_traits = std::allocator_traits<Alloc>; #endif } // detail } // beast } // boost #endif PK PP�[`�� � core/detail/type_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_TYPE_TRAITS_HPP #define BOOST_BEAST_DETAIL_TYPE_TRAITS_HPP #include <boost/type_traits/make_void.hpp> #include <type_traits> #include <new> namespace boost { namespace beast { namespace detail { template<class U> std::size_t constexpr max_sizeof() { return sizeof(U); } template<class U0, class U1, class... Us> std::size_t constexpr max_sizeof() { return max_sizeof<U0>() > max_sizeof<U1, Us...>() ? max_sizeof<U0>() : max_sizeof<U1, Us...>(); } template<class U> std::size_t constexpr max_alignof() { return alignof(U); } template<class U0, class U1, class... Us> std::size_t constexpr max_alignof() { return max_alignof<U0>() > max_alignof<U1, Us...>() ? max_alignof<U0>() : max_alignof<U1, Us...>(); } // (since C++17) template<class... Ts> using make_void = boost::make_void<Ts...>; template<class... Ts> using void_t = boost::void_t<Ts...>; // (since C++11) missing from g++4.8 template<std::size_t Len, class... Ts> struct aligned_union { static std::size_t constexpr alignment_value = max_alignof<Ts...>(); using type = typename std::aligned_storage< (Len > max_sizeof<Ts...>()) ? Len : (max_sizeof<Ts...>()), alignment_value>::type; }; template<std::size_t Len, class... Ts> using aligned_union_t = typename aligned_union<Len, Ts...>::type; //------------------------------------------------------------------------------ // for span template<class T, class E, class = void> struct is_contiguous_container: std::false_type {}; template<class T, class E> struct is_contiguous_container<T, E, void_t< decltype( std::declval<std::size_t&>() = std::declval<T const&>().size(), std::declval<E*&>() = std::declval<T&>().data()), typename std::enable_if< std::is_same< typename std::remove_cv<E>::type, typename std::remove_cv< typename std::remove_pointer< decltype(std::declval<T&>().data()) >::type >::type >::value >::type>>: std::true_type {}; template <class T, class U> T launder_cast(U* u) { #if defined(__cpp_lib_launder) && __cpp_lib_launder >= 201606 return std::launder(reinterpret_cast<T>(u)); #elif defined(BOOST_GCC) && BOOST_GCC_VERSION > 80000 return __builtin_launder(reinterpret_cast<T>(u)); #else return reinterpret_cast<T>(u); #endif } } // detail } // beast } // boost #endif PK PP�[Ty��* �* core/detail/bind_handler.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BIND_HANDLER_HPP #define BOOST_BEAST_DETAIL_BIND_HANDLER_HPP #include <boost/beast/core/error.hpp> #include <boost/beast/core/detail/tuple.hpp> #include <boost/asio/associated_allocator.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/handler_alloc_hook.hpp> #include <boost/asio/handler_continuation_hook.hpp> #include <boost/asio/handler_invoke_hook.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/mp11/integer_sequence.hpp> #include <boost/is_placeholder.hpp> #include <functional> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace detail { //------------------------------------------------------------------------------ // // bind_handler // //------------------------------------------------------------------------------ template<class Handler, class... Args> class bind_wrapper { using args_type = detail::tuple<Args...>; Handler h_; args_type args_; template<class T, class Executor> friend struct net::associated_executor; template<class T, class Allocator> friend struct net::associated_allocator; template<class Arg, class Vals> static typename std::enable_if< std::is_placeholder<typename std::decay<Arg>::type>::value == 0 && boost::is_placeholder<typename std::decay<Arg>::type>::value == 0, Arg&&>::type extract(Arg&& arg, Vals&& vals) { boost::ignore_unused(vals); return std::forward<Arg>(arg); } template<class Arg, class Vals> static typename std::enable_if< std::is_placeholder<typename std::decay<Arg>::type>::value != 0, tuple_element<std::is_placeholder< typename std::decay<Arg>::type>::value - 1, Vals>>::type&& extract(Arg&&, Vals&& vals) { return detail::get<std::is_placeholder< typename std::decay<Arg>::type>::value - 1>( std::forward<Vals>(vals)); } template<class Arg, class Vals> static typename std::enable_if< boost::is_placeholder<typename std::decay<Arg>::type>::value != 0, tuple_element<boost::is_placeholder< typename std::decay<Arg>::type>::value - 1, Vals>>::type&& extract(Arg&&, Vals&& vals) { return detail::get<boost::is_placeholder< typename std::decay<Arg>::type>::value - 1>( std::forward<Vals>(vals)); } template<class ArgsTuple, std::size_t... S> static void invoke( Handler& h, ArgsTuple& args, tuple<>&&, mp11::index_sequence<S...>) { boost::ignore_unused(args); h(detail::get<S>(std::move(args))...); } template< class ArgsTuple, class ValsTuple, std::size_t... S> static void invoke( Handler& h, ArgsTuple& args, ValsTuple&& vals, mp11::index_sequence<S...>) { boost::ignore_unused(args); boost::ignore_unused(vals); h(extract(detail::get<S>(std::move(args)), std::forward<ValsTuple>(vals))...); } public: using result_type = void; // asio needs this bind_wrapper(bind_wrapper&&) = default; bind_wrapper(bind_wrapper const&) = default; template< class DeducedHandler, class... Args_> explicit bind_wrapper( DeducedHandler&& handler, Args_&&... args) : h_(std::forward<DeducedHandler>(handler)) , args_(std::forward<Args_>(args)...) { } template<class... Values> void operator()(Values&&... values) { invoke(h_, args_, tuple<Values&&...>( std::forward<Values>(values)...), mp11::index_sequence_for<Args...>()); } // template<class Function> friend boost::asio::asio_handler_invoke_is_deprecated asio_handler_invoke( Function&& f, bind_wrapper* op) { using boost::asio::asio_handler_invoke; return asio_handler_invoke(f, std::addressof(op->h_)); } friend bool asio_handler_is_continuation( bind_wrapper* op) { using boost::asio::asio_handler_is_continuation; return asio_handler_is_continuation( std::addressof(op->h_)); } friend boost::asio::asio_handler_allocate_is_deprecated asio_handler_allocate( std::size_t size, bind_wrapper* op) { using boost::asio::asio_handler_allocate; return asio_handler_allocate( size, std::addressof(op->h_)); } friend boost::asio::asio_handler_deallocate_is_deprecated asio_handler_deallocate( void* p, std::size_t size, bind_wrapper* op) { using boost::asio::asio_handler_deallocate; return asio_handler_deallocate( p, size, std::addressof(op->h_)); } }; template<class Handler, class... Args> class bind_back_wrapper; template<class Handler, class... Args> class bind_front_wrapper; //------------------------------------------------------------------------------ // // bind_front // //------------------------------------------------------------------------------ template<class Handler, class... Args> class bind_front_wrapper { Handler h_; detail::tuple<Args...> args_; template<class T, class Executor> friend struct net::associated_executor; template<class T, class Allocator> friend struct net::associated_allocator; template<std::size_t... I, class... Ts> void invoke( std::false_type, mp11::index_sequence<I...>, Ts&&... ts) { h_( detail::get<I>(std::move(args_))..., std::forward<Ts>(ts)...); } template<std::size_t... I, class... Ts> void invoke( std::true_type, mp11::index_sequence<I...>, Ts&&... ts) { std::mem_fn(h_)( detail::get<I>(std::move(args_))..., std::forward<Ts>(ts)...); } public: using result_type = void; // asio needs this bind_front_wrapper(bind_front_wrapper&&) = default; bind_front_wrapper(bind_front_wrapper const&) = default; template<class Handler_, class... Args_> bind_front_wrapper( Handler_&& handler, Args_&&... args) : h_(std::forward<Handler_>(handler)) , args_(std::forward<Args_>(args)...) { } template<class... Ts> void operator()(Ts&&... ts) { invoke( std::is_member_function_pointer<Handler>{}, mp11::index_sequence_for<Args...>{}, std::forward<Ts>(ts)...); } // template<class Function> friend boost::asio::asio_handler_invoke_is_deprecated asio_handler_invoke( Function&& f, bind_front_wrapper* op) { using boost::asio::asio_handler_invoke; return asio_handler_invoke(f, std::addressof(op->h_)); } friend bool asio_handler_is_continuation( bind_front_wrapper* op) { using boost::asio::asio_handler_is_continuation; return asio_handler_is_continuation( std::addressof(op->h_)); } friend boost::asio::asio_handler_allocate_is_deprecated asio_handler_allocate( std::size_t size, bind_front_wrapper* op) { using boost::asio::asio_handler_allocate; return asio_handler_allocate( size, std::addressof(op->h_)); } friend boost::asio::asio_handler_deallocate_is_deprecated asio_handler_deallocate( void* p, std::size_t size, bind_front_wrapper* op) { using boost::asio::asio_handler_deallocate; return asio_handler_deallocate( p, size, std::addressof(op->h_)); } }; } // detail } // beast } // boost //------------------------------------------------------------------------------ namespace boost { namespace asio { template<class Handler, class... Args, class Executor> struct associated_executor< beast::detail::bind_wrapper<Handler, Args...>, Executor> { using type = typename associated_executor<Handler, Executor>::type; static type get(beast::detail::bind_wrapper<Handler, Args...> const& op, Executor const& ex = Executor{}) noexcept { return associated_executor< Handler, Executor>::get(op.h_, ex); } }; template<class Handler, class... Args, class Executor> struct associated_executor< beast::detail::bind_front_wrapper<Handler, Args...>, Executor> { using type = typename associated_executor<Handler, Executor>::type; static type get(beast::detail::bind_front_wrapper<Handler, Args...> const& op, Executor const& ex = Executor{}) noexcept { return associated_executor< Handler, Executor>::get(op.h_, ex); } }; // template<class Handler, class... Args, class Allocator> struct associated_allocator< beast::detail::bind_wrapper<Handler, Args...>, Allocator> { using type = typename associated_allocator<Handler, Allocator>::type; static type get(beast::detail::bind_wrapper<Handler, Args...> const& op, Allocator const& alloc = Allocator{}) noexcept { return associated_allocator< Handler, Allocator>::get(op.h_, alloc); } }; template<class Handler, class... Args, class Allocator> struct associated_allocator< beast::detail::bind_front_wrapper<Handler, Args...>, Allocator> { using type = typename associated_allocator<Handler, Allocator>::type; static type get(beast::detail::bind_front_wrapper<Handler, Args...> const& op, Allocator const& alloc = Allocator{}) noexcept { return associated_allocator< Handler, Allocator>::get(op.h_, alloc); } }; } // asio } // boost //------------------------------------------------------------------------------ namespace std { // VFALCO Using std::bind on a completion handler will // cause undefined behavior later, because the executor // associated with the handler is not propagated to the // wrapper returned by std::bind; these overloads are // deleted to prevent mistakes. If this creates a problem // please contact me. template<class Handler, class... Args> void bind(boost::beast::detail::bind_wrapper< Handler, Args...>, ...) = delete; template<class Handler, class... Args> void bind(boost::beast::detail::bind_front_wrapper< Handler, Args...>, ...) = delete; } // std //------------------------------------------------------------------------------ #endif PK PP�[�w#Yh h # core/detail/remap_post_to_defer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_REMAP_POST_TO_DEFER_HPP #define BOOST_BEAST_DETAIL_REMAP_POST_TO_DEFER_HPP #include <boost/asio/is_executor.hpp> #include <boost/core/empty_value.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace detail { template<class Executor> class remap_post_to_defer : private boost::empty_value<Executor> { BOOST_STATIC_ASSERT( net::is_executor<Executor>::value); Executor const& ex() const noexcept { return this->get(); } public: remap_post_to_defer( remap_post_to_defer&&) = default; remap_post_to_defer( remap_post_to_defer const&) = default; explicit remap_post_to_defer( Executor const& ex) : boost::empty_value<Executor>( boost::empty_init_t{}, ex) { } bool operator==( remap_post_to_defer const& other) const noexcept { return ex() == other.ex(); } bool operator!=( remap_post_to_defer const& other) const noexcept { return ex() != other.ex(); } decltype(std::declval<Executor const&>().context()) context() const noexcept { return ex().context(); } void on_work_started() const noexcept { ex().on_work_started(); } void on_work_finished() const noexcept { ex().on_work_finished(); } template<class F, class A> void dispatch(F&& f, A const& a) const { ex().dispatch(std::forward<F>(f), a); } template<class F, class A> void post(F&& f, A const& a) const { ex().defer(std::forward<F>(f), a); } template<class F, class A> void defer(F&& f, A const& a) const { ex().defer(std::forward<F>(f), a); } }; } // detail } // beast } // boost #endif PK PP�[Gw0# core/detail/char_buffer.hppnu �[��� // // Copyright (c) 2019 Damian Jarek(damian.jarek93@gmail.com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_CHAR_BUFFER_HPP #define BOOST_BEAST_CORE_DETAIL_CHAR_BUFFER_HPP #include <boost/config.hpp> #include <cstddef> #include <cstring> #include <cstdint> namespace boost { namespace beast { namespace detail { template <std::size_t N> class char_buffer { public: bool try_push_back(char c) { if (size_ == N) return false; buf_[size_++] = c; return true; } bool try_append(char const* first, char const* last) { std::size_t const n = last - first; if (n > N - size_) return false; std::memmove(&buf_[size_], first, n); size_ += n; return true; } void clear() noexcept { size_ = 0; } char* data() noexcept { return buf_; } char const* data() const noexcept { return buf_; } std::size_t size() const noexcept { return size_; } bool empty() const noexcept { return size_ == 0; } private: std::size_t size_= 0; char buf_[N]; }; } // detail } // beast } // boost #endif PK PP�[ `�� � % core/detail/impl/temporary_buffer.ippnu �[��� // // Copyright (c) 2019 Damian Jarek(damian.jarek93@gmail.com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_IMPL_TEMPORARY_BUFFER_IPP #define BOOST_BEAST_DETAIL_IMPL_TEMPORARY_BUFFER_IPP #include <boost/beast/core/detail/temporary_buffer.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/core/exchange.hpp> #include <boost/assert.hpp> #include <memory> #include <cstring> namespace boost { namespace beast { namespace detail { void temporary_buffer:: append(string_view s) { grow(s.size()); unchecked_append(s); } void temporary_buffer:: append(string_view s1, string_view s2) { grow(s1.size() + s2.size()); unchecked_append(s1); unchecked_append(s2); } void temporary_buffer:: unchecked_append(string_view s) { auto n = s.size(); std::memcpy(&data_[size_], s.data(), n); size_ += n; } void temporary_buffer:: grow(std::size_t n) { if (capacity_ - size_ >= n) return; auto const capacity = (n + size_) * 2u; BOOST_ASSERT(! detail::sum_exceeds( n, size_, capacity)); char* const p = new char[capacity]; std::memcpy(p, data_, size_); deallocate(boost::exchange(data_, p)); capacity_ = capacity; } } // detail } // beast } // boost #endif PK PP�[���{P P core/detail/impl/read.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_IMPL_READ_HPP #define BOOST_BEAST_DETAIL_IMPL_READ_HPP #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/flat_static_buffer.hpp> #include <boost/beast/core/read_size.hpp> #include <boost/asio/basic_stream_socket.hpp> #include <boost/asio/coroutine.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { namespace detail { // The number of bytes in the stack buffer when using non-blocking. static std::size_t constexpr default_max_stack_buffer = 16384; //------------------------------------------------------------------------------ struct dynamic_read_ops { // read into a dynamic buffer until the // condition is met or an error occurs template< class Stream, class DynamicBuffer, class Condition, class Handler> class read_op : public asio::coroutine , public async_base< Handler, beast::executor_type<Stream>> { Stream& s_; DynamicBuffer& b_; Condition cond_; error_code ec_; std::size_t total_ = 0; public: read_op(read_op&&) = default; template<class Handler_, class Condition_> read_op( Handler_&& h, Stream& s, DynamicBuffer& b, Condition_&& cond) : async_base<Handler, beast::executor_type<Stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , b_(b) , cond_(std::forward<Condition_>(cond)) { (*this)({}, 0, false); } void operator()( error_code ec, std::size_t bytes_transferred, bool cont = true) { std::size_t max_prepare; BOOST_ASIO_CORO_REENTER(*this) { for(;;) { max_prepare = beast::read_size(b_, cond_(ec, total_, b_)); if(max_prepare == 0) break; BOOST_ASIO_CORO_YIELD s_.async_read_some( b_.prepare(max_prepare), std::move(*this)); b_.commit(bytes_transferred); total_ += bytes_transferred; } if(! cont) { // run this handler "as-if" using net::post // to reduce template instantiations ec_ = ec; BOOST_ASIO_CORO_YIELD s_.async_read_some( b_.prepare(0), std::move(*this)); ec = ec_; } this->complete_now(ec, total_); } } }; //------------------------------------------------------------------------------ struct run_read_op { template< class AsyncReadStream, class DynamicBuffer, class Condition, class ReadHandler> void operator()( ReadHandler&& h, AsyncReadStream* s, DynamicBuffer* b, Condition&& c) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_op< AsyncReadStream, DynamicBuffer, typename std::decay<Condition>::type, typename std::decay<ReadHandler>::type>( std::forward<ReadHandler>(h), *s, *b, std::forward<Condition>(c)); } }; }; //------------------------------------------------------------------------------ template< class SyncReadStream, class DynamicBuffer, class CompletionCondition, class> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition cond) { static_assert(is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert( detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value, "CompletionCondition type requirements not met"); error_code ec; auto const bytes_transferred = detail::read( stream, buffer, std::move(cond), ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncReadStream, class DynamicBuffer, class CompletionCondition, class> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition cond, error_code& ec) { static_assert(is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert( detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value, "CompletionCondition type requirements not met"); ec = {}; std::size_t total = 0; std::size_t max_prepare; for(;;) { max_prepare = beast::read_size(buffer, cond(ec, total, buffer)); if(max_prepare == 0) break; std::size_t const bytes_transferred = stream.read_some(buffer.prepare(max_prepare), ec); buffer.commit(bytes_transferred); total += bytes_transferred; } return total; } template< class AsyncReadStream, class DynamicBuffer, class CompletionCondition, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler, class> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition&& cond, ReadHandler&& handler) { static_assert(is_async_read_stream<AsyncReadStream>::value, "AsyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert( detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value, "CompletionCondition type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( typename dynamic_read_ops::run_read_op{}, handler, &stream, &buffer, std::forward<CompletionCondition>(cond)); } } // detail } // beast } // boost #endif PK PP�[ 7�W� � ! core/detail/bind_continuation.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BIND_CONTINUATION_HPP #define BOOST_BEAST_DETAIL_BIND_CONTINUATION_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/remap_post_to_defer.hpp> #include <boost/asio/bind_executor.hpp> #include <boost/core/empty_value.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace detail { #if 0 /** Mark a completion handler as a continuation. This function wraps a completion handler to associate it with an executor whose `post` operation is remapped to the `defer` operation. It is used by composed asynchronous operation implementations to indicate that a completion handler submitted to an initiating function represents a continuation of the current asynchronous flow of control. @param handler The handler to wrap. The implementation takes ownership of the handler by performing a decay-copy. @see @li <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4242.html">[N4242] Executors and Asynchronous Operations, Revision 1</a> */ template<class CompletionHandler> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else net::executor_binder< typename std::decay<CompletionHandler>::type, detail::remap_post_to_defer< net::associated_executor_t<CompletionHandler>>> #endif bind_continuation(CompletionHandler&& handler) { return net::bind_executor( detail::remap_post_to_defer< net::associated_executor_t<CompletionHandler>>( net::get_associated_executor(handler)), std::forward<CompletionHandler>(handler)); } /** Mark a completion handler as a continuation. This function wraps a completion handler to associate it with an executor whose `post` operation is remapped to the `defer` operation. It is used by composed asynchronous operation implementations to indicate that a completion handler submitted to an initiating function represents a continuation of the current asynchronous flow of control. @param ex The executor to use @param handler The handler to wrap The implementation takes ownership of the handler by performing a decay-copy. @see @li <a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2014/n4242.html">[N4242] Executors and Asynchronous Operations, Revision 1</a> */ template<class Executor, class CompletionHandler> #if BOOST_BEAST_DOXYGEN __implementation_defined__ #else net::executor_binder<typename std::decay<CompletionHandler>::type, detail::remap_post_to_defer<Executor>> #endif bind_continuation( Executor const& ex, CompletionHandler&& handler) { return net::bind_executor( detail::remap_post_to_defer<Executor>(ex), std::forward<CompletionHandler>(handler)); } #else // VFALCO I turned these off at the last minute because they cause // the completion handler to be moved before the initiating // function is invoked rather than after, which is a foot-gun. // // REMINDER: Uncomment the tests when this is put back template<class F> F&& bind_continuation(F&& f) { return std::forward<F>(f); } #endif } // detail } // beast } // boost #endif PK PP�[�)�\ \ core/detail/ostream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_OSTREAM_HPP #define BOOST_BEAST_DETAIL_OSTREAM_HPP #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/throw_exception.hpp> #include <boost/asio/buffer.hpp> #include <memory> #include <ostream> #include <streambuf> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace detail { struct basic_streambuf_movable_helper : std::basic_streambuf<char, std::char_traits<char>> { basic_streambuf_movable_helper( basic_streambuf_movable_helper&&) = default; }; using basic_streambuf_movable = std::is_move_constructible<basic_streambuf_movable_helper>; template<class DynamicBuffer, class CharT, class Traits, bool isMovable> class ostream_buffer; //------------------------------------------------------------------------------ template<class DynamicBuffer, class CharT, class Traits> class ostream_buffer <DynamicBuffer, CharT, Traits, true> final : public std::basic_streambuf<CharT, Traits> { using int_type = typename std::basic_streambuf<CharT, Traits>::int_type; using traits_type = typename std::basic_streambuf<CharT, Traits>::traits_type; DynamicBuffer& b_; public: ostream_buffer(ostream_buffer&&) = default; ostream_buffer(ostream_buffer const&) = delete; ~ostream_buffer() noexcept { sync(); } explicit ostream_buffer(DynamicBuffer& b) : b_(b) { b_.prepare(0); } int_type overflow(int_type ch) override { BOOST_ASSERT(! Traits::eq_int_type( ch, Traits::eof())); sync(); static std::size_t constexpr max_size = 65536; auto const max_prepare = std::min<std::size_t>( std::max<std::size_t>( 512, b_.capacity() - b_.size()), std::min<std::size_t>( max_size, b_.max_size() - b_.size())); if(max_prepare == 0) return Traits::eof(); auto const bs = b_.prepare(max_prepare); auto const b = buffers_front(bs); auto const p = static_cast<CharT*>(b.data()); this->setp(p, p + b.size() / sizeof(CharT)); BOOST_ASSERT(b_.capacity() > b_.size()); return this->sputc( Traits::to_char_type(ch)); } int sync() override { b_.commit( (this->pptr() - this->pbase()) * sizeof(CharT)); this->setp(nullptr, nullptr); return 0; } }; //------------------------------------------------------------------------------ // This nonsense is all to work around a glitch in libstdc++ // where std::basic_streambuf copy constructor is private: // https://github.com/gcc-mirror/gcc/blob/gcc-4_8-branch/libstdc%2B%2B-v3/include/std/streambuf#L799 template<class DynamicBuffer, class CharT, class Traits> class ostream_buffer <DynamicBuffer, CharT, Traits, false> : public std::basic_streambuf<CharT, Traits> { using int_type = typename std::basic_streambuf<CharT, Traits>::int_type; using traits_type = typename std::basic_streambuf<CharT, Traits>::traits_type; DynamicBuffer& b_; public: ostream_buffer(ostream_buffer&&) = delete; ostream_buffer(ostream_buffer const&) = delete; ~ostream_buffer() noexcept { sync(); } explicit ostream_buffer(DynamicBuffer& b) : b_(b) { } int_type overflow(int_type ch) override { BOOST_ASSERT(! Traits::eq_int_type( ch, Traits::eof())); sync(); static std::size_t constexpr max_size = 65536; auto const max_prepare = std::min<std::size_t>( std::max<std::size_t>( 512, b_.capacity() - b_.size()), std::min<std::size_t>( max_size, b_.max_size() - b_.size())); if(max_prepare == 0) return Traits::eof(); auto const bs = b_.prepare(max_prepare); auto const b = buffers_front(bs); auto const p = static_cast<CharT*>(b.data()); this->setp(p, p + b.size() / sizeof(CharT)); BOOST_ASSERT(b_.capacity() > b_.size()); return this->sputc( Traits::to_char_type(ch)); } int sync() override { b_.commit( (this->pptr() - this->pbase()) * sizeof(CharT)); this->setp(nullptr, nullptr); return 0; } }; //------------------------------------------------------------------------------ template<class DynamicBuffer, class CharT, class Traits, bool isMovable> class ostream_helper; template<class DynamicBuffer, class CharT, class Traits> class ostream_helper< DynamicBuffer, CharT, Traits, true> : public std::basic_ostream<CharT, Traits> { ostream_buffer< DynamicBuffer, CharT, Traits, true> osb_; public: explicit ostream_helper(DynamicBuffer& b); ostream_helper(ostream_helper&& other); }; template<class DynamicBuffer, class CharT, class Traits> ostream_helper<DynamicBuffer, CharT, Traits, true>:: ostream_helper(DynamicBuffer& b) : std::basic_ostream<CharT, Traits>(&this->osb_) , osb_(b) { } template<class DynamicBuffer, class CharT, class Traits> ostream_helper<DynamicBuffer, CharT, Traits, true>:: ostream_helper(ostream_helper&& other) : std::basic_ostream<CharT, Traits>(&osb_) , osb_(std::move(other.osb_)) { } // This work-around is for libstdc++ versions that // don't have a movable std::basic_streambuf template<class T> class ostream_helper_base { protected: std::unique_ptr<T> member; ostream_helper_base( ostream_helper_base&&) = default; explicit ostream_helper_base(T* t) : member(t) { } }; template<class DynamicBuffer, class CharT, class Traits> class ostream_helper< DynamicBuffer, CharT, Traits, false> : private ostream_helper_base<ostream_buffer< DynamicBuffer, CharT, Traits, false>> , public std::basic_ostream<CharT, Traits> { public: explicit ostream_helper(DynamicBuffer& b) : ostream_helper_base<ostream_buffer< DynamicBuffer, CharT, Traits, false>>( new ostream_buffer<DynamicBuffer, CharT, Traits, false>(b)) , std::basic_ostream<CharT, Traits>( this->member.get()) { } ostream_helper(ostream_helper&& other) : ostream_helper_base<ostream_buffer< DynamicBuffer, CharT, Traits, false>>( std::move(other)) , std::basic_ostream<CharT, Traits>( this->member.get()) { } }; } // detail } // beast } // boost #endif PK PP�[%���; ; core/detail/work_guard.hppnu �[��� #ifndef BOOST_BEAST_CORE_DETAIL_WORK_GUARD_HPP #define BOOST_BEAST_CORE_DETAIL_WORK_GUARD_HPP #include <boost/asio/executor_work_guard.hpp> #include <boost/asio/execution.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace detail { template<class Executor, class Enable = void> struct select_work_guard; template<class Executor> using select_work_guard_t = typename select_work_guard<Executor>::type; #if !defined(BOOST_ASIO_NO_TS_EXECUTORS) template<class Executor> struct select_work_guard < Executor, typename std::enable_if < net::is_executor<Executor>::value >::type > { using type = net::executor_work_guard<Executor>; }; #endif template<class Executor> struct execution_work_guard { using executor_type = decltype( net::prefer(std::declval<Executor const&>(), net::execution::outstanding_work.tracked)); execution_work_guard(Executor const& exec) : ex_(net::prefer(exec, net::execution::outstanding_work.tracked)) { } executor_type get_executor() const noexcept { BOOST_ASSERT(ex_.has_value()); return *ex_; } void reset() noexcept { ex_.reset(); } private: boost::optional<executor_type> ex_; }; template<class Executor> struct select_work_guard < Executor, typename std::enable_if < net::execution::is_executor<Executor>::value #if defined(BOOST_ASIO_NO_TS_EXECUTORS) || net::is_executor<Executor>::value #else && !net::is_executor<Executor>::value #endif >::type > { using type = execution_work_guard<Executor>; }; template<class Executor> select_work_guard_t<Executor> make_work_guard(Executor const& exec) noexcept { return select_work_guard_t<Executor>(exec); } } } } #endif // BOOST_BEAST_CORE_DETAIL_WORK_GUARD_HPP PK PP�[j�>D D core/detail/config.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_CONFIG_HPP #define BOOST_BEAST_CORE_DETAIL_CONFIG_HPP // Available to every header #include <boost/config.hpp> #include <boost/version.hpp> #include <boost/core/ignore_unused.hpp> #include <boost/static_assert.hpp> namespace boost { namespace asio { } // asio namespace beast { namespace net = boost::asio; } // beast } // boost /* _MSC_VER and _MSC_FULL_VER by version: 14.0 (2015) 1900 190023026 14.0 (2015 Update 1) 1900 190023506 14.0 (2015 Update 2) 1900 190023918 14.0 (2015 Update 3) 1900 190024210 */ #if defined(BOOST_MSVC) # if BOOST_MSVC_FULL_VER < 190024210 # error Beast requires C++11: Visual Studio 2015 Update 3 or later needed # endif #elif defined(BOOST_GCC) # if(BOOST_GCC < 40801) # error Beast requires C++11: gcc version 4.8 or later needed # endif #else # if \ defined(BOOST_NO_CXX11_DECLTYPE) || \ defined(BOOST_NO_CXX11_HDR_TUPLE) || \ defined(BOOST_NO_CXX11_TEMPLATE_ALIASES) || \ defined(BOOST_NO_CXX11_VARIADIC_TEMPLATES) # error Beast requires C++11: a conforming compiler is needed # endif #endif #define BOOST_BEAST_DEPRECATION_STRING \ "This is a deprecated interface, #define BOOST_BEAST_ALLOW_DEPRECATED to allow it" #ifndef BOOST_BEAST_ASSUME # ifdef BOOST_GCC # define BOOST_BEAST_ASSUME(cond) \ do { if (!(cond)) __builtin_unreachable(); } while (0) # else # define BOOST_BEAST_ASSUME(cond) do { } while(0) # endif #endif // Default to a header-only implementation. The user must specifically // request separate compilation by defining BOOST_BEAST_SEPARATE_COMPILATION #ifndef BOOST_BEAST_HEADER_ONLY # ifndef BOOST_BEAST_SEPARATE_COMPILATION # define BOOST_BEAST_HEADER_ONLY 1 # endif #endif #if BOOST_BEAST_DOXYGEN # define BOOST_BEAST_DECL #elif defined(BOOST_BEAST_HEADER_ONLY) # define BOOST_BEAST_DECL inline #else # define BOOST_BEAST_DECL #endif #ifndef BOOST_BEAST_ASYNC_RESULT1 #define BOOST_BEAST_ASYNC_RESULT1(type) \ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(type, void(::boost::beast::error_code)) #endif #ifndef BOOST_BEAST_ASYNC_RESULT2 #define BOOST_BEAST_ASYNC_RESULT2(type) \ BOOST_ASIO_INITFN_AUTO_RESULT_TYPE(type, void(::boost::beast::error_code, ::std::size_t)) #endif #ifndef BOOST_BEAST_ASYNC_TPARAM1 #define BOOST_BEAST_ASYNC_TPARAM1 BOOST_ASIO_COMPLETION_TOKEN_FOR(void(::boost::beast::error_code)) #endif #ifndef BOOST_BEAST_ASYNC_TPARAM2 #define BOOST_BEAST_ASYNC_TPARAM2 BOOST_ASIO_COMPLETION_TOKEN_FOR(void(::boost::beast::error_code, ::std::size_t)) #endif #endif PK PP�[�1 � � core/detail/stream_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_STREAM_TRAITS_HPP #define BOOST_BEAST_DETAIL_STREAM_TRAITS_HPP #include <boost/beast/core/error.hpp> #include <boost/asio/buffer.hpp> #include <boost/type_traits/make_void.hpp> #include <type_traits> namespace boost { namespace beast { namespace detail { //------------------------------------------------------------------------------ // // get_lowest_layer // lowest_layer_type // detail::has_next_layer // template <class T> std::false_type has_next_layer_impl(void*); template <class T> auto has_next_layer_impl(decltype(nullptr)) -> decltype(std::declval<T&>().next_layer(), std::true_type{}); template <class T> using has_next_layer = decltype(has_next_layer_impl<T>(nullptr)); template<class T, bool = has_next_layer<T>::value> struct lowest_layer_type_impl { using type = typename std::remove_reference<T>::type; }; template<class T> struct lowest_layer_type_impl<T, true> { using type = typename lowest_layer_type_impl< decltype(std::declval<T&>().next_layer())>::type; }; template<class T> using lowest_layer_type = typename lowest_layer_type_impl<T>::type; template<class T> T& get_lowest_layer_impl( T& t, std::false_type) noexcept { return t; } template<class T> lowest_layer_type<T>& get_lowest_layer_impl( T& t, std::true_type) noexcept { return get_lowest_layer_impl(t.next_layer(), has_next_layer<typename std::decay< decltype(t.next_layer())>::type>{}); } //------------------------------------------------------------------------------ // Types that meet the requirements, // for use with std::declval only. template<class BufferType> struct BufferSequence { using value_type = BufferType; using const_iterator = BufferType const*; ~BufferSequence() = default; BufferSequence(BufferSequence const&) = default; const_iterator begin() const noexcept { return {}; } const_iterator end() const noexcept { return {}; } }; using ConstBufferSequence = BufferSequence<net::const_buffer>; using MutableBufferSequence = BufferSequence<net::mutable_buffer>; // // Types that meet the requirements, // for use with std::declval only. struct StreamHandler { StreamHandler(StreamHandler const&) = default; void operator()(error_code, std::size_t) {} }; using ReadHandler = StreamHandler; using WriteHandler = StreamHandler; //------------------------------------------------------------------------------ } // detail } // beast } // boost #endif PK PP�[l�>0� � core/detail/async_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_ASYNC_BASE_HPP #define BOOST_BEAST_CORE_DETAIL_ASYNC_BASE_HPP #include <boost/core/exchange.hpp> namespace boost { namespace beast { namespace detail { struct stable_base { static void destroy_list(stable_base*& list) { while(list) { auto next = list->next_; list->destroy(); list = next; } } stable_base* next_ = nullptr; protected: stable_base() = default; virtual ~stable_base() = default; virtual void destroy() = 0; }; } // detail } // beast } // boost #endif PK PP�[�ƴ6� � core/detail/string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_STRING_HPP #define BOOST_BEAST_DETAIL_STRING_HPP #include <boost/beast/core/string_type.hpp> namespace boost { namespace beast { namespace detail { // Pulling in the UDL directly breaks in some places on MSVC, // so introduce a namespace for this purprose. namespace string_literals { inline string_view operator"" _sv(char const* p, std::size_t n) { return string_view{p, n}; } } // string_literals inline char ascii_tolower(char c) { return ((static_cast<unsigned>(c) - 65U) < 26) ? c + 'a' - 'A' : c; } } // detail } // beast } // boost #endif PK PP�[�&� � core/detail/cpu_info.hppnu �[��� // // Copyright (c) 2017 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_CPU_INFO_HPP #define BOOST_BEAST_DETAIL_CPU_INFO_HPP #include <boost/config.hpp> #ifndef BOOST_BEAST_NO_INTRINSICS # if defined(BOOST_MSVC) || ((defined(BOOST_GCC) || defined(BOOST_CLANG)) && defined(__SSE4_2__)) # define BOOST_BEAST_NO_INTRINSICS 0 # else # define BOOST_BEAST_NO_INTRINSICS 1 # endif #endif #if ! BOOST_BEAST_NO_INTRINSICS #ifdef BOOST_MSVC #include <intrin.h> // __cpuid #else #include <cpuid.h> // __get_cpuid #endif namespace boost { namespace beast { namespace detail { /* Portions from Boost, Copyright Andrey Semashev 2007 - 2015. */ template<class = void> void cpuid( std::uint32_t id, std::uint32_t& eax, std::uint32_t& ebx, std::uint32_t& ecx, std::uint32_t& edx) { #ifdef BOOST_MSVC int regs[4]; __cpuid(regs, id); eax = regs[0]; ebx = regs[1]; ecx = regs[2]; edx = regs[3]; #else __get_cpuid(id, &eax, &ebx, &ecx, &edx); #endif } struct cpu_info { bool sse42 = false; cpu_info(); }; inline cpu_info:: cpu_info() { constexpr std::uint32_t SSE42 = 1 << 20; std::uint32_t eax = 0; std::uint32_t ebx = 0; std::uint32_t ecx = 0; std::uint32_t edx = 0; cpuid(0, eax, ebx, ecx, edx); if(eax >= 1) { cpuid(1, eax, ebx, ecx, edx); sse42 = (ecx & SSE42) != 0; } } template<class = void> cpu_info const& get_cpu_info() { static cpu_info const ci; return ci; } } // detail } // beast } // boost #endif #endif PK PP�[LZ��� � core/detail/static_const.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_STATIC_CONST_HPP #define BOOST_BEAST_DETAIL_STATIC_CONST_HPP /* This is a derivative work, original copyright: Copyright Eric Niebler 2013-present Use, modification and distribution is subject to the Boost Software License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) Project home: https://github.com/ericniebler/range-v3 */ namespace boost { namespace beast { namespace detail { template<typename T> struct static_const { static constexpr T value {}; }; template<typename T> constexpr T static_const<T>::value; #define BOOST_BEAST_INLINE_VARIABLE(name, type) \ namespace \ { \ constexpr auto& name = \ ::boost::beast::detail::static_const<type>::value; \ } } // detail } // beast } // boost #endif PK PP�[v�G G core/detail/chacha.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // // // This is a derivative work, original copyright follows: // /* Copyright (c) 2015 Orson Peters <orsonpeters@gmail.com> This software is provided 'as-is', without any express or implied warranty. In no event will the authors be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this software must not be misrepresented; you must not claim that you wrote the original software. If you use this software in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original software. 3. This notice may not be removed or altered from any source distribution. */ #ifndef BOOST_BEAST_CORE_DETAIL_CHACHA_HPP #define BOOST_BEAST_CORE_DETAIL_CHACHA_HPP #include <cstdint> #include <limits> namespace boost { namespace beast { namespace detail { template<std::size_t R> class chacha { alignas(16) std::uint32_t block_[16]; std::uint32_t keysetup_[8]; std::uint64_t ctr_ = 0; int idx_ = 16; void generate_block() { std::uint32_t constexpr constants[4] = { 0x61707865, 0x3320646e, 0x79622d32, 0x6b206574 }; std::uint32_t input[16]; for (int i = 0; i < 4; ++i) input[i] = constants[i]; for (int i = 0; i < 8; ++i) input[4 + i] = keysetup_[i]; input[12] = (ctr_ / 16) & 0xffffffffu; input[13] = (ctr_ / 16) >> 32; input[14] = input[15] = 0xdeadbeef; // Could use 128-bit counter. for (int i = 0; i < 16; ++i) block_[i] = input[i]; chacha_core(); for (int i = 0; i < 16; ++i) block_[i] += input[i]; } void chacha_core() { #define BOOST_BEAST_CHACHA_ROTL32(x, n) (((x) << (n)) | ((x) >> (32 - (n)))) #define BOOST_BEAST_CHACHA_QUARTERROUND(x, a, b, c, d) \ x[a] = x[a] + x[b]; x[d] ^= x[a]; x[d] = BOOST_BEAST_CHACHA_ROTL32(x[d], 16); \ x[c] = x[c] + x[d]; x[b] ^= x[c]; x[b] = BOOST_BEAST_CHACHA_ROTL32(x[b], 12); \ x[a] = x[a] + x[b]; x[d] ^= x[a]; x[d] = BOOST_BEAST_CHACHA_ROTL32(x[d], 8); \ x[c] = x[c] + x[d]; x[b] ^= x[c]; x[b] = BOOST_BEAST_CHACHA_ROTL32(x[b], 7) for (unsigned i = 0; i < R; i += 2) { BOOST_BEAST_CHACHA_QUARTERROUND(block_, 0, 4, 8, 12); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 1, 5, 9, 13); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 2, 6, 10, 14); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 3, 7, 11, 15); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 0, 5, 10, 15); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 1, 6, 11, 12); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 2, 7, 8, 13); BOOST_BEAST_CHACHA_QUARTERROUND(block_, 3, 4, 9, 14); } #undef BOOST_BEAST_CHACHA_QUARTERROUND #undef BOOST_BEAST_CHACHA_ROTL32 } public: static constexpr std::size_t state_size = sizeof(chacha::keysetup_); using result_type = std::uint32_t; chacha(std::uint32_t const* v, std::uint64_t stream) { for (int i = 0; i < 6; ++i) keysetup_[i] = v[i]; keysetup_[6] = v[6] + (stream & 0xffffffff); keysetup_[7] = v[7] + ((stream >> 32) & 0xffffffff); } std::uint32_t operator()() { if(idx_ == 16) { idx_ = 0; ++ctr_; generate_block(); } return block_[idx_++]; } }; } // detail } // beast } // boost #endif PK PP�[Î�G� � core/detail/clamp.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_CLAMP_HPP #define BOOST_BEAST_CORE_DETAIL_CLAMP_HPP #include <cstdlib> #include <limits> #include <type_traits> namespace boost { namespace beast { namespace detail { template<class UInt> static std::size_t clamp(UInt x) { if(x >= (std::numeric_limits<std::size_t>::max)()) return (std::numeric_limits<std::size_t>::max)(); return static_cast<std::size_t>(x); } template<class UInt> static std::size_t clamp(UInt x, std::size_t limit) { if(x >= limit) return limit; return static_cast<std::size_t>(x); } // return `true` if x + y > z, which are unsigned template< class U1, class U2, class U3> constexpr bool sum_exceeds(U1 x, U2 y, U3 z) { static_assert( std::is_unsigned<U1>::value && std::is_unsigned<U2>::value && std::is_unsigned<U3>::value, ""); return y > z || x > z - y; } } // detail } // beast } // boost #endif PK PP�[Ll{�/ / core/detail/buffer_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BUFFER_TRAITS_HPP #define BOOST_BEAST_DETAIL_BUFFER_TRAITS_HPP #include <boost/asio/buffer.hpp> #include <boost/config/workaround.hpp> #include <boost/type_traits/make_void.hpp> #include <cstdint> #include <type_traits> namespace boost { namespace beast { namespace detail { #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) template<class T> struct buffers_iterator_type_helper { using type = decltype( net::buffer_sequence_begin( std::declval<T const&>())); }; template<> struct buffers_iterator_type_helper< net::const_buffer> { using type = net::const_buffer const*; }; template<> struct buffers_iterator_type_helper< net::mutable_buffer> { using type = net::mutable_buffer const*; }; #endif struct buffer_bytes_impl { std::size_t operator()(net::const_buffer b) const noexcept { return net::const_buffer(b).size(); } std::size_t operator()(net::mutable_buffer b) const noexcept { return net::mutable_buffer(b).size(); } template< class B, class = typename std::enable_if< net::is_const_buffer_sequence<B>::value>::type> std::size_t operator()(B const& b) const noexcept { using net::buffer_size; return buffer_size(b); } }; /** Return `true` if a buffer sequence is empty This is sometimes faster than using @ref buffer_bytes */ template<class ConstBufferSequence> bool buffers_empty(ConstBufferSequence const& buffers) { auto it = net::buffer_sequence_begin(buffers); auto end = net::buffer_sequence_end(buffers); while(it != end) { if(net::const_buffer(*it).size() > 0) return false; ++it; } return true; } } // detail } // beast } // boost #endif PK PP�[5v�^X X core/detail/sha1.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_SHA1_HPP #define BOOST_BEAST_DETAIL_SHA1_HPP #include <boost/beast/core/detail/config.hpp> #include <cstdint> #include <cstddef> // Based on https://github.com/vog/sha1 /* Original authors: Steve Reid (Original C Code) Bruce Guenter (Small changes to fit into bglibs) Volker Grabsch (Translation to simpler C++ Code) Eugene Hopkinson (Safety improvements) Vincent Falco (beast adaptation) */ namespace boost { namespace beast { namespace detail { namespace sha1 { static std::size_t constexpr BLOCK_INTS = 16; static std::size_t constexpr BLOCK_BYTES = 64; static std::size_t constexpr DIGEST_BYTES = 20; } // sha1 struct sha1_context { static unsigned int constexpr block_size = sha1::BLOCK_BYTES; static unsigned int constexpr digest_size = 20; std::size_t buflen; std::size_t blocks; std::uint32_t digest[5]; std::uint8_t buf[block_size]; }; BOOST_BEAST_DECL void init(sha1_context& ctx) noexcept; BOOST_BEAST_DECL void update( sha1_context& ctx, void const* message, std::size_t size) noexcept; BOOST_BEAST_DECL void finish( sha1_context& ctx, void* digest) noexcept; } // detail } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/detail/sha1.ipp> #endif #endif PK PP�[r��-> > core/detail/sha1.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_SHA1_IPP #define BOOST_BEAST_DETAIL_SHA1_IPP #include <boost/beast/core/detail/sha1.hpp> #include <algorithm> #include <cstdint> #include <cstring> // Based on https://github.com/vog/sha1 /* Original authors: Steve Reid (Original C Code) Bruce Guenter (Small changes to fit into bglibs) Volker Grabsch (Translation to simpler C++ Code) Eugene Hopkinson (Safety improvements) Vincent Falco (beast adaptation) */ namespace boost { namespace beast { namespace detail { namespace sha1 { inline std::uint32_t rol(std::uint32_t value, std::size_t bits) { return (value << bits) | (value >> (32 - bits)); } inline std::uint32_t blk(std::uint32_t block[BLOCK_INTS], std::size_t i) { return rol( block[(i+13)&15] ^ block[(i+8)&15] ^ block[(i+2)&15] ^ block[i], 1); } inline void R0(std::uint32_t block[BLOCK_INTS], std::uint32_t v, std::uint32_t &w, std::uint32_t x, std::uint32_t y, std::uint32_t &z, std::size_t i) { z += ((w&(x^y))^y) + block[i] + 0x5a827999 + rol(v, 5); w = rol(w, 30); } inline void R1(std::uint32_t block[BLOCK_INTS], std::uint32_t v, std::uint32_t &w, std::uint32_t x, std::uint32_t y, std::uint32_t &z, std::size_t i) { block[i] = blk(block, i); z += ((w&(x^y))^y) + block[i] + 0x5a827999 + rol(v, 5); w = rol(w, 30); } inline void R2(std::uint32_t block[BLOCK_INTS], std::uint32_t v, std::uint32_t &w, std::uint32_t x, std::uint32_t y, std::uint32_t &z, std::size_t i) { block[i] = blk(block, i); z += (w^x^y) + block[i] + 0x6ed9eba1 + rol(v, 5); w = rol(w, 30); } inline void R3(std::uint32_t block[BLOCK_INTS], std::uint32_t v, std::uint32_t &w, std::uint32_t x, std::uint32_t y, std::uint32_t &z, std::size_t i) { block[i] = blk(block, i); z += (((w|x)&y)|(w&x)) + block[i] + 0x8f1bbcdc + rol(v, 5); w = rol(w, 30); } inline void R4(std::uint32_t block[BLOCK_INTS], std::uint32_t v, std::uint32_t &w, std::uint32_t x, std::uint32_t y, std::uint32_t &z, std::size_t i) { block[i] = blk(block, i); z += (w^x^y) + block[i] + 0xca62c1d6 + rol(v, 5); w = rol(w, 30); } inline void make_block(std::uint8_t const* p, std::uint32_t block[BLOCK_INTS]) { for(std::size_t i = 0; i < BLOCK_INTS; i++) block[i] = (static_cast<std::uint32_t>(p[4*i+3])) | (static_cast<std::uint32_t>(p[4*i+2]))<< 8 | (static_cast<std::uint32_t>(p[4*i+1]))<<16 | (static_cast<std::uint32_t>(p[4*i+0]))<<24; } inline void transform( std::uint32_t digest[], std::uint32_t block[BLOCK_INTS]) { std::uint32_t a = digest[0]; std::uint32_t b = digest[1]; std::uint32_t c = digest[2]; std::uint32_t d = digest[3]; std::uint32_t e = digest[4]; R0(block, a, b, c, d, e, 0); R0(block, e, a, b, c, d, 1); R0(block, d, e, a, b, c, 2); R0(block, c, d, e, a, b, 3); R0(block, b, c, d, e, a, 4); R0(block, a, b, c, d, e, 5); R0(block, e, a, b, c, d, 6); R0(block, d, e, a, b, c, 7); R0(block, c, d, e, a, b, 8); R0(block, b, c, d, e, a, 9); R0(block, a, b, c, d, e, 10); R0(block, e, a, b, c, d, 11); R0(block, d, e, a, b, c, 12); R0(block, c, d, e, a, b, 13); R0(block, b, c, d, e, a, 14); R0(block, a, b, c, d, e, 15); R1(block, e, a, b, c, d, 0); R1(block, d, e, a, b, c, 1); R1(block, c, d, e, a, b, 2); R1(block, b, c, d, e, a, 3); R2(block, a, b, c, d, e, 4); R2(block, e, a, b, c, d, 5); R2(block, d, e, a, b, c, 6); R2(block, c, d, e, a, b, 7); R2(block, b, c, d, e, a, 8); R2(block, a, b, c, d, e, 9); R2(block, e, a, b, c, d, 10); R2(block, d, e, a, b, c, 11); R2(block, c, d, e, a, b, 12); R2(block, b, c, d, e, a, 13); R2(block, a, b, c, d, e, 14); R2(block, e, a, b, c, d, 15); R2(block, d, e, a, b, c, 0); R2(block, c, d, e, a, b, 1); R2(block, b, c, d, e, a, 2); R2(block, a, b, c, d, e, 3); R2(block, e, a, b, c, d, 4); R2(block, d, e, a, b, c, 5); R2(block, c, d, e, a, b, 6); R2(block, b, c, d, e, a, 7); R3(block, a, b, c, d, e, 8); R3(block, e, a, b, c, d, 9); R3(block, d, e, a, b, c, 10); R3(block, c, d, e, a, b, 11); R3(block, b, c, d, e, a, 12); R3(block, a, b, c, d, e, 13); R3(block, e, a, b, c, d, 14); R3(block, d, e, a, b, c, 15); R3(block, c, d, e, a, b, 0); R3(block, b, c, d, e, a, 1); R3(block, a, b, c, d, e, 2); R3(block, e, a, b, c, d, 3); R3(block, d, e, a, b, c, 4); R3(block, c, d, e, a, b, 5); R3(block, b, c, d, e, a, 6); R3(block, a, b, c, d, e, 7); R3(block, e, a, b, c, d, 8); R3(block, d, e, a, b, c, 9); R3(block, c, d, e, a, b, 10); R3(block, b, c, d, e, a, 11); R4(block, a, b, c, d, e, 12); R4(block, e, a, b, c, d, 13); R4(block, d, e, a, b, c, 14); R4(block, c, d, e, a, b, 15); R4(block, b, c, d, e, a, 0); R4(block, a, b, c, d, e, 1); R4(block, e, a, b, c, d, 2); R4(block, d, e, a, b, c, 3); R4(block, c, d, e, a, b, 4); R4(block, b, c, d, e, a, 5); R4(block, a, b, c, d, e, 6); R4(block, e, a, b, c, d, 7); R4(block, d, e, a, b, c, 8); R4(block, c, d, e, a, b, 9); R4(block, b, c, d, e, a, 10); R4(block, a, b, c, d, e, 11); R4(block, e, a, b, c, d, 12); R4(block, d, e, a, b, c, 13); R4(block, c, d, e, a, b, 14); R4(block, b, c, d, e, a, 15); digest[0] += a; digest[1] += b; digest[2] += c; digest[3] += d; digest[4] += e; } } // sha1 void init(sha1_context& ctx) noexcept { ctx.buflen = 0; ctx.blocks = 0; ctx.digest[0] = 0x67452301; ctx.digest[1] = 0xefcdab89; ctx.digest[2] = 0x98badcfe; ctx.digest[3] = 0x10325476; ctx.digest[4] = 0xc3d2e1f0; } void update( sha1_context& ctx, void const* message, std::size_t size) noexcept { auto p = static_cast< std::uint8_t const*>(message); for(;;) { auto const n = (std::min)( size, sizeof(ctx.buf) - ctx.buflen); std::memcpy(ctx.buf + ctx.buflen, p, n); ctx.buflen += n; if(ctx.buflen != 64) return; p += n; size -= n; ctx.buflen = 0; std::uint32_t block[sha1::BLOCK_INTS]; sha1::make_block(ctx.buf, block); sha1::transform(ctx.digest, block); ++ctx.blocks; } } void finish( sha1_context& ctx, void* digest) noexcept { using sha1::BLOCK_INTS; using sha1::BLOCK_BYTES; std::uint64_t total_bits = (ctx.blocks*64 + ctx.buflen) * 8; // pad ctx.buf[ctx.buflen++] = 0x80; auto const buflen = ctx.buflen; while(ctx.buflen < 64) ctx.buf[ctx.buflen++] = 0x00; std::uint32_t block[BLOCK_INTS]; sha1::make_block(ctx.buf, block); if(buflen > BLOCK_BYTES - 8) { sha1::transform(ctx.digest, block); for(size_t i = 0; i < BLOCK_INTS - 2; i++) block[i] = 0; } /* Append total_bits, split this uint64_t into two uint32_t */ block[BLOCK_INTS - 1] = total_bits & 0xffffffff; block[BLOCK_INTS - 2] = (total_bits >> 32); sha1::transform(ctx.digest, block); for(std::size_t i = 0; i < sha1::DIGEST_BYTES/4; i++) { std::uint8_t* d = static_cast<std::uint8_t*>(digest) + 4 * i; d[3] = ctx.digest[i] & 0xff; d[2] = (ctx.digest[i] >> 8) & 0xff; d[1] = (ctx.digest[i] >> 16) & 0xff; d[0] = (ctx.digest[i] >> 24) & 0xff; } } } // detail } // beast } // boost #endif PK PP�[l��� � % core/detail/bind_default_executor.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_BIND_DEFAULT_EXECUTOR_HPP #define BOOST_BEAST_CORE_DETAIL_BIND_DEFAULT_EXECUTOR_HPP #include <boost/asio/associated_allocator.hpp> #include <boost/asio/associated_executor.hpp> #include <boost/asio/dispatch.hpp> #include <boost/asio/executor.hpp> #include <boost/asio/handler_alloc_hook.hpp> #include <boost/asio/handler_continuation_hook.hpp> #include <boost/asio/handler_invoke_hook.hpp> #include <boost/core/empty_value.hpp> #include <utility> namespace boost { namespace beast { namespace detail { template<class Handler, class Executor> class bind_default_executor_wrapper : private boost::empty_value<Executor> { Handler h_; public: template<class Handler_> bind_default_executor_wrapper( Handler_&& h, Executor const& ex) : boost::empty_value<Executor>( boost::empty_init_t{}, ex) , h_(std::forward<Handler_>(h)) { } template<class... Args> void operator()(Args&&... args) { h_(std::forward<Args>(args)...); } using allocator_type = net::associated_allocator_t<Handler>; allocator_type get_allocator() const noexcept { return net::get_associated_allocator(h_); } using executor_type = net::associated_executor_t<Handler, Executor>; executor_type get_executor() const noexcept { return net::get_associated_executor( h_, this->get()); } // The allocation hooks are still defined because they trivially forward to // user hooks. Forward here ensures that the user will get a compile error // if they build their code with BOOST_ASIO_NO_DEPRECATED. friend boost::asio::asio_handler_allocate_is_deprecated asio_handler_allocate( std::size_t size, bind_default_executor_wrapper* p) { using boost::asio::asio_handler_allocate; return asio_handler_allocate( size, std::addressof(p->h_)); } friend boost::asio::asio_handler_deallocate_is_deprecated asio_handler_deallocate( void* mem, std::size_t size, bind_default_executor_wrapper* p) { using boost::asio::asio_handler_deallocate; return asio_handler_deallocate(mem, size, std::addressof(p->h_)); } friend bool asio_handler_is_continuation( bind_default_executor_wrapper* p) { using boost::asio::asio_handler_is_continuation; return asio_handler_is_continuation( std::addressof(p->h_)); } }; template<class Executor, class Handler> auto bind_default_executor(Executor const& ex, Handler&& h) -> bind_default_executor_wrapper< typename std::decay<Handler>::type, Executor> { return bind_default_executor_wrapper< typename std::decay<Handler>::type, Executor>(std::forward<Handler>(h), ex); } } // detail } // beast } // boost #endif PK PP�[�Y�v core/detail/base64.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // /* Portions from http://www.adp-gmbh.ch/cpp/common/base64.html Copyright notice: base64.cpp and base64.h Copyright (C) 2004-2008 Rene Nyffenegger This source code is provided 'as-is', without any express or implied warranty. In no event will the author be held liable for any damages arising from the use of this software. Permission is granted to anyone to use this software for any purpose, including commercial applications, and to alter it and redistribute it freely, subject to the following restrictions: 1. The origin of this source code must not be misrepresented; you must not claim that you wrote the original source code. If you use this source code in a product, an acknowledgment in the product documentation would be appreciated but is not required. 2. Altered source versions must be plainly marked as such, and must not be misrepresented as being the original source code. 3. This notice may not be removed or altered from any source distribution. Rene Nyffenegger rene.nyffenegger@adp-gmbh.ch */ #ifndef BOOST_BEAST_DETAIL_BASE64_IPP #define BOOST_BEAST_DETAIL_BASE64_IPP #include <boost/beast/core/detail/base64.hpp> #include <boost/beast/core/string.hpp> #include <cctype> #include <string> #include <utility> namespace boost { namespace beast { namespace detail { namespace base64 { char const* get_alphabet() { static char constexpr tab[] = { "ABCDEFGHIJKLMNOP" "QRSTUVWXYZabcdef" "ghijklmnopqrstuv" "wxyz0123456789+/" }; return &tab[0]; } signed char const* get_inverse() { static signed char constexpr tab[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0-15 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16-31 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1, -1, 63, // 32-47 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, // 48-63 -1, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, // 64-79 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, // 80-95 -1, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, // 96-111 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1, -1, -1, // 112-127 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 128-143 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 144-159 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 160-175 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 176-191 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 192-207 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 208-223 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224-239 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240-255 }; return &tab[0]; } /** Encode a series of octets as a padded, base64 string. The resulting string will not be null terminated. @par Requires The memory pointed to by `out` points to valid memory of at least `encoded_size(len)` bytes. @return The number of characters written to `out`. This will exclude any null termination. */ std::size_t encode(void* dest, void const* src, std::size_t len) { char* out = static_cast<char*>(dest); char const* in = static_cast<char const*>(src); auto const tab = base64::get_alphabet(); for(auto n = len / 3; n--;) { *out++ = tab[ (in[0] & 0xfc) >> 2]; *out++ = tab[((in[0] & 0x03) << 4) + ((in[1] & 0xf0) >> 4)]; *out++ = tab[((in[2] & 0xc0) >> 6) + ((in[1] & 0x0f) << 2)]; *out++ = tab[ in[2] & 0x3f]; in += 3; } switch(len % 3) { case 2: *out++ = tab[ (in[0] & 0xfc) >> 2]; *out++ = tab[((in[0] & 0x03) << 4) + ((in[1] & 0xf0) >> 4)]; *out++ = tab[ (in[1] & 0x0f) << 2]; *out++ = '='; break; case 1: *out++ = tab[ (in[0] & 0xfc) >> 2]; *out++ = tab[((in[0] & 0x03) << 4)]; *out++ = '='; *out++ = '='; break; case 0: break; } return out - static_cast<char*>(dest); } /** Decode a padded base64 string into a series of octets. @par Requires The memory pointed to by `out` points to valid memory of at least `decoded_size(len)` bytes. @return The number of octets written to `out`, and the number of characters read from the input string, expressed as a pair. */ std::pair<std::size_t, std::size_t> decode(void* dest, char const* src, std::size_t len) { char* out = static_cast<char*>(dest); auto in = reinterpret_cast<unsigned char const*>(src); unsigned char c3[3], c4[4]; int i = 0; int j = 0; auto const inverse = base64::get_inverse(); while(len-- && *in != '=') { auto const v = inverse[*in]; if(v == -1) break; ++in; c4[i] = v; if(++i == 4) { c3[0] = (c4[0] << 2) + ((c4[1] & 0x30) >> 4); c3[1] = ((c4[1] & 0xf) << 4) + ((c4[2] & 0x3c) >> 2); c3[2] = ((c4[2] & 0x3) << 6) + c4[3]; for(i = 0; i < 3; i++) *out++ = c3[i]; i = 0; } } if(i) { c3[0] = ( c4[0] << 2) + ((c4[1] & 0x30) >> 4); c3[1] = ((c4[1] & 0xf) << 4) + ((c4[2] & 0x3c) >> 2); c3[2] = ((c4[2] & 0x3) << 6) + c4[3]; for(j = 0; j < i - 1; j++) *out++ = c3[j]; } return {out - static_cast<char*>(dest), in - reinterpret_cast<unsigned char const*>(src)}; } } // base64 } // detail } // beast } // boost #endif PK PP�[� f core/detail/variant.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_VARIANT_HPP #define BOOST_BEAST_DETAIL_VARIANT_HPP #include <boost/beast/core/detail/type_traits.hpp> #include <boost/assert.hpp> #include <boost/mp11/algorithm.hpp> namespace boost { namespace beast { namespace detail { // This simple variant gets the job done without // causing too much trouble with template depth: // // * Always allows an empty state I==0 // * emplace() and get() support 1-based indexes only // * Basic exception guarantee // * Max 255 types // template<class... TN> class variant { detail::aligned_union_t<1, TN...> buf_; unsigned char i_ = 0; struct destroy { variant& self; void operator()(mp11::mp_size_t<0>) { } template<class I> void operator()(I) noexcept { using T = mp11::mp_at_c<variant, I::value - 1>; detail::launder_cast<T*>(&self.buf_)->~T(); } }; struct copy { variant& self; variant const& other; void operator()(mp11::mp_size_t<0>) { } template<class I> void operator()(I) { using T = mp11::mp_at_c<variant, I::value - 1>; ::new(&self.buf_) T( *detail::launder_cast<T const*>(&other.buf_)); self.i_ = I::value; } }; struct move { variant& self; variant& other; void operator()(mp11::mp_size_t<0>) { } template<class I> void operator()(I) { using T = mp11::mp_at_c<variant, I::value - 1>; ::new(&self.buf_) T(std::move( *detail::launder_cast<T*>(&other.buf_))); detail::launder_cast<T*>(&other.buf_)->~T(); self.i_ = I::value; } }; struct equals { variant const& self; variant const& other; bool operator()(mp11::mp_size_t<0>) { return true; } template<class I> bool operator()(I) { using T = mp11::mp_at_c<variant, I::value - 1>; return *detail::launder_cast<T const*>(&self.buf_) == *detail::launder_cast<T const*>(&other.buf_); } }; void destruct() { mp11::mp_with_index< sizeof...(TN) + 1>( i_, destroy{*this}); i_ = 0; } void copy_construct(variant const& other) { mp11::mp_with_index< sizeof...(TN) + 1>( other.i_, copy{*this, other}); } void move_construct(variant& other) { mp11::mp_with_index< sizeof...(TN) + 1>( other.i_, move{*this, other}); other.i_ = 0; } public: variant() = default; ~variant() { destruct(); } bool operator==(variant const& other) const { if(i_ != other.i_) return false; return mp11::mp_with_index< sizeof...(TN) + 1>( i_, equals{*this, other}); } // 0 = empty unsigned char index() const { return i_; } // moved-from object becomes empty variant(variant&& other) noexcept { move_construct(other); } variant(variant const& other) { copy_construct(other); } // moved-from object becomes empty variant& operator=(variant&& other) { if(this != &other) { destruct(); move_construct(other); } return *this; } variant& operator=(variant const& other) { if(this != &other) { destruct(); copy_construct(other); } return *this; } template<std::size_t I, class... Args> void emplace(Args&&... args) noexcept { destruct(); ::new(&buf_) mp11::mp_at_c<variant, I - 1>( std::forward<Args>(args)...); i_ = I; } template<std::size_t I> mp11::mp_at_c<variant, I - 1>& get() { BOOST_ASSERT(i_ == I); return *detail::launder_cast< mp11::mp_at_c<variant, I - 1>*>(&buf_); } template<std::size_t I> mp11::mp_at_c<variant, I - 1> const& get() const { BOOST_ASSERT(i_ == I); return *detail::launder_cast< mp11::mp_at_c<variant, I - 1> const*>(&buf_); } void reset() { destruct(); } }; } // detail } // beast } // boost #endif PK PP�[v�n�` ` core/detail/is_invocable.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_IS_INVOCABLE_HPP #define BOOST_BEAST_DETAIL_IS_INVOCABLE_HPP #include <boost/asio/async_result.hpp> #include <boost/type_traits/make_void.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace detail { template<class R, class C, class ...A> auto is_invocable_test(C&& c, int, A&& ...a) -> decltype(std::is_convertible< decltype(c(std::forward<A>(a)...)), R>::value || std::is_same<R, void>::value, std::true_type()); template<class R, class C, class ...A> std::false_type is_invocable_test(C&& c, long, A&& ...a); /** Metafunction returns `true` if F callable as R(A...) Example: @code is_invocable<T, void(std::string)>::value @endcode */ /** @{ */ template<class C, class F> struct is_invocable : std::false_type { }; template<class C, class R, class ...A> struct is_invocable<C, R(A...)> : decltype(is_invocable_test<R>( std::declval<C>(), 1, std::declval<A>()...)) { }; /** @} */ template<class CompletionToken, class Signature, class = void> struct is_completion_token_for : std::false_type { }; struct any_initiation { template<class...AnyArgs> void operator()(AnyArgs&&...); }; template<class CompletionToken, class R, class...Args> struct is_completion_token_for< CompletionToken, R(Args...), boost::void_t<decltype( boost::asio::async_initiate<CompletionToken, R(Args...)>( any_initiation(), std::declval<CompletionToken&>()) )>> : std::true_type { }; } // detail } // beast } // boost #endif PK PP�[��1�� � core/detail/base64.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BASE64_HPP #define BOOST_BEAST_DETAIL_BASE64_HPP #include <boost/beast/core/string.hpp> #include <cctype> #include <utility> namespace boost { namespace beast { namespace detail { namespace base64 { BOOST_BEAST_DECL char const* get_alphabet(); BOOST_BEAST_DECL signed char const* get_inverse(); /// Returns max chars needed to encode a base64 string BOOST_BEAST_DECL std::size_t constexpr encoded_size(std::size_t n) { return 4 * ((n + 2) / 3); } /// Returns max bytes needed to decode a base64 string inline std::size_t constexpr decoded_size(std::size_t n) { return n / 4 * 3; // requires n&3==0, smaller } /** Encode a series of octets as a padded, base64 string. The resulting string will not be null terminated. @par Requires The memory pointed to by `out` points to valid memory of at least `encoded_size(len)` bytes. @return The number of characters written to `out`. This will exclude any null termination. */ BOOST_BEAST_DECL std::size_t encode(void* dest, void const* src, std::size_t len); /** Decode a padded base64 string into a series of octets. @par Requires The memory pointed to by `out` points to valid memory of at least `decoded_size(len)` bytes. @return The number of octets written to `out`, and the number of characters read from the input string, expressed as a pair. */ BOOST_BEAST_DECL std::pair<std::size_t, std::size_t> decode(void* dest, char const* src, std::size_t len); } // base64 } // detail } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/detail/base64.ipp> #endif #endif PK PP�[���$ $ core/detail/read.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_READ_HPP #define BOOST_BEAST_DETAIL_READ_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/async_result.hpp> #include <cstdlib> namespace boost { namespace beast { namespace detail { //------------------------------------------------------------------------------ /** Read data into a dynamic buffer from a stream until a condition is met. This function is used to read from a stream into a dynamic buffer until a condition is met. The call will block until one of the following is true: @li The specified dynamic buffer sequence is full (that is, it has reached its currently configured maximum size). @li The `completion_condition` function object returns 0. This operation is implemented in terms of zero or more calls to the stream's `read_some` function. @param stream The stream from which the data is to be read. The type must support the <em>SyncReadStream</em> requirements. @param buffer The dynamic buffer sequence into which the data will be read. @param completion_condition The function object to be called to determine whether the read operation is complete. The function object must be invocable with this signature: @code std::size_t completion_condition( // Modifiable result of latest read_some operation. error_code& ec, // Number of bytes transferred so far. std::size_t bytes_transferred // The dynamic buffer used to store the bytes read DynamicBuffer& buffer ); @endcode A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's `read_some` function. A return value of 0 from the completion condition indicates that the read operation is complete; in this case the optionally modifiable error passed to the completion condition will be delivered to the caller as an exception. @returns The number of bytes transferred from the stream. @throws net::system_error Thrown on failure. */ template< class SyncReadStream, class DynamicBuffer, class CompletionCondition #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< is_sync_read_stream<SyncReadStream>::value && net::is_dynamic_buffer<DynamicBuffer>::value && detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value >::type #endif > std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition completion_condition); /** Read data into a dynamic buffer from a stream until a condition is met. This function is used to read from a stream into a dynamic buffer until a condition is met. The call will block until one of the following is true: @li The specified dynamic buffer sequence is full (that is, it has reached its currently configured maximum size). @li The `completion_condition` function object returns 0. This operation is implemented in terms of zero or more calls to the stream's `read_some` function. @param stream The stream from which the data is to be read. The type must support the <em>SyncReadStream</em> requirements. @param buffer The dynamic buffer sequence into which the data will be read. @param completion_condition The function object to be called to determine whether the read operation is complete. The function object must be invocable with this signature: @code std::size_t completion_condition( // Modifiable result of latest read_some operation. error_code& ec, // Number of bytes transferred so far. std::size_t bytes_transferred // The dynamic buffer used to store the bytes read DynamicBuffer& buffer ); @endcode A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's `read_some` function. A return value of 0 from the completion condition indicates that the read operation is complete; in this case the optionally modifiable error passed to the completion condition will be delivered to the caller. @returns The number of bytes transferred from the stream. */ template< class SyncReadStream, class DynamicBuffer, class CompletionCondition #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< is_sync_read_stream<SyncReadStream>::value && net::is_dynamic_buffer<DynamicBuffer>::value && detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value >::type #endif > std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition completion_condition, error_code& ec); /** Asynchronously read data into a dynamic buffer from a stream until a condition is met. This function is used to asynchronously read from a stream into a dynamic buffer until a condition is met. The function call always returns immediately. The asynchronous operation will continue until one of the following is true: @li The specified dynamic buffer sequence is full (that is, it has reached its currently configured maximum size). @li The `completion_condition` function object returns 0. This operation is implemented in terms of zero or more calls to the stream's `async_read_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other read operations (such as `async_read`, the stream's `async_read_some` function, or any other composed operations that perform reads) until this operation completes. @param stream The stream from which the data is to be read. The type must support the <em>AsyncReadStream</em> requirements. @param buffer The dynamic buffer sequence into which the data will be read. Ownership of the object is retained by the caller, which must guarantee that it remains valid until the handler is called. @param completion_condition The function object to be called to determine whether the read operation is complete. The function object must be invocable with this signature: @code std::size_t completion_condition( // Modifiable result of latest async_read_some operation. error_code& ec, // Number of bytes transferred so far. std::size_t bytes_transferred, // The dynamic buffer used to store the bytes read DynamicBuffer& buffer ); @endcode A non-zero return value indicates the maximum number of bytes to be read on the next call to the stream's `async_read_some` function. A return value of 0 from the completion condition indicates that the read operation is complete; in this case the optionally modifiable error passed to the completion condition will be delivered to the completion handler. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation. std::size_t bytes_transferred // Number of bytes copied into // the dynamic buffer. If an error // occurred, this will be the number // of bytes successfully transferred // prior to the error. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class AsyncReadStream, class DynamicBuffer, class CompletionCondition, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< is_async_read_stream<AsyncReadStream>::value && net::is_dynamic_buffer<DynamicBuffer>::value && detail::is_invocable<CompletionCondition, void(error_code&, std::size_t, DynamicBuffer&)>::value >::type #endif > BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, CompletionCondition&& completion_condition, ReadHandler&& handler); } // detail } // beast } // boost #include <boost/beast/core/detail/impl/read.hpp> #endif PK PP�[,���" " core/detail/get_io_context.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_GET_IO_CONTEXT_HPP #define BOOST_BEAST_DETAIL_GET_IO_CONTEXT_HPP #include <boost/beast/core/stream_traits.hpp> #ifdef BOOST_ASIO_NO_TS_EXECUTORS #include <boost/asio/execution.hpp> #endif #include <boost/asio/executor.hpp> #include <boost/asio/io_context.hpp> #include <boost/asio/strand.hpp> #include <memory> #include <type_traits> namespace boost { namespace beast { namespace detail { //------------------------------------------------------------------------------ inline net::io_context* get_io_context(net::io_context& ioc) { return std::addressof(ioc); } inline net::io_context* get_io_context(net::io_context::executor_type const& ex) { return std::addressof(net::query(ex, net::execution::context)); } inline net::io_context* get_io_context(net::strand< net::io_context::executor_type> const& ex) { return get_io_context(ex.get_inner_executor()); } template<class Executor> net::io_context* get_io_context(net::strand<Executor> const& ex) { return get_io_context(ex.get_inner_executor()); } template< class T, class = typename std::enable_if< std::is_same<T, net::executor>::value || std::is_same<T, net::any_io_executor>::value>::type> net::io_context* get_io_context(T const& ex) { auto p = ex.template target<typename net::io_context::executor_type>(); if(! p) return nullptr; return get_io_context(*p); } inline net::io_context* get_io_context(...) { return nullptr; } //------------------------------------------------------------------------------ template<class T> net::io_context* get_io_context_impl(T& t, std::true_type) { return get_io_context( t.get_executor()); } template<class T> net::io_context* get_io_context_impl(T const&, std::false_type) { return nullptr; } // Returns the io_context*, or nullptr, for any object. template<class T> net::io_context* get_io_context(T& t) { return get_io_context_impl(t, has_get_executor<T>{}); } } // detail } // beast } // boost #endif PK PP�[/2 d d " core/detail/win32_unicode_path.hppnu �[��� // // Copyright (c) 2019 Mika Fischer (mika.fischer@zoopnet.de) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_WIN32_UNICODE_PATH_HPP #define BOOST_BEAST_CORE_DETAIL_WIN32_UNICODE_PATH_HPP #ifdef _WIN32 #include <boost/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/winapi/character_code_conversion.hpp> #include <boost/winapi/file_management.hpp> #include <boost/winapi/get_last_error.hpp> #include <array> #include <vector> namespace boost { namespace beast { namespace detail { class win32_unicode_path { using WCHAR_ = boost::winapi::WCHAR_; public: win32_unicode_path(const char* utf8_path, error_code& ec) { int ret = mb2wide(utf8_path, static_buf_.data(), static_buf_.size()); if (ret == 0) { int sz = mb2wide(utf8_path, nullptr, 0); if (sz == 0) { ec.assign(boost::winapi::GetLastError(), system_category()); return; } dynamic_buf_.resize(sz); int ret2 = mb2wide(utf8_path, dynamic_buf_.data(), dynamic_buf_.size()); if (ret2 == 0) { ec.assign(boost::winapi::GetLastError(), system_category()); return; } } } WCHAR_ const* c_str() const noexcept { return dynamic_buf_.empty() ? static_buf_.data() : dynamic_buf_.data(); } private: int mb2wide(const char* utf8_path, WCHAR_* buf, size_t sz) { return boost::winapi::MultiByteToWideChar( boost::winapi::CP_UTF8_, boost::winapi::MB_ERR_INVALID_CHARS_, utf8_path, -1, buf, static_cast<int>(sz)); } std::array<WCHAR_, boost::winapi::MAX_PATH_> static_buf_; std::vector<WCHAR_> dynamic_buf_; }; } // detail } // beast } // boost #endif #endif PK PP�[R�|L L core/detail/buffers_pair.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BUFFERS_PAIR_HPP #define BOOST_BEAST_DETAIL_BUFFERS_PAIR_HPP #include <boost/asio/buffer.hpp> #include <boost/assert.hpp> #include <boost/config/workaround.hpp> #include <type_traits> namespace boost { namespace beast { namespace detail { #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (push) # pragma warning (disable: 4521) // multiple copy constructors specified # pragma warning (disable: 4522) // multiple assignment operators specified #endif template<bool isMutable> class buffers_pair { public: // VFALCO: This type is public otherwise // asio::buffers_iterator won't compile. using value_type = typename std::conditional<isMutable, net::mutable_buffer, net::const_buffer>::type; using const_iterator = value_type const*; buffers_pair() = default; #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) buffers_pair(buffers_pair const& other) : buffers_pair( *other.begin(), *(other.begin() + 1)) { } buffers_pair& operator=(buffers_pair const& other) { b_[0] = *other.begin(); b_[1] = *(other.begin() + 1); return *this; } #else buffers_pair(buffers_pair const& other) = default; buffers_pair& operator=(buffers_pair const& other) = default; #endif template< bool isMutable_ = isMutable, class = typename std::enable_if< ! isMutable_>::type> buffers_pair(buffers_pair<true> const& other) : buffers_pair( *other.begin(), *(other.begin() + 1)) { } template< bool isMutable_ = isMutable, class = typename std::enable_if< ! isMutable_>::type> buffers_pair& operator=(buffers_pair<true> const& other) { b_[0] = *other.begin(); b_[1] = *(other.begin() + 1); return *this; } buffers_pair(value_type b0, value_type b1) : b_{b0, b1} { } const_iterator begin() const noexcept { return &b_[0]; } const_iterator end() const noexcept { if(b_[1].size() > 0) return &b_[2]; return &b_[1]; } private: value_type b_[2]; }; #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) # pragma warning (pop) #endif } // detail } // beast } // boost #endif PK PP�[ nW� � core/detail/tuple.hppnu �[��� // // Copyright (c) 2016-2019 Damian Jarek (damian dot jarek93 at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_TUPLE_HPP #define BOOST_BEAST_DETAIL_TUPLE_HPP #include <boost/mp11/integer_sequence.hpp> #include <boost/mp11/algorithm.hpp> #include <boost/type_traits/remove_cv.hpp> #include <boost/type_traits/copy_cv.hpp> #include <cstdlib> #include <utility> namespace boost { namespace beast { namespace detail { template<std::size_t I, class T> struct tuple_element_impl { T t; tuple_element_impl(T const& t_) : t(t_) { } tuple_element_impl(T&& t_) : t(std::move(t_)) { } }; template<std::size_t I, class T> struct tuple_element_impl<I, T&> { T& t; tuple_element_impl(T& t_) : t(t_) { } }; template<class... Ts> struct tuple_impl; template<class... Ts, std::size_t... Is> struct tuple_impl< boost::mp11::index_sequence<Is...>, Ts...> : tuple_element_impl<Is, Ts>... { template<class... Us> explicit tuple_impl(Us&&... us) : tuple_element_impl<Is, Ts>( std::forward<Us>(us))... { } }; template<class... Ts> struct tuple : tuple_impl< boost::mp11::index_sequence_for<Ts...>, Ts...> { template<class... Us> explicit tuple(Us&&... us) : tuple_impl< boost::mp11::index_sequence_for<Ts...>, Ts...>{ std::forward<Us>(us)...} { } }; template<std::size_t I, class T> T& get(tuple_element_impl<I, T>& te) { return te.t; } template<std::size_t I, class T> T const& get(tuple_element_impl<I, T> const& te) { return te.t; } template<std::size_t I, class T> T&& get(tuple_element_impl<I, T>&& te) { return std::move(te.t); } template<std::size_t I, class T> T& get(tuple_element_impl<I, T&>&& te) { return te.t; } template <std::size_t I, class T> using tuple_element = typename boost::copy_cv< mp11::mp_at_c<typename remove_cv<T>::type, I>, T>::type; } // detail } // beast } // boost #endif PK PP�[ �y�p p core/detail/buffers_ref.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BUFFERS_REF_HPP #define BOOST_BEAST_DETAIL_BUFFERS_REF_HPP #include <boost/beast/core/buffer_traits.hpp> #include <iterator> #include <memory> namespace boost { namespace beast { namespace detail { // A very lightweight reference to a buffer sequence template<class BufferSequence> class buffers_ref { BufferSequence const* buffers_; public: using const_iterator = buffers_iterator_type<BufferSequence>; using value_type = typename std::iterator_traits<const_iterator>::value_type; buffers_ref(buffers_ref const&) = default; buffers_ref& operator=(buffers_ref const&) = default; explicit buffers_ref(BufferSequence const& buffers) : buffers_(std::addressof(buffers)) { } const_iterator begin() const { return net::buffer_sequence_begin(*buffers_); } const_iterator end() const { return net::buffer_sequence_end(*buffers_); } }; // Return a reference to a buffer sequence template<class BufferSequence> buffers_ref<BufferSequence> make_buffers_ref(BufferSequence const& buffers) { static_assert( is_const_buffer_sequence<BufferSequence>::value, "BufferSequence type requirements not met"); return buffers_ref<BufferSequence>(buffers); } } // detail } // beast } // boost #endif PK PP�[�D抰 � core/detail/varint.hppnu �[��� // // Copyright (c) 2017 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_VARINT_HPP #define BOOST_BEAST_DETAIL_VARINT_HPP #include <boost/static_assert.hpp> #include <cstdlib> #include <iterator> #include <type_traits> namespace boost { namespace beast { namespace detail { // https://developers.google.com/protocol-buffers/docs/encoding#varints inline std::size_t varint_size(std::size_t value) { std::size_t n = 1; while(value > 127) { ++n; value /= 128; } return n; } template<class FwdIt> std::size_t varint_read(FwdIt& first) { using value_type = typename std::iterator_traits<FwdIt>::value_type; BOOST_STATIC_ASSERT( std::is_integral<value_type>::value && sizeof(value_type) == 1); std::size_t value = 0; std::size_t factor = 1; while((*first & 0x80) != 0) { value += (*first++ & 0x7f) * factor; factor *= 128; } value += *first++ * factor; return value; } template<class FwdIt> void varint_write(FwdIt& first, std::size_t value) { using value_type = typename std::iterator_traits<FwdIt>::value_type; BOOST_STATIC_ASSERT( std::is_integral<value_type>::value && sizeof(value_type) == 1); while(value > 127) { *first++ = static_cast<value_type>( 0x80 | value); value /= 128; } *first++ = static_cast<value_type>(value); } } // detail } // beast } // boost #endif PK PP�[d�-CR R core/detail/service_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_SERVICE_BASE_HPP #define BOOST_BEAST_DETAIL_SERVICE_BASE_HPP #include <boost/asio/execution_context.hpp> namespace boost { namespace beast { namespace detail { template<class T> struct service_base : net::execution_context::service { static net::execution_context::id const id; explicit service_base(net::execution_context& ctx) : net::execution_context::service(ctx) { } }; template<class T> net::execution_context::id const service_base<T>::id; } // detail } // beast } // boost #endif PK PP�[>�I^ ^ core/detail/stream_base.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP #define BOOST_BEAST_CORE_DETAIL_STREAM_BASE_HPP #include <boost/asio/steady_timer.hpp> #include <boost/assert.hpp> #include <boost/core/exchange.hpp> #include <chrono> #include <cstdint> #include <utility> namespace boost { namespace beast { namespace detail { struct any_endpoint { template<class Error, class Endpoint> bool operator()( Error const&, Endpoint const&) const noexcept { return true; } }; struct stream_base { using clock_type = std::chrono::steady_clock; using time_point = typename std::chrono::steady_clock::time_point; using tick_type = std::uint64_t; struct op_state { net::steady_timer timer; // for timing out tick_type tick = 0; // counts waits bool pending = false; // if op is pending bool timeout = false; // if timed out template<class... Args> explicit op_state(Args&&... args) : timer(std::forward<Args>(args)...) { } }; class pending_guard { bool* b_ = nullptr; bool clear_ = true; public: ~pending_guard() { if(clear_ && b_) *b_ = false; } pending_guard() : b_(nullptr) , clear_(true) { } explicit pending_guard(bool& b) : b_(&b) { // If this assert goes off, it means you are attempting // to issue two of the same asynchronous I/O operation // at the same time, without waiting for the first one // to complete. For example, attempting two simultaneous // calls to async_read_some. Only one pending call of // each I/O type (read and write) is permitted. // BOOST_ASSERT(! *b_); *b_ = true; } pending_guard( pending_guard&& other) noexcept : b_(other.b_) , clear_(boost::exchange( other.clear_, false)) { } void assign(bool& b) { BOOST_ASSERT(!b_); BOOST_ASSERT(clear_); b_ = &b; // If this assert goes off, it means you are attempting // to issue two of the same asynchronous I/O operation // at the same time, without waiting for the first one // to complete. For example, attempting two simultaneous // calls to async_read_some. Only one pending call of // each I/O type (read and write) is permitted. // BOOST_ASSERT(! *b_); *b_ = true; } void reset() { BOOST_ASSERT(clear_); if (b_) *b_ = false; clear_ = false; } }; static time_point never() noexcept { return (time_point::max)(); } static std::size_t constexpr no_limit = (std::numeric_limits<std::size_t>::max)(); }; } // detail } // beast } // boost #endif PK PP�[���� � core/detail/static_string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_STATIC_STRING_HPP #define BOOST_BEAST_DETAIL_STATIC_STRING_HPP #include <boost/beast/core/string.hpp> #include <boost/assert.hpp> #include <iterator> #include <type_traits> namespace boost { namespace beast { namespace detail { // Because k-ballo said so template<class T> using is_input_iterator = std::integral_constant<bool, ! std::is_integral<T>::value>; template<class CharT, class Traits> int lexicographical_compare( CharT const* s1, std::size_t n1, CharT const* s2, std::size_t n2) { if(n1 < n2) return Traits::compare( s1, s2, n1) <= 0 ? -1 : 1; if(n1 > n2) return Traits::compare( s1, s2, n2) >= 0 ? 1 : -1; return Traits::compare(s1, s2, n1); } template<class CharT, class Traits> int lexicographical_compare( basic_string_view<CharT, Traits> s1, CharT const* s2, std::size_t n2) { return detail::lexicographical_compare< CharT, Traits>(s1.data(), s1.size(), s2, n2); } template<class CharT, class Traits> int lexicographical_compare( basic_string_view<CharT, Traits> s1, basic_string_view<CharT, Traits> s2) { return detail::lexicographical_compare<CharT, Traits>( s1.data(), s1.size(), s2.data(), s2.size()); } // Maximum number of characters in the decimal // representation of a binary number. This includes // the potential minus sign. // inline std::size_t constexpr max_digits(std::size_t bytes) { return static_cast<std::size_t>( bytes * 2.41) + 1 + 1; } template<class CharT, class Integer, class Traits> CharT* raw_to_string( CharT* buf, Integer x, std::true_type) { if(x == 0) { Traits::assign(*--buf, '0'); return buf; } if(x < 0) { x = -x; for(;x > 0; x /= 10) Traits::assign(*--buf , "0123456789"[x % 10]); Traits::assign(*--buf, '-'); return buf; } for(;x > 0; x /= 10) Traits::assign(*--buf , "0123456789"[x % 10]); return buf; } template<class CharT, class Integer, class Traits> CharT* raw_to_string( CharT* buf, Integer x, std::false_type) { if(x == 0) { *--buf = '0'; return buf; } for(;x > 0; x /= 10) Traits::assign(*--buf , "0123456789"[x % 10]); return buf; } template< class CharT, class Integer, class Traits = std::char_traits<CharT>> CharT* raw_to_string(CharT* last, std::size_t size, Integer i) { boost::ignore_unused(size); BOOST_ASSERT(size >= max_digits(sizeof(Integer))); return raw_to_string<CharT, Integer, Traits>( last, i, std::is_signed<Integer>{}); } } // detail } // beast } // boost #endif PK PP�[���Ÿ � core/detail/pcg.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_PCG_HPP #define BOOST_BEAST_CORE_DETAIL_PCG_HPP #include <boost/core/ignore_unused.hpp> #include <cstdint> #include <random> namespace boost { namespace beast { namespace detail { class pcg { std::uint64_t state_ = 0; std::uint64_t increment_; public: using result_type = std::uint32_t; // Initialize the generator. // There are no restrictions on the input values. pcg( std::uint64_t seed, std::uint64_t stream) { // increment must be odd increment_ = 2 * stream + 1; boost::ignore_unused((*this)()); state_ += seed; boost::ignore_unused((*this)()); } std::uint32_t operator()() { std::uint64_t const p = state_; state_ = p * 6364136223846793005ULL + increment_; std::uint32_t const x = static_cast<std::uint32_t>( ((p >> 18) ^ p) >> 27); std::uint32_t const r = p >> 59; #ifdef BOOST_MSVC return _rotr(x, r); #else return (x >> r) | (x << ((1 + ~r) & 31)); #endif } }; } // detail } // beast } // boost #endif PK PP�[הGW core/detail/flat_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_DETAIL_FLAT_STREAM_HPP #define BOOST_BEAST_CORE_DETAIL_FLAT_STREAM_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/asio/buffer.hpp> #include <cstdlib> namespace boost { namespace beast { namespace detail { class flat_stream_base { public: // Largest buffer size we will flatten. // 16KB is the upper limit on reasonably sized HTTP messages. static std::size_t constexpr max_size = 16 * 1024; // Largest stack we will use to flatten static std::size_t constexpr max_stack = 8 * 1024; struct flatten_result { std::size_t size; bool flatten; }; // calculates the flatten settings for a buffer sequence template<class BufferSequence> static flatten_result flatten( BufferSequence const& buffers, std::size_t limit) { flatten_result result{0, false}; auto first = net::buffer_sequence_begin(buffers); auto last = net::buffer_sequence_end(buffers); if(first != last) { result.size = buffer_bytes(*first); if(result.size < limit) { auto it = first; auto prev = first; while(++it != last) { auto const n = buffer_bytes(*it); if(result.size + n > limit) break; result.size += n; prev = it; } result.flatten = prev != first; } } return result; } }; } // detail } // beast } // boost #endif PK PP�[�p�� � core/detail/static_ostream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_STATIC_OSTREAM_HPP #define BOOST_BEAST_DETAIL_STATIC_OSTREAM_HPP #include <locale> #include <ostream> #include <streambuf> namespace boost { namespace beast { namespace detail { // http://www.mr-edd.co.uk/blog/beginners_guide_streambuf class static_ostream_buffer : public std::basic_streambuf<char> { using CharT = char; using Traits = std::char_traits<CharT>; using int_type = typename std::basic_streambuf<CharT, Traits>::int_type; using traits_type = typename std::basic_streambuf<CharT, Traits>::traits_type; char* data_; std::size_t size_; std::size_t len_ = 0; std::string s_; public: static_ostream_buffer(static_ostream_buffer&&) = delete; static_ostream_buffer(static_ostream_buffer const&) = delete; static_ostream_buffer(char* data, std::size_t size) : data_(data) , size_(size) { this->setp(data_, data_ + size - 1); } ~static_ostream_buffer() noexcept { } string_view str() const { if(! s_.empty()) return {s_.data(), len_}; return {data_, len_}; } int_type overflow(int_type ch) override { if(! Traits::eq_int_type(ch, Traits::eof())) { Traits::assign(*this->pptr(), static_cast<CharT>(ch)); flush(1); prepare(); return ch; } flush(); return traits_type::eof(); } int sync() override { flush(); prepare(); return 0; } private: void prepare() { static auto const growth_factor = 1.5; if(len_ < size_ - 1) { this->setp( data_ + len_, data_ + size_ - 2); return; } if(s_.empty()) { s_.resize(static_cast<std::size_t>( growth_factor * len_)); Traits::copy(&s_[0], data_, len_); } else { s_.resize(static_cast<std::size_t>( growth_factor * len_)); } this->setp(&s_[len_], &s_[len_] + s_.size() - len_ - 1); } void flush(int extra = 0) { len_ += static_cast<std::size_t>( this->pptr() - this->pbase() + extra); } }; class static_ostream : public std::basic_ostream<char> { static_ostream_buffer osb_; public: static_ostream(char* data, std::size_t size) : std::basic_ostream<char>(&this->osb_) , osb_(data, size) { imbue(std::locale::classic()); } string_view str() const { return osb_.str(); } }; } // detail } // beast } // boost #endif PK PP�[}BK K core/detail/temporary_buffer.hppnu �[��� // // Copyright (c) 2019 Damian Jarek(damian.jarek93@gmail.com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_TEMPORARY_BUFFER_HPP #define BOOST_BEAST_DETAIL_TEMPORARY_BUFFER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <memory> namespace boost { namespace beast { namespace detail { struct temporary_buffer { temporary_buffer() = default; temporary_buffer(temporary_buffer const&) = delete; temporary_buffer& operator=(temporary_buffer const&) = delete; ~temporary_buffer() noexcept { deallocate(data_); } BOOST_BEAST_DECL void append(string_view s); BOOST_BEAST_DECL void append(string_view s1, string_view s2); string_view view() const noexcept { return {data_, size_}; } bool empty() const noexcept { return size_ == 0; } private: BOOST_BEAST_DECL void unchecked_append(string_view s); BOOST_BEAST_DECL void grow(std::size_t n); void deallocate(char* data) noexcept { if (data != buffer_) delete[] data; } char buffer_[4096]; char* data_ = buffer_; std::size_t capacity_ = sizeof(buffer_); std::size_t size_ = 0; }; } // detail } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/detail/impl/temporary_buffer.ipp> #endif #endif PK PP�['���[ [ % core/detail/buffers_range_adaptor.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_DETAIL_BUFFERS_RANGE_ADAPTOR_HPP #define BOOST_BEAST_DETAIL_BUFFERS_RANGE_ADAPTOR_HPP #include <boost/beast/core/buffer_traits.hpp> #include <iterator> #include <type_traits> namespace boost { namespace beast { namespace detail { template<class BufferSequence> class buffers_range_adaptor { BufferSequence b_; public: #if BOOST_BEAST_DOXYGEN using value_type = __see_below__; #else using value_type = buffers_type<BufferSequence>; #endif class const_iterator { friend class buffers_range_adaptor; using iter_type = buffers_iterator_type<BufferSequence>; iter_type it_{}; const_iterator(iter_type const& it) : it_(it) { } public: using value_type = typename buffers_range_adaptor::value_type; using pointer = value_type const*; using reference = value_type; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; const_iterator() = default; bool operator==(const_iterator const& other) const { return it_ == other.it_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { return *it_; } pointer operator->() const = delete; const_iterator& operator++() { ++it_; return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } const_iterator& operator--() { --it_; return *this; } const_iterator operator--(int) { auto temp = *this; --(*this); return temp; } }; explicit buffers_range_adaptor(BufferSequence const& b) : b_(b) { } const_iterator begin() const noexcept { return {net::buffer_sequence_begin(b_)}; } const_iterator end() const noexcept { return {net::buffer_sequence_end(b_)}; } }; } // detail } // beast } // boost #endif PK PP�["��0* * core/role.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_ROLE_HPP #define BOOST_BEAST_ROLE_HPP #include <boost/beast/core/detail/config.hpp> namespace boost { namespace beast { /** The role of local or remote peer. Whether the endpoint is a client or server affects the behavior of teardown. The teardown behavior also depends on the type of the stream being torn down. The default implementation of teardown for regular TCP/IP sockets is as follows: @li In the client role, a TCP/IP shutdown is sent after reading all remaining data on the connection. @li In the server role, a TCP/IP shutdown is sent before reading all remaining data on the connection. When the next layer type is a `net::ssl::stream`, the connection is closed by performing the SSL closing handshake corresponding to the role type, client or server. */ enum class role_type { /// The stream is operating as a client. client, /// The stream is operating as a server. server }; } // beast } // boost #endif PK PP�[H�� core/buffers_adaptor.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_ADAPTOR_HPP #define BOOST_BEAST_BUFFERS_ADAPTOR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/optional.hpp> #include <type_traits> namespace boost { namespace beast { /** Adapts a <em>MutableBufferSequence</em> into a <em>DynamicBuffer</em>. This class wraps a <em>MutableBufferSequence</em> to meet the requirements of <em>DynamicBuffer</em>. Upon construction the input and output sequences are empty. A copy of the mutable buffer sequence object is stored; however, ownership of the underlying memory is not transferred. The caller is responsible for making sure that referenced memory remains valid for the duration of any operations. The size of the mutable buffer sequence determines the maximum number of bytes which may be prepared and committed. @tparam MutableBufferSequence The type of mutable buffer sequence to adapt. */ template<class MutableBufferSequence> class buffers_adaptor { static_assert(net::is_mutable_buffer_sequence< MutableBufferSequence>::value, "MutableBufferSequence type requirements not met"); using iter_type = buffers_iterator_type<MutableBufferSequence>; template<bool> class subrange; MutableBufferSequence bs_; iter_type begin_; iter_type out_; iter_type end_; std::size_t max_size_; std::size_t in_pos_ = 0; // offset in *begin_ std::size_t in_size_ = 0; // size of input sequence std::size_t out_pos_ = 0; // offset in *out_ std::size_t out_end_ = 0; // output end offset iter_type end_impl() const; buffers_adaptor( buffers_adaptor const& other, std::size_t nbegin, std::size_t nout, std::size_t nend); public: /// The type of the underlying mutable buffer sequence using value_type = MutableBufferSequence; /** Construct a buffers adaptor. @param buffers The mutable buffer sequence to wrap. A copy of the object will be made, but ownership of the memory is not transferred. */ explicit buffers_adaptor(MutableBufferSequence const& buffers); /** Constructor This constructs the buffer adaptor in-place from a list of arguments. @param args Arguments forwarded to the buffers constructor. */ template<class... Args> explicit buffers_adaptor(boost::in_place_init_t, Args&&... args); /// Copy Constructor buffers_adaptor(buffers_adaptor const& other); /// Copy Assignment buffers_adaptor& operator=(buffers_adaptor const&); /// Returns the original mutable buffer sequence value_type const& value() const { return bs_; } //-------------------------------------------------------------------------- #if BOOST_BEAST_DOXYGEN /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = __implementation_defined__; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = __implementation_defined__; #else using const_buffers_type = subrange<false>; using mutable_buffers_type = subrange<true>; #endif /// Returns the number of readable bytes. std::size_t size() const noexcept { return in_size_; } /// Return the maximum number of bytes, both readable and writable, that can ever be held. std::size_t max_size() const noexcept { return max_size_; } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept { return max_size_; } /// Returns a constant buffer sequence representing the readable bytes const_buffers_type data() const noexcept; /// Returns a constant buffer sequence representing the readable bytes const_buffers_type cdata() const noexcept { return data(); } /// Returns a mutable buffer sequence representing the readable bytes. mutable_buffers_type data() noexcept; /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. This function does not allocate memory. Instead, the storage comes from the underlying mutable buffer sequence. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds `max_size()`. @esafe Strong guarantee. */ mutable_buffers_type prepare(std::size_t n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ void commit(std::size_t n) noexcept; /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ void consume(std::size_t n) noexcept; private: subrange<true> make_subrange(std::size_t pos, std::size_t n); subrange<false> make_subrange(std::size_t pos, std::size_t n) const; friend struct buffers_adaptor_test_hook; }; } // beast } // boost #include <boost/beast/core/impl/buffers_adaptor.hpp> #endif PK PP�[yU��� � core/span.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_SPAN_HPP #define BOOST_BEAST_CORE_SPAN_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/type_traits.hpp> #include <algorithm> #include <iterator> #include <string> #include <type_traits> namespace boost { namespace beast { /** A range of bytes expressed as a ContiguousContainer This class implements a non-owning reference to a storage area of a certain size and having an underlying integral type with size of 1. @tparam T The type pointed to by span iterators */ template<class T> class span { T* data_ = nullptr; std::size_t size_ = 0; public: /// The type of value, including cv qualifiers using element_type = T; /// The type of value of each span element using value_type = typename std::remove_const<T>::type; /// The type of integer used to index the span using index_type = std::ptrdiff_t; /// A pointer to a span element using pointer = T*; /// A reference to a span element using reference = T&; /// The iterator used by the container using iterator = pointer; /// The const pointer used by the container using const_pointer = T const*; /// The const reference used by the container using const_reference = T const&; /// The const iterator used by the container using const_iterator = const_pointer; /// Constructor span() = default; /// Constructor span(span const&) = default; /// Assignment span& operator=(span const&) = default; /** Constructor @param data A pointer to the beginning of the range of elements @param size The number of elements pointed to by `data` */ span(T* data, std::size_t size) : data_(data), size_(size) { } /** Constructor @param container The container to construct from */ template<class ContiguousContainer #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< detail::is_contiguous_container< ContiguousContainer, T>::value>::type #endif > explicit span(ContiguousContainer&& container) : data_(container.data()) , size_(container.size()) { } #if ! BOOST_BEAST_DOXYGEN template<class CharT, class Traits, class Allocator> explicit span(std::basic_string<CharT, Traits, Allocator>& s) : data_(&s[0]) , size_(s.size()) { } template<class CharT, class Traits, class Allocator> explicit span(std::basic_string<CharT, Traits, Allocator> const& s) : data_(s.data()) , size_(s.size()) { } #endif /** Assignment @param container The container to assign from */ template<class ContiguousContainer> #if BOOST_BEAST_DOXYGEN span& #else typename std::enable_if<detail::is_contiguous_container< ContiguousContainer, T>::value, span&>::type #endif operator=(ContiguousContainer&& container) { data_ = container.data(); size_ = container.size(); return *this; } #if ! BOOST_BEAST_DOXYGEN template<class CharT, class Traits, class Allocator> span& operator=(std::basic_string< CharT, Traits, Allocator>& s) { data_ = &s[0]; size_ = s.size(); return *this; } template<class CharT, class Traits, class Allocator> span& operator=(std::basic_string< CharT, Traits, Allocator> const& s) { data_ = s.data(); size_ = s.size(); return *this; } #endif /// Returns `true` if the span is empty bool empty() const { return size_ == 0; } /// Returns a pointer to the beginning of the span T* data() const { return data_; } /// Returns the number of elements in the span std::size_t size() const { return size_; } /// Returns an iterator to the beginning of the span const_iterator begin() const { return data_; } /// Returns an iterator to the beginning of the span const_iterator cbegin() const { return data_; } /// Returns an iterator to one past the end of the span const_iterator end() const { return data_ + size_; } /// Returns an iterator to one past the end of the span const_iterator cend() const { return data_ + size_; } }; } // beast } // boost #endif PK PP�[c�r�� � core/file_base.hppnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FILE_BASE_HPP #define BOOST_BEAST_CORE_FILE_BASE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/type_traits/make_void.hpp> #include <type_traits> namespace boost { namespace beast { /* file_mode acesss sharing seeking file std mode -------------------------------------------------------------------------------------- read read-only shared random must exist "rb" scan read-only shared sequential must exist "rbS" write read/write exclusive random create/truncate "wb+" write_new read/write exclusive random must not exist "wbx" write_existing read/write exclusive random must exist "rb+" append write-only exclusive sequential create/truncate "ab" append_existing write-only exclusive sequential must exist "ab" */ /** File open modes These modes are used when opening files using instances of the <em>File</em> concept. @see file_stdio */ enum class file_mode { /// Random read-only access to an existing file read, /// Sequential read-only access to an existing file scan, /** Random reading and writing to a new or truncated file This mode permits random-access reading and writing for the specified file. If the file does not exist prior to the function call, it is created with an initial size of zero bytes. Otherwise if the file already exists, the size is truncated to zero bytes. */ write, /** Random reading and writing to a new file only This mode permits random-access reading and writing for the specified file. The file will be created with an initial size of zero bytes. If the file already exists prior to the function call, an error is returned and no file is opened. */ write_new, /** Random write-only access to existing file If the file does not exist, an error is generated. */ write_existing, /** Appending to a new or truncated file The current file position shall be set to the end of the file prior to each write. @li If the file does not exist, it is created. @li If the file exists, it is truncated to zero size upon opening. */ append, /** Appending to an existing file The current file position shall be set to the end of the file prior to each write. If the file does not exist, an error is generated. */ append_existing }; /** Determine if `T` meets the requirements of <em>File</em>. Metafunctions are used to perform compile time checking of template types. This type will be `std::true_type` if `T` meets the requirements, else the type will be `std::false_type`. @par Example Use with `static_assert`: @code template<class File> void f(File& file) { static_assert(is_file<File>::value, "File type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<class File> typename std::enable_if<is_file<File>::value>::type f(File& file); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> struct is_file : std::integral_constant<bool, ...>{}; #else template<class T, class = void> struct is_file : std::false_type {}; template<class T> struct is_file<T, boost::void_t<decltype( std::declval<bool&>() = std::declval<T const&>().is_open(), std::declval<T&>().close(std::declval<error_code&>()), std::declval<T&>().open( std::declval<char const*>(), std::declval<file_mode>(), std::declval<error_code&>()), std::declval<std::uint64_t&>() = std::declval<T&>().size( std::declval<error_code&>()), std::declval<std::uint64_t&>() = std::declval<T&>().pos( std::declval<error_code&>()), std::declval<T&>().seek( std::declval<std::uint64_t>(), std::declval<error_code&>()), std::declval<std::size_t&>() = std::declval<T&>().read( std::declval<void*>(), std::declval<std::size_t>(), std::declval<error_code&>()), std::declval<std::size_t&>() = std::declval<T&>().write( std::declval<void const*>(), std::declval<std::size_t>(), std::declval<error_code&>()) )>> : std::integral_constant<bool, std::is_default_constructible<T>::value && std::is_destructible<T>::value > {}; #endif } // beast } // boost #endif PK PP�[���� core/buffers_prefix.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERS_PREFIX_HPP #define BOOST_BEAST_BUFFERS_PREFIX_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/optional/optional.hpp> // for in_place_init_t #include <algorithm> #include <cstdint> #include <type_traits> #if BOOST_WORKAROUND(BOOST_MSVC, < 1910) #include <boost/type_traits/is_convertible.hpp> #endif namespace boost { namespace beast { /** A buffer sequence adaptor that shortens the sequence size. The class adapts a buffer sequence to efficiently represent a shorter subset of the original list of buffers starting with the first byte of the original sequence. @tparam BufferSequence The buffer sequence to adapt. */ template<class BufferSequence> class buffers_prefix_view { using iter_type = buffers_iterator_type<BufferSequence>; BufferSequence bs_; std::size_t size_ = 0; std::size_t remain_ = 0; iter_type end_{}; void setup(std::size_t size); buffers_prefix_view( buffers_prefix_view const& other, std::size_t dist); public: /** The type for each element in the list of buffers. If the type `BufferSequence` meets the requirements of <em>MutableBufferSequence</em>, then `value_type` is `net::mutable_buffer`. Otherwise, `value_type` is `net::const_buffer`. @see buffers_type */ #if BOOST_BEAST_DOXYGEN using value_type = __see_below__; #elif BOOST_WORKAROUND(BOOST_MSVC, < 1910) using value_type = typename std::conditional< boost::is_convertible<typename std::iterator_traits<iter_type>::value_type, net::mutable_buffer>::value, net::mutable_buffer, net::const_buffer>::type; #else using value_type = buffers_type<BufferSequence>; #endif #if BOOST_BEAST_DOXYGEN /// A bidirectional iterator type that may be used to read elements. using const_iterator = __implementation_defined__; #else class const_iterator; #endif /// Copy Constructor buffers_prefix_view(buffers_prefix_view const&); /// Copy Assignment buffers_prefix_view& operator=(buffers_prefix_view const&); /** Construct a buffer sequence prefix. @param size The maximum number of bytes in the prefix. If this is larger than the size of passed buffers, the resulting sequence will represent the entire input sequence. @param buffers The buffer sequence to adapt. A copy of the sequence will be made, but ownership of the underlying memory is not transferred. The copy is maintained for the lifetime of the view. */ buffers_prefix_view( std::size_t size, BufferSequence const& buffers); /** Construct a buffer sequence prefix in-place. @param size The maximum number of bytes in the prefix. If this is larger than the size of passed buffers, the resulting sequence will represent the entire input sequence. @param args Arguments forwarded to the contained buffer's constructor. */ template<class... Args> buffers_prefix_view( std::size_t size, boost::in_place_init_t, Args&&... args); /// Returns an iterator to the first buffer in the sequence const_iterator begin() const; /// Returns an iterator to one past the last buffer in the sequence const_iterator end() const; #if ! BOOST_BEAST_DOXYGEN std::size_t buffer_bytes_impl() const noexcept { return size_; } #endif }; //------------------------------------------------------------------------------ /** Returns a prefix of a constant or mutable buffer sequence. The returned buffer sequence points to the same memory as the passed buffer sequence, but with a size that is equal to or smaller. No memory allocations are performed; the resulting sequence is calculated as a lazy range. @param size The maximum size of the returned buffer sequence in bytes. If this is greater than or equal to the size of the passed buffer sequence, the result will have the same size as the original buffer sequence. @param buffers An object whose type meets the requirements of <em>BufferSequence</em>. The returned value will maintain a copy of the passed buffers for its lifetime; however, ownership of the underlying memory is not transferred. @return A constant buffer sequence that represents the prefix of the original buffer sequence. If the original buffer sequence also meets the requirements of <em>MutableBufferSequence</em>, then the returned value will also be a mutable buffer sequence. */ template<class BufferSequence> buffers_prefix_view<BufferSequence> buffers_prefix( std::size_t size, BufferSequence const& buffers) { static_assert( net::is_const_buffer_sequence<BufferSequence>::value, "BufferSequence type requirements not met"); return buffers_prefix_view<BufferSequence>(size, buffers); } /** Returns the first buffer in a buffer sequence This returns the first buffer in the buffer sequence. If the buffer sequence is an empty range, the returned buffer will have a zero buffer size. @param buffers The buffer sequence. If the sequence is mutable, the returned buffer sequence will also be mutable. Otherwise, the returned buffer sequence will be constant. */ template<class BufferSequence> buffers_type<BufferSequence> buffers_front(BufferSequence const& buffers) { auto const first = net::buffer_sequence_begin(buffers); if(first == net::buffer_sequence_end(buffers)) return {}; return *first; } } // beast } // boost #include <boost/beast/core/impl/buffers_prefix.hpp> #endif PK PP�[�z�ye. e. core/buffered_read_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_BUFFERED_READ_STREAM_HPP #define BOOST_BEAST_BUFFERED_READ_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/multi_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/buffer.hpp> #include <boost/asio/io_context.hpp> #include <cstdint> #include <utility> namespace boost { namespace beast { /** A <em>Stream</em> with attached <em>DynamicBuffer</em> to buffer reads. This wraps a <em>Stream</em> implementation so that calls to write are passed through to the underlying stream, while calls to read will first consume the input sequence stored in a <em>DynamicBuffer</em> which is part of the object. The use-case for this class is different than that of the `net::buffered_read_stream`. It is designed to facilitate the use of `net::read_until`, and to allow buffers acquired during detection of handshakes to be made transparently available to callers. A hypothetical implementation of the buffered version of `net::ssl::stream::async_handshake` could make use of this wrapper. Uses: @li Transparently leave untouched input acquired in calls to `net::read_until` behind for subsequent callers. @li "Preload" a stream with handshake input data acquired from other sources. Example: @code // Process the next HTTP header on the stream, // leaving excess bytes behind for the next call. // template<class Stream, class DynamicBuffer> void process_http_message( buffered_read_stream<Stream, DynamicBuffer>& stream) { // Read up to and including the end of the HTTP // header, leaving the sequence in the stream's // buffer. read_until may read past the end of the // headers; the return value will include only the // part up to the end of the delimiter. // std::size_t bytes_transferred = net::read_until( stream.next_layer(), stream.buffer(), "\r\n\r\n"); // Use buffers_prefix() to limit the input // sequence to only the data up to and including // the trailing "\r\n\r\n". // auto header_buffers = buffers_prefix( bytes_transferred, stream.buffer().data()); ... // Discard the portion of the input corresponding // to the HTTP headers. // stream.buffer().consume(bytes_transferred); // Everything we read from the stream // is part of the content-body. } @endcode @tparam Stream The type of stream to wrap. @tparam DynamicBuffer The type of stream buffer to use. */ template<class Stream, class DynamicBuffer> class buffered_read_stream { static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); struct ops; DynamicBuffer buffer_; std::size_t capacity_ = 0; Stream next_layer_; public: /// The type of the internal buffer using buffer_type = DynamicBuffer; /// The type of the next layer. using next_layer_type = typename std::remove_reference<Stream>::type; /** Move constructor. @note The behavior of move assignment on or from streams with active or pending operations is undefined. */ buffered_read_stream(buffered_read_stream&&) = default; /** Move assignment. @note The behavior of move assignment on or from streams with active or pending operations is undefined. */ buffered_read_stream& operator=(buffered_read_stream&&) = default; /** Construct the wrapping stream. @param args Parameters forwarded to the `Stream` constructor. */ template<class... Args> explicit buffered_read_stream(Args&&... args); /// Get a reference to the next layer. next_layer_type& next_layer() noexcept { return next_layer_; } /// Get a const reference to the next layer. next_layer_type const& next_layer() const noexcept { return next_layer_; } using executor_type = beast::executor_type<next_layer_type>; /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept { return next_layer_.get_executor(); } /** Access the internal buffer. The internal buffer is returned. It is possible for the caller to break invariants with this function. For example, by causing the internal buffer size to increase beyond the caller defined maximum. */ DynamicBuffer& buffer() noexcept { return buffer_; } /// Access the internal buffer DynamicBuffer const& buffer() const noexcept { return buffer_; } /** Set the maximum buffer size. This changes the maximum size of the internal buffer used to hold read data. No bytes are discarded by this call. If the buffer size is set to zero, no more data will be buffered. Thread safety: The caller is responsible for making sure the call is made from the same implicit or explicit strand. @param size The number of bytes in the read buffer. @note This is a soft limit. If the new maximum size is smaller than the amount of data in the buffer, no bytes are discarded. */ void capacity(std::size_t size) noexcept { capacity_ = size; } /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers One or more buffers into which the data will be read. @return The number of bytes read. @throws system_error Thrown on failure. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers); /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers One or more buffers into which the data will be read. @param ec Set to the error, if any occurred. @return The number of bytes read, or 0 on error. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers, error_code& ec); /** Start an asynchronous read. This function is used to asynchronously read data from the stream. The function call always returns immediately. @param buffers One or more buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // number of bytes transferred ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t<executor_type>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler = net::default_completion_token_t<executor_type>{}); /** Write some data to the stream. This function is used to write data to the stream. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs. @param buffers One or more data buffers to be written to the stream. @return The number of bytes written. @throws system_error Thrown on failure. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers) { static_assert(is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); return next_layer_.write_some(buffers); } /** Write some data to the stream. This function is used to write data to the stream. The function call will block until one or more bytes of the data has been written successfully, or until an error occurs. @param buffers One or more data buffers to be written to the stream. @param ec Set to the error, if any occurred. @return The number of bytes written. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers, error_code& ec) { static_assert(is_sync_write_stream<next_layer_type>::value, "SyncWriteStream type requirements not met"); return next_layer_.write_some(buffers, ec); } /** Start an asynchronous write. This function is used to asynchronously write data from the stream. The function call always returns immediately. @param buffers One or more data buffers to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // number of bytes transferred ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t<executor_type>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t<executor_type>{}); }; } // beast } // boost #include <boost/beast/core/impl/buffered_read_stream.hpp> #endif PK PP�[�(b� core/file.hppnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FILE_HPP #define BOOST_BEAST_CORE_FILE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/file_base.hpp> #include <boost/beast/core/file_posix.hpp> #include <boost/beast/core/file_stdio.hpp> #include <boost/beast/core/file_win32.hpp> namespace boost { namespace beast { /** An implementation of File. This alias is set to the best available implementation of <em>File</em> given the platform and build settings. */ #if BOOST_BEAST_DOXYGEN struct file : file_stdio { }; #else #if BOOST_BEAST_USE_WIN32_FILE using file = file_win32; #elif BOOST_BEAST_USE_POSIX_FILE using file = file_posix; #else using file = file_stdio; #endif #endif } // beast } // boost #endif PK PP�[8�7�F �F core/multi_buffer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_MULTI_BUFFER_HPP #define BOOST_BEAST_MULTI_BUFFER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/allocator.hpp> #include <boost/asio/buffer.hpp> #include <boost/core/empty_value.hpp> #include <boost/intrusive/list.hpp> #include <boost/type_traits/type_with_alignment.hpp> #include <iterator> #include <limits> #include <memory> #include <type_traits> namespace boost { namespace beast { /** A dynamic buffer providing sequences of variable length. A dynamic buffer encapsulates memory storage that may be automatically resized as required, where the memory is divided into two regions: readable bytes followed by writable bytes. These memory regions are internal to the dynamic buffer, but direct access to the elements is provided to permit them to be efficiently used with I/O operations. The implementation uses a sequence of one or more byte arrays of varying sizes to represent the readable and writable bytes. Additional byte array objects are appended to the sequence to accommodate changes in the desired size. The behavior and implementation of this container is most similar to `std::deque`. Objects of this type meet the requirements of <em>DynamicBuffer</em> and have the following additional properties: @li A mutable buffer sequence representing the readable bytes is returned by @ref data when `this` is non-const. @li Buffer sequences representing the readable and writable bytes, returned by @ref data and @ref prepare, may have length greater than one. @li A configurable maximum size may be set upon construction and adjusted afterwards. Calls to @ref prepare that would exceed this size will throw `std::length_error`. @li Sequences previously obtained using @ref data remain valid after calls to @ref prepare or @ref commit. @tparam Allocator The allocator to use for managing memory. */ template<class Allocator> class basic_multi_buffer #if ! BOOST_BEAST_DOXYGEN : private boost::empty_value<Allocator> #endif { // Fancy pointers are not supported static_assert(std::is_pointer<typename std::allocator_traits<Allocator>::pointer>::value, "Allocator must use regular pointers"); static bool constexpr default_nothrow = std::is_nothrow_default_constructible<Allocator>::value; // Storage for the list of buffers representing the input // and output sequences. The allocation for each element // contains `element` followed by raw storage bytes. class element : public boost::intrusive::list_base_hook< boost::intrusive::link_mode< boost::intrusive::normal_link>> { using size_type = typename detail::allocator_traits<Allocator>::size_type; size_type const size_; public: element(element const&) = delete; explicit element(size_type n) noexcept : size_(n) { } size_type size() const noexcept { return size_; } char* data() const noexcept { return const_cast<char*>( reinterpret_cast<char const*>(this + 1)); } }; template<bool> class subrange; using size_type = typename detail::allocator_traits<Allocator>::size_type; using align_type = typename boost::type_with_alignment<alignof(element)>::type; using rebind_type = typename beast::detail::allocator_traits<Allocator>:: template rebind_alloc<align_type>; using alloc_traits = beast::detail::allocator_traits<rebind_type>; using list_type = typename boost::intrusive::make_list< element, boost::intrusive::constant_time_size<true>>::type; using iter = typename list_type::iterator; using const_iter = typename list_type::const_iterator; using pocma = typename alloc_traits::propagate_on_container_move_assignment; using pocca = typename alloc_traits::propagate_on_container_copy_assignment; static_assert(std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<iter>::iterator_category>::value, "BidirectionalIterator type requirements not met"); static_assert(std::is_base_of<std::bidirectional_iterator_tag, typename std::iterator_traits<const_iter>::iterator_category>::value, "BidirectionalIterator type requirements not met"); std::size_t max_; list_type list_; // list of allocated buffers iter out_; // element that contains out_pos_ size_type in_size_ = 0; // size of the input sequence size_type in_pos_ = 0; // input offset in list_.front() size_type out_pos_ = 0; // output offset in *out_ size_type out_end_ = 0; // output end offset in list_.back() public: #if BOOST_BEAST_DOXYGEN /// The ConstBufferSequence used to represent the readable bytes. using const_buffers_type = __implementation_defined__; /// The MutableBufferSequence used to represent the writable bytes. using mutable_buffers_type = __implementation_defined__; #else using const_buffers_type = subrange<false>; using mutable_buffers_type = subrange<true>; #endif /// The type of allocator used. using allocator_type = Allocator; /// Destructor ~basic_multi_buffer(); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the largest value which may be passed to the allocator's `allocate` function. */ basic_multi_buffer() noexcept(default_nothrow); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the specified value of `limit`. @param limit The desired maximum size. */ explicit basic_multi_buffer( std::size_t limit) noexcept(default_nothrow); /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the largest value which may be passed to the allocator's `allocate` function. @param alloc The allocator to use for the object. @esafe No-throw guarantee. */ explicit basic_multi_buffer(Allocator const& alloc) noexcept; /** Constructor After construction, @ref capacity will return zero, and @ref max_size will return the specified value of `limit`. @param limit The desired maximum size. @param alloc The allocator to use for the object. @esafe No-throw guarantee. */ basic_multi_buffer( std::size_t limit, Allocator const& alloc) noexcept; /** Move Constructor The container is constructed with the contents of `other` using move semantics. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare remain valid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. @esafe No-throw guarantee. */ basic_multi_buffer(basic_multi_buffer&& other) noexcept; /** Move Constructor Using `alloc` as the allocator for the new container, the contents of `other` are moved. If `alloc != other.get_allocator()`, this results in a copy. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare become invalid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ basic_multi_buffer( basic_multi_buffer&& other, Allocator const& alloc); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ basic_multi_buffer(basic_multi_buffer const& other); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics and the specified allocator. The maximum size will be the same as the copied object. @param other The object to copy from. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ basic_multi_buffer(basic_multi_buffer const& other, Allocator const& alloc); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ template<class OtherAlloc> basic_multi_buffer(basic_multi_buffer< OtherAlloc> const& other); /** Copy Constructor This container is constructed with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. @param other The object to copy from. @param alloc The allocator to use for the object. @throws std::length_error if `other.size()` exceeds the maximum allocation size of `alloc`. */ template<class OtherAlloc> basic_multi_buffer( basic_multi_buffer<OtherAlloc> const& other, allocator_type const& alloc); /** Move Assignment The container is assigned with the contents of `other` using move semantics. The maximum size will be the same as the moved-from object. Buffer sequences previously obtained from `other` using @ref data or @ref prepare remain valid after the move. @param other The object to move from. After the move, the moved-from object will have zero capacity, zero readable bytes, and zero writable bytes. */ basic_multi_buffer& operator=(basic_multi_buffer&& other); /** Copy Assignment The container is assigned with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. After the copy, `this` will have zero writable bytes. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ basic_multi_buffer& operator=( basic_multi_buffer const& other); /** Copy Assignment The container is assigned with the contents of `other` using copy semantics. The maximum size will be the same as the copied object. After the copy, `this` will have zero writable bytes. @param other The object to copy from. @throws std::length_error if `other.size()` exceeds the maximum allocation size of the allocator. */ template<class OtherAlloc> basic_multi_buffer& operator=( basic_multi_buffer<OtherAlloc> const& other); /// Returns a copy of the allocator used. allocator_type get_allocator() const { return this->get(); } /** Set the maximum allowed capacity This function changes the currently configured upper limit on capacity to the specified value. @param n The maximum number of bytes ever allowed for capacity. @esafe No-throw guarantee. */ void max_size(std::size_t n) noexcept { max_ = n; } /** Guarantee a minimum capacity This function adjusts the internal storage (if necessary) to guarantee space for at least `n` bytes. Buffer sequences previously obtained using @ref data remain valid, while buffer sequences previously obtained using @ref prepare become invalid. @param n The minimum number of byte for the new capacity. If this value is greater than the maximum size, then the maximum size will be adjusted upwards to this value. @throws std::length_error if n is larger than the maximum allocation size of the allocator. @esafe Strong guarantee. */ void reserve(std::size_t n); /** Reallocate the buffer to fit the readable bytes exactly. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @esafe Strong guarantee. */ void shrink_to_fit(); /** Set the size of the readable and writable bytes to zero. This clears the buffer without changing capacity. Buffer sequences previously obtained using @ref data or @ref prepare become invalid. @esafe No-throw guarantee. */ void clear() noexcept; /// Exchange two dynamic buffers template<class Alloc> friend void swap( basic_multi_buffer<Alloc>& lhs, basic_multi_buffer<Alloc>& rhs) noexcept; //-------------------------------------------------------------------------- /// Returns the number of readable bytes. size_type size() const noexcept { return in_size_; } /// Return the maximum number of bytes, both readable and writable, that can ever be held. size_type max_size() const noexcept { return max_; } /// Return the maximum number of bytes, both readable and writable, that can be held without requiring an allocation. std::size_t capacity() const noexcept; /** Returns a constant buffer sequence representing the readable bytes @note The sequence may contain multiple contiguous memory regions. */ const_buffers_type data() const noexcept; /** Returns a constant buffer sequence representing the readable bytes @note The sequence may contain multiple contiguous memory regions. */ const_buffers_type cdata() const noexcept { return data(); } /** Returns a mutable buffer sequence representing the readable bytes. @note The sequence may contain multiple contiguous memory regions. */ mutable_buffers_type data() noexcept; /** Returns a mutable buffer sequence representing writable bytes. Returns a mutable buffer sequence representing the writable bytes containing exactly `n` bytes of storage. Memory may be reallocated as needed. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The desired number of bytes in the returned buffer sequence. @throws std::length_error if `size() + n` exceeds `max_size()`. @esafe Strong guarantee. */ mutable_buffers_type prepare(size_type n); /** Append writable bytes to the readable bytes. Appends n bytes from the start of the writable bytes to the end of the readable bytes. The remainder of the writable bytes are discarded. If n is greater than the number of writable bytes, all writable bytes are appended to the readable bytes. All buffer sequences previously obtained using @ref prepare are invalidated. Buffer sequences previously obtained using @ref data remain valid. @param n The number of bytes to append. If this number is greater than the number of writable bytes, all writable bytes are appended. @esafe No-throw guarantee. */ void commit(size_type n) noexcept; /** Remove bytes from beginning of the readable bytes. Removes n bytes from the beginning of the readable bytes. All buffers sequences previously obtained using @ref data or @ref prepare are invalidated. @param n The number of bytes to remove. If this number is greater than the number of readable bytes, all readable bytes are removed. @esafe No-throw guarantee. */ void consume(size_type n) noexcept; private: template<class OtherAlloc> friend class basic_multi_buffer; template<class OtherAlloc> void copy_from(basic_multi_buffer<OtherAlloc> const&); void move_assign(basic_multi_buffer& other, std::false_type); void move_assign(basic_multi_buffer& other, std::true_type) noexcept; void copy_assign(basic_multi_buffer const& other, std::false_type); void copy_assign(basic_multi_buffer const& other, std::true_type); void swap(basic_multi_buffer&) noexcept; void swap(basic_multi_buffer&, std::true_type) noexcept; void swap(basic_multi_buffer&, std::false_type) noexcept; void destroy(list_type& list) noexcept; void destroy(const_iter it); void destroy(element& e); element& alloc(std::size_t size); void debug_check() const; }; /// A typical multi buffer using multi_buffer = basic_multi_buffer<std::allocator<char>>; } // beast } // boost #include <boost/beast/core/impl/multi_buffer.hpp> #endifPK PP�[��xd xd core/static_string.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STATIC_STRING_HPP #define BOOST_BEAST_STATIC_STRING_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/static_string.hpp> #include <algorithm> #include <cstdint> #include <initializer_list> #include <iosfwd> #include <stdexcept> #include <string> #include <type_traits> namespace boost { namespace beast { /** A modifiable string with a fixed-size storage area. These objects behave like `std::string` except that the storage is not dynamically allocated but rather fixed in size. These strings offer performance advantages when a protocol imposes a natural small upper limit on the size of a value. @note The stored string is always null-terminated. @see to_static_string */ template< std::size_t N, class CharT = char, class Traits = std::char_traits<CharT>> class static_string { template<std::size_t, class, class> friend class static_string; void term() { Traits::assign(s_[n_], 0); } std::size_t n_; CharT s_[N+1]; public: // // Member types // using traits_type = Traits; using value_type = typename Traits::char_type; using size_type = std::size_t; using difference_type = std::ptrdiff_t; using pointer = value_type*; using reference = value_type&; using const_pointer = value_type const*; using const_reference = value_type const&; using iterator = value_type*; using const_iterator = value_type const*; using reverse_iterator = std::reverse_iterator<iterator>; using const_reverse_iterator = std::reverse_iterator<const_iterator>; /// The type of `string_view` returned by the interface using string_view_type = basic_string_view<CharT, Traits>; // // Constants // /// Maximum size of the string excluding the null terminator static std::size_t constexpr max_size_n = N; /// A special index static constexpr size_type npos = size_type(-1); // // (constructor) // /// Default constructor (empty string). static_string(); /** Construct with count copies of character `ch`. The behavior is undefined if `count >= npos` */ static_string(size_type count, CharT ch); /// Construct with a substring (pos, other.size()) of `other`. template<std::size_t M> static_string(static_string<M, CharT, Traits> const& other, size_type pos); /// Construct with a substring (pos, count) of `other`. template<std::size_t M> static_string(static_string<M, CharT, Traits> const& other, size_type pos, size_type count); /// Construct with the first `count` characters of `s`, including nulls. static_string(CharT const* s, size_type count); /// Construct from a null terminated string. static_string(CharT const* s); /// Construct from a range of characters template<class InputIt> static_string(InputIt first, InputIt last); /// Copy constructor. static_string(static_string const& other); /// Copy constructor. template<std::size_t M> static_string(static_string<M, CharT, Traits> const& other); /// Construct from an initializer list static_string(std::initializer_list<CharT> init); /// Construct from a `string_view` explicit static_string(string_view_type sv); /** Construct from any object convertible to `string_view_type`. The range (pos, n) is extracted from the value obtained by converting `t` to `string_view_type`, and used to construct the string. */ #if BOOST_BEAST_DOXYGEN template<class T> #else template<class T, class = typename std::enable_if< std::is_convertible<T, string_view_type>::value>::type> #endif static_string(T const& t, size_type pos, size_type n); // // (assignment) // /// Copy assignment. static_string& operator=(static_string const& str) { return assign(str); } /// Copy assignment. template<std::size_t M> static_string& operator=(static_string<M, CharT, Traits> const& str) { return assign(str); } /// Assign from null-terminated string. static_string& operator=(CharT const* s); /// Assign from single character. static_string& operator=(CharT ch) { return assign_char(ch, std::integral_constant<bool, (N>0)>{}); } /// Assign from initializer list. static_string& operator=(std::initializer_list<CharT> init) { return assign(init); } /// Assign from `string_view_type`. static_string& operator=(string_view_type sv) { return assign(sv); } /// Assign `count` copies of `ch`. static_string& assign(size_type count, CharT ch); /// Assign from another `static_string` static_string& assign(static_string const& str); // VFALCO NOTE this could come in two flavors, // N>M and N<M, and skip the exception // check when N>M /// Assign from another `static_string` template<std::size_t M> static_string& assign(static_string<M, CharT, Traits> const& str) { return assign(str.data(), str.size()); } /// Assign `count` characterss starting at `npos` from `other`. template<std::size_t M> static_string& assign(static_string<M, CharT, Traits> const& str, size_type pos, size_type count = npos); /// Assign the first `count` characters of `s`, including nulls. static_string& assign(CharT const* s, size_type count); /// Assign a null terminated string. static_string& assign(CharT const* s) { return assign(s, Traits::length(s)); } /// Assign from an iterator range of characters. template<class InputIt> static_string& assign(InputIt first, InputIt last); /// Assign from initializer list. static_string& assign(std::initializer_list<CharT> init) { return assign(init.begin(), init.end()); } /// Assign from `string_view_type`. static_string& assign(string_view_type str) { return assign(str.data(), str.size()); } /** Assign from any object convertible to `string_view_type`. The range (pos, n) is extracted from the value obtained by converting `t` to `string_view_type`, and used to assign the string. */ template<class T> #if BOOST_BEAST_DOXYGEN static_string& #else typename std::enable_if<std::is_convertible<T, string_view_type>::value, static_string&>::type #endif assign(T const& t, size_type pos, size_type count = npos); // // Element access // /// Access specified character with bounds checking. reference at(size_type pos); /// Access specified character with bounds checking. const_reference at(size_type pos) const; /// Access specified character. reference operator[](size_type pos) { return s_[pos]; } /// Access specified character. const_reference operator[](size_type pos) const { return s_[pos]; } /// Accesses the first character. CharT& front() { return s_[0]; } /// Accesses the first character. CharT const& front() const { return s_[0]; } /// Accesses the last character. CharT& back() { return s_[n_-1]; } /// Accesses the last character. CharT const& back() const { return s_[n_-1]; } /// Returns a pointer to the first character of a string. CharT* data() { return &s_[0]; } /// Returns a pointer to the first character of a string. CharT const* data() const { return &s_[0]; } /// Returns a non-modifiable standard C character array version of the string. CharT const* c_str() const { return data(); } /// Convert a static string to a `string_view_type` operator string_view_type() const { return basic_string_view< CharT, Traits>{data(), size()}; } // // Iterators // /// Returns an iterator to the beginning. iterator begin() { return &s_[0]; } /// Returns an iterator to the beginning. const_iterator begin() const { return &s_[0]; } /// Returns an iterator to the beginning. const_iterator cbegin() const { return &s_[0]; } /// Returns an iterator to the end. iterator end() { return &s_[n_]; } /// Returns an iterator to the end. const_iterator end() const { return &s_[n_]; } /// Returns an iterator to the end. const_iterator cend() const { return &s_[n_]; } /// Returns a reverse iterator to the beginning. reverse_iterator rbegin() { return reverse_iterator{end()}; } /// Returns a reverse iterator to the beginning. const_reverse_iterator rbegin() const { return const_reverse_iterator{cend()}; } /// Returns a reverse iterator to the beginning. const_reverse_iterator crbegin() const { return const_reverse_iterator{cend()}; } /// Returns a reverse iterator to the end. reverse_iterator rend() { return reverse_iterator{begin()}; } /// Returns a reverse iterator to the end. const_reverse_iterator rend() const { return const_reverse_iterator{cbegin()}; } /// Returns a reverse iterator to the end. const_reverse_iterator crend() const { return const_reverse_iterator{cbegin()}; } // // Capacity // /// Returns `true` if the string is empty. bool empty() const { return n_ == 0; } /// Returns the number of characters, excluding the null terminator. size_type size() const { return n_; } /// Returns the number of characters, excluding the null terminator. size_type length() const { return size(); } /// Returns the maximum number of characters that can be stored, excluding the null terminator. size_type constexpr max_size() const { return N; } /** Reserves storage. This actually just throws an exception if `n > N`, otherwise does nothing since the storage is fixed. */ void reserve(std::size_t n); /// Returns the number of characters that can be held in currently allocated storage. size_type constexpr capacity() const { return max_size(); } /** Reduces memory usage by freeing unused memory. This actually does nothing, since the storage is fixed. */ void shrink_to_fit() { } // // Operations // /// Clears the contents. void clear(); static_string& insert(size_type index, size_type count, CharT ch); static_string& insert(size_type index, CharT const* s) { return insert(index, s, Traits::length(s)); } static_string& insert(size_type index, CharT const* s, size_type count); template<std::size_t M> static_string& insert(size_type index, static_string<M, CharT, Traits> const& str) { return insert(index, str.data(), str.size()); } template<std::size_t M> static_string& insert(size_type index, static_string<M, CharT, Traits> const& str, size_type index_str, size_type count = npos); iterator insert(const_iterator pos, CharT ch) { return insert(pos, 1, ch); } iterator insert(const_iterator pos, size_type count, CharT ch); template<class InputIt> #if BOOST_BEAST_DOXYGEN iterator #else typename std::enable_if< detail::is_input_iterator<InputIt>::value, iterator>::type #endif insert(const_iterator pos, InputIt first, InputIt last); iterator insert(const_iterator pos, std::initializer_list<CharT> init) { return insert(pos, init.begin(), init.end()); } static_string& insert(size_type index, string_view_type str) { return insert(index, str.data(), str.size()); } template<class T> #if BOOST_BEAST_DOXYGEN static_string& #else typename std::enable_if< std::is_convertible<T const&, string_view_type>::value && ! std::is_convertible<T const&, CharT const*>::value, static_string&>::type #endif insert(size_type index, T const& t, size_type index_str, size_type count = npos); static_string& erase(size_type index = 0, size_type count = npos); iterator erase(const_iterator pos); iterator erase(const_iterator first, const_iterator last); void push_back(CharT ch); void pop_back() { Traits::assign(s_[--n_], 0); } static_string& append(size_type count, CharT ch) { insert(end(), count, ch); return *this; } template<std::size_t M> static_string& append(static_string<M, CharT, Traits> const& str) { insert(size(), str); return *this; } template<std::size_t M> static_string& append(static_string<M, CharT, Traits> const& str, size_type pos, size_type count = npos); static_string& append(CharT const* s, size_type count) { insert(size(), s, count); return *this; } static_string& append(CharT const* s) { insert(size(), s); return *this; } template<class InputIt> #if BOOST_BEAST_DOXYGEN static_string& #else typename std::enable_if< detail::is_input_iterator<InputIt>::value, static_string&>::type #endif append(InputIt first, InputIt last) { insert(end(), first, last); return *this; } static_string& append(std::initializer_list<CharT> init) { insert(end(), init); return *this; } static_string& append(string_view_type sv) { insert(size(), sv); return *this; } template<class T> typename std::enable_if< std::is_convertible<T const&, string_view_type>::value && ! std::is_convertible<T const&, CharT const*>::value, static_string&>::type append(T const& t, size_type pos, size_type count = npos) { insert(size(), t, pos, count); return *this; } template<std::size_t M> static_string& operator+=(static_string<M, CharT, Traits> const& str) { return append(str.data(), str.size()); } static_string& operator+=(CharT ch) { push_back(ch); return *this; } static_string& operator+=(CharT const* s) { return append(s); } static_string& operator+=(std::initializer_list<CharT> init) { return append(init); } static_string& operator+=(string_view_type const& str) { return append(str); } template<std::size_t M> int compare(static_string<M, CharT, Traits> const& str) const { return detail::lexicographical_compare<CharT, Traits>( &s_[0], n_, &str.s_[0], str.n_); } template<std::size_t M> int compare(size_type pos1, size_type count1, static_string<M, CharT, Traits> const& str) const { return detail::lexicographical_compare<CharT, Traits>( substr(pos1, count1), str.data(), str.size()); } template<std::size_t M> int compare(size_type pos1, size_type count1, static_string<M, CharT, Traits> const& str, size_type pos2, size_type count2 = npos) const { return detail::lexicographical_compare( substr(pos1, count1), str.substr(pos2, count2)); } int compare(CharT const* s) const { return detail::lexicographical_compare<CharT, Traits>( &s_[0], n_, s, Traits::length(s)); } int compare(size_type pos1, size_type count1, CharT const* s) const { return detail::lexicographical_compare<CharT, Traits>( substr(pos1, count1), s, Traits::length(s)); } int compare(size_type pos1, size_type count1, CharT const*s, size_type count2) const { return detail::lexicographical_compare<CharT, Traits>( substr(pos1, count1), s, count2); } int compare(string_view_type str) const { return detail::lexicographical_compare<CharT, Traits>( &s_[0], n_, str.data(), str.size()); } int compare(size_type pos1, size_type count1, string_view_type str) const { return detail::lexicographical_compare<CharT, Traits>( substr(pos1, count1), str); } template<class T> #if BOOST_BEAST_DOXYGEN int #else typename std::enable_if< std::is_convertible<T const&, string_view_type>::value && ! std::is_convertible<T const&, CharT const*>::value, int>::type #endif compare(size_type pos1, size_type count1, T const& t, size_type pos2, size_type count2 = npos) const { return compare(pos1, count1, string_view_type(t).substr(pos2, count2)); } string_view_type substr(size_type pos = 0, size_type count = npos) const; /// Copy a substring (pos, pos+count) to character string pointed to by `dest`. size_type copy(CharT* dest, size_type count, size_type pos = 0) const; /** Changes the number of characters stored. If the resulting string is larger, the new characters are uninitialized. */ void resize(std::size_t n); /** Changes the number of characters stored. If the resulting string is larger, the new characters are initialized to the value of `c`. */ void resize(std::size_t n, CharT c); /// Exchange the contents of this string with another. void swap(static_string& str); /// Exchange the contents of this string with another. template<std::size_t M> void swap(static_string<M, CharT, Traits>& str); // // Search // private: static_string& assign_char(CharT ch, std::true_type); static_string& assign_char(CharT ch, std::false_type); }; // // Disallowed operations // // These operations are explicitly deleted since // there is no reasonable implementation possible. template<std::size_t N, std::size_t M, class CharT, class Traits> void operator+( static_string<N, CharT, Traits>const&, static_string<M, CharT, Traits>const&) = delete; template<std::size_t N, class CharT, class Traits> void operator+(CharT const*, static_string<N, CharT, Traits>const&) = delete; template<std::size_t N, class CharT, class Traits> void operator+(CharT, static_string<N, CharT, Traits> const&) = delete; template<std::size_t N, class CharT, class Traits> void operator+(static_string<N, CharT, Traits> const&, CharT const*) = delete; template<std::size_t N, class CharT, class Traits> void operator+(static_string<N, CharT, Traits> const&, CharT) = delete; // // Non-member functions // template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator==( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) == 0; } template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator!=( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) != 0; } template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator<( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) < 0; } template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator<=( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) <= 0; } template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator>( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) > 0; } template<std::size_t N, std::size_t M, class CharT, class Traits> bool operator>=( static_string<N, CharT, Traits> const& lhs, static_string<M, CharT, Traits> const& rhs) { return lhs.compare(rhs) >= 0; } template<std::size_t N, class CharT, class Traits> bool operator==( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) == 0; } template<std::size_t N, class CharT, class Traits> bool operator==( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) == 0; } template<std::size_t N, class CharT, class Traits> bool operator!=( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) != 0; } template<std::size_t N, class CharT, class Traits> bool operator!=( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) != 0; } template<std::size_t N, class CharT, class Traits> bool operator<( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) < 0; } template<std::size_t N, class CharT, class Traits> bool operator<( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) < 0; } template<std::size_t N, class CharT, class Traits> bool operator<=( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) <= 0; } template<std::size_t N, class CharT, class Traits> bool operator<=( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) <= 0; } template<std::size_t N, class CharT, class Traits> bool operator>( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) > 0; } template<std::size_t N, class CharT, class Traits> bool operator>( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) > 0; } template<std::size_t N, class CharT, class Traits> bool operator>=( CharT const* lhs, static_string<N, CharT, Traits> const& rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs, Traits::length(lhs), rhs.data(), rhs.size()) >= 0; } template<std::size_t N, class CharT, class Traits> bool operator>=( static_string<N, CharT, Traits> const& lhs, CharT const* rhs) { return detail::lexicographical_compare<CharT, Traits>( lhs.data(), lhs.size(), rhs, Traits::length(rhs)) >= 0; } // // swap // template<std::size_t N, class CharT, class Traits> void swap( static_string<N, CharT, Traits>& lhs, static_string<N, CharT, Traits>& rhs) { lhs.swap(rhs); } template<std::size_t N, std::size_t M, class CharT, class Traits> void swap( static_string<N, CharT, Traits>& lhs, static_string<M, CharT, Traits>& rhs) { lhs.swap(rhs); } // // Input/Output // template<std::size_t N, class CharT, class Traits> std::basic_ostream<CharT, Traits>& operator<<(std::basic_ostream<CharT, Traits>& os, static_string<N, CharT, Traits> const& str) { return os << static_cast< beast::basic_string_view<CharT, Traits>>(str); } // // Numeric conversions // /** Returns a static string representing an integer as a decimal. @param x The signed or unsigned integer to convert. This must be an integral type. @return A @ref static_string with an implementation defined maximum size large enough to hold the longest possible decimal representation of any integer of the given type. */ template< class Integer #ifndef BOOST_BEAST_DOXYGEN ,class = typename std::enable_if< std::is_integral<Integer>::value>::type #endif > static_string<detail::max_digits(sizeof(Integer))> to_static_string(Integer x); } // beast } // boost #include <boost/beast/core/impl/static_string.hpp> #endif PK PP�[��Js~ ~ core/file_posix.hppnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FILE_POSIX_HPP #define BOOST_BEAST_CORE_FILE_POSIX_HPP #include <boost/beast/core/detail/config.hpp> #if ! defined(BOOST_BEAST_NO_POSIX_FILE) # if ! defined(__APPLE__) && ! defined(__linux__) # define BOOST_BEAST_NO_POSIX_FILE # endif #endif #if ! defined(BOOST_BEAST_USE_POSIX_FILE) # if ! defined(BOOST_BEAST_NO_POSIX_FILE) # define BOOST_BEAST_USE_POSIX_FILE 1 # else # define BOOST_BEAST_USE_POSIX_FILE 0 # endif #endif #if BOOST_BEAST_USE_POSIX_FILE #include <boost/beast/core/error.hpp> #include <boost/beast/core/file_base.hpp> #include <cstdint> namespace boost { namespace beast { /** An implementation of File for POSIX systems. This class implements a <em>File</em> using POSIX interfaces. */ class file_posix { int fd_ = -1; BOOST_BEAST_DECL static int native_close(int& fd); public: /** The type of the underlying file handle. This is platform-specific. */ using native_handle_type = int; /** Destructor If the file is open it is first closed. */ BOOST_BEAST_DECL ~file_posix(); /** Constructor There is no open file initially. */ file_posix() = default; /** Constructor The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_posix(file_posix&& other); /** Assignment The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_posix& operator=(file_posix&& other); /// Returns the native handle associated with the file. native_handle_type native_handle() const { return fd_; } /** Set the native handle associated with the file. If the file is open it is first closed. @param fd The native file handle to assign. */ BOOST_BEAST_DECL void native_handle(native_handle_type fd); /// Returns `true` if the file is open bool is_open() const { return fd_ != -1; } /** Close the file if open @param ec Set to the error, if any occurred. */ BOOST_BEAST_DECL void close(error_code& ec); /** Open a file at the given path with the specified mode @param path The utf-8 encoded path to the file @param mode The file mode to use @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void open(char const* path, file_mode mode, error_code& ec); /** Return the size of the open file @param ec Set to the error, if any occurred @return The size in bytes */ BOOST_BEAST_DECL std::uint64_t size(error_code& ec) const; /** Return the current position in the open file @param ec Set to the error, if any occurred @return The offset in bytes from the beginning of the file */ BOOST_BEAST_DECL std::uint64_t pos(error_code& ec) const; /** Adjust the current position in the open file @param offset The offset in bytes from the beginning of the file @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void seek(std::uint64_t offset, error_code& ec); /** Read from the open file @param buffer The buffer for storing the result of the read @param n The number of bytes to read @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t read(void* buffer, std::size_t n, error_code& ec) const; /** Write to the open file @param buffer The buffer holding the data to write @param n The number of bytes to write @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t write(void const* buffer, std::size_t n, error_code& ec); }; } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/file_posix.ipp> #endif #endif #endif PK PP�[�&l�;1 ;1 core/flat_stream.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FLAT_STREAM_HPP #define BOOST_BEAST_CORE_FLAT_STREAM_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/flat_buffer.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/flat_stream.hpp> #include <boost/asio/async_result.hpp> #include <cstdlib> #include <utility> namespace boost { namespace beast { /** Stream wrapper to improve write performance. This wrapper flattens writes for buffer sequences having length greater than 1 and total size below a predefined amount, using a dynamic memory allocation. It is primarily designed to overcome a performance limitation of the current version of `net::ssl::stream`, which does not use OpenSSL's scatter/gather interface for its low-level read some and write some operations. It is normally not necessary to use this class directly if you are already using @ref ssl_stream. The following examples shows how to use this class with the ssl stream that comes with networking: @par Example To use the @ref flat_stream template with SSL streams, declare a variable of the correct type. Parameters passed to the constructor will be forwarded to the next layer's constructor: @code flat_stream<net::ssl::stream<ip::tcp::socket>> fs{ioc, ctx}; @endcode Alternatively you can write @code ssl::stream<ip::tcp::socket> ss{ioc, ctx}; flat_stream<net::ssl::stream<ip::tcp::socket>&> fs{ss}; @endcode The resulting stream may be passed to any stream algorithms which operate on synchronous or asynchronous read or write streams, examples include: @li `net::read`, `net::async_read` @li `net::write`, `net::async_write` @li `net::read_until`, `net::async_read_until` The stream may also be used as a template parameter in other stream wrappers, such as for websocket: @code websocket::stream<flat_stream<net::ssl::stream<ip::tcp::socket>>> ws{ioc, ctx}; @endcode @tparam NextLayer The type representing the next layer, to which data will be read and written during operations. For synchronous operations, the type must support the @b SyncStream concept. For asynchronous operations, the type must support the @b AsyncStream concept. This type will usually be some variation of `net::ssl::stream`. @par Concepts @li SyncStream @li AsyncStream @see @li https://github.com/boostorg/asio/issues/100 @li https://github.com/boostorg/beast/issues/1108 @li https://stackoverflow.com/questions/38198638/openssl-ssl-write-from-multiple-buffers-ssl-writev @li https://stackoverflow.com/questions/50026167/performance-drop-on-port-from-beast-1-0-0-b66-to-boost-1-67-0-beast */ template<class NextLayer> class flat_stream #if ! BOOST_BEAST_DOXYGEN : private detail::flat_stream_base #endif { NextLayer stream_; flat_buffer buffer_; BOOST_STATIC_ASSERT(has_get_executor<NextLayer>::value); struct ops; template<class ConstBufferSequence> std::size_t stack_write_some( std::size_t size, ConstBufferSequence const& buffers, error_code& ec); public: /// The type of the next layer. using next_layer_type = typename std::remove_reference<NextLayer>::type; /// The type of the executor associated with the object. using executor_type = beast::executor_type<next_layer_type>; flat_stream(flat_stream&&) = default; flat_stream(flat_stream const&) = default; flat_stream& operator=(flat_stream&&) = default; flat_stream& operator=(flat_stream const&) = default; /** Destructor The treatment of pending operations will be the same as that of the next layer. */ ~flat_stream() = default; /** Constructor Arguments, if any, are forwarded to the next layer's constructor. */ template<class... Args> explicit flat_stream(Args&&... args); //-------------------------------------------------------------------------- /** Get the executor associated with the object. This function may be used to obtain the executor object that the stream uses to dispatch handlers for asynchronous operations. @return A copy of the executor that stream will use to dispatch handlers. */ executor_type get_executor() noexcept { return stream_.get_executor(); } /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type& next_layer() noexcept { return stream_; } /** Get a reference to the next layer This function returns a reference to the next layer in a stack of stream layers. @return A reference to the next layer in the stack of stream layers. */ next_layer_type const& next_layer() const noexcept { return stream_; } //-------------------------------------------------------------------------- /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @returns The number of bytes read. @throws boost::system::system_error Thrown on failure. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some(MutableBufferSequence const& buffers); /** Read some data from the stream. This function is used to read data from the stream. The function call will block until one or more bytes of data has been read successfully, or until an error occurs. @param buffers The buffers into which the data will be read. @param ec Set to indicate what error occurred, if any. @returns The number of bytes read. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::read` if you need to ensure that the requested amount of data is read before the blocking operation completes. */ template<class MutableBufferSequence> std::size_t read_some( MutableBufferSequence const& buffers, error_code& ec); /** Start an asynchronous read. This function is used to asynchronously read one or more bytes of data from the stream. The function call always returns immediately. @param buffers The buffers into which the data will be read. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // Result of operation. std::size_t bytes_transferred // Number of bytes read. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `read_some` operation may not read all of the requested number of bytes. Consider using the function `net::async_read` if you need to ensure that the requested amount of data is read before the asynchronous operation completes. */ template< class MutableBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t<executor_type>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( MutableBufferSequence const& buffers, ReadHandler&& handler = net::default_completion_token_t<executor_type>{}); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @returns The number of bytes written. @throws boost::system::system_error Thrown on failure. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some(ConstBufferSequence const& buffers); /** Write some data to the stream. This function is used to write data on the stream. The function call will block until one or more bytes of data has been written successfully, or until an error occurs. @param buffers The data to be written. @param ec Set to indicate what error occurred, if any. @returns The number of bytes written. @note The `write_some` operation may not transmit all of the data to the peer. Consider using the function `net::write` if you need to ensure that all data is written before the blocking operation completes. */ template<class ConstBufferSequence> std::size_t write_some( ConstBufferSequence const& buffers, error_code& ec); /** Start an asynchronous write. This function is used to asynchronously write one or more bytes of data to the stream. The function call always returns immediately. @param buffers The data to be written to the stream. Although the buffers object may be copied as necessary, ownership of the underlying buffers is retained by the caller, which must guarantee that they remain valid until the handler is called. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& ec, // Result of operation. std::size_t bytes_transferred // Number of bytes written. ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The `async_write_some` operation may not transmit all of the data to the peer. Consider using the function `net::async_write` if you need to ensure that all data is written before the asynchronous operation completes. */ template< class ConstBufferSequence, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t<executor_type>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( ConstBufferSequence const& buffers, WriteHandler&& handler = net::default_completion_token_t<executor_type>{}); }; } // beast } // boost #include <boost/beast/core/impl/flat_stream.hpp> #endif PK PP�[P��;� � core/rate_policy.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_RATE_POLICY_HPP #define BOOST_BEAST_CORE_RATE_POLICY_HPP #include <boost/beast/core/detail/config.hpp> #include <cstdint> #include <limits> namespace boost { namespace beast { /** Helper class to assist implementing a <em>RatePolicy</em>. This class is used by the implementation to gain access to the private members of a user-defined object meeting the requirements of <em>RatePolicy</em>. To use it, simply declare it as a friend in your class: @par Example @code class custom_rate_policy { friend class beast::rate_policy_access; ... @endcode @par Concepts @li <em>RatePolicy</em> @see beast::basic_stream */ class rate_policy_access { private: template<class, class, class> friend class basic_stream; template<class Policy> static std::size_t available_read_bytes(Policy& policy) { return policy.available_read_bytes(); } template<class Policy> static std::size_t available_write_bytes(Policy& policy) { return policy.available_write_bytes(); } template<class Policy> static void transfer_read_bytes( Policy& policy, std::size_t n) { return policy.transfer_read_bytes(n); } template<class Policy> static void transfer_write_bytes( Policy& policy, std::size_t n) { return policy.transfer_write_bytes(n); } template<class Policy> static void on_timer(Policy& policy) { return policy.on_timer(); } }; //------------------------------------------------------------------------------ /** A rate policy with unlimited throughput. This rate policy object does not apply any rate limit. @par Concepts @li <em>RatePolicy</em> @see beast::basic_stream, beast::tcp_stream */ class unlimited_rate_policy { friend class rate_policy_access; static std::size_t constexpr all = (std::numeric_limits<std::size_t>::max)(); std::size_t available_read_bytes() const noexcept { return all; } std::size_t available_write_bytes() const noexcept { return all; } void transfer_read_bytes(std::size_t) const noexcept { } void transfer_write_bytes(std::size_t) const noexcept { } void on_timer() const noexcept { } }; //------------------------------------------------------------------------------ /** A rate policy with simple, configurable limits on reads and writes. This rate policy allows for simple individual limits on the amount of bytes per second allowed for reads and writes. @par Concepts @li <em>RatePolicy</em> @see beast::basic_stream */ class simple_rate_policy { friend class rate_policy_access; static std::size_t constexpr all = (std::numeric_limits<std::size_t>::max)(); std::size_t rd_remain_ = all; std::size_t wr_remain_ = all; std::size_t rd_limit_ = all; std::size_t wr_limit_ = all; std::size_t available_read_bytes() const noexcept { return rd_remain_; } std::size_t available_write_bytes() const noexcept { return wr_remain_; } void transfer_read_bytes(std::size_t n) noexcept { if( rd_remain_ != all) rd_remain_ = (n < rd_remain_) ? rd_remain_ - n : 0; } void transfer_write_bytes(std::size_t n) noexcept { if( wr_remain_ != all) wr_remain_ = (n < wr_remain_) ? wr_remain_ - n : 0; } void on_timer() noexcept { rd_remain_ = rd_limit_; wr_remain_ = wr_limit_; } public: /// Set the limit of bytes per second to read void read_limit(std::size_t bytes_per_second) noexcept { rd_limit_ = bytes_per_second; if( rd_remain_ > bytes_per_second) rd_remain_ = bytes_per_second; } /// Set the limit of bytes per second to write void write_limit(std::size_t bytes_per_second) noexcept { wr_limit_ = bytes_per_second; if( wr_remain_ > bytes_per_second) wr_remain_ = bytes_per_second; } }; } // beast } // boost #endif PK PP�[2�m core/file_stdio.hppnu �[��� // // Copyright (c) 2015-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_CORE_FILE_STDIO_HPP #define BOOST_BEAST_CORE_FILE_STDIO_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/file_base.hpp> #include <cstdio> #include <cstdint> namespace boost { namespace beast { /** An implementation of File which uses cstdio. This class implements a file using the interfaces present in the C++ Standard Library, in `<stdio>`. */ class file_stdio { std::FILE* f_ = nullptr; public: /** The type of the underlying file handle. This is platform-specific. */ using native_handle_type = std::FILE*; /** Destructor If the file is open it is first closed. */ BOOST_BEAST_DECL ~file_stdio(); /** Constructor There is no open file initially. */ file_stdio() = default; /** Constructor The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_stdio(file_stdio&& other); /** Assignment The moved-from object behaves as if default constructed. */ BOOST_BEAST_DECL file_stdio& operator=(file_stdio&& other); /// Returns the native handle associated with the file. std::FILE* native_handle() const { return f_; } /** Set the native handle associated with the file. If the file is open it is first closed. @param f The native file handle to assign. */ BOOST_BEAST_DECL void native_handle(std::FILE* f); /// Returns `true` if the file is open bool is_open() const { return f_ != nullptr; } /** Close the file if open @param ec Set to the error, if any occurred. */ BOOST_BEAST_DECL void close(error_code& ec); /** Open a file at the given path with the specified mode @param path The utf-8 encoded path to the file @param mode The file mode to use @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void open(char const* path, file_mode mode, error_code& ec); /** Return the size of the open file @param ec Set to the error, if any occurred @return The size in bytes */ BOOST_BEAST_DECL std::uint64_t size(error_code& ec) const; /** Return the current position in the open file @param ec Set to the error, if any occurred @return The offset in bytes from the beginning of the file */ BOOST_BEAST_DECL std::uint64_t pos(error_code& ec) const; /** Adjust the current position in the open file @param offset The offset in bytes from the beginning of the file @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL void seek(std::uint64_t offset, error_code& ec); /** Read from the open file @param buffer The buffer for storing the result of the read @param n The number of bytes to read @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t read(void* buffer, std::size_t n, error_code& ec) const; /** Write to the open file @param buffer The buffer holding the data to write @param n The number of bytes to write @param ec Set to the error, if any occurred */ BOOST_BEAST_DECL std::size_t write(void const* buffer, std::size_t n, error_code& ec); }; } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/core/impl/file_stdio.ipp> #endif #endif PK PP�[��4 4 core/read_size.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_READ_SIZE_HELPER_HPP #define BOOST_BEAST_READ_SIZE_HELPER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { /** Returns a natural read size. This function inspects the capacity, size, and maximum size of the dynamic buffer. Then it computes a natural read size given the passed-in upper limit. It favors a read size that does not require a reallocation, subject to a reasonable minimum to avoid tiny reads. @param buffer The dynamic buffer to inspect. @param max_size An upper limit on the returned value. @note If the buffer is already at its maximum size, zero is returned. */ template<class DynamicBuffer> std::size_t read_size(DynamicBuffer& buffer, std::size_t max_size); /** Returns a natural read size or throw if the buffer is full. This function inspects the capacity, size, and maximum size of the dynamic buffer. Then it computes a natural read size given the passed-in upper limit. It favors a read size that does not require a reallocation, subject to a reasonable minimum to avoid tiny reads. @param buffer The dynamic buffer to inspect. @param max_size An upper limit on the returned value. @throws std::length_error if `max_size > 0` and the buffer is full. */ template<class DynamicBuffer> std::size_t read_size_or_throw(DynamicBuffer& buffer, std::size_t max_size); } // beast } // boost #include <boost/beast/core/impl/read_size.hpp> #endif PK PP�[���� � core/string_param.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_STRING_PARAM_HPP #define BOOST_BEAST_STRING_PARAM_HPP #if defined(BOOST_BEAST_ALLOW_DEPRECATED) && !defined(BOOST_BEAST_DOXYGEN) #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/static_string.hpp> #include <boost/beast/core/detail/static_ostream.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { /** A function parameter which efficiently converts to string. This is used as a function parameter type to allow callers notational convenience: objects other than strings may be passed in contexts where a string is expected. The conversion to string is made using `operator<<` to a non-dynamically allocated static buffer if possible, else to a `std::string` on overflow. To use it, modify your function signature to accept `string_param` and then extract the string inside the function: @code void print(string_param s) { std::cout << s.str(); } @endcode */ class string_param { string_view sv_; char buf_[128]; boost::optional<detail::static_ostream> os_; template<class T> typename std::enable_if< std::is_integral<T>::value>::type print(T const&); template<class T> typename std::enable_if< ! std::is_integral<T>::value && ! std::is_convertible<T, string_view>::value >::type print(T const&); void print(string_view); template<class T> typename std::enable_if< std::is_integral<T>::value>::type print_1(T const&); template<class T> typename std::enable_if< ! std::is_integral<T>::value>::type print_1(T const&); void print_n() { } template<class T0, class... TN> void print_n(T0 const&, TN const&...); template<class T0, class T1, class... TN> void print(T0 const&, T1 const&, TN const&...); public: /// Copy constructor (disallowed) string_param(string_param const&) = delete; /// Copy assignment (disallowed) string_param& operator=(string_param const&) = delete; /** Constructor This function constructs a string as if by concatenating the result of streaming each argument in order into an output stream. It is used as a notational convenience at call sites which expect a parameter with the semantics of a @ref string_view. The implementation uses a small, internal static buffer to avoid memory allocations especially for the case where the list of arguments to be converted consists of a single integral type. @param args One or more arguments to convert */ template<class... Args> string_param(Args const&... args); /// Returns the contained string string_view str() const { return sv_; } /// Implicit conversion to @ref string_view operator string_view const() const { return sv_; } }; } // beast } // boost #include <boost/beast/core/impl/string_param.hpp> #endif // defined(BOOST_BEAST_ALLOW_DEPRECATED) && !BOOST_BEAST_DOXYGEN #endif PK PP�[}B��� � http/type_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_TYPE_TRAITS_HPP #define BOOST_BEAST_HTTP_TYPE_TRAITS_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/http/detail/type_traits.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { template<bool, class, class> class message; /** Determine if a type meets the <em>Body</em> named requirements. This alias template is `std::true_type` if `T` meets the requirements, otherwise it is `std::false_type`. @tparam T The type to test. @par Example @code template<bool isRequest, class Body, class Fields> void check_body(message<isRequest, Body, Fields> const&) { static_assert(is_body<Body>::value, "Body type requirements not met"); } @endcode */ template<class T> #if BOOST_BEAST_DOXYGEN using is_body = __see_below__; #else using is_body = detail::has_value_type<T>; #endif /** Determine if a type has a nested <em>BodyWriter</em>. This alias template is `std::true_type` when: @li `T` has a nested type named `writer` @li `writer` meets the requirements of <em>BodyWriter</em>. @tparam T The body type to test. @par Example @code template<bool isRequest, class Body, class Fields> void check_can_serialize(message<isRequest, Body, Fields> const&) { static_assert(is_body_writer<Body>::value, "Cannot serialize Body, no reader"); } @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_body_writer = __see_below__; #else template<class T, class = void> struct is_body_writer : std::false_type {}; template<class T> struct is_body_writer<T, beast::detail::void_t< typename T::writer, typename T::writer::const_buffers_type, decltype( std::declval<typename T::writer&>().init(std::declval<error_code&>()), std::declval<boost::optional<std::pair< typename T::writer::const_buffers_type, bool>>&>() = std::declval<typename T::writer>().get(std::declval<error_code&>()) )>> : std::integral_constant<bool, net::is_const_buffer_sequence< typename T::writer::const_buffers_type>::value && ( (std::is_constructible<typename T::writer, header<true, detail::fields_model>&, typename T::value_type&>::value && std::is_constructible<typename T::writer, header<false, detail::fields_model>&, typename T::value_type&>::value) ) > {}; #endif /** Determine if a type has a nested <em>BodyWriter</em>. This alias template is `std::true_type` when: @li `T` has a nested type named `writer` @li `writer` meets the requirements of <em>BodyWriter</em>. @tparam T The body type to test. */ #if BOOST_BEAST_DOXYGEN template<class T> using is_mutable_body_writer = __see_below__; #else template<class T, class = void> struct is_mutable_body_writer : std::false_type {}; template<class T> struct is_mutable_body_writer<T, beast::detail::void_t< typename T::writer, typename T::writer::const_buffers_type, decltype( std::declval<typename T::writer&>().init(std::declval<error_code&>()), std::declval<boost::optional<std::pair< typename T::writer::const_buffers_type, bool>>&>() = std::declval<typename T::writer>().get(std::declval<error_code&>()) )>> : std::integral_constant<bool, net::is_const_buffer_sequence< typename T::writer::const_buffers_type>::value && (( std::is_constructible<typename T::writer, header<true, detail::fields_model>&, typename T::value_type&>::value && std::is_constructible<typename T::writer, header<false, detail::fields_model>&, typename T::value_type&>::value && ! std::is_constructible<typename T::writer, header<true, detail::fields_model> const&, typename T::value_type const&>::value && ! std::is_constructible<typename T::writer, header<false, detail::fields_model> const&, typename T::value_type const&>::value )) >{}; #endif /** Determine if a type has a nested <em>BodyReader</em>. This alias template is `std::true_type` when: @li `T` has a nested type named `reader` @li `reader` meets the requirements of <em>BodyReader</em>. @tparam T The body type to test. @par Example @code template<bool isRequest, class Body, class Fields> void check_can_parse(message<isRequest, Body, Fields>&) { static_assert(is_body_reader<Body>::value, "Cannot parse Body, no reader"); } @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_body_reader = __see_below__; #else template<class T, class = void> struct is_body_reader : std::false_type {}; template<class T> struct is_body_reader<T, beast::detail::void_t<decltype( std::declval<typename T::reader&>().init( boost::optional<std::uint64_t>(), std::declval<error_code&>()), std::declval<std::size_t&>() = std::declval<typename T::reader&>().put( std::declval<net::const_buffer>(), std::declval<error_code&>()), std::declval<typename T::reader&>().finish( std::declval<error_code&>()) )>> : std::integral_constant<bool, (std::is_constructible<typename T::reader, header<true, detail::fields_model>&, typename T::value_type&>::value && std::is_constructible<typename T::reader, header<false,detail::fields_model>&, typename T::value_type&>::value) > { }; #endif /** Determine if a type meets the <em>Fields</em> named requirements. This alias template is `std::true_type` if `T` meets the requirements, otherwise it is `std::false_type`. @tparam T The type to test. @par Example Use with `static_assert`: @code template<bool isRequest, class Body, class Fields> void f(message<isRequest, Body, Fields> const&) { static_assert(is_fields<Fields>::value, "Fields type requirements not met"); ... @endcode Use with `std::enable_if` (SFINAE): @code template<bool isRequest, class Body, class Fields> typename std::enable_if<is_fields<Fields>::value>::type f(message<isRequest, Body, Fields> const&); @endcode */ #if BOOST_BEAST_DOXYGEN template<class T> using is_fields = __see_below__; #else template<class T> using is_fields = typename detail::is_fields_helper<T>::type; #endif } // http } // beast } // boost #endif PK PP�[դ7I I http/verb.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_VERB_HPP #define BOOST_BEAST_HTTP_VERB_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <iosfwd> namespace boost { namespace beast { namespace http { /** HTTP request method verbs Each verb corresponds to a particular method string used in HTTP request messages. */ enum class verb { /** An unknown method. This value indicates that the request method string is not one of the recognized verbs. Callers interested in the method should use an interface which returns the original string. */ unknown = 0, /// The DELETE method deletes the specified resource delete_, /** The GET method requests a representation of the specified resource. Requests using GET should only retrieve data and should have no other effect. */ get, /** The HEAD method asks for a response identical to that of a GET request, but without the response body. This is useful for retrieving meta-information written in response headers, without having to transport the entire content. */ head, /** The POST method requests that the server accept the entity enclosed in the request as a new subordinate of the web resource identified by the URI. The data POSTed might be, for example, an annotation for existing resources; a message for a bulletin board, newsgroup, mailing list, or comment thread; a block of data that is the result of submitting a web form to a data-handling process; or an item to add to a database */ post, /** The PUT method requests that the enclosed entity be stored under the supplied URI. If the URI refers to an already existing resource, it is modified; if the URI does not point to an existing resource, then the server can create the resource with that URI. */ put, /** The CONNECT method converts the request connection to a transparent TCP/IP tunnel. This is usually to facilitate SSL-encrypted communication (HTTPS) through an unencrypted HTTP proxy. */ connect, /** The OPTIONS method returns the HTTP methods that the server supports for the specified URL. This can be used to check the functionality of a web server by requesting '*' instead of a specific resource. */ options, /** The TRACE method echoes the received request so that a client can see what (if any) changes or additions have been made by intermediate servers. */ trace, // WebDAV copy, lock, mkcol, move, propfind, proppatch, search, unlock, bind, rebind, unbind, acl, // subversion report, mkactivity, checkout, merge, // upnp msearch, notify, subscribe, unsubscribe, // RFC-5789 patch, purge, // CalDAV mkcalendar, // RFC-2068, section 19.6.1.2 link, unlink }; /** Converts a string to the request method verb. If the string does not match a known request method, @ref verb::unknown is returned. */ BOOST_BEAST_DECL verb string_to_verb(string_view s); /// Returns the text representation of a request method verb. BOOST_BEAST_DECL string_view to_string(verb v); /// Write the text for a request method verb to an output stream. inline std::ostream& operator<<(std::ostream& os, verb v) { return os << to_string(v); } } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/verb.ipp> #endif #endif PK PP�[�)�0� � http/empty_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_EMPTY_BODY_HPP #define BOOST_BEAST_HTTP_EMPTY_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace http { /** An empty <em>Body</em> This body is used to represent messages which do not have a message body. If this body is used with a parser, and the parser encounters octets corresponding to a message body, the parser will fail with the error @ref http::unexpected_body. The Content-Length of this body is always 0. */ struct empty_body { /** The type of container used for the body This determines the type of @ref message::body when this body type is used with a message container. */ struct value_type { }; /** Returns the payload size of the body When this body is used with @ref message::prepare_payload, the Content-Length will be set to the payload size, and any chunked Transfer-Encoding will be removed. */ static std::uint64_t size(value_type) { return 0; } /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else struct reader { template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type&) { } void init(boost::optional<std::uint64_t> const&, error_code& ec) { ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const&, error_code& ec) { ec = error::unexpected_body; return 0; } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else struct writer { using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const&) { } void init(error_code& ec) { ec = {}; } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { ec = {}; return boost::none; } }; #endif }; } // http } // beast } // boost #endif PK PP�[� ��7 7 http/impl/rfc7230.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_RFC7230_IPP #define BOOST_BEAST_HTTP_IMPL_RFC7230_IPP #include <boost/beast/http/rfc7230.hpp> #include <algorithm> namespace boost { namespace beast { namespace http { std::string param_list::const_iterator:: unquote(string_view sr) { std::string s; s.reserve(sr.size()); auto it = sr.begin() + 1; auto end = sr.end() - 1; while(it != end) { if(*it == '\\') ++it; s.push_back(*it); ++it; } return s; } void param_list::const_iterator:: increment() { s_.clear(); pi_.increment(); if(pi_.empty()) { pi_.it = pi_.last; pi_.first = pi_.last; } else if(! pi_.v.second.empty() && pi_.v.second.front() == '"') { s_ = unquote(pi_.v.second); pi_.v.second = string_view{ s_.data(), s_.size()}; } } void ext_list::const_iterator:: increment() { /* ext-list = *( "," OWS ) ext *( OWS "," [ OWS ext ] ) ext = token param-list param-list = *( OWS ";" OWS param ) param = token OWS "=" OWS ( token / quoted-string ) chunked;a=b;i=j;gzip;windowBits=12 x,y ,,,,,chameleon */ auto const err = [&] { it_ = last_; first_ = last_; }; auto need_comma = it_ != first_; v_.first = {}; first_ = it_; for(;;) { detail::skip_ows(it_, last_); if(it_ == last_) return err(); auto const c = *it_; if(detail::is_token_char(c)) { if(need_comma) return err(); auto const p0 = it_; for(;;) { ++it_; if(it_ == last_) break; if(! detail::is_token_char(*it_)) break; } v_.first = string_view{&*p0, static_cast<std::size_t>(it_ - p0)}; if (it_ == last_) return; detail::param_iter pi; pi.it = it_; pi.first = it_; pi.last = last_; for(;;) { pi.increment(); if(pi.empty()) break; } v_.second = param_list{string_view{&*it_, static_cast<std::size_t>(pi.it - it_)}}; it_ = pi.it; return; } if(c != ',') return err(); need_comma = false; ++it_; } } auto ext_list:: find(string_view const& s) -> const_iterator { return std::find_if(begin(), end(), [&s](value_type const& v) { return beast::iequals(s, v.first); }); } bool ext_list:: exists(string_view const& s) { return find(s) != end(); } void token_list::const_iterator:: increment() { /* token-list = *( "," OWS ) token *( OWS "," [ OWS ext ] ) */ auto const err = [&] { it_ = last_; first_ = last_; }; auto need_comma = it_ != first_; v_ = {}; first_ = it_; for(;;) { detail::skip_ows(it_, last_); if(it_ == last_) return err(); auto const c = *it_; if(detail::is_token_char(c)) { if(need_comma) return err(); auto const p0 = it_; for(;;) { ++it_; if(it_ == last_) break; if(! detail::is_token_char(*it_)) break; } v_ = string_view{&*p0, static_cast<std::size_t>(it_ - p0)}; return; } if(c != ',') return err(); need_comma = false; ++it_; } } bool token_list:: exists(string_view const& s) { return std::find_if(begin(), end(), [&s](value_type const& v) { return beast::iequals(s, v); } ) != end(); } } // http } // beast } // boost #endif // BOOST_BEAST_HTTP_IMPL_RFC7230_IPP PK PP�[�� �j �j http/impl/fields.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_FIELDS_HPP #define BOOST_BEAST_HTTP_IMPL_FIELDS_HPP #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/buffers_ref.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/static_string.hpp> #include <boost/beast/core/detail/temporary_buffer.hpp> #include <boost/beast/core/static_string.hpp> #include <boost/beast/http/verb.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/http/status.hpp> #include <boost/beast/http/chunk_encode.hpp> #include <boost/core/exchange.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> #include <string> namespace boost { namespace beast { namespace http { template<class Allocator> class basic_fields<Allocator>::writer { public: using iter_type = typename list_t::const_iterator; struct field_iterator { iter_type it_; using value_type = net::const_buffer; using pointer = value_type const*; using reference = value_type const; using difference_type = std::ptrdiff_t; using iterator_category = std::bidirectional_iterator_tag; field_iterator() = default; field_iterator(field_iterator&& other) = default; field_iterator(field_iterator const& other) = default; field_iterator& operator=(field_iterator&& other) = default; field_iterator& operator=(field_iterator const& other) = default; explicit field_iterator(iter_type it) : it_(it) { } bool operator==(field_iterator const& other) const { return it_ == other.it_; } bool operator!=(field_iterator const& other) const { return !(*this == other); } reference operator*() const { return it_->buffer(); } field_iterator& operator++() { ++it_; return *this; } field_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } field_iterator& operator--() { --it_; return *this; } field_iterator operator--(int) { auto temp = *this; --(*this); return temp; } }; class field_range { field_iterator first_; field_iterator last_; public: using const_iterator = field_iterator; using value_type = typename const_iterator::value_type; field_range(iter_type first, iter_type last) : first_(first) , last_(last) { } const_iterator begin() const { return first_; } const_iterator end() const { return last_; } }; using view_type = buffers_cat_view< net::const_buffer, net::const_buffer, net::const_buffer, field_range, chunk_crlf>; basic_fields const& f_; boost::optional<view_type> view_; char buf_[13]; public: using const_buffers_type = beast::detail::buffers_ref<view_type>; writer(basic_fields const& f, unsigned version, verb v); writer(basic_fields const& f, unsigned version, unsigned code); writer(basic_fields const& f); const_buffers_type get() const { return const_buffers_type(*view_); } }; template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f) : f_(f) { view_.emplace( net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0}, net::const_buffer{nullptr, 0}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf()); } template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f, unsigned version, verb v) : f_(f) { /* request "<method>" " <target>" " HTTP/X.Y\r\n" (11 chars) */ string_view sv; if(v == verb::unknown) sv = f_.get_method_impl(); else sv = to_string(v); // target_or_reason_ has a leading SP buf_[0] = ' '; buf_[1] = 'H'; buf_[2] = 'T'; buf_[3] = 'T'; buf_[4] = 'P'; buf_[5] = '/'; buf_[6] = '0' + static_cast<char>(version / 10); buf_[7] = '.'; buf_[8] = '0' + static_cast<char>(version % 10); buf_[9] = '\r'; buf_[10]= '\n'; view_.emplace( net::const_buffer{sv.data(), sv.size()}, net::const_buffer{ f_.target_or_reason_.data(), f_.target_or_reason_.size()}, net::const_buffer{buf_, 11}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf()); } template<class Allocator> basic_fields<Allocator>::writer:: writer(basic_fields const& f, unsigned version, unsigned code) : f_(f) { /* response "HTTP/X.Y ### " (13 chars) "<reason>" "\r\n" */ buf_[0] = 'H'; buf_[1] = 'T'; buf_[2] = 'T'; buf_[3] = 'P'; buf_[4] = '/'; buf_[5] = '0' + static_cast<char>(version / 10); buf_[6] = '.'; buf_[7] = '0' + static_cast<char>(version % 10); buf_[8] = ' '; buf_[9] = '0' + static_cast<char>(code / 100); buf_[10]= '0' + static_cast<char>((code / 10) % 10); buf_[11]= '0' + static_cast<char>(code % 10); buf_[12]= ' '; string_view sv; if(! f_.target_or_reason_.empty()) sv = f_.target_or_reason_; else sv = obsolete_reason(static_cast<status>(code)); view_.emplace( net::const_buffer{buf_, 13}, net::const_buffer{sv.data(), sv.size()}, net::const_buffer{"\r\n", 2}, field_range(f_.list_.begin(), f_.list_.end()), chunk_crlf{}); } //------------------------------------------------------------------------------ template<class Allocator> char* basic_fields<Allocator>:: value_type:: data() const { return const_cast<char*>( reinterpret_cast<char const*>( static_cast<element const*>(this) + 1)); } template<class Allocator> net::const_buffer basic_fields<Allocator>:: value_type:: buffer() const { return net::const_buffer{data(), static_cast<std::size_t>(off_) + len_ + 2}; } template<class Allocator> basic_fields<Allocator>:: value_type:: value_type(field name, string_view sname, string_view value) : off_(static_cast<off_t>(sname.size() + 2)) , len_(static_cast<off_t>(value.size())) , f_(name) { //BOOST_ASSERT(name == field::unknown || // iequals(sname, to_string(name))); char* p = data(); p[off_-2] = ':'; p[off_-1] = ' '; p[off_ + len_] = '\r'; p[off_ + len_ + 1] = '\n'; sname.copy(p, sname.size()); value.copy(p + off_, value.size()); } template<class Allocator> field basic_fields<Allocator>:: value_type:: name() const { return f_; } template<class Allocator> string_view const basic_fields<Allocator>:: value_type:: name_string() const { return {data(), static_cast<std::size_t>(off_ - 2)}; } template<class Allocator> string_view const basic_fields<Allocator>:: value_type:: value() const { return {data() + off_, static_cast<std::size_t>(len_)}; } template<class Allocator> basic_fields<Allocator>:: element:: element(field name, string_view sname, string_view value) : value_type(name, sname, value) { } //------------------------------------------------------------------------------ template<class Allocator> basic_fields<Allocator>:: ~basic_fields() { delete_list(); realloc_string(method_, {}); realloc_string( target_or_reason_, {}); } template<class Allocator> basic_fields<Allocator>:: basic_fields(Allocator const& alloc) noexcept : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields&& other) noexcept : boost::empty_value<Allocator>(boost::empty_init_t(), std::move(other.get())) , set_(std::move(other.set_)) , list_(std::move(other.list_)) , method_(boost::exchange(other.method_, {})) , target_or_reason_(boost::exchange(other.target_or_reason_, {})) { } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields&& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { if(this->get() != other.get()) { copy_all(other); } else { set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; } } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields const& other) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc_traits:: select_on_container_copy_construction(other.get())) { copy_all(other); } template<class Allocator> basic_fields<Allocator>:: basic_fields(basic_fields const& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { copy_all(other); } template<class Allocator> template<class OtherAlloc> basic_fields<Allocator>:: basic_fields(basic_fields<OtherAlloc> const& other) { copy_all(other); } template<class Allocator> template<class OtherAlloc> basic_fields<Allocator>:: basic_fields(basic_fields<OtherAlloc> const& other, Allocator const& alloc) : boost::empty_value<Allocator>(boost::empty_init_t(), alloc) { copy_all(other); } template<class Allocator> auto basic_fields<Allocator>:: operator=(basic_fields&& other) noexcept( alloc_traits::propagate_on_container_move_assignment::value) -> basic_fields& { static_assert(is_nothrow_move_assignable<Allocator>::value, "Allocator must be noexcept assignable."); if(this == &other) return *this; move_assign(other, std::integral_constant<bool, alloc_traits:: propagate_on_container_move_assignment::value>{}); return *this; } template<class Allocator> auto basic_fields<Allocator>:: operator=(basic_fields const& other) -> basic_fields& { copy_assign(other, std::integral_constant<bool, alloc_traits::propagate_on_container_copy_assignment::value>{}); return *this; } template<class Allocator> template<class OtherAlloc> auto basic_fields<Allocator>:: operator=(basic_fields<OtherAlloc> const& other) -> basic_fields& { clear_all(); copy_all(other); return *this; } //------------------------------------------------------------------------------ // // Element access // //------------------------------------------------------------------------------ template<class Allocator> string_view const basic_fields<Allocator>:: at(field name) const { BOOST_ASSERT(name != field::unknown); auto const it = find(name); if(it == end()) BOOST_THROW_EXCEPTION(std::out_of_range{ "field not found"}); return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: at(string_view name) const { auto const it = find(name); if(it == end()) BOOST_THROW_EXCEPTION(std::out_of_range{ "field not found"}); return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: operator[](field name) const { BOOST_ASSERT(name != field::unknown); auto const it = find(name); if(it == end()) return {}; return it->value(); } template<class Allocator> string_view const basic_fields<Allocator>:: operator[](string_view name) const { auto const it = find(name); if(it == end()) return {}; return it->value(); } //------------------------------------------------------------------------------ // // Modifiers // //------------------------------------------------------------------------------ template<class Allocator> void basic_fields<Allocator>:: clear() { delete_list(); set_.clear(); list_.clear(); } template<class Allocator> inline void basic_fields<Allocator>:: insert(field name, string_view const& value) { BOOST_ASSERT(name != field::unknown); insert(name, to_string(name), value); } template<class Allocator> void basic_fields<Allocator>:: insert(string_view sname, string_view const& value) { auto const name = string_to_field(sname); insert(name, sname, value); } template<class Allocator> void basic_fields<Allocator>:: insert(field name, string_view sname, string_view const& value) { auto& e = new_element(name, sname, static_cast<string_view>(value)); auto const before = set_.upper_bound(sname, key_compare{}); if(before == set_.begin()) { BOOST_ASSERT(count(sname) == 0); set_.insert_before(before, e); list_.push_back(e); return; } auto const last = std::prev(before); // VFALCO is it worth comparing `field name` first? if(! beast::iequals(sname, last->name_string())) { BOOST_ASSERT(count(sname) == 0); set_.insert_before(before, e); list_.push_back(e); return; } // keep duplicate fields together in the list set_.insert_before(before, e); list_.insert(++list_.iterator_to(*last), e); } template<class Allocator> void basic_fields<Allocator>:: set(field name, string_view const& value) { BOOST_ASSERT(name != field::unknown); set_element(new_element(name, to_string(name), static_cast<string_view>(value))); } template<class Allocator> void basic_fields<Allocator>:: set(string_view sname, string_view const& value) { set_element(new_element( string_to_field(sname), sname, value)); } template<class Allocator> auto basic_fields<Allocator>:: erase(const_iterator pos) -> const_iterator { auto next = pos; auto& e = *next++; set_.erase(set_.iterator_to(e)); list_.erase(pos); delete_element(const_cast<element&>(e)); return next; } template<class Allocator> std::size_t basic_fields<Allocator>:: erase(field name) { BOOST_ASSERT(name != field::unknown); return erase(to_string(name)); } template<class Allocator> std::size_t basic_fields<Allocator>:: erase(string_view name) { std::size_t n =0; set_.erase_and_dispose(name, key_compare{}, [&](element* e) { ++n; list_.erase(list_.iterator_to(*e)); delete_element(*e); }); return n; } template<class Allocator> void basic_fields<Allocator>:: swap(basic_fields<Allocator>& other) { swap(other, std::integral_constant<bool, alloc_traits::propagate_on_container_swap::value>{}); } template<class Allocator> void swap( basic_fields<Allocator>& lhs, basic_fields<Allocator>& rhs) { lhs.swap(rhs); } //------------------------------------------------------------------------------ // // Lookup // //------------------------------------------------------------------------------ template<class Allocator> inline std::size_t basic_fields<Allocator>:: count(field name) const { BOOST_ASSERT(name != field::unknown); return count(to_string(name)); } template<class Allocator> std::size_t basic_fields<Allocator>:: count(string_view name) const { return set_.count(name, key_compare{}); } template<class Allocator> inline auto basic_fields<Allocator>:: find(field name) const -> const_iterator { BOOST_ASSERT(name != field::unknown); return find(to_string(name)); } template<class Allocator> auto basic_fields<Allocator>:: find(string_view name) const -> const_iterator { auto const it = set_.find( name, key_compare{}); if(it == set_.end()) return list_.end(); return list_.iterator_to(*it); } template<class Allocator> inline auto basic_fields<Allocator>:: equal_range(field name) const -> std::pair<const_iterator, const_iterator> { BOOST_ASSERT(name != field::unknown); return equal_range(to_string(name)); } template<class Allocator> auto basic_fields<Allocator>:: equal_range(string_view name) const -> std::pair<const_iterator, const_iterator> { auto result = set_.equal_range(name, key_compare{}); if(result.first == result.second) return {list_.end(), list_.end()}; return { list_.iterator_to(*result.first), ++list_.iterator_to(*(--result.second))}; } //------------------------------------------------------------------------------ namespace detail { struct iequals_predicate { bool operator()(string_view s) const { return beast::iequals(s, sv1) || beast::iequals(s, sv2); } string_view sv1; string_view sv2; }; // Filter the last item in a token list BOOST_BEAST_DECL void filter_token_list_last( beast::detail::temporary_buffer& s, string_view value, iequals_predicate const& pred); BOOST_BEAST_DECL void keep_alive_impl( beast::detail::temporary_buffer& s, string_view value, unsigned version, bool keep_alive); } // detail //------------------------------------------------------------------------------ // Fields template<class Allocator> inline string_view basic_fields<Allocator>:: get_method_impl() const { return method_; } template<class Allocator> inline string_view basic_fields<Allocator>:: get_target_impl() const { if(target_or_reason_.empty()) return target_or_reason_; return { target_or_reason_.data() + 1, target_or_reason_.size() - 1}; } template<class Allocator> inline string_view basic_fields<Allocator>:: get_reason_impl() const { return target_or_reason_; } template<class Allocator> bool basic_fields<Allocator>:: get_chunked_impl() const { auto const te = token_list{ (*this)[field::transfer_encoding]}; for(auto it = te.begin(); it != te.end();) { auto const next = std::next(it); if(next == te.end()) return beast::iequals(*it, "chunked"); it = next; } return false; } template<class Allocator> bool basic_fields<Allocator>:: get_keep_alive_impl(unsigned version) const { auto const it = find(field::connection); if(version < 11) { if(it == end()) return false; return token_list{ it->value()}.exists("keep-alive"); } if(it == end()) return true; return ! token_list{ it->value()}.exists("close"); } template<class Allocator> bool basic_fields<Allocator>:: has_content_length_impl() const { return count(field::content_length) > 0; } template<class Allocator> inline void basic_fields<Allocator>:: set_method_impl(string_view s) { realloc_string(method_, s); } template<class Allocator> inline void basic_fields<Allocator>:: set_target_impl(string_view s) { realloc_target( target_or_reason_, s); } template<class Allocator> inline void basic_fields<Allocator>:: set_reason_impl(string_view s) { realloc_string( target_or_reason_, s); } template<class Allocator> void basic_fields<Allocator>:: set_chunked_impl(bool value) { beast::detail::temporary_buffer buf; auto it = find(field::transfer_encoding); if(value) { // append "chunked" if(it == end()) { set(field::transfer_encoding, "chunked"); return; } auto const te = token_list{it->value()}; for(auto itt = te.begin();;) { auto const next = std::next(itt); if(next == te.end()) { if(beast::iequals(*itt, "chunked")) return; // already set break; } itt = next; } buf.append(it->value(), ", chunked"); set(field::transfer_encoding, buf.view()); return; } // filter "chunked" if(it == end()) return; detail::filter_token_list_last(buf, it->value(), {"chunked", {}}); if(! buf.empty()) set(field::transfer_encoding, buf.view()); else erase(field::transfer_encoding); } template<class Allocator> void basic_fields<Allocator>:: set_content_length_impl( boost::optional<std::uint64_t> const& value) { if(! value) erase(field::content_length); else { set(field::content_length, to_static_string(*value)); } } template<class Allocator> void basic_fields<Allocator>:: set_keep_alive_impl( unsigned version, bool keep_alive) { // VFALCO What about Proxy-Connection ? auto const value = (*this)[field::connection]; beast::detail::temporary_buffer buf; detail::keep_alive_impl(buf, value, version, keep_alive); if(buf.empty()) erase(field::connection); else set(field::connection, buf.view()); } //------------------------------------------------------------------------------ template<class Allocator> auto basic_fields<Allocator>:: new_element(field name, string_view sname, string_view value) -> element& { if(sname.size() + 2 > (std::numeric_limits<off_t>::max)()) BOOST_THROW_EXCEPTION(std::length_error{ "field name too large"}); if(value.size() + 2 > (std::numeric_limits<off_t>::max)()) BOOST_THROW_EXCEPTION(std::length_error{ "field value too large"}); value = detail::trim(value); std::uint16_t const off = static_cast<off_t>(sname.size() + 2); std::uint16_t const len = static_cast<off_t>(value.size()); auto a = rebind_type{this->get()}; auto const p = alloc_traits::allocate(a, (sizeof(element) + off + len + 2 + sizeof(align_type) - 1) / sizeof(align_type)); return *(::new(p) element(name, sname, value)); } template<class Allocator> void basic_fields<Allocator>:: delete_element(element& e) { auto a = rebind_type{this->get()}; auto const n = (sizeof(element) + e.off_ + e.len_ + 2 + sizeof(align_type) - 1) / sizeof(align_type); e.~element(); alloc_traits::deallocate(a, reinterpret_cast<align_type*>(&e), n); } template<class Allocator> void basic_fields<Allocator>:: set_element(element& e) { auto it = set_.lower_bound( e.name_string(), key_compare{}); if(it == set_.end() || ! beast::iequals( e.name_string(), it->name_string())) { set_.insert_before(it, e); list_.push_back(e); return; } for(;;) { auto next = it; ++next; set_.erase(it); list_.erase(list_.iterator_to(*it)); delete_element(*it); it = next; if(it == set_.end() || ! beast::iequals(e.name_string(), it->name_string())) break; } set_.insert_before(it, e); list_.push_back(e); } template<class Allocator> void basic_fields<Allocator>:: realloc_string(string_view& dest, string_view s) { if(dest.empty() && s.empty()) return; auto a = typename beast::detail::allocator_traits< Allocator>::template rebind_alloc< char>(this->get()); char* p = nullptr; if(! s.empty()) { p = a.allocate(s.size()); s.copy(p, s.size()); } if(! dest.empty()) a.deallocate(const_cast<char*>( dest.data()), dest.size()); if(p) dest = {p, s.size()}; else dest = {}; } template<class Allocator> void basic_fields<Allocator>:: realloc_target( string_view& dest, string_view s) { // The target string are stored with an // extra space at the beginning to help // the writer class. if(dest.empty() && s.empty()) return; auto a = typename beast::detail::allocator_traits< Allocator>::template rebind_alloc< char>(this->get()); char* p = nullptr; if(! s.empty()) { p = a.allocate(1 + s.size()); p[0] = ' '; s.copy(p + 1, s.size()); } if(! dest.empty()) a.deallocate(const_cast<char*>( dest.data()), dest.size()); if(p) dest = {p, 1 + s.size()}; else dest = {}; } template<class Allocator> template<class OtherAlloc> void basic_fields<Allocator>:: copy_all(basic_fields<OtherAlloc> const& other) { for(auto const& e : other.list_) insert(e.name(), e.name_string(), e.value()); realloc_string(method_, other.method_); realloc_string(target_or_reason_, other.target_or_reason_); } template<class Allocator> void basic_fields<Allocator>:: clear_all() { clear(); realloc_string(method_, {}); realloc_string(target_or_reason_, {}); } template<class Allocator> void basic_fields<Allocator>:: delete_list() { for(auto it = list_.begin(); it != list_.end();) delete_element(*it++); } //------------------------------------------------------------------------------ template<class Allocator> inline void basic_fields<Allocator>:: move_assign(basic_fields& other, std::true_type) { clear_all(); set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; other.method_ = {}; other.target_or_reason_ = {}; this->get() = other.get(); } template<class Allocator> inline void basic_fields<Allocator>:: move_assign(basic_fields& other, std::false_type) { clear_all(); if(this->get() != other.get()) { copy_all(other); } else { set_ = std::move(other.set_); list_ = std::move(other.list_); method_ = other.method_; target_or_reason_ = other.target_or_reason_; other.method_ = {}; other.target_or_reason_ = {}; } } template<class Allocator> inline void basic_fields<Allocator>:: copy_assign(basic_fields const& other, std::true_type) { clear_all(); this->get() = other.get(); copy_all(other); } template<class Allocator> inline void basic_fields<Allocator>:: copy_assign(basic_fields const& other, std::false_type) { clear_all(); copy_all(other); } template<class Allocator> inline void basic_fields<Allocator>:: swap(basic_fields& other, std::true_type) { using std::swap; swap(this->get(), other.get()); swap(set_, other.set_); swap(list_, other.list_); swap(method_, other.method_); swap(target_or_reason_, other.target_or_reason_); } template<class Allocator> inline void basic_fields<Allocator>:: swap(basic_fields& other, std::false_type) { BOOST_ASSERT(this->get() == other.get()); using std::swap; swap(set_, other.set_); swap(list_, other.list_); swap(method_, other.method_); swap(target_or_reason_, other.target_or_reason_); } } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/fields.ipp> #endif #endif PK PP�[C��B�e �e http/impl/write.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_WRITE_HPP #define BOOST_BEAST_HTTP_IMPL_WRITE_HPP #include <boost/beast/http/type_traits.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/make_printable.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/asio/coroutine.hpp> #include <boost/asio/post.hpp> #include <boost/asio/write.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <ostream> #include <sstream> namespace boost { namespace beast { namespace http { namespace detail { template< class Handler, class Stream, bool isRequest, class Body, class Fields> class write_some_op : public beast::async_base< Handler, beast::executor_type<Stream>> { Stream& s_; serializer<isRequest,Body, Fields>& sr_; class lambda { write_some_op& op_; public: bool invoked = false; explicit lambda(write_some_op& op) : op_(op) { } template<class ConstBufferSequence> void operator()( error_code& ec, ConstBufferSequence const& buffers) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write_some")); invoked = true; ec = {}; op_.s_.async_write_some( buffers, std::move(op_)); } }; public: template<class Handler_> write_some_op( Handler_&& h, Stream& s, serializer<isRequest, Body, Fields>& sr) : async_base< Handler, beast::executor_type<Stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , sr_(sr) { (*this)(); } void operator()() { error_code ec; if(! sr_.is_done()) { lambda f{*this}; sr_.next(ec, f); if(ec) { BOOST_ASSERT(! f.invoked); BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write_some")); return net::post( s_.get_executor(), beast::bind_front_handler( std::move(*this), ec, 0)); } if(f.invoked) { // *this is now moved-from, return; } // What else could it be? BOOST_ASSERT(sr_.is_done()); } BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write_some")); return net::post( s_.get_executor(), beast::bind_front_handler( std::move(*this), ec, 0)); } void operator()( error_code ec, std::size_t bytes_transferred) { if(! ec) sr_.consume(bytes_transferred); this->complete_now(ec, bytes_transferred); } }; //------------------------------------------------------------------------------ struct serializer_is_header_done { template< bool isRequest, class Body, class Fields> bool operator()( serializer<isRequest, Body, Fields>& sr) const { return sr.is_header_done(); } }; struct serializer_is_done { template< bool isRequest, class Body, class Fields> bool operator()( serializer<isRequest, Body, Fields>& sr) const { return sr.is_done(); } }; //------------------------------------------------------------------------------ template< class Handler, class Stream, class Predicate, bool isRequest, class Body, class Fields> class write_op : public beast::async_base< Handler, beast::executor_type<Stream>> , public asio::coroutine { Stream& s_; serializer<isRequest, Body, Fields>& sr_; std::size_t bytes_transferred_ = 0; public: template<class Handler_> write_op( Handler_&& h, Stream& s, serializer<isRequest, Body, Fields>& sr) : async_base< Handler, beast::executor_type<Stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , sr_(sr) { (*this)(); } void operator()( error_code ec = {}, std::size_t bytes_transferred = 0) { BOOST_ASIO_CORO_REENTER(*this) { if(Predicate{}(sr_)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write")); net::post( s_.get_executor(), std::move(*this)); } goto upcall; } for(;;) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write")); beast::http::async_write_some( s_, sr_, std::move(*this)); } bytes_transferred_ += bytes_transferred; if(ec) goto upcall; if(Predicate{}(sr_)) break; } upcall: this->complete_now(ec, bytes_transferred_); } } }; //------------------------------------------------------------------------------ template< class Handler, class Stream, bool isRequest, class Body, class Fields> class write_msg_op : public beast::stable_async_base< Handler, beast::executor_type<Stream>> { Stream& s_; serializer<isRequest, Body, Fields>& sr_; public: template< class Handler_, class... Args> write_msg_op( Handler_&& h, Stream& s, Args&&... args) : stable_async_base< Handler, beast::executor_type<Stream>>( std::forward<Handler_>(h), s.get_executor()) , s_(s) , sr_(beast::allocate_stable< serializer<isRequest, Body, Fields>>( *this, std::forward<Args>(args)...)) { (*this)(); } void operator()() { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_write(msg)")); async_write(s_, sr_, std::move(*this)); } void operator()( error_code ec, std::size_t bytes_transferred) { this->complete_now(ec, bytes_transferred); } }; struct run_write_some_op { template< class WriteHandler, class Stream, bool isRequest, class Body, class Fields> void operator()( WriteHandler&& h, Stream* s, serializer<isRequest, Body, Fields>* sr) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_some_op< typename std::decay<WriteHandler>::type, Stream, isRequest, Body, Fields>( std::forward<WriteHandler>(h), *s, *sr); } }; struct run_write_op { template< class WriteHandler, class Stream, class Predicate, bool isRequest, class Body, class Fields> void operator()( WriteHandler&& h, Stream* s, Predicate const&, serializer<isRequest, Body, Fields>* sr) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_op< typename std::decay<WriteHandler>::type, Stream, Predicate, isRequest, Body, Fields>( std::forward<WriteHandler>(h), *s, *sr); } }; struct run_write_msg_op { template< class WriteHandler, class Stream, bool isRequest, class Body, class Fields, class... Args> void operator()( WriteHandler&& h, Stream* s, message<isRequest, Body, Fields>* m, std::false_type, Args&&... args) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_msg_op< typename std::decay<WriteHandler>::type, Stream, isRequest, Body, Fields>( std::forward<WriteHandler>(h), *s, *m, std::forward<Args>(args)...); } template< class WriteHandler, class Stream, bool isRequest, class Body, class Fields, class... Args> void operator()( WriteHandler&& h, Stream* s, message<isRequest, Body, Fields> const* m, std::true_type, Args&&... args) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_msg_op< typename std::decay<WriteHandler>::type, Stream, isRequest, Body, Fields>( std::forward<WriteHandler>(h), *s, *m, std::forward<Args>(args)...); } }; //------------------------------------------------------------------------------ template<class Stream> class write_some_lambda { Stream& stream_; public: bool invoked = false; std::size_t bytes_transferred = 0; explicit write_some_lambda(Stream& stream) : stream_(stream) { } template<class ConstBufferSequence> void operator()(error_code& ec, ConstBufferSequence const& buffers) { invoked = true; bytes_transferred = stream_.write_some(buffers, ec); } }; template<class Stream> class write_lambda { Stream& stream_; public: bool invoked = false; std::size_t bytes_transferred = 0; explicit write_lambda(Stream& stream) : stream_(stream) { } template<class ConstBufferSequence> void operator()(error_code& ec, ConstBufferSequence const& buffers) { invoked = true; bytes_transferred = net::write( stream_, buffers, ec); } }; template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_some_impl( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec) { if(! sr.is_done()) { write_some_lambda<SyncWriteStream> f{stream}; sr.next(ec, f); if(ec) return f.bytes_transferred; if(f.invoked) sr.consume(f.bytes_transferred); return f.bytes_transferred; } ec = {}; return 0; } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some_impl( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler) { return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( run_write_some_op{}, handler, &stream, &sr); } } // detail //------------------------------------------------------------------------------ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_some( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); error_code ec; auto const bytes_transferred = write_some(stream, sr, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_some( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); return detail::write_some_impl(stream, sr, ec); } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler) { static_assert(is_async_write_stream< AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); return detail::async_write_some_impl(stream, sr, std::forward<WriteHandler>(handler)); } //------------------------------------------------------------------------------ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_header(SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); error_code ec; auto const bytes_transferred = write_header(stream, sr, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_header( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); sr.split(true); std::size_t bytes_transferred = 0; if(! sr.is_header_done()) { detail::write_lambda<SyncWriteStream> f{stream}; do { sr.next(ec, f); bytes_transferred += f.bytes_transferred; if(ec) return bytes_transferred; BOOST_ASSERT(f.invoked); sr.consume(f.bytes_transferred); } while(! sr.is_header_done()); } else { ec = {}; } return bytes_transferred; } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_header( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler) { static_assert(is_async_write_stream< AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); sr.split(true); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( detail::run_write_op{}, handler, &stream, detail::serializer_is_header_done{}, &sr); } //------------------------------------------------------------------------------ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); error_code ec; auto const bytes_transferred = write(stream, sr, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); std::size_t bytes_transferred = 0; sr.split(false); for(;;) { bytes_transferred += write_some(stream, sr, ec); if(ec) return bytes_transferred; if(sr.is_done()) break; } return bytes_transferred; } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler) { static_assert(is_async_write_stream< AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); sr.split(false); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( detail::run_write_op{}, handler, &stream, detail::serializer_is_done{}, &sr); } //------------------------------------------------------------------------------ template< class SyncWriteStream, bool isRequest, class Body, class Fields> typename std::enable_if< is_mutable_body_writer<Body>::value, std::size_t>::type write( SyncWriteStream& stream, message<isRequest, Body, Fields>& msg) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); error_code ec; auto const bytes_transferred = write(stream, msg, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncWriteStream, bool isRequest, class Body, class Fields> typename std::enable_if< ! is_mutable_body_writer<Body>::value, std::size_t>::type write( SyncWriteStream& stream, message<isRequest, Body, Fields> const& msg) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); error_code ec; auto const bytes_transferred = write(stream, msg, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncWriteStream, bool isRequest, class Body, class Fields> typename std::enable_if< is_mutable_body_writer<Body>::value, std::size_t>::type write( SyncWriteStream& stream, message<isRequest, Body, Fields>& msg, error_code& ec) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); serializer<isRequest, Body, Fields> sr{msg}; return write(stream, sr, ec); } template< class SyncWriteStream, bool isRequest, class Body, class Fields> typename std::enable_if< ! is_mutable_body_writer<Body>::value, std::size_t>::type write( SyncWriteStream& stream, message<isRequest, Body, Fields> const& msg, error_code& ec) { static_assert(is_sync_write_stream<SyncWriteStream>::value, "SyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); serializer<isRequest, Body, Fields> sr{msg}; return write(stream, sr, ec); } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, message<isRequest, Body, Fields>& msg, WriteHandler&& handler, typename std::enable_if< is_mutable_body_writer<Body>::value>::type*) { static_assert( is_async_write_stream<AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( detail::run_write_msg_op{}, handler, &stream, &msg, std::false_type{}); } template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, message<isRequest, Body, Fields> const& msg, WriteHandler&& handler, typename std::enable_if< ! is_mutable_body_writer<Body>::value>::type*) { static_assert( is_async_write_stream<AsyncWriteStream>::value, "AsyncWriteStream type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( detail::run_write_msg_op{}, handler, &stream, &msg, std::true_type{}); } //------------------------------------------------------------------------------ namespace detail { template<class Serializer> class write_ostream_lambda { std::ostream& os_; Serializer& sr_; public: write_ostream_lambda(std::ostream& os, Serializer& sr) : os_(os) , sr_(sr) { } template<class ConstBufferSequence> void operator()(error_code& ec, ConstBufferSequence const& buffers) const { ec = {}; if(os_.fail()) return; std::size_t bytes_transferred = 0; for(auto b : beast::buffers_range_ref(buffers)) { os_.write(static_cast<char const*>( b.data()), b.size()); if(os_.fail()) return; bytes_transferred += b.size(); } sr_.consume(bytes_transferred); } }; } // detail template<class Fields> std::ostream& operator<<(std::ostream& os, header<true, Fields> const& h) { typename Fields::writer fr{ h, h.version(), h.method()}; return os << beast::make_printable(fr.get()); } template<class Fields> std::ostream& operator<<(std::ostream& os, header<false, Fields> const& h) { typename Fields::writer fr{ h, h.version(), h.result_int()}; return os << beast::make_printable(fr.get()); } template<bool isRequest, class Body, class Fields> std::ostream& operator<<(std::ostream& os, message<isRequest, Body, Fields> const& msg) { static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); serializer<isRequest, Body, Fields> sr{msg}; error_code ec; detail::write_ostream_lambda<decltype(sr)> f{os, sr}; do { sr.next(ec, f); if(os.fail()) break; if(ec) { os.setstate(std::ios::failbit); break; } } while(! sr.is_done()); return os; } } // http } // beast } // boost #endif PK PP�[� � http/impl/error.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_ERROR_IPP #define BOOST_BEAST_HTTP_IMPL_ERROR_IPP #include <boost/beast/http/error.hpp> #include <type_traits> namespace boost { namespace beast { namespace http { namespace detail { class http_error_category : public error_category { public: const char* name() const noexcept override { return "beast.http"; } std::string message(int ev) const override { switch(static_cast<error>(ev)) { case error::end_of_stream: return "end of stream"; case error::partial_message: return "partial message"; case error::need_more: return "need more"; case error::unexpected_body: return "unexpected body"; case error::need_buffer: return "need buffer"; case error::end_of_chunk: return "end of chunk"; case error::buffer_overflow: return "buffer overflow"; case error::header_limit: return "header limit exceeded"; case error::body_limit: return "body limit exceeded"; case error::bad_alloc: return "bad alloc"; case error::bad_line_ending: return "bad line ending"; case error::bad_method: return "bad method"; case error::bad_target: return "bad target"; case error::bad_version: return "bad version"; case error::bad_status: return "bad status"; case error::bad_reason: return "bad reason"; case error::bad_field: return "bad field"; case error::bad_value: return "bad value"; case error::bad_content_length: return "bad Content-Length"; case error::bad_transfer_encoding: return "bad Transfer-Encoding"; case error::bad_chunk: return "bad chunk"; case error::bad_chunk_extension: return "bad chunk extension"; case error::bad_obs_fold: return "bad obs-fold"; case error::stale_parser: return "stale parser"; case error::short_read: return "unexpected eof in body"; default: return "beast.http error"; } } error_condition default_error_condition( int ev) const noexcept override { return error_condition{ev, *this}; } bool equivalent(int ev, error_condition const& condition ) const noexcept override { return condition.value() == ev && &condition.category() == this; } bool equivalent(error_code const& error, int ev) const noexcept override { return error.value() == ev && &error.category() == this; } }; } // detail error_code make_error_code(error ev) { static detail::http_error_category const cat{}; return error_code{static_cast< std::underlying_type<error>::type>(ev), cat}; } } // http } // beast } // boost #endif PK PP�[�2�C� � http/impl/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_ERROR_HPP #define BOOST_BEAST_HTTP_IMPL_ERROR_HPP #include <type_traits> namespace boost { namespace system { template<> struct is_error_code_enum<::boost::beast::http::error> { static bool const value = true; }; } // system } // boost namespace boost { namespace beast { namespace http { BOOST_BEAST_DECL error_code make_error_code(error ev); } // http } // beast } // boost #endif PK PP�[��� � http/impl/parser.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_PARSER_HPP #define BOOST_BEAST_HTTP_IMPL_PARSER_HPP #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace beast { namespace http { template<bool isRequest, class Body, class Allocator> parser<isRequest, Body, Allocator>:: parser() : rd_(m_.base(), m_.body()) { } template<bool isRequest, class Body, class Allocator> template<class Arg1, class... ArgN, class> parser<isRequest, Body, Allocator>:: parser(Arg1&& arg1, ArgN&&... argn) : m_( std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...) , rd_(m_.base(), m_.body()) { m_.clear(); } template<bool isRequest, class Body, class Allocator> template<class OtherBody, class... Args, class> parser<isRequest, Body, Allocator>:: parser( parser<isRequest, OtherBody, Allocator>&& other, Args&&... args) : basic_parser<isRequest>(std::move(other)) , m_(other.release(), std::forward<Args>(args)...) , rd_(m_.base(), m_.body()) { if(other.rd_inited_) BOOST_THROW_EXCEPTION(std::invalid_argument{ "moved-from parser has a body"}); } } // http } // beast } // boost #endif PK PP�[���( ( http/impl/message.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_MESSAGE_HPP #define BOOST_BEAST_HTTP_IMPL_MESSAGE_HPP #include <boost/beast/core/error.hpp> #include <boost/assert.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace beast { namespace http { template<class Fields> template<class Arg1, class... ArgN, class> header<true, Fields>:: header(Arg1&& arg1, ArgN&&... argn) : Fields(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...) { } template<class Fields> verb header<true, Fields>:: method() const { return method_; } template<class Fields> void header<true, Fields>:: method(verb v) { if(v == verb::unknown) BOOST_THROW_EXCEPTION( std::invalid_argument{"unknown method"}); method_ = v; this->set_method_impl({}); } template<class Fields> string_view header<true, Fields>:: method_string() const { if(method_ != verb::unknown) return to_string(method_); return this->get_method_impl(); } template<class Fields> void header<true, Fields>:: method_string(string_view s) { method_ = string_to_verb(s); if(method_ != verb::unknown) this->set_method_impl({}); else this->set_method_impl(s); } template<class Fields> string_view header<true, Fields>:: target() const { return this->get_target_impl(); } template<class Fields> void header<true, Fields>:: target(string_view s) { this->set_target_impl(s); } template<class Fields> void swap( header<true, Fields>& h1, header<true, Fields>& h2) { using std::swap; swap( static_cast<Fields&>(h1), static_cast<Fields&>(h2)); swap(h1.version_, h2.version_); swap(h1.method_, h2.method_); } //------------------------------------------------------------------------------ template<class Fields> template<class Arg1, class... ArgN, class> header<false, Fields>:: header(Arg1&& arg1, ArgN&&... argn) : Fields(std::forward<Arg1>(arg1), std::forward<ArgN>(argn)...) { } template<class Fields> status header<false, Fields>:: result() const { return int_to_status( static_cast<int>(result_)); } template<class Fields> void header<false, Fields>:: result(status v) { result_ = v; } template<class Fields> void header<false, Fields>:: result(unsigned v) { if(v > 999) BOOST_THROW_EXCEPTION( std::invalid_argument{ "invalid status-code"}); result_ = static_cast<status>(v); } template<class Fields> unsigned header<false, Fields>:: result_int() const { return static_cast<unsigned>(result_); } template<class Fields> string_view header<false, Fields>:: reason() const { auto const s = this->get_reason_impl(); if(! s.empty()) return s; return obsolete_reason(result_); } template<class Fields> void header<false, Fields>:: reason(string_view s) { this->set_reason_impl(s); } template<class Fields> void swap( header<false, Fields>& h1, header<false, Fields>& h2) { using std::swap; swap( static_cast<Fields&>(h1), static_cast<Fields&>(h2)); swap(h1.version_, h2.version_); swap(h1.result_, h2.result_); } //------------------------------------------------------------------------------ template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(header_type&& h, BodyArgs&&... body_args) : header_type(std::move(h)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>(body_args)...) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(header_type const& h, BodyArgs&&... body_args) : header_type(h) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>(body_args)...) { } template<bool isRequest, class Body, class Fields> template<class Version, class> message<isRequest, Body, Fields>:: message(verb method, string_view target, Version version) : header_type(method, target, version) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class> message<isRequest, Body, Fields>:: message(verb method, string_view target, Version version, BodyArg&& body_arg) : header_type(method, target, version) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class FieldsArg, class> message<isRequest, Body, Fields>:: message( verb method, string_view target, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg) : header_type(method, target, version, std::forward<FieldsArg>(fields_arg)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class> message<isRequest, Body, Fields>:: message(status result, Version version) : header_type(result, version) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class> message<isRequest, Body, Fields>:: message(status result, Version version, BodyArg&& body_arg) : header_type(result, version) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> template<class Version, class BodyArg, class FieldsArg, class> message<isRequest, Body, Fields>:: message(status result, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg) : header_type(result, version, std::forward<FieldsArg>(fields_arg)) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArg>(body_arg)) { } template<bool isRequest, class Body, class Fields> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args) : message(std::piecewise_construct, body_args, mp11::make_index_sequence< sizeof...(BodyArgs)>{}) { } template<bool isRequest, class Body, class Fields> template<class... BodyArgs, class... FieldsArgs> message<isRequest, Body, Fields>:: message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args, std::tuple<FieldsArgs...> fields_args) : message(std::piecewise_construct, body_args, fields_args, mp11::make_index_sequence< sizeof...(BodyArgs)>{}, mp11::make_index_sequence< sizeof...(FieldsArgs)>{}) { } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: chunked(bool value) { this->set_chunked_impl(value); this->set_content_length_impl(boost::none); } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: content_length( boost::optional<std::uint64_t> const& value) { this->set_content_length_impl(value); this->set_chunked_impl(false); } template<bool isRequest, class Body, class Fields> boost::optional<std::uint64_t> message<isRequest, Body, Fields>:: payload_size() const { return payload_size(detail::is_body_sized<Body>{}); } template<bool isRequest, class Body, class Fields> bool message<isRequest, Body, Fields>:: need_eof(std::false_type) const { // VFALCO Do we need a way to let the caller say "the body is intentionally skipped"? if( this->result() == status::no_content || this->result() == status::not_modified || to_status_class(this->result()) == status_class::informational || has_content_length() || chunked()) return ! keep_alive(); return true; } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: prepare_payload(std::true_type) { auto const n = payload_size(); if(this->method() == verb::trace && (! n || *n > 0)) BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid request body"}); if(n) { if(*n > 0 || this->method() == verb::options || this->method() == verb::put || this->method() == verb::post) { this->content_length(n); } else { this->chunked(false); } } else if(this->version() == 11) { this->chunked(true); } else { this->chunked(false); } } template<bool isRequest, class Body, class Fields> void message<isRequest, Body, Fields>:: prepare_payload(std::false_type) { auto const n = payload_size(); if( (! n || *n > 0) && ( (status_class(this->result()) == status_class::informational || this->result() == status::no_content || this->result() == status::not_modified))) { // The response body MUST be empty for this case BOOST_THROW_EXCEPTION(std::invalid_argument{ "invalid response body"}); } if(n) this->content_length(n); else if(this->version() == 11) this->chunked(true); else this->chunked(false); } //------------------------------------------------------------------------------ template<bool isRequest, class Body, class Fields> void swap( message<isRequest, Body, Fields>& m1, message<isRequest, Body, Fields>& m2) { using std::swap; swap( static_cast<header<isRequest, Fields>&>(m1), static_cast<header<isRequest, Fields>&>(m2)); swap(m1.body(), m2.body()); } } // http } // beast } // boost #endif PK PP�[,ȁ��< �< http/impl/field.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_FIELD_IPP #define BOOST_BEAST_HTTP_IMPL_FIELD_IPP #include <boost/beast/http/field.hpp> #include <boost/assert.hpp> #include <algorithm> #include <array> #include <cstring> #include <ostream> namespace boost { namespace beast { namespace http { namespace detail { struct field_table { static std::uint32_t get_chars( unsigned char const* p) noexcept { // VFALCO memcpy is endian-dependent //std::memcpy(&v, p, 4); // Compiler should be smart enough to // optimize this down to one instruction. return p[0] | (p[1] << 8) | (p[2] << 16) | (p[3] << 24); } using array_type = std::array<string_view, 357>; // Strings are converted to lowercase static std::uint32_t digest(string_view s) { std::uint32_t r = 0; std::size_t n = s.size(); auto p = reinterpret_cast< unsigned char const*>(s.data()); // consume N characters at a time // VFALCO Can we do 8 on 64-bit systems? while(n >= 4) { auto const v = get_chars(p); r = (r * 5 + ( v | 0x20202020 )); // convert to lower p += 4; n -= 4; } // handle remaining characters while( n > 0 ) { r = r * 5 + ( *p | 0x20 ); ++p; --n; } return r; } // This comparison is case-insensitive, and the // strings must contain only valid http field characters. static bool equals(string_view lhs, string_view rhs) { using Int = std::uint32_t; // VFALCO std::size_t? auto n = lhs.size(); if(n != rhs.size()) return false; auto p1 = reinterpret_cast< unsigned char const*>(lhs.data()); auto p2 = reinterpret_cast< unsigned char const*>(rhs.data()); auto constexpr S = sizeof(Int); auto constexpr Mask = static_cast<Int>( 0xDFDFDFDFDFDFDFDF & ~Int{0}); for(; n >= S; p1 += S, p2 += S, n -= S) { Int const v1 = get_chars(p1); Int const v2 = get_chars(p2); if((v1 ^ v2) & Mask) return false; } for(; n; ++p1, ++p2, --n) if(( *p1 ^ *p2) & 0xDF) return false; return true; } array_type by_name_; enum { N = 5155 }; unsigned char map_[ N ][ 2 ] = {}; /* From: https://www.iana.org/assignments/message-headers/message-headers.xhtml */ field_table() : by_name_({{ // string constants "<unknown-field>", "A-IM", "Accept", "Accept-Additions", "Accept-Charset", "Accept-Datetime", "Accept-Encoding", "Accept-Features", "Accept-Language", "Accept-Patch", "Accept-Post", "Accept-Ranges", "Access-Control", "Access-Control-Allow-Credentials", "Access-Control-Allow-Headers", "Access-Control-Allow-Methods", "Access-Control-Allow-Origin", "Access-Control-Expose-Headers", "Access-Control-Max-Age", "Access-Control-Request-Headers", "Access-Control-Request-Method", "Age", "Allow", "ALPN", "Also-Control", "Alt-Svc", "Alt-Used", "Alternate-Recipient", "Alternates", "Apparently-To", "Apply-To-Redirect-Ref", "Approved", "Archive", "Archived-At", "Article-Names", "Article-Updates", "Authentication-Control", "Authentication-Info", "Authentication-Results", "Authorization", "Auto-Submitted", "Autoforwarded", "Autosubmitted", "Base", "Bcc", "Body", "C-Ext", "C-Man", "C-Opt", "C-PEP", "C-PEP-Info", "Cache-Control", "CalDAV-Timezones", "Cancel-Key", "Cancel-Lock", "Cc", "Close", "Comments", "Compliance", "Connection", "Content-Alternative", "Content-Base", "Content-Description", "Content-Disposition", "Content-Duration", "Content-Encoding", "Content-features", "Content-ID", "Content-Identifier", "Content-Language", "Content-Length", "Content-Location", "Content-MD5", "Content-Range", "Content-Return", "Content-Script-Type", "Content-Style-Type", "Content-Transfer-Encoding", "Content-Type", "Content-Version", "Control", "Conversion", "Conversion-With-Loss", "Cookie", "Cookie2", "Cost", "DASL", "Date", "Date-Received", "DAV", "Default-Style", "Deferred-Delivery", "Delivery-Date", "Delta-Base", "Depth", "Derived-From", "Destination", "Differential-ID", "Digest", "Discarded-X400-IPMS-Extensions", "Discarded-X400-MTS-Extensions", "Disclose-Recipients", "Disposition-Notification-Options", "Disposition-Notification-To", "Distribution", "DKIM-Signature", "DL-Expansion-History", "Downgraded-Bcc", "Downgraded-Cc", "Downgraded-Disposition-Notification-To", "Downgraded-Final-Recipient", "Downgraded-From", "Downgraded-In-Reply-To", "Downgraded-Mail-From", "Downgraded-Message-Id", "Downgraded-Original-Recipient", "Downgraded-Rcpt-To", "Downgraded-References", "Downgraded-Reply-To", "Downgraded-Resent-Bcc", "Downgraded-Resent-Cc", "Downgraded-Resent-From", "Downgraded-Resent-Reply-To", "Downgraded-Resent-Sender", "Downgraded-Resent-To", "Downgraded-Return-Path", "Downgraded-Sender", "Downgraded-To", "EDIINT-Features", "Eesst-Version", "Encoding", "Encrypted", "Errors-To", "ETag", "Expect", "Expires", "Expiry-Date", "Ext", "Followup-To", "Forwarded", "From", "Generate-Delivery-Report", "GetProfile", "Hobareg", "Host", "HTTP2-Settings", "If", "If-Match", "If-Modified-Since", "If-None-Match", "If-Range", "If-Schedule-Tag-Match", "If-Unmodified-Since", "IM", "Importance", "In-Reply-To", "Incomplete-Copy", "Injection-Date", "Injection-Info", "Jabber-ID", "Keep-Alive", "Keywords", "Label", "Language", "Last-Modified", "Latest-Delivery-Time", "Lines", "Link", "List-Archive", "List-Help", "List-ID", "List-Owner", "List-Post", "List-Subscribe", "List-Unsubscribe", "List-Unsubscribe-Post", "Location", "Lock-Token", "Man", "Max-Forwards", "Memento-Datetime", "Message-Context", "Message-ID", "Message-Type", "Meter", "Method-Check", "Method-Check-Expires", "MIME-Version", "MMHS-Acp127-Message-Identifier", "MMHS-Authorizing-Users", "MMHS-Codress-Message-Indicator", "MMHS-Copy-Precedence", "MMHS-Exempted-Address", "MMHS-Extended-Authorisation-Info", "MMHS-Handling-Instructions", "MMHS-Message-Instructions", "MMHS-Message-Type", "MMHS-Originator-PLAD", "MMHS-Originator-Reference", "MMHS-Other-Recipients-Indicator-CC", "MMHS-Other-Recipients-Indicator-To", "MMHS-Primary-Precedence", "MMHS-Subject-Indicator-Codes", "MT-Priority", "Negotiate", "Newsgroups", "NNTP-Posting-Date", "NNTP-Posting-Host", "Non-Compliance", "Obsoletes", "Opt", "Optional", "Optional-WWW-Authenticate", "Ordering-Type", "Organization", "Origin", "Original-Encoded-Information-Types", "Original-From", "Original-Message-ID", "Original-Recipient", "Original-Sender", "Original-Subject", "Originator-Return-Address", "Overwrite", "P3P", "Path", "PEP", "Pep-Info", "PICS-Label", "Position", "Posting-Version", "Pragma", "Prefer", "Preference-Applied", "Prevent-NonDelivery-Report", "Priority", "Privicon", "ProfileObject", "Protocol", "Protocol-Info", "Protocol-Query", "Protocol-Request", "Proxy-Authenticate", "Proxy-Authentication-Info", "Proxy-Authorization", "Proxy-Connection", "Proxy-Features", "Proxy-Instruction", "Public", "Public-Key-Pins", "Public-Key-Pins-Report-Only", "Range", "Received", "Received-SPF", "Redirect-Ref", "References", "Referer", "Referer-Root", "Relay-Version", "Reply-By", "Reply-To", "Require-Recipient-Valid-Since", "Resent-Bcc", "Resent-Cc", "Resent-Date", "Resent-From", "Resent-Message-ID", "Resent-Reply-To", "Resent-Sender", "Resent-To", "Resolution-Hint", "Resolver-Location", "Retry-After", "Return-Path", "Safe", "Schedule-Reply", "Schedule-Tag", "Sec-Fetch-Dest", "Sec-Fetch-Mode", "Sec-Fetch-Site", "Sec-Fetch-User", "Sec-WebSocket-Accept", "Sec-WebSocket-Extensions", "Sec-WebSocket-Key", "Sec-WebSocket-Protocol", "Sec-WebSocket-Version", "Security-Scheme", "See-Also", "Sender", "Sensitivity", "Server", "Set-Cookie", "Set-Cookie2", "SetProfile", "SIO-Label", "SIO-Label-History", "SLUG", "SoapAction", "Solicitation", "Status-URI", "Strict-Transport-Security", "Subject", "SubOK", "Subst", "Summary", "Supersedes", "Surrogate-Capability", "Surrogate-Control", "TCN", "TE", "Timeout", "Title", "To", "Topic", "Trailer", "Transfer-Encoding", "TTL", "UA-Color", "UA-Media", "UA-Pixels", "UA-Resolution", "UA-Windowpixels", "Upgrade", "Urgency", "URI", "User-Agent", "Variant-Vary", "Vary", "VBR-Info", "Version", "Via", "Want-Digest", "Warning", "WWW-Authenticate", "X-Archived-At", "X-Device-Accept", "X-Device-Accept-Charset", "X-Device-Accept-Encoding", "X-Device-Accept-Language", "X-Device-User-Agent", "X-Frame-Options", "X-Mittente", "X-PGP-Sig", "X-Ricevuta", "X-Riferimento-Message-ID", "X-TipoRicevuta", "X-Trasporto", "X-VerificaSicurezza", "X400-Content-Identifier", "X400-Content-Return", "X400-Content-Type", "X400-MTS-Identifier", "X400-Originator", "X400-Received", "X400-Recipients", "X400-Trace", "Xref" }}) { for(std::size_t i = 1, n = 256; i < n; ++i) { auto sv = by_name_[ i ]; auto h = digest(sv); auto j = h % N; BOOST_ASSERT(map_[j][0] == 0); map_[j][0] = static_cast<unsigned char>(i); } for(std::size_t i = 256, n = by_name_.size(); i < n; ++i) { auto sv = by_name_[i]; auto h = digest(sv); auto j = h % N; BOOST_ASSERT(map_[j][1] == 0); map_[j][1] = static_cast<unsigned char>(i - 255); } } field string_to_field(string_view s) const { auto h = digest(s); auto j = h % N; int i = map_[j][0]; string_view s2 = by_name_[i]; if(i != 0 && equals(s, s2)) return static_cast<field>(i); i = map_[j][1]; if(i == 0) return field::unknown; i += 255; s2 = by_name_[i]; if(equals(s, s2)) return static_cast<field>(i); return field::unknown; } // // Deprecated // using const_iterator = array_type::const_iterator; std::size_t size() const { return by_name_.size(); } const_iterator begin() const { return by_name_.begin(); } const_iterator end() const { return by_name_.end(); } }; BOOST_BEAST_DECL field_table const& get_field_table() { static field_table const tab; return tab; } BOOST_BEAST_DECL string_view to_string(field f) { auto const& v = get_field_table(); BOOST_ASSERT(static_cast<unsigned>(f) < v.size()); return v.begin()[static_cast<unsigned>(f)]; } } // detail string_view to_string(field f) { return detail::to_string(f); } field string_to_field(string_view s) { return detail::get_field_table().string_to_field(s); } std::ostream& operator<<(std::ostream& os, field f) { return os << to_string(f); } } // http } // beast } // boost #endif PK PP�[o��B( B( http/impl/serializer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_SERIALIZER_HPP #define BOOST_BEAST_HTTP_IMPL_SERIALIZER_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/buffers_ref.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/status.hpp> #include <boost/beast/core/detail/config.hpp> #include <boost/assert.hpp> #include <ostream> namespace boost { namespace beast { namespace http { template< bool isRequest, class Body, class Fields> void serializer<isRequest, Body, Fields>:: fwrinit(std::true_type) { fwr_.emplace(m_, m_.version(), m_.method()); } template< bool isRequest, class Body, class Fields> void serializer<isRequest, Body, Fields>:: fwrinit(std::false_type) { fwr_.emplace(m_, m_.version(), m_.result_int()); } template< bool isRequest, class Body, class Fields> template<std::size_t I, class Visit> inline void serializer<isRequest, Body, Fields>:: do_visit(error_code& ec, Visit& visit) { pv_.template emplace<I>(limit_, v_.template get<I>()); visit(ec, beast::detail::make_buffers_ref( pv_.template get<I>())); } //------------------------------------------------------------------------------ template< bool isRequest, class Body, class Fields> serializer<isRequest, Body, Fields>:: serializer(value_type& m) : m_(m) , wr_(m_.base(), m_.body()) { } template< bool isRequest, class Body, class Fields> template<class Visit> void serializer<isRequest, Body, Fields>:: next(error_code& ec, Visit&& visit) { switch(s_) { case do_construct: { fwrinit(std::integral_constant<bool, isRequest>{}); if(m_.chunked()) goto go_init_c; s_ = do_init; BOOST_FALLTHROUGH; } case do_init: { wr_.init(ec); if(ec) return; if(split_) goto go_header_only; auto result = wr_.get(ec); if(ec == error::need_more) goto go_header_only; if(ec) return; if(! result) goto go_header_only; more_ = result->second; v_.template emplace<2>( boost::in_place_init, fwr_->get(), result->first); s_ = do_header; BOOST_FALLTHROUGH; } case do_header: do_visit<2>(ec, visit); break; go_header_only: v_.template emplace<1>(fwr_->get()); s_ = do_header_only; BOOST_FALLTHROUGH; case do_header_only: do_visit<1>(ec, visit); break; case do_body: s_ = do_body + 1; BOOST_FALLTHROUGH; case do_body + 1: { auto result = wr_.get(ec); if(ec) return; if(! result) goto go_complete; more_ = result->second; v_.template emplace<3>(result->first); s_ = do_body + 2; BOOST_FALLTHROUGH; } case do_body + 2: do_visit<3>(ec, visit); break; //---------------------------------------------------------------------- go_init_c: s_ = do_init_c; BOOST_FALLTHROUGH; case do_init_c: { wr_.init(ec); if(ec) return; if(split_) goto go_header_only_c; auto result = wr_.get(ec); if(ec == error::need_more) goto go_header_only_c; if(ec) return; if(! result) goto go_header_only_c; more_ = result->second; if(! more_) { // do it all in one buffer v_.template emplace<7>( boost::in_place_init, fwr_->get(), buffer_bytes(result->first), net::const_buffer{nullptr, 0}, chunk_crlf{}, result->first, chunk_crlf{}, detail::chunk_last(), net::const_buffer{nullptr, 0}, chunk_crlf{}); goto go_all_c; } v_.template emplace<4>( boost::in_place_init, fwr_->get(), buffer_bytes(result->first), net::const_buffer{nullptr, 0}, chunk_crlf{}, result->first, chunk_crlf{}); s_ = do_header_c; BOOST_FALLTHROUGH; } case do_header_c: do_visit<4>(ec, visit); break; go_header_only_c: v_.template emplace<1>(fwr_->get()); s_ = do_header_only_c; BOOST_FALLTHROUGH; case do_header_only_c: do_visit<1>(ec, visit); break; case do_body_c: s_ = do_body_c + 1; BOOST_FALLTHROUGH; case do_body_c + 1: { auto result = wr_.get(ec); if(ec) return; if(! result) goto go_final_c; more_ = result->second; if(! more_) { // do it all in one buffer v_.template emplace<6>( boost::in_place_init, buffer_bytes(result->first), net::const_buffer{nullptr, 0}, chunk_crlf{}, result->first, chunk_crlf{}, detail::chunk_last(), net::const_buffer{nullptr, 0}, chunk_crlf{}); goto go_body_final_c; } v_.template emplace<5>( boost::in_place_init, buffer_bytes(result->first), net::const_buffer{nullptr, 0}, chunk_crlf{}, result->first, chunk_crlf{}); s_ = do_body_c + 2; BOOST_FALLTHROUGH; } case do_body_c + 2: do_visit<5>(ec, visit); break; go_body_final_c: s_ = do_body_final_c; BOOST_FALLTHROUGH; case do_body_final_c: do_visit<6>(ec, visit); break; go_all_c: s_ = do_all_c; BOOST_FALLTHROUGH; case do_all_c: do_visit<7>(ec, visit); break; go_final_c: case do_final_c: v_.template emplace<8>( boost::in_place_init, detail::chunk_last(), net::const_buffer{nullptr, 0}, chunk_crlf{}); s_ = do_final_c + 1; BOOST_FALLTHROUGH; case do_final_c + 1: do_visit<8>(ec, visit); break; //---------------------------------------------------------------------- default: case do_complete: BOOST_ASSERT(false); break; go_complete: s_ = do_complete; break; } } template< bool isRequest, class Body, class Fields> void serializer<isRequest, Body, Fields>:: consume(std::size_t n) { switch(s_) { case do_header: BOOST_ASSERT( n <= buffer_bytes(v_.template get<2>())); v_.template get<2>().consume(n); if(buffer_bytes(v_.template get<2>()) > 0) break; header_done_ = true; v_.reset(); if(! more_) goto go_complete; s_ = do_body + 1; break; case do_header_only: BOOST_ASSERT( n <= buffer_bytes(v_.template get<1>())); v_.template get<1>().consume(n); if(buffer_bytes(v_.template get<1>()) > 0) break; fwr_ = boost::none; header_done_ = true; if(! split_) goto go_complete; s_ = do_body; break; case do_body + 2: { BOOST_ASSERT( n <= buffer_bytes(v_.template get<3>())); v_.template get<3>().consume(n); if(buffer_bytes(v_.template get<3>()) > 0) break; v_.reset(); if(! more_) goto go_complete; s_ = do_body + 1; break; } //---------------------------------------------------------------------- case do_header_c: BOOST_ASSERT( n <= buffer_bytes(v_.template get<4>())); v_.template get<4>().consume(n); if(buffer_bytes(v_.template get<4>()) > 0) break; header_done_ = true; v_.reset(); if(more_) s_ = do_body_c + 1; else s_ = do_final_c; break; case do_header_only_c: { BOOST_ASSERT( n <= buffer_bytes(v_.template get<1>())); v_.template get<1>().consume(n); if(buffer_bytes(v_.template get<1>()) > 0) break; fwr_ = boost::none; header_done_ = true; if(! split_) { s_ = do_final_c; break; } s_ = do_body_c; break; } case do_body_c + 2: BOOST_ASSERT( n <= buffer_bytes(v_.template get<5>())); v_.template get<5>().consume(n); if(buffer_bytes(v_.template get<5>()) > 0) break; v_.reset(); if(more_) s_ = do_body_c + 1; else s_ = do_final_c; break; case do_body_final_c: { BOOST_ASSERT( n <= buffer_bytes(v_.template get<6>())); v_.template get<6>().consume(n); if(buffer_bytes(v_.template get<6>()) > 0) break; v_.reset(); s_ = do_complete; break; } case do_all_c: { BOOST_ASSERT( n <= buffer_bytes(v_.template get<7>())); v_.template get<7>().consume(n); if(buffer_bytes(v_.template get<7>()) > 0) break; header_done_ = true; v_.reset(); s_ = do_complete; break; } case do_final_c + 1: BOOST_ASSERT(buffer_bytes(v_.template get<8>())); v_.template get<8>().consume(n); if(buffer_bytes(v_.template get<8>()) > 0) break; v_.reset(); goto go_complete; //---------------------------------------------------------------------- default: BOOST_ASSERT(false); case do_complete: break; go_complete: s_ = do_complete; break; } } } // http } // beast } // boost #endif PK PP�[c�pY Y http/impl/rfc7230.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_RFC7230_HPP #define BOOST_BEAST_HTTP_IMPL_RFC7230_HPP #include <boost/beast/http/detail/rfc7230.hpp> #include <iterator> namespace boost { namespace beast { namespace http { class param_list::const_iterator { using iter_type = string_view::const_iterator; std::string s_; detail::param_iter pi_; public: using value_type = param_list::value_type; using pointer = value_type const*; using reference = value_type const&; using difference_type = std::ptrdiff_t; using iterator_category = std::input_iterator_tag; const_iterator() = default; bool operator==(const_iterator const& other) const { return other.pi_.it == pi_.it && other.pi_.last == pi_.last && other.pi_.first == pi_.first; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { return pi_.v; } pointer operator->() const { return &*(*this); } const_iterator& operator++() { increment(); return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } private: friend class param_list; const_iterator(iter_type first, iter_type last) { pi_.it = first; pi_.first = first; pi_.last = last; increment(); } BOOST_BEAST_DECL static std::string unquote(string_view sr); BOOST_BEAST_DECL void increment(); }; inline auto param_list:: begin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto param_list:: end() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } inline auto param_list:: cbegin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto param_list:: cend() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } //------------------------------------------------------------------------------ class ext_list::const_iterator { ext_list::value_type v_; iter_type it_; iter_type first_; iter_type last_; public: using value_type = ext_list::value_type; using pointer = value_type const*; using reference = value_type const&; using difference_type = std::ptrdiff_t; using iterator_category = std::forward_iterator_tag; const_iterator() = default; bool operator==(const_iterator const& other) const { return other.it_ == it_ && other.first_ == first_ && other.last_ == last_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { return v_; } pointer operator->() const { return &*(*this); } const_iterator& operator++() { increment(); return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } private: friend class ext_list; const_iterator(iter_type begin, iter_type end) { it_ = begin; first_ = begin; last_ = end; increment(); } BOOST_BEAST_DECL void increment(); }; inline auto ext_list:: begin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto ext_list:: end() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } inline auto ext_list:: cbegin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto ext_list:: cend() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } //------------------------------------------------------------------------------ class token_list::const_iterator { token_list::value_type v_; iter_type it_; iter_type first_; iter_type last_; public: using value_type = token_list::value_type; using pointer = value_type const*; using reference = value_type const&; using difference_type = std::ptrdiff_t; using iterator_category = std::forward_iterator_tag; const_iterator() = default; bool operator==(const_iterator const& other) const { return other.it_ == it_ && other.first_ == first_ && other.last_ == last_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*() const { return v_; } pointer operator->() const { return &*(*this); } const_iterator& operator++() { increment(); return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } private: friend class token_list; const_iterator(iter_type begin, iter_type end) { it_ = begin; first_ = begin; last_ = end; increment(); } BOOST_BEAST_DECL void increment(); }; inline auto token_list:: begin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto token_list:: end() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } inline auto token_list:: cbegin() const -> const_iterator { return const_iterator{s_.begin(), s_.end()}; } inline auto token_list:: cend() const -> const_iterator { return const_iterator{s_.end(), s_.end()}; } template<class Policy> bool validate_list(detail::basic_parsed_list< Policy> const& list) { auto const last = list.end(); auto it = list.begin(); if(it.error()) return false; while(it != last) { ++it; if(it.error()) return false; if(it == last) break; } return true; } } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/rfc7230.ipp> #endif #endif PK PP�[��ݽ@ �@ http/impl/chunk_encode.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_CHUNK_ENCODE_HPP #define BOOST_BEAST_HTTP_IMPL_CHUNK_ENCODE_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/varint.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/detail/rfc7230.hpp> #include <algorithm> namespace boost { namespace beast { namespace http { inline chunk_header:: chunk_header(std::size_t size) : view_( size, net::const_buffer{nullptr, 0}, chunk_crlf{}) { BOOST_ASSERT(size > 0); } inline chunk_header:: chunk_header( std::size_t size, string_view extensions) : view_( size, net::const_buffer{ extensions.data(), extensions.size()}, chunk_crlf{}) { BOOST_ASSERT(size > 0); } template<class ChunkExtensions, class> chunk_header:: chunk_header( std::size_t size, ChunkExtensions&& extensions) : exts_(std::make_shared<detail::chunk_extensions_impl< typename std::decay<ChunkExtensions>::type>>( std::forward<ChunkExtensions>(extensions))) , view_( size, exts_->str(), chunk_crlf{}) { static_assert( detail::is_chunk_extensions<ChunkExtensions>::value, "ChunkExtensions requirements not met"); BOOST_ASSERT(size > 0); } template<class ChunkExtensions, class Allocator, class> chunk_header:: chunk_header( std::size_t size, ChunkExtensions&& extensions, Allocator const& allocator) : exts_(std::allocate_shared<detail::chunk_extensions_impl< typename std::decay<ChunkExtensions>::type>>(allocator, std::forward<ChunkExtensions>(extensions))) , view_( size, exts_->str(), chunk_crlf{}) { static_assert( detail::is_chunk_extensions<ChunkExtensions>::value, "ChunkExtensions requirements not met"); BOOST_ASSERT(size > 0); } //------------------------------------------------------------------------------ template<class ConstBufferSequence> chunk_body<ConstBufferSequence>:: chunk_body(ConstBufferSequence const& buffers) : view_( buffer_bytes(buffers), net::const_buffer{nullptr, 0}, chunk_crlf{}, buffers, chunk_crlf{}) { } template<class ConstBufferSequence> chunk_body<ConstBufferSequence>:: chunk_body( ConstBufferSequence const& buffers, string_view extensions) : view_( buffer_bytes(buffers), net::const_buffer{ extensions.data(), extensions.size()}, chunk_crlf{}, buffers, chunk_crlf{}) { } template<class ConstBufferSequence> template<class ChunkExtensions, class> chunk_body<ConstBufferSequence>:: chunk_body( ConstBufferSequence const& buffers, ChunkExtensions&& extensions) : exts_(std::make_shared<detail::chunk_extensions_impl< typename std::decay<ChunkExtensions>::type>>( std::forward<ChunkExtensions>(extensions))) , view_( buffer_bytes(buffers), exts_->str(), chunk_crlf{}, buffers, chunk_crlf{}) { } template<class ConstBufferSequence> template<class ChunkExtensions, class Allocator, class> chunk_body<ConstBufferSequence>:: chunk_body( ConstBufferSequence const& buffers, ChunkExtensions&& extensions, Allocator const& allocator) : exts_(std::allocate_shared<detail::chunk_extensions_impl< typename std::decay<ChunkExtensions>::type>>(allocator, std::forward<ChunkExtensions>(extensions))) , view_( buffer_bytes(buffers), exts_->str(), chunk_crlf{}, buffers, chunk_crlf{}) { } //------------------------------------------------------------------------------ template<class Trailer> template<class Allocator> auto chunk_last<Trailer>:: prepare(Trailer const& trailer, Allocator const& allocator) -> buffers_type { auto sp = std::allocate_shared<typename Trailer::writer>(allocator, trailer); sp_ = sp; return sp->get(); } template<class Trailer> auto chunk_last<Trailer>:: prepare(Trailer const& trailer, std::true_type) -> buffers_type { auto sp = std::make_shared< typename Trailer::writer>(trailer); sp_ = sp; return sp->get(); } template<class Trailer> auto chunk_last<Trailer>:: prepare(Trailer const& trailer, std::false_type) -> buffers_type { return trailer; } template<class Trailer> chunk_last<Trailer>:: chunk_last() : view_( detail::chunk_size0{}, Trailer{}) { } template<class Trailer> chunk_last<Trailer>:: chunk_last(Trailer const& trailer) : view_( detail::chunk_size0{}, prepare(trailer, is_fields<Trailer>{})) { } template<class Trailer> template<class DeducedTrailer, class Allocator, class> chunk_last<Trailer>:: chunk_last( DeducedTrailer const& trailer, Allocator const& allocator) : view_( detail::chunk_size0{}, prepare(trailer, allocator)) { } //------------------------------------------------------------------------------ template<class Allocator> class basic_chunk_extensions<Allocator>::const_iterator { friend class basic_chunk_extensions; using iter_type = char const*; iter_type it_; typename basic_chunk_extensions::value_type value_; explicit const_iterator(iter_type it) : it_(it) { } void increment(); public: using value_type = typename basic_chunk_extensions::value_type; using pointer = value_type const*; using reference = value_type const&; using difference_type = std::ptrdiff_t; using iterator_category = std::forward_iterator_tag; const_iterator() = default; const_iterator(const_iterator&& other) = default; const_iterator(const_iterator const& other) = default; const_iterator& operator=(const_iterator&& other) = default; const_iterator& operator=(const_iterator const& other) = default; bool operator==(const_iterator const& other) const { return it_ == other.it_; } bool operator!=(const_iterator const& other) const { return !(*this == other); } reference operator*(); pointer operator->() { return &(**this); } const_iterator& operator++() { increment(); return *this; } const_iterator operator++(int) { auto temp = *this; increment(); return temp; } }; template<class Allocator> void basic_chunk_extensions<Allocator>:: const_iterator:: increment() { using beast::detail::varint_read; auto n = varint_read(it_); it_ += n; n = varint_read(it_); it_ += n; } template<class Allocator> auto basic_chunk_extensions<Allocator>:: const_iterator:: operator*() -> reference { using beast::detail::varint_read; auto it = it_; auto n = varint_read(it); value_.first = string_view{it, n}; it += n; n = varint_read(it); value_.second = string_view{it, n}; return value_; } //------------------------------------------------------------------------------ template<class Allocator> template<class FwdIt> FwdIt basic_chunk_extensions<Allocator>:: do_parse(FwdIt it, FwdIt last, error_code& ec) { /* chunk-ext = *( BWS ";" BWS chunk-ext-name [ BWS "=" BWS chunk-ext-val ] ) BWS = *( SP / HTAB ) ; "Bad White Space" chunk-ext-name = token chunk-ext-val = token / quoted-string token = 1*tchar quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) obs-text = %x80-FF https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4667 */ using beast::detail::varint_size; using beast::detail::varint_write; using CharT = char; using Traits = std::char_traits<CharT>; range_.reserve(static_cast<std::size_t>( std::distance(it, last) * 1.2)); range_.resize(0); auto const emit_string = [this](FwdIt from, FwdIt to) { auto const len = std::distance(from, to); auto const offset = range_.size(); range_.resize( offset + varint_size(len) + len); auto dest = &range_[offset]; varint_write(dest, len); Traits::copy(dest, from, len); }; auto const emit_string_plus_empty = [this](FwdIt from, FwdIt to) { auto const len = std::distance(from, to); auto const offset = range_.size(); range_.resize( offset + varint_size(len) + len + varint_size(0)); auto dest = &range_[offset]; varint_write(dest, len); Traits::copy(dest, from, len); dest += len; varint_write(dest, 0); }; auto const emit_empty_string = [this] { auto const offset = range_.size(); range_.resize(offset + varint_size(0)); auto dest = &range_[offset]; varint_write(dest, 0); }; loop: if(it == last) { ec = {}; return it; } // BWS if(*it == ' ' || *it == '\t') { for(;;) { ++it; if(it == last) { ec = error::bad_chunk_extension; return it; } if(*it != ' ' && *it != '\t') break; } } // ';' if(*it != ';') { ec = error::bad_chunk_extension; return it; } semi: ++it; // skip ';' // BWS for(;;) { if(it == last) { ec = error::bad_chunk_extension; return it; } if(*it != ' ' && *it != '\t') break; ++it; } // chunk-ext-name { if(! detail::is_token_char(*it)) { ec = error::bad_chunk_extension; return it; } auto const first = it; for(;;) { ++it; if(it == last) { emit_string_plus_empty(first, it); return it; } if(! detail::is_token_char(*it)) break; } emit_string(first, it); } // BWS [ ";" / "=" ] for(;;) { if(*it != ' ' && *it != '\t') break; ++it; if(it == last) { ec = error::bad_chunk_extension; return it; } } if(*it == ';') { emit_empty_string(); goto semi; } if(*it != '=') { ec = error::bad_chunk_extension; return it; } ++it; // skip '=' // BWS for(;;) { if(it == last) { ec = error::bad_chunk_extension; return it; } if(*it != ' ' && *it != '\t') break; ++it; } // chunk-ext-val if(*it != '"') { // token if(! detail::is_token_char(*it)) { ec = error::bad_chunk_extension; return it; } auto const first = it; for(;;) { ++it; if(it == last) break; if(! detail::is_token_char(*it)) break; } emit_string(first, it); if(it == last) return it; } else { // quoted-string auto const first = ++it; // skip DQUOTE // first pass, count chars std::size_t len = 0; for(;;) { if(it == last) { ec = error::bad_chunk_extension; return it; } if(*it == '"') break; if(*it == '\\') { ++it; if(it == last) { ec = error::bad_chunk_extension; return it; } } ++len; ++it; } // now build the string auto const offset = range_.size(); range_.resize( offset + varint_size(len) + len); auto dest = &range_[offset]; varint_write(dest, len); it = first; for(;;) { BOOST_ASSERT(it != last); if(*it == '"') break; if(*it == '\\') { ++it; BOOST_ASSERT(it != last); } Traits::assign(*dest++, *it++); } ++it; // skip DQUOTE } goto loop; } template<class Allocator> void basic_chunk_extensions<Allocator>:: do_insert(string_view name, string_view value) { /* chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string token = 1*tchar quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) obs-text = %x80-FF */ if(value.empty()) { s_.reserve(1 + name.size()); s_.push_back(';'); s_.append(name.data(), name.size()); return; } bool is_token = true; for(auto const c : value) { if(! detail::is_token_char(c)) { is_token = false; break; } } if(is_token) { // token s_.reserve(1 + name.size() + 1 + value.size()); s_.push_back(';'); s_.append(name.data(), name.size()); s_.push_back('='); s_.append(value.data(), value.size()); } else { // quoted-string s_.reserve( 1 + name.size() + 1 + 1 + value.size() + 20 + 1); s_.push_back(';'); s_.append(name.data(), name.size()); s_.append("=\"", 2); for(auto const c : value) { if(c == '\\') s_.append(R"(\\)", 2); else if(c == '\"') s_.append(R"(\")", 2); else s_.push_back(c); } s_.push_back('"'); } } template<class Allocator> void basic_chunk_extensions<Allocator>:: parse(string_view s, error_code& ec) { do_parse(s.data(), s.data() + s.size(), ec); if(! ec) { s_.clear(); for(auto const& v : *this) do_insert(v.first, v.second); } } template<class Allocator> void basic_chunk_extensions<Allocator>:: insert(string_view name) { do_insert(name, {}); using beast::detail::varint_size; using beast::detail::varint_write; auto const offset = range_.size(); range_.resize( offset + varint_size(name.size()) + name.size() + varint_size(0)); auto dest = &range_[offset]; varint_write(dest, name.size()); std::memcpy(dest, name.data(), name.size()); dest += name.size(); varint_write(dest, 0); } template<class Allocator> void basic_chunk_extensions<Allocator>:: insert(string_view name, string_view value) { do_insert(name, value); using beast::detail::varint_size; using beast::detail::varint_write; auto const offset = range_.size(); range_.resize( offset + varint_size(name.size()) + name.size() + varint_size(value.size()) + value.size()); auto dest = &range_[offset]; varint_write(dest, name.size()); std::memcpy(dest, name.data(), name.size()); dest += name.size(); varint_write(dest, value.size()); std::memcpy(dest, value.data(), value.size()); } template<class Allocator> auto basic_chunk_extensions<Allocator>:: begin() const -> const_iterator { return const_iterator{range_.data()}; } template<class Allocator> auto basic_chunk_extensions<Allocator>:: end() const -> const_iterator { return const_iterator{ range_.data() + range_.size()}; } } // http } // beast } // boost #endif PK PP�[eo��4K 4K http/impl/read.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // Copyright (c) 2020 Richard Hodges (hodges.r@gmail.com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_READ_HPP #define BOOST_BEAST_HTTP_IMPL_READ_HPP #include <boost/beast/http/type_traits.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/parser.hpp> #include <boost/beast/http/read.hpp> #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/core/detail/read.hpp> #include <boost/asio/error.hpp> #include <boost/asio/compose.hpp> #include <boost/asio/coroutine.hpp> namespace boost { namespace beast { namespace http { namespace detail { struct parser_is_done { template<bool isRequest> bool operator()(basic_parser<isRequest> const& p) const { return p.is_done(); } }; struct parser_is_header_done { template<bool isRequest> bool operator()(basic_parser<isRequest> const& p) const { return p.is_header_done(); } }; //------------------------------------------------------------------------------ template< class Stream, class DynamicBuffer, bool isRequest, class Body, class Allocator, class Handler> class read_msg_op : public beast::stable_async_base< Handler, beast::executor_type<Stream>> , public asio::coroutine { using parser_type = parser<isRequest, Body, Allocator>; using message_type = typename parser_type::value_type; struct data { Stream& s; message_type& m; parser_type p; data( Stream& s_, message_type& m_) : s(s_) , m(m_) , p(std::move(m)) { } }; data& d_; public: template<class Handler_> read_msg_op( Handler_&& h, Stream& s, DynamicBuffer& b, message_type& m) : stable_async_base< Handler, beast::executor_type<Stream>>( std::forward<Handler_>(h), s.get_executor()) , d_(beast::allocate_stable<data>( *this, s, m)) { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_read(msg)")); http::async_read(d_.s, b, d_.p, std::move(*this)); } void operator()( error_code ec, std::size_t bytes_transferred) { if(! ec) d_.m = d_.p.release(); this->complete_now(ec, bytes_transferred); } }; struct run_read_msg_op { template< class ReadHandler, class AsyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator> void operator()( ReadHandler&& h, AsyncReadStream* s, DynamicBuffer* b, message<isRequest, Body, basic_fields<Allocator>>* m) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<ReadHandler, void(error_code, std::size_t)>::value, "ReadHandler type requirements not met"); read_msg_op< AsyncReadStream, DynamicBuffer, isRequest, Body, Allocator, typename std::decay<ReadHandler>::type>( std::forward<ReadHandler>(h), *s, *b, *m); } }; template<class AsyncReadStream, class DynamicBuffer, bool isRequest> class read_some_op : asio::coroutine { AsyncReadStream& s_; DynamicBuffer& b_; basic_parser<isRequest>& p_; std::size_t bytes_transferred_; bool cont_; public: read_some_op( AsyncReadStream& s, DynamicBuffer& b, basic_parser<isRequest>& p) : s_(s) , b_(b) , p_(p) , bytes_transferred_(0) , cont_(false) { } template<class Self> void operator()( Self& self, error_code ec = {}, std::size_t bytes_transferred = 0) { BOOST_ASIO_CORO_REENTER(*this) { if(b_.size() == 0) goto do_read; for(;;) { // parse { auto const used = p_.put(b_.data(), ec); bytes_transferred_ += used; b_.consume(used); } if(ec != http::error::need_more) break; do_read: BOOST_ASIO_CORO_YIELD { cont_ = true; // VFALCO This was read_size_or_throw auto const size = read_size(b_, 65536); if(size == 0) { ec = error::buffer_overflow; goto upcall; } auto const mb = beast::detail::dynamic_buffer_prepare( b_, size, ec, error::buffer_overflow); if(ec) goto upcall; BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_read_some")); s_.async_read_some(*mb, std::move(self)); } b_.commit(bytes_transferred); if(ec == net::error::eof) { BOOST_ASSERT(bytes_transferred == 0); if(p_.got_some()) { // caller sees EOF on next read ec.assign(0, ec.category()); p_.put_eof(ec); if(ec) goto upcall; BOOST_ASSERT(p_.is_done()); goto upcall; } ec = error::end_of_stream; break; } if(ec) break; } upcall: if(! cont_) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_read_some")); net::post( beast::bind_front_handler(std::move(self), ec)); } } self.complete(ec, bytes_transferred_); } } }; template<class Stream, class DynamicBuffer, bool isRequest, class Condition> class read_op : asio::coroutine { Stream& s_; DynamicBuffer& b_; basic_parser<isRequest>& p_; std::size_t bytes_transferred_; public: read_op(Stream& s, DynamicBuffer& b, basic_parser<isRequest>& p) : s_(s) , b_(b) , p_(p) , bytes_transferred_(0) { } template<class Self> void operator()(Self& self, error_code ec = {}, std::size_t bytes_transferred = 0) { BOOST_ASIO_CORO_REENTER(*this) { if (Condition{}(p_)) { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_read")); net::post(std::move(self)); } } else { do { BOOST_ASIO_CORO_YIELD { BOOST_ASIO_HANDLER_LOCATION(( __FILE__, __LINE__, "http::async_read")); async_read_some( s_, b_, p_, std::move(self)); } bytes_transferred_ += bytes_transferred; } while (!ec && !Condition{}(p_)); } self.complete(ec, bytes_transferred_); } } }; template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_some(SyncReadStream& s, DynamicBuffer& b, basic_parser<isRequest>& p, error_code& ec) { std::size_t total = 0; ec.clear(); if(b.size() == 0) goto do_read; for(;;) { // parse { auto const used = p.put(b.data(), ec); total += used; b.consume(used); } if(ec != http::error::need_more) break; do_read: // VFALCO This was read_size_or_throw auto const size = read_size(b, 65536); if(size == 0) { ec = error::buffer_overflow; return total; } auto const mb = beast::detail::dynamic_buffer_prepare( b, size, ec, error::buffer_overflow); if(ec) return total; std::size_t bytes_transferred = s.read_some(*mb, ec); b.commit(bytes_transferred); if(ec == net::error::eof) { BOOST_ASSERT(bytes_transferred == 0); if(p.got_some()) { // caller sees EOF on next read ec.assign(0, ec.category()); p.put_eof(ec); if(ec) return total; BOOST_ASSERT(p.is_done()); return total; } ec = error::end_of_stream; break; } if(ec) break; } return total; } template<class Condition, class Stream, class DynamicBuffer, bool isRequest> std::size_t sync_read_op(Stream& s, DynamicBuffer& b, basic_parser<isRequest>& p, error_code& ec) { std::size_t total = 0; ec.clear(); if (!Condition{}(p)) { do { total += detail::read_some(s, b, p, ec); } while (!ec && !Condition{}(p)); } return total; } } // detail //------------------------------------------------------------------------------ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_some( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); error_code ec; auto const bytes_transferred = http::read_some(stream, buffer, parser, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_some( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); return detail::read_some(stream, buffer, parser, ec); } template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler) { return net::async_compose<ReadHandler, void(beast::error_code, std::size_t)>( detail::read_some_op<AsyncReadStream, DynamicBuffer, isRequest> { stream, buffer, parser }, handler, stream); } //------------------------------------------------------------------------------ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_header( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); error_code ec; auto const bytes_transferred = http::read_header(stream, buffer, parser, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_header( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); parser.eager(false); return detail::sync_read_op< detail::parser_is_header_done>( stream, buffer, parser, ec); } template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_header( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler) { parser.eager(false); return net::async_compose< ReadHandler, void(error_code, std::size_t)>( detail::read_op< AsyncReadStream, DynamicBuffer, isRequest, detail::parser_is_header_done>( stream, buffer, parser), handler, stream); } //------------------------------------------------------------------------------ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); error_code ec; auto const bytes_transferred = http::read(stream, buffer, parser, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); parser.eager(true); return detail::sync_read_op< detail::parser_is_done>( stream, buffer, parser, ec); } template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler) { static_assert( is_async_read_stream<AsyncReadStream>::value, "AsyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); parser.eager(true); return net::async_compose< ReadHandler, void(error_code, std::size_t)>( detail::read_op< AsyncReadStream, DynamicBuffer, isRequest, detail::parser_is_done>( stream, buffer, parser), handler, stream); } //------------------------------------------------------------------------------ template< class SyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_reader<Body>::value, "BodyReader type requirements not met"); error_code ec; auto const bytes_transferred = http::read(stream, buffer, msg, ec); if(ec) BOOST_THROW_EXCEPTION(system_error{ec}); return bytes_transferred; } template< class SyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg, error_code& ec) { static_assert( is_sync_read_stream<SyncReadStream>::value, "SyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_reader<Body>::value, "BodyReader type requirements not met"); parser<isRequest, Body, Allocator> p(std::move(msg)); p.eager(true); auto const bytes_transferred = http::read(stream, buffer, p, ec); if(ec) return bytes_transferred; msg = p.release(); return bytes_transferred; } template< class AsyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg, ReadHandler&& handler) { static_assert( is_async_read_stream<AsyncReadStream>::value, "AsyncReadStream type requirements not met"); static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_reader<Body>::value, "BodyReader type requirements not met"); return net::async_initiate< ReadHandler, void(error_code, std::size_t)>( detail::run_read_msg_op{}, handler, &stream, &buffer, &msg); } } // http } // beast } // boost #endif PK PP�[�P�� � http/impl/basic_parser.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_BASIC_PARSER_HPP #define BOOST_BEAST_HTTP_IMPL_BASIC_PARSER_HPP #include <boost/beast/core/buffer_traits.hpp> #include <boost/asio/buffer.hpp> #include <boost/make_unique.hpp> namespace boost { namespace beast { namespace http { template<bool isRequest> template<class ConstBufferSequence> std::size_t basic_parser<isRequest>:: put(ConstBufferSequence const& buffers, error_code& ec) { static_assert(net::is_const_buffer_sequence< ConstBufferSequence>::value, "ConstBufferSequence type requirements not met"); auto const p = net::buffer_sequence_begin(buffers); auto const last = net::buffer_sequence_end(buffers); if(p == last) { ec = {}; return 0; } if(std::next(p) == last) { // single buffer return put(net::const_buffer(*p), ec); } auto const size = buffer_bytes(buffers); if(size <= max_stack_buffer) return put_from_stack(size, buffers, ec); if(size > buf_len_) { // reallocate buf_ = boost::make_unique_noinit<char[]>(size); buf_len_ = size; } // flatten net::buffer_copy(net::buffer( buf_.get(), size), buffers); return put(net::const_buffer{ buf_.get(), size}, ec); } template<bool isRequest> boost::optional<std::uint64_t> basic_parser<isRequest>:: content_length_unchecked() const { if(f_ & flagContentLength) return len0_; return boost::none; } template<bool isRequest> template<class ConstBufferSequence> std::size_t basic_parser<isRequest>:: put_from_stack(std::size_t size, ConstBufferSequence const& buffers, error_code& ec) { char buf[max_stack_buffer]; net::buffer_copy(net::mutable_buffer( buf, sizeof(buf)), buffers); return put(net::const_buffer{ buf, size}, ec); } } // http } // beast } // boost #endif PK PP�[�}}"# "# http/impl/status.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_STATUS_IPP #define BOOST_BEAST_HTTP_IMPL_STATUS_IPP #include <boost/beast/http/status.hpp> #include <boost/throw_exception.hpp> namespace boost { namespace beast { namespace http { status int_to_status(unsigned v) { switch(static_cast<status>(v)) { // 1xx case status::continue_: case status::switching_protocols: case status::processing: BOOST_FALLTHROUGH; // 2xx case status::ok: case status::created: case status::accepted: case status::non_authoritative_information: case status::no_content: case status::reset_content: case status::partial_content: case status::multi_status: case status::already_reported: case status::im_used: BOOST_FALLTHROUGH; // 3xx case status::multiple_choices: case status::moved_permanently: case status::found: case status::see_other: case status::not_modified: case status::use_proxy: case status::temporary_redirect: case status::permanent_redirect: BOOST_FALLTHROUGH; // 4xx case status::bad_request: case status::unauthorized: case status::payment_required: case status::forbidden: case status::not_found: case status::method_not_allowed: case status::not_acceptable: case status::proxy_authentication_required: case status::request_timeout: case status::conflict: case status::gone: case status::length_required: case status::precondition_failed: case status::payload_too_large: case status::uri_too_long: case status::unsupported_media_type: case status::range_not_satisfiable: case status::expectation_failed: case status::misdirected_request: case status::unprocessable_entity: case status::locked: case status::failed_dependency: case status::upgrade_required: case status::precondition_required: case status::too_many_requests: case status::request_header_fields_too_large: case status::connection_closed_without_response: case status::unavailable_for_legal_reasons: case status::client_closed_request: BOOST_FALLTHROUGH; // 5xx case status::internal_server_error: case status::not_implemented: case status::bad_gateway: case status::service_unavailable: case status::gateway_timeout: case status::http_version_not_supported: case status::variant_also_negotiates: case status::insufficient_storage: case status::loop_detected: case status::not_extended: case status::network_authentication_required: case status::network_connect_timeout_error: return static_cast<status>(v); default: break; } return status::unknown; } status_class to_status_class(unsigned v) { switch(v / 100) { case 1: return status_class::informational; case 2: return status_class::successful; case 3: return status_class::redirection; case 4: return status_class::client_error; case 5: return status_class::server_error; default: break; } return status_class::unknown; } status_class to_status_class(status v) { return to_status_class(static_cast<int>(v)); } string_view obsolete_reason(status v) { switch(static_cast<status>(v)) { // 1xx case status::continue_: return "Continue"; case status::switching_protocols: return "Switching Protocols"; case status::processing: return "Processing"; // 2xx case status::ok: return "OK"; case status::created: return "Created"; case status::accepted: return "Accepted"; case status::non_authoritative_information: return "Non-Authoritative Information"; case status::no_content: return "No Content"; case status::reset_content: return "Reset Content"; case status::partial_content: return "Partial Content"; case status::multi_status: return "Multi-Status"; case status::already_reported: return "Already Reported"; case status::im_used: return "IM Used"; // 3xx case status::multiple_choices: return "Multiple Choices"; case status::moved_permanently: return "Moved Permanently"; case status::found: return "Found"; case status::see_other: return "See Other"; case status::not_modified: return "Not Modified"; case status::use_proxy: return "Use Proxy"; case status::temporary_redirect: return "Temporary Redirect"; case status::permanent_redirect: return "Permanent Redirect"; // 4xx case status::bad_request: return "Bad Request"; case status::unauthorized: return "Unauthorized"; case status::payment_required: return "Payment Required"; case status::forbidden: return "Forbidden"; case status::not_found: return "Not Found"; case status::method_not_allowed: return "Method Not Allowed"; case status::not_acceptable: return "Not Acceptable"; case status::proxy_authentication_required: return "Proxy Authentication Required"; case status::request_timeout: return "Request Timeout"; case status::conflict: return "Conflict"; case status::gone: return "Gone"; case status::length_required: return "Length Required"; case status::precondition_failed: return "Precondition Failed"; case status::payload_too_large: return "Payload Too Large"; case status::uri_too_long: return "URI Too Long"; case status::unsupported_media_type: return "Unsupported Media Type"; case status::range_not_satisfiable: return "Range Not Satisfiable"; case status::expectation_failed: return "Expectation Failed"; case status::misdirected_request: return "Misdirected Request"; case status::unprocessable_entity: return "Unprocessable Entity"; case status::locked: return "Locked"; case status::failed_dependency: return "Failed Dependency"; case status::upgrade_required: return "Upgrade Required"; case status::precondition_required: return "Precondition Required"; case status::too_many_requests: return "Too Many Requests"; case status::request_header_fields_too_large: return "Request Header Fields Too Large"; case status::connection_closed_without_response: return "Connection Closed Without Response"; case status::unavailable_for_legal_reasons: return "Unavailable For Legal Reasons"; case status::client_closed_request: return "Client Closed Request"; // 5xx case status::internal_server_error: return "Internal Server Error"; case status::not_implemented: return "Not Implemented"; case status::bad_gateway: return "Bad Gateway"; case status::service_unavailable: return "Service Unavailable"; case status::gateway_timeout: return "Gateway Timeout"; case status::http_version_not_supported: return "HTTP Version Not Supported"; case status::variant_also_negotiates: return "Variant Also Negotiates"; case status::insufficient_storage: return "Insufficient Storage"; case status::loop_detected: return "Loop Detected"; case status::not_extended: return "Not Extended"; case status::network_authentication_required: return "Network Authentication Required"; case status::network_connect_timeout_error: return "Network Connect Timeout Error"; default: break; } return "<unknown-status>"; } std::ostream& operator<<(std::ostream& os, status v) { return os << obsolete_reason(v); } } // http } // beast } // boost #endif PK PP�[���4 http/impl/fields.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_FIELDS_IPP #define BOOST_BEAST_HTTP_IMPL_FIELDS_IPP #include <boost/beast/http/fields.hpp> namespace boost { namespace beast { namespace http { namespace detail { // `basic_fields` assumes that `std::size_t` is larger than `uint16_t`, so we // verify it explicitly here, so that users that use split compilation don't // need to pay the (fairly small) price for this sanity check BOOST_STATIC_ASSERT((std::numeric_limits<std::size_t>::max)() >= (std::numeric_limits<std::uint32_t>::max)()); // Filter a token list // inline void filter_token_list( beast::detail::temporary_buffer& s, string_view value, iequals_predicate const& pred) { token_list te{value}; auto it = te.begin(); auto last = te.end(); if(it == last) return; while(pred(*it)) if(++it == last) return; s.append(*it); while(++it != last) { if(! pred(*it)) { s.append(", ", *it); } } } void filter_token_list_last( beast::detail::temporary_buffer& s, string_view value, iequals_predicate const& pred) { token_list te{value}; if(te.begin() != te.end()) { auto it = te.begin(); auto next = std::next(it); if(next == te.end()) { if(! pred(*it)) s.append(*it); return; } s.append(*it); for(;;) { it = next; next = std::next(it); if(next == te.end()) { if(! pred(*it)) { s.append(", ", *it); } return; } s.append(", ", *it); } } } void keep_alive_impl( beast::detail::temporary_buffer& s, string_view value, unsigned version, bool keep_alive) { if(version < 11) { if(keep_alive) { // remove close filter_token_list(s, value, iequals_predicate{"close", {}}); // add keep-alive if(s.empty()) s.append("keep-alive"); else if(! token_list{value}.exists("keep-alive")) s.append(", keep-alive"); } else { // remove close and keep-alive filter_token_list(s, value, iequals_predicate{"close", "keep-alive"}); } } else { if(keep_alive) { // remove close and keep-alive filter_token_list(s, value, iequals_predicate{"close", "keep-alive"}); } else { // remove keep-alive filter_token_list(s, value, iequals_predicate{"keep-alive", {}}); // add close if(s.empty()) s.append("close"); else if(! token_list{value}.exists("close")) s.append(", close"); } } } } // detail } // http } // beast } // boost #endif // BOOST_BEAST_HTTP_IMPL_FIELDS_IPP PK PP�[���. . http/impl/verb.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_VERB_IPP #define BOOST_BEAST_HTTP_IMPL_VERB_IPP #include <boost/beast/http/verb.hpp> #include <boost/throw_exception.hpp> #include <stdexcept> namespace boost { namespace beast { namespace http { string_view to_string(verb v) { using namespace beast::detail::string_literals; switch(v) { case verb::delete_: return "DELETE"_sv; case verb::get: return "GET"_sv; case verb::head: return "HEAD"_sv; case verb::post: return "POST"_sv; case verb::put: return "PUT"_sv; case verb::connect: return "CONNECT"_sv; case verb::options: return "OPTIONS"_sv; case verb::trace: return "TRACE"_sv; case verb::copy: return "COPY"_sv; case verb::lock: return "LOCK"_sv; case verb::mkcol: return "MKCOL"_sv; case verb::move: return "MOVE"_sv; case verb::propfind: return "PROPFIND"_sv; case verb::proppatch: return "PROPPATCH"_sv; case verb::search: return "SEARCH"_sv; case verb::unlock: return "UNLOCK"_sv; case verb::bind: return "BIND"_sv; case verb::rebind: return "REBIND"_sv; case verb::unbind: return "UNBIND"_sv; case verb::acl: return "ACL"_sv; case verb::report: return "REPORT"_sv; case verb::mkactivity: return "MKACTIVITY"_sv; case verb::checkout: return "CHECKOUT"_sv; case verb::merge: return "MERGE"_sv; case verb::msearch: return "M-SEARCH"_sv; case verb::notify: return "NOTIFY"_sv; case verb::subscribe: return "SUBSCRIBE"_sv; case verb::unsubscribe: return "UNSUBSCRIBE"_sv; case verb::patch: return "PATCH"_sv; case verb::purge: return "PURGE"_sv; case verb::mkcalendar: return "MKCALENDAR"_sv; case verb::link: return "LINK"_sv; case verb::unlink: return "UNLINK"_sv; case verb::unknown: return "<unknown>"_sv; } BOOST_THROW_EXCEPTION(std::invalid_argument{"unknown verb"}); } verb string_to_verb(string_view v) { /* ACL BIND CHECKOUT CONNECT COPY DELETE GET HEAD LINK LOCK M-SEARCH MERGE MKACTIVITY MKCALENDAR MKCOL MOVE NOTIFY OPTIONS PATCH POST PROPFIND PROPPATCH PURGE PUT REBIND REPORT SEARCH SUBSCRIBE TRACE UNBIND UNLINK UNLOCK UNSUBSCRIBE */ using namespace beast::detail::string_literals; if(v.size() < 3) return verb::unknown; auto c = v[0]; v.remove_prefix(1); switch(c) { case 'A': if(v == "CL"_sv) return verb::acl; break; case 'B': if(v == "IND"_sv) return verb::bind; break; case 'C': c = v[0]; v.remove_prefix(1); switch(c) { case 'H': if(v == "ECKOUT"_sv) return verb::checkout; break; case 'O': if(v == "NNECT"_sv) return verb::connect; if(v == "PY"_sv) return verb::copy; BOOST_FALLTHROUGH; default: break; } break; case 'D': if(v == "ELETE"_sv) return verb::delete_; break; case 'G': if(v == "ET"_sv) return verb::get; break; case 'H': if(v == "EAD"_sv) return verb::head; break; case 'L': if(v == "INK"_sv) return verb::link; if(v == "OCK"_sv) return verb::lock; break; case 'M': c = v[0]; v.remove_prefix(1); switch(c) { case '-': if(v == "SEARCH"_sv) return verb::msearch; break; case 'E': if(v == "RGE"_sv) return verb::merge; break; case 'K': if(v == "ACTIVITY"_sv) return verb::mkactivity; if(v[0] == 'C') { v.remove_prefix(1); if(v == "ALENDAR"_sv) return verb::mkcalendar; if(v == "OL"_sv) return verb::mkcol; break; } break; case 'O': if(v == "VE"_sv) return verb::move; BOOST_FALLTHROUGH; default: break; } break; case 'N': if(v == "OTIFY"_sv) return verb::notify; break; case 'O': if(v == "PTIONS"_sv) return verb::options; break; case 'P': c = v[0]; v.remove_prefix(1); switch(c) { case 'A': if(v == "TCH"_sv) return verb::patch; break; case 'O': if(v == "ST"_sv) return verb::post; break; case 'R': if(v == "OPFIND"_sv) return verb::propfind; if(v == "OPPATCH"_sv) return verb::proppatch; break; case 'U': if(v == "RGE"_sv) return verb::purge; if(v == "T"_sv) return verb::put; BOOST_FALLTHROUGH; default: break; } break; case 'R': if(v[0] != 'E') break; v.remove_prefix(1); if(v == "BIND"_sv) return verb::rebind; if(v == "PORT"_sv) return verb::report; break; case 'S': if(v == "EARCH"_sv) return verb::search; if(v == "UBSCRIBE"_sv) return verb::subscribe; break; case 'T': if(v == "RACE"_sv) return verb::trace; break; case 'U': if(v[0] != 'N') break; v.remove_prefix(1); if(v == "BIND"_sv) return verb::unbind; if(v == "LINK"_sv) return verb::unlink; if(v == "LOCK"_sv) return verb::unlock; if(v == "SUBSCRIBE"_sv) return verb::unsubscribe; break; default: break; } return verb::unknown; } } // http } // beast } // boost #endif PK PP�[�Y���> �> http/impl/file_body_win32.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_FILE_BODY_WIN32_HPP #define BOOST_BEAST_HTTP_IMPL_FILE_BODY_WIN32_HPP #if BOOST_BEAST_USE_WIN32_FILE #include <boost/beast/core/async_base.hpp> #include <boost/beast/core/bind_handler.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/is_invocable.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/write.hpp> #include <boost/beast/http/serializer.hpp> #include <boost/asio/async_result.hpp> #include <boost/asio/basic_stream_socket.hpp> #include <boost/asio/windows/overlapped_ptr.hpp> #include <boost/make_unique.hpp> #include <boost/smart_ptr/make_shared_array.hpp> #include <boost/winapi/basic_types.hpp> #include <boost/winapi/error_codes.hpp> #include <boost/winapi/get_last_error.hpp> #include <algorithm> #include <cstring> namespace boost { namespace beast { namespace http { namespace detail { template<class, class, bool, class, class> class write_some_win32_op; } // detail template<> struct basic_file_body<file_win32> { using file_type = file_win32; class writer; class reader; //-------------------------------------------------------------------------- class value_type { friend class writer; friend class reader; friend struct basic_file_body<file_win32>; template<class, class, bool, class, class> friend class detail::write_some_win32_op; template< class Protocol, class Executor, bool isRequest, class Fields> friend std::size_t write_some( net::basic_stream_socket<Protocol, Executor>& sock, serializer<isRequest, basic_file_body<file_win32>, Fields>& sr, error_code& ec); file_win32 file_; std::uint64_t size_ = 0; // cached file size std::uint64_t first_; // starting offset of the range std::uint64_t last_; // ending offset of the range public: ~value_type() = default; value_type() = default; value_type(value_type&& other) = default; value_type& operator=(value_type&& other) = default; file_win32& file() { return file_; } bool is_open() const { return file_.is_open(); } std::uint64_t size() const { return size_; } void close(); void open(char const* path, file_mode mode, error_code& ec); void reset(file_win32&& file, error_code& ec); }; //-------------------------------------------------------------------------- class writer { template<class, class, bool, class, class> friend class detail::write_some_win32_op; template< class Protocol, class Executor, bool isRequest, class Fields> friend std::size_t write_some( net::basic_stream_socket<Protocol, Executor>& sock, serializer<isRequest, basic_file_body<file_win32>, Fields>& sr, error_code& ec); value_type& body_; // The body we are reading from std::uint64_t pos_; // The current position in the file char buf_[4096]; // Small buffer for reading public: using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> writer(header<isRequest, Fields>&, value_type& b) : body_(b) , pos_(body_.first_) { BOOST_ASSERT(body_.file_.is_open()); } void init(error_code& ec) { BOOST_ASSERT(body_.file_.is_open()); ec.clear(); } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { std::size_t const n = (std::min)(sizeof(buf_), beast::detail::clamp(body_.last_ - pos_)); if(n == 0) { ec = {}; return boost::none; } auto const nread = body_.file_.read(buf_, n, ec); if(ec) return boost::none; if (nread == 0) { ec = error::short_read; return boost::none; } BOOST_ASSERT(nread != 0); pos_ += nread; ec = {}; return {{ {buf_, nread}, // buffer to return. pos_ < body_.last_}}; // `true` if there are more buffers. } }; //-------------------------------------------------------------------------- class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional< std::uint64_t> const& content_length, error_code& ec) { // VFALCO We could reserve space in the file boost::ignore_unused(content_length); BOOST_ASSERT(body_.file_.is_open()); ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { std::size_t nwritten = 0; for(auto buffer : beast::buffers_range_ref(buffers)) { nwritten += body_.file_.write( buffer.data(), buffer.size(), ec); if(ec) return nwritten; } ec = {}; return nwritten; } void finish(error_code& ec) { ec = {}; } }; //-------------------------------------------------------------------------- static std::uint64_t size(value_type const& body) { return body.size(); } }; //------------------------------------------------------------------------------ inline void basic_file_body<file_win32>:: value_type:: close() { error_code ignored; file_.close(ignored); } inline void basic_file_body<file_win32>:: value_type:: open(char const* path, file_mode mode, error_code& ec) { file_.open(path, mode, ec); if(ec) return; size_ = file_.size(ec); if(ec) { close(); return; } first_ = 0; last_ = size_; } inline void basic_file_body<file_win32>:: value_type:: reset(file_win32&& file, error_code& ec) { if(file_.is_open()) { error_code ignored; file_.close(ignored); } file_ = std::move(file); if(file_.is_open()) { size_ = file_.size(ec); if(ec) { close(); return; } first_ = 0; last_ = size_; } } //------------------------------------------------------------------------------ namespace detail { template<class Unsigned> boost::winapi::DWORD_ lowPart(Unsigned n) { return static_cast< boost::winapi::DWORD_>( n & 0xffffffff); } template<class Unsigned> boost::winapi::DWORD_ highPart(Unsigned n, std::true_type) { return static_cast< boost::winapi::DWORD_>( (n>>32)&0xffffffff); } template<class Unsigned> boost::winapi::DWORD_ highPart(Unsigned, std::false_type) { return 0; } template<class Unsigned> boost::winapi::DWORD_ highPart(Unsigned n) { return highPart(n, std::integral_constant< bool, (sizeof(Unsigned)>4)>{}); } class null_lambda { public: template<class ConstBufferSequence> void operator()(error_code&, ConstBufferSequence const&) const { BOOST_ASSERT(false); } }; // https://github.com/boostorg/beast/issues/1815 // developer commentary: // This function mimics the behaviour of ASIO. // Perhaps the correct fix is to insist on the use // of an appropriate error_condition to detect // connection_reset and connection_refused? inline error_code make_win32_error( boost::winapi::DWORD_ dwError) noexcept { // from // https://github.com/boostorg/asio/blob/6534af41b471288091ae39f9ab801594189b6fc9/include/boost/asio/detail/impl/socket_ops.ipp#L842 switch(dwError) { case boost::winapi::ERROR_NETNAME_DELETED_: return net::error::connection_reset; case boost::winapi::ERROR_PORT_UNREACHABLE_: return net::error::connection_refused; case boost::winapi::WSAEMSGSIZE_: case boost::winapi::ERROR_MORE_DATA_: return {}; } return error_code( static_cast<int>(dwError), system_category()); } inline error_code make_win32_error( error_code ec) noexcept { if(ec.category() != system_category()) return ec; return make_win32_error( static_cast<boost::winapi::DWORD_>( ec.value())); } //------------------------------------------------------------------------------ #if BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR template< class Protocol, class Executor, bool isRequest, class Fields, class Handler> class write_some_win32_op : public beast::async_base<Handler, Executor> { net::basic_stream_socket< Protocol, Executor>& sock_; serializer<isRequest, basic_file_body<file_win32>, Fields>& sr_; bool header_ = false; public: template<class Handler_> write_some_win32_op( Handler_&& h, net::basic_stream_socket< Protocol, Executor>& s, serializer<isRequest, basic_file_body<file_win32>,Fields>& sr) : async_base< Handler, Executor>( std::forward<Handler_>(h), s.get_executor()) , sock_(s) , sr_(sr) { (*this)(); } void operator()() { if(! sr_.is_header_done()) { header_ = true; sr_.split(true); return detail::async_write_some_impl( sock_, sr_, std::move(*this)); } if(sr_.get().chunked()) { return detail::async_write_some_impl( sock_, sr_, std::move(*this)); } auto& w = sr_.writer_impl(); boost::winapi::DWORD_ const nNumberOfBytesToWrite = static_cast<boost::winapi::DWORD_>( (std::min<std::uint64_t>)( (std::min<std::uint64_t>)(w.body_.last_ - w.pos_, sr_.limit()), (std::numeric_limits<boost::winapi::DWORD_>::max)())); net::windows::overlapped_ptr overlapped{ sock_.get_executor(), std::move(*this)}; // Note that we have moved *this, so we cannot access // the handler since it is now moved-from. We can still // access simple things like references and built-in types. auto& ov = *overlapped.get(); ov.Offset = lowPart(w.pos_); ov.OffsetHigh = highPart(w.pos_); auto const bSuccess = ::TransmitFile( sock_.native_handle(), sr_.get().body().file_.native_handle(), nNumberOfBytesToWrite, 0, overlapped.get(), nullptr, 0); auto const dwError = boost::winapi::GetLastError(); if(! bSuccess && dwError != boost::winapi::ERROR_IO_PENDING_) { // VFALCO This needs review, is 0 the right number? // completed immediately (with error?) overlapped.complete( make_win32_error(dwError), 0); return; } overlapped.release(); } void operator()( error_code ec, std::size_t bytes_transferred = 0) { if(ec) { ec = make_win32_error(ec); } else if(! ec && ! header_) { auto& w = sr_.writer_impl(); w.pos_ += bytes_transferred; BOOST_ASSERT(w.pos_ <= w.body_.last_); if(w.pos_ >= w.body_.last_) { sr_.next(ec, null_lambda{}); BOOST_ASSERT(! ec); BOOST_ASSERT(sr_.is_done()); } } this->complete_now(ec, bytes_transferred); } }; struct run_write_some_win32_op { template< class Protocol, class Executor, bool isRequest, class Fields, class WriteHandler> void operator()( WriteHandler&& h, net::basic_stream_socket< Protocol, Executor>* s, serializer<isRequest, basic_file_body<file_win32>, Fields>* sr) { // If you get an error on the following line it means // that your handler does not meet the documented type // requirements for the handler. static_assert( beast::detail::is_invocable<WriteHandler, void(error_code, std::size_t)>::value, "WriteHandler type requirements not met"); write_some_win32_op< Protocol, Executor, isRequest, Fields, typename std::decay<WriteHandler>::type>( std::forward<WriteHandler>(h), *s, *sr); } }; #endif } // detail //------------------------------------------------------------------------------ template< class Protocol, class Executor, bool isRequest, class Fields> std::size_t write_some( net::basic_stream_socket< Protocol, Executor>& sock, serializer<isRequest, basic_file_body<file_win32>, Fields>& sr, error_code& ec) { if(! sr.is_header_done()) { sr.split(true); auto const bytes_transferred = detail::write_some_impl(sock, sr, ec); if(ec) return bytes_transferred; return bytes_transferred; } if(sr.get().chunked()) { auto const bytes_transferred = detail::write_some_impl(sock, sr, ec); if(ec) return bytes_transferred; return bytes_transferred; } auto& w = sr.writer_impl(); w.body_.file_.seek(w.pos_, ec); if(ec) return 0; boost::winapi::DWORD_ const nNumberOfBytesToWrite = static_cast<boost::winapi::DWORD_>( (std::min<std::uint64_t>)( (std::min<std::uint64_t>)(w.body_.last_ - w.pos_, sr.limit()), (std::numeric_limits<boost::winapi::DWORD_>::max)())); auto const bSuccess = ::TransmitFile( sock.native_handle(), w.body_.file_.native_handle(), nNumberOfBytesToWrite, 0, nullptr, nullptr, 0); if(! bSuccess) { ec = detail::make_win32_error( boost::winapi::GetLastError()); return 0; } w.pos_ += nNumberOfBytesToWrite; BOOST_ASSERT(w.pos_ <= w.body_.last_); if(w.pos_ < w.body_.last_) { ec = {}; } else { sr.next(ec, detail::null_lambda{}); BOOST_ASSERT(! ec); BOOST_ASSERT(sr.is_done()); } return nNumberOfBytesToWrite; } #if BOOST_ASIO_HAS_WINDOWS_OVERLAPPED_PTR template< class Protocol, class Executor, bool isRequest, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( net::basic_stream_socket< Protocol, Executor>& sock, serializer<isRequest, basic_file_body<file_win32>, Fields>& sr, WriteHandler&& handler) { return net::async_initiate< WriteHandler, void(error_code, std::size_t)>( detail::run_write_some_win32_op{}, handler, &sock, &sr); } #endif } // http } // beast } // boost #endif #endif PK PP�[ @�L �L http/impl/basic_parser.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_IMPL_BASIC_PARSER_IPP #define BOOST_BEAST_HTTP_IMPL_BASIC_PARSER_IPP #include <boost/beast/http/basic_parser.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/rfc7230.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/detail/string.hpp> #include <boost/asio/buffer.hpp> #include <algorithm> #include <utility> namespace boost { namespace beast { namespace http { template<bool isRequest> bool basic_parser<isRequest>:: keep_alive() const { BOOST_ASSERT(is_header_done()); if(f_ & flagHTTP11) { if(f_ & flagConnectionClose) return false; } else { if(! (f_ & flagConnectionKeepAlive)) return false; } return (f_ & flagNeedEOF) == 0; } template<bool isRequest> boost::optional<std::uint64_t> basic_parser<isRequest>:: content_length() const { BOOST_ASSERT(is_header_done()); return content_length_unchecked(); } template<bool isRequest> boost::optional<std::uint64_t> basic_parser<isRequest>:: content_length_remaining() const { BOOST_ASSERT(is_header_done()); if(! (f_ & flagContentLength)) return boost::none; return len_; } template<bool isRequest> void basic_parser<isRequest>:: skip(bool v) { BOOST_ASSERT(! got_some()); if(v) f_ |= flagSkipBody; else f_ &= ~flagSkipBody; } template<bool isRequest> std::size_t basic_parser<isRequest>:: put(net::const_buffer buffer, error_code& ec) { BOOST_ASSERT(state_ != state::complete); auto p = static_cast<char const*>(buffer.data()); auto n = buffer.size(); auto const p0 = p; auto const p1 = p0 + n; ec = {}; loop: switch(state_) { case state::nothing_yet: if(n == 0) { ec = error::need_more; return 0; } state_ = state::start_line; BOOST_FALLTHROUGH; case state::start_line: { maybe_need_more(p, n, ec); if(ec) goto done; parse_start_line(p, p + (std::min<std::size_t>)( header_limit_, n), ec, is_request{}); if(ec) { if(ec == error::need_more) { if(n >= header_limit_) { ec = error::header_limit; goto done; } if(p + 3 <= p1) skip_ = static_cast< std::size_t>(p1 - p - 3); } goto done; } BOOST_ASSERT(! is_done()); n = static_cast<std::size_t>(p1 - p); if(p >= p1) { ec = error::need_more; goto done; } BOOST_FALLTHROUGH; } case state::fields: maybe_need_more(p, n, ec); if(ec) goto done; parse_fields(p, p + (std::min<std::size_t>)( header_limit_, n), ec); if(ec) { if(ec == error::need_more) { if(n >= header_limit_) { ec = error::header_limit; goto done; } if(p + 3 <= p1) skip_ = static_cast< std::size_t>(p1 - p - 3); } goto done; } finish_header(ec, is_request{}); break; case state::body0: BOOST_ASSERT(! skip_); this->on_body_init_impl(content_length(), ec); if(ec) goto done; state_ = state::body; BOOST_FALLTHROUGH; case state::body: BOOST_ASSERT(! skip_); parse_body(p, n, ec); if(ec) goto done; break; case state::body_to_eof0: BOOST_ASSERT(! skip_); this->on_body_init_impl(content_length(), ec); if(ec) goto done; state_ = state::body_to_eof; BOOST_FALLTHROUGH; case state::body_to_eof: BOOST_ASSERT(! skip_); parse_body_to_eof(p, n, ec); if(ec) goto done; break; case state::chunk_header0: this->on_body_init_impl(content_length(), ec); if(ec) goto done; state_ = state::chunk_header; BOOST_FALLTHROUGH; case state::chunk_header: parse_chunk_header(p, n, ec); if(ec) goto done; break; case state::chunk_body: parse_chunk_body(p, n, ec); if(ec) goto done; break; case state::complete: ec = {}; goto done; } if(p < p1 && ! is_done() && eager()) { n = static_cast<std::size_t>(p1 - p); goto loop; } done: return static_cast<std::size_t>(p - p0); } template<bool isRequest> void basic_parser<isRequest>:: put_eof(error_code& ec) { BOOST_ASSERT(got_some()); if( state_ == state::start_line || state_ == state::fields) { ec = error::partial_message; return; } if(f_ & (flagContentLength | flagChunked)) { if(state_ != state::complete) { ec = error::partial_message; return; } ec = {}; return; } ec = {}; this->on_finish_impl(ec); if(ec) return; state_ = state::complete; } template<bool isRequest> void basic_parser<isRequest>:: maybe_need_more( char const* p, std::size_t n, error_code& ec) { if(skip_ == 0) return; if( n > header_limit_) n = header_limit_; if(n < skip_ + 4) { ec = error::need_more; return; } auto const term = find_eom(p + skip_, p + n); if(! term) { skip_ = n - 3; if(skip_ + 4 > header_limit_) { ec = error::header_limit; return; } ec = error::need_more; return; } skip_ = 0; } template<bool isRequest> void basic_parser<isRequest>:: parse_start_line( char const*& in, char const* last, error_code& ec, std::true_type) { /* request-line = method SP request-target SP HTTP-version CRLF method = token */ auto p = in; string_view method; parse_method(p, last, method, ec); if(ec) return; string_view target; parse_target(p, last, target, ec); if(ec) return; int version = 0; parse_version(p, last, version, ec); if(ec) return; if(version < 10 || version > 11) { ec = error::bad_version; return; } if(p + 2 > last) { ec = error::need_more; return; } if(p[0] != '\r' || p[1] != '\n') { ec = error::bad_version; return; } p += 2; if(version >= 11) f_ |= flagHTTP11; this->on_request_impl(string_to_verb(method), method, target, version, ec); if(ec) return; in = p; state_ = state::fields; } template<bool isRequest> void basic_parser<isRequest>:: parse_start_line( char const*& in, char const* last, error_code& ec, std::false_type) { /* status-line = HTTP-version SP status-code SP reason-phrase CRLF status-code = 3*DIGIT reason-phrase = *( HTAB / SP / VCHAR / obs-text ) */ auto p = in; int version = 0; parse_version(p, last, version, ec); if(ec) return; if(version < 10 || version > 11) { ec = error::bad_version; return; } // SP if(p + 1 > last) { ec = error::need_more; return; } if(*p++ != ' ') { ec = error::bad_version; return; } parse_status(p, last, status_, ec); if(ec) return; // parse reason CRLF string_view reason; parse_reason(p, last, reason, ec); if(ec) return; if(version >= 11) f_ |= flagHTTP11; this->on_response_impl( status_, reason, version, ec); if(ec) return; in = p; state_ = state::fields; } template<bool isRequest> void basic_parser<isRequest>:: parse_fields(char const*& in, char const* last, error_code& ec) { string_view name; string_view value; // https://stackoverflow.com/questions/686217/maximum-on-http-header-values beast::detail::char_buffer<max_obs_fold> buf; auto p = in; for(;;) { if(p + 2 > last) { ec = error::need_more; return; } if(p[0] == '\r') { if(p[1] != '\n') ec = error::bad_line_ending; in = p + 2; return; } parse_field(p, last, name, value, buf, ec); if(ec) return; auto const f = string_to_field(name); do_field(f, value, ec); if(ec) return; this->on_field_impl(f, name, value, ec); if(ec) return; in = p; } } template<bool isRequest> void basic_parser<isRequest>:: finish_header(error_code& ec, std::true_type) { // RFC 7230 section 3.3 // https://tools.ietf.org/html/rfc7230#section-3.3 if(f_ & flagSkipBody) { state_ = state::complete; } else if(f_ & flagContentLength) { if(body_limit_.has_value() && len_ > body_limit_) { ec = error::body_limit; return; } if(len_ > 0) { f_ |= flagHasBody; state_ = state::body0; } else { state_ = state::complete; } } else if(f_ & flagChunked) { f_ |= flagHasBody; state_ = state::chunk_header0; } else { len_ = 0; len0_ = 0; state_ = state::complete; } ec = {}; this->on_header_impl(ec); if(ec) return; if(state_ == state::complete) { this->on_finish_impl(ec); if(ec) return; } } template<bool isRequest> void basic_parser<isRequest>:: finish_header(error_code& ec, std::false_type) { // RFC 7230 section 3.3 // https://tools.ietf.org/html/rfc7230#section-3.3 if( (f_ & flagSkipBody) || // e.g. response to a HEAD request status_ / 100 == 1 || // 1xx e.g. Continue status_ == 204 || // No Content status_ == 304) // Not Modified { // VFALCO Content-Length may be present, but we // treat the message as not having a body. // https://github.com/boostorg/beast/issues/692 state_ = state::complete; } else if(f_ & flagContentLength) { if(len_ > 0) { f_ |= flagHasBody; state_ = state::body0; if(body_limit_.has_value() && len_ > body_limit_) { ec = error::body_limit; return; } } else { state_ = state::complete; } } else if(f_ & flagChunked) { f_ |= flagHasBody; state_ = state::chunk_header0; } else { f_ |= flagHasBody; f_ |= flagNeedEOF; state_ = state::body_to_eof0; } ec = {}; this->on_header_impl(ec); if(ec) return; if(state_ == state::complete) { this->on_finish_impl(ec); if(ec) return; } } template<bool isRequest> void basic_parser<isRequest>:: parse_body(char const*& p, std::size_t n, error_code& ec) { ec = {}; n = this->on_body_impl(string_view{p, beast::detail::clamp(len_, n)}, ec); p += n; len_ -= n; if(ec) return; if(len_ > 0) return; this->on_finish_impl(ec); if(ec) return; state_ = state::complete; } template<bool isRequest> void basic_parser<isRequest>:: parse_body_to_eof(char const*& p, std::size_t n, error_code& ec) { if(body_limit_.has_value()) { if (n > *body_limit_) { ec = error::body_limit; return; } *body_limit_ -= n; } ec = {}; n = this->on_body_impl(string_view{p, n}, ec); p += n; if(ec) return; } template<bool isRequest> void basic_parser<isRequest>:: parse_chunk_header(char const*& p0, std::size_t n, error_code& ec) { /* chunked-body = *chunk last-chunk trailer-part CRLF chunk = chunk-size [ chunk-ext ] CRLF chunk-data CRLF last-chunk = 1*("0") [ chunk-ext ] CRLF trailer-part = *( header-field CRLF ) chunk-size = 1*HEXDIG chunk-data = 1*OCTET ; a sequence of chunk-size octets chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string */ auto p = p0; auto const pend = p + n; char const* eol; if(! (f_ & flagFinalChunk)) { if(n < skip_ + 2) { ec = error::need_more; return; } if(f_ & flagExpectCRLF) { // Treat the last CRLF in a chunk as // part of the next chunk, so p can // be parsed in one call instead of two. if(! parse_crlf(p)) { ec = error::bad_chunk; return; } } eol = find_eol(p0 + skip_, pend, ec); if(ec) return; if(! eol) { ec = error::need_more; skip_ = n - 1; return; } skip_ = static_cast< std::size_t>(eol - 2 - p0); std::uint64_t size; if(! parse_hex(p, size)) { ec = error::bad_chunk; return; } if(size != 0) { if (body_limit_.has_value()) { if (size > *body_limit_) { ec = error::body_limit; return; } *body_limit_ -= size; } auto const start = p; parse_chunk_extensions(p, pend, ec); if(ec) return; if(p != eol -2 ) { ec = error::bad_chunk_extension; return; } auto const ext = make_string(start, p); this->on_chunk_header_impl(size, ext, ec); if(ec) return; len_ = size; skip_ = 2; p0 = eol; f_ |= flagExpectCRLF; state_ = state::chunk_body; return; } f_ |= flagFinalChunk; } else { BOOST_ASSERT(n >= 5); if(f_ & flagExpectCRLF) BOOST_VERIFY(parse_crlf(p)); std::uint64_t size; BOOST_VERIFY(parse_hex(p, size)); eol = find_eol(p, pend, ec); BOOST_ASSERT(! ec); } auto eom = find_eom(p0 + skip_, pend); if(! eom) { BOOST_ASSERT(n >= 3); skip_ = n - 3; ec = error::need_more; return; } auto const start = p; parse_chunk_extensions(p, pend, ec); if(ec) return; if(p != eol - 2) { ec = error::bad_chunk_extension; return; } auto const ext = make_string(start, p); this->on_chunk_header_impl(0, ext, ec); if(ec) return; p = eol; parse_fields(p, eom, ec); if(ec) return; BOOST_ASSERT(p == eom); p0 = eom; this->on_finish_impl(ec); if(ec) return; state_ = state::complete; } template<bool isRequest> void basic_parser<isRequest>:: parse_chunk_body(char const*& p, std::size_t n, error_code& ec) { ec = {}; n = this->on_chunk_body_impl( len_, string_view{p, beast::detail::clamp(len_, n)}, ec); p += n; len_ -= n; if(len_ == 0) state_ = state::chunk_header; } template<bool isRequest> void basic_parser<isRequest>:: do_field(field f, string_view value, error_code& ec) { using namespace beast::detail::string_literals; // Connection if(f == field::connection || f == field::proxy_connection) { auto const list = opt_token_list{value}; if(! validate_list(list)) { // VFALCO Should this be a field specific error? ec = error::bad_value; return; } for(auto const& s : list) { if(beast::iequals("close"_sv, s)) { f_ |= flagConnectionClose; continue; } if(beast::iequals("keep-alive"_sv, s)) { f_ |= flagConnectionKeepAlive; continue; } if(beast::iequals("upgrade"_sv, s)) { f_ |= flagConnectionUpgrade; continue; } } ec = {}; return; } // Content-Length if(f == field::content_length) { auto bad_content_length = [&ec] { ec = error::bad_content_length; }; // conflicting field if(f_ & flagChunked) return bad_content_length(); // Content-length may be a comma-separated list of integers auto tokens_unprocessed = 1 + std::count(value.begin(), value.end(), ','); auto tokens = opt_token_list(value); if (tokens.begin() == tokens.end() || !validate_list(tokens)) return bad_content_length(); auto existing = this->content_length_unchecked(); for (auto tok : tokens) { std::uint64_t v; if (!parse_dec(tok, v)) return bad_content_length(); --tokens_unprocessed; if (existing.has_value()) { if (v != *existing) return bad_content_length(); } else { existing = v; } } if (tokens_unprocessed) return bad_content_length(); BOOST_ASSERT(existing.has_value()); ec = {}; len_ = *existing; len0_ = *existing; f_ |= flagContentLength; return; } // Transfer-Encoding if(f == field::transfer_encoding) { if(f_ & flagChunked) { // duplicate ec = error::bad_transfer_encoding; return; } if(f_ & flagContentLength) { // conflicting field ec = error::bad_transfer_encoding; return; } ec = {}; auto const v = token_list{value}; auto const p = std::find_if(v.begin(), v.end(), [&](string_view const& s) { return beast::iequals("chunked"_sv, s); }); if(p == v.end()) return; if(std::next(p) != v.end()) return; len_ = 0; f_ |= flagChunked; return; } // Upgrade if(f == field::upgrade) { ec = {}; f_ |= flagUpgrade; return; } ec = {}; } #ifdef BOOST_BEAST_SOURCE template class http::basic_parser<true>; template class http::basic_parser<false>; #endif } // http } // beast } // boost #endif PK PP�[9 � http/file_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_FILE_BODY_HPP #define BOOST_BEAST_HTTP_FILE_BODY_HPP #include <boost/beast/core/file.hpp> #include <boost/beast/http/basic_file_body.hpp> #include <boost/assert.hpp> #include <boost/optional.hpp> #include <algorithm> #include <cstdio> #include <cstdint> #include <utility> namespace boost { namespace beast { namespace http { /// A message body represented by a file on the filesystem. using file_body = basic_file_body<file>; } // http } // beast } // boost #ifndef BOOST_BEAST_NO_FILE_BODY_WIN32 #include <boost/beast/http/impl/file_body_win32.hpp> #endif #endif PK PP�[F��- http/basic_dynamic_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_BASIC_DYNAMIC_BODY_HPP #define BOOST_BEAST_HTTP_BASIC_DYNAMIC_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/detail/buffer.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/optional.hpp> #include <algorithm> #include <cstdint> #include <utility> namespace boost { namespace beast { namespace http { /** A <em>Body</em> using a <em>DynamicBuffer</em> This body uses a <em>DynamicBuffer</em> as a memory-based container for holding message payloads. Messages using this body type may be serialized and parsed. */ template<class DynamicBuffer> struct basic_dynamic_body { static_assert( net::is_dynamic_buffer<DynamicBuffer>::value, "DynamicBuffer type requirements not met"); /** The type of container used for the body This determines the type of @ref message::body when this body type is used with a message container. */ using value_type = DynamicBuffer; /** Returns the payload size of the body When this body is used with @ref message::prepare_payload, the Content-Length will be set to the payload size, and any chunked Transfer-Encoding will be removed. */ static std::uint64_t size(value_type const& v) { return v.size(); } /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional< std::uint64_t> const&, error_code& ec) { ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { auto const n = buffer_bytes(buffers); if(beast::detail::sum_exceeds(body_.size(), n, body_.max_size())) { ec = error::buffer_overflow; return 0; } auto const mb = beast::detail::dynamic_buffer_prepare( body_, (std::min)(n, body_.max_size() - body_.size()), ec, error::buffer_overflow); if(ec) return 0; auto const bytes_transferred = net::buffer_copy(*mb, buffers); body_.commit(bytes_transferred); return bytes_transferred; } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer { DynamicBuffer const& body_; public: using const_buffers_type = typename DynamicBuffer::const_buffers_type; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const& b) : body_(b) { } void init(error_code& ec) { ec = {}; } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { ec = {}; return {{body_.data(), false}}; } }; #endif }; } // http } // beast } // boost #endif PK PP�[W`�pQ Q http/fields.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_FIELDS_HPP #define BOOST_BEAST_HTTP_FIELDS_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/allocator.hpp> #include <boost/beast/http/field.hpp> #include <boost/asio/buffer.hpp> #include <boost/core/empty_value.hpp> #include <boost/intrusive/list.hpp> #include <boost/intrusive/set.hpp> #include <boost/optional.hpp> #include <algorithm> #include <cctype> #include <cstring> #include <memory> #include <string> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { /** A container for storing HTTP header fields. This container is designed to store the field value pairs that make up the fields and trailers in an HTTP message. Objects of this type are iterable, with each element holding the field name and field value. Field names are stored as-is, but comparisons are case-insensitive. The container behaves as a `std::multiset`; there will be a separate value for each occurrence of the same field name. When the container is iterated the fields are presented in the order of insertion, with fields having the same name following each other consecutively. Meets the requirements of <em>Fields</em> @tparam Allocator The allocator to use. */ template<class Allocator> class basic_fields #if ! BOOST_BEAST_DOXYGEN : private boost::empty_value<Allocator> #endif { // Fancy pointers are not supported static_assert(std::is_pointer<typename std::allocator_traits<Allocator>::pointer>::value, "Allocator must use regular pointers"); friend class fields_test; // for `header` struct element; using off_t = std::uint16_t; public: /// The type of allocator used. using allocator_type = Allocator; /// The type of element used to represent a field class value_type { friend class basic_fields; off_t off_; off_t len_; field f_; char* data() const; net::const_buffer buffer() const; protected: value_type(field name, string_view sname, string_view value); public: /// Constructor (deleted) value_type(value_type const&) = delete; /// Assignment (deleted) value_type& operator=(value_type const&) = delete; /// Returns the field enum, which can be @ref field::unknown field name() const; /// Returns the field name as a string string_view const name_string() const; /// Returns the value of the field string_view const value() const; }; /** A strictly less predicate for comparing keys, using a case-insensitive comparison. The case-comparison operation is defined only for low-ASCII characters. */ #if BOOST_BEAST_DOXYGEN using key_compare = __implementation_defined__; #else struct key_compare : beast::iless #endif { /// Returns `true` if lhs is less than rhs using a strict ordering bool operator()( string_view lhs, value_type const& rhs) const noexcept { if(lhs.size() < rhs.name_string().size()) return true; if(lhs.size() > rhs.name_string().size()) return false; return iless::operator()(lhs, rhs.name_string()); } /// Returns `true` if lhs is less than rhs using a strict ordering bool operator()( value_type const& lhs, string_view rhs) const noexcept { if(lhs.name_string().size() < rhs.size()) return true; if(lhs.name_string().size() > rhs.size()) return false; return iless::operator()(lhs.name_string(), rhs); } /// Returns `true` if lhs is less than rhs using a strict ordering bool operator()( value_type const& lhs, value_type const& rhs) const noexcept { if(lhs.name_string().size() < rhs.name_string().size()) return true; if(lhs.name_string().size() > rhs.name_string().size()) return false; return iless::operator()(lhs.name_string(), rhs.name_string()); } }; /// The algorithm used to serialize the header #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer; #endif private: struct element : public boost::intrusive::list_base_hook< boost::intrusive::link_mode< boost::intrusive::normal_link>> , public boost::intrusive::set_base_hook< boost::intrusive::link_mode< boost::intrusive::normal_link>> , public value_type { element(field name, string_view sname, string_view value); }; using list_t = typename boost::intrusive::make_list< element, boost::intrusive::constant_time_size<false> >::type; using set_t = typename boost::intrusive::make_multiset< element, boost::intrusive::constant_time_size<true>, boost::intrusive::compare<key_compare> >::type; using align_type = typename boost::type_with_alignment<alignof(element)>::type; using rebind_type = typename beast::detail::allocator_traits<Allocator>:: template rebind_alloc<align_type>; using alloc_traits = beast::detail::allocator_traits<rebind_type>; using size_type = typename beast::detail::allocator_traits<Allocator>::size_type; public: /// Destructor ~basic_fields(); /// Constructor. basic_fields() = default; /** Constructor. @param alloc The allocator to use. */ explicit basic_fields(Allocator const& alloc) noexcept; /** Move constructor. The state of the moved-from object is as if constructed using the same allocator. */ basic_fields(basic_fields&&) noexcept; /** Move constructor. The state of the moved-from object is as if constructed using the same allocator. @param alloc The allocator to use. */ basic_fields(basic_fields&&, Allocator const& alloc); /// Copy constructor. basic_fields(basic_fields const&); /** Copy constructor. @param alloc The allocator to use. */ basic_fields(basic_fields const&, Allocator const& alloc); /// Copy constructor. template<class OtherAlloc> basic_fields(basic_fields<OtherAlloc> const&); /** Copy constructor. @param alloc The allocator to use. */ template<class OtherAlloc> basic_fields(basic_fields<OtherAlloc> const&, Allocator const& alloc); /** Move assignment. The state of the moved-from object is as if constructed using the same allocator. */ basic_fields& operator=(basic_fields&&) noexcept( alloc_traits::propagate_on_container_move_assignment::value); /// Copy assignment. basic_fields& operator=(basic_fields const&); /// Copy assignment. template<class OtherAlloc> basic_fields& operator=(basic_fields<OtherAlloc> const&); public: /// A constant iterator to the field sequence. #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else using const_iterator = typename list_t::const_iterator; #endif /// A constant iterator to the field sequence. using iterator = const_iterator; /// Return a copy of the allocator associated with the container. allocator_type get_allocator() const { return this->get(); } //-------------------------------------------------------------------------- // // Element access // //-------------------------------------------------------------------------- /** Returns the value for a field, or throws an exception. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The name of the field. @return The field value. @throws std::out_of_range if the field is not found. */ string_view const at(field name) const; /** Returns the value for a field, or throws an exception. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The name of the field. @return The field value. @throws std::out_of_range if the field is not found. */ string_view const at(string_view name) const; /** Returns the value for a field, or `""` if it does not exist. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The name of the field. */ string_view const operator[](field name) const; /** Returns the value for a case-insensitive matching header, or `""` if it does not exist. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The name of the field. */ string_view const operator[](string_view name) const; //-------------------------------------------------------------------------- // // Iterators // //-------------------------------------------------------------------------- /// Return a const iterator to the beginning of the field sequence. const_iterator begin() const { return list_.cbegin(); } /// Return a const iterator to the end of the field sequence. const_iterator end() const { return list_.cend(); } /// Return a const iterator to the beginning of the field sequence. const_iterator cbegin() const { return list_.cbegin(); } /// Return a const iterator to the end of the field sequence. const_iterator cend() const { return list_.cend(); } //-------------------------------------------------------------------------- // // Capacity // //-------------------------------------------------------------------------- private: // VFALCO Since the header and message derive from Fields, // what does the expression m.empty() mean? Its confusing. bool empty() const { return list_.empty(); } public: //-------------------------------------------------------------------------- // // Modifiers // //-------------------------------------------------------------------------- /** Remove all fields from the container All references, pointers, or iterators referring to contained elements are invalidated. All past-the-end iterators are also invalidated. @par Postconditions: @code std::distance(this->begin(), this->end()) == 0 @endcode */ void clear(); /** Insert a field. If one or more fields with the same name already exist, the new field will be inserted after the last field with the matching name, in serialization order. @param name The field name. @param value The value of the field, as a @ref string_view */ void insert(field name, string_view const& value); /* Set a field from a null pointer (deleted). */ void insert(field, std::nullptr_t) = delete; /** Insert a field. If one or more fields with the same name already exist, the new field will be inserted after the last field with the matching name, in serialization order. @param name The field name. @param value The value of the field, as a @ref string_view */ void insert(string_view name, string_view const& value); /* Insert a field from a null pointer (deleted). */ void insert(string_view, std::nullptr_t) = delete; /** Insert a field. If one or more fields with the same name already exist, the new field will be inserted after the last field with the matching name, in serialization order. @param name The field name. @param name_string The literal text corresponding to the field name. If `name != field::unknown`, then this value must be equal to `to_string(name)` using a case-insensitive comparison, otherwise the behavior is undefined. @param value The value of the field, as a @ref string_view */ void insert(field name, string_view name_string, string_view const& value); void insert(field, string_view, std::nullptr_t) = delete; /** Set a field value, removing any other instances of that field. First removes any values with matching field names, then inserts the new field value. @param name The field name. @param value The value of the field, as a @ref string_view @return The field value. */ void set(field name, string_view const& value); void set(field, std::nullptr_t) = delete; /** Set a field value, removing any other instances of that field. First removes any values with matching field names, then inserts the new field value. @param name The field name. @param value The value of the field, as a @ref string_view */ void set(string_view name, string_view const& value); void set(string_view, std::nullptr_t) = delete; /** Remove a field. References and iterators to the erased elements are invalidated. Other references and iterators are not affected. @param pos An iterator to the element to remove. @return An iterator following the last removed element. If the iterator refers to the last element, the end() iterator is returned. */ const_iterator erase(const_iterator pos); /** Remove all fields with the specified name. All fields with the same field name are erased from the container. References and iterators to the erased elements are invalidated. Other references and iterators are not affected. @param name The field name. @return The number of fields removed. */ std::size_t erase(field name); /** Remove all fields with the specified name. All fields with the same field name are erased from the container. References and iterators to the erased elements are invalidated. Other references and iterators are not affected. @param name The field name. @return The number of fields removed. */ std::size_t erase(string_view name); /** Return a buffer sequence representing the trailers. This function returns a buffer sequence holding the serialized representation of the trailer fields promised in the Accept field. Before calling this function the Accept field must contain the exact trailer fields desired. Each field must also exist. */ /// Swap this container with another void swap(basic_fields& other); /// Swap two field containers template<class Alloc> friend void swap(basic_fields<Alloc>& lhs, basic_fields<Alloc>& rhs); //-------------------------------------------------------------------------- // // Lookup // //-------------------------------------------------------------------------- /** Return the number of fields with the specified name. @param name The field name. */ std::size_t count(field name) const; /** Return the number of fields with the specified name. @param name The field name. */ std::size_t count(string_view name) const; /** Returns an iterator to the case-insensitive matching field. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The field name. @return An iterator to the matching field, or `end()` if no match was found. */ const_iterator find(field name) const; /** Returns an iterator to the case-insensitive matching field name. If more than one field with the specified name exists, the first field defined by insertion order is returned. @param name The field name. @return An iterator to the matching field, or `end()` if no match was found. */ const_iterator find(string_view name) const; /** Returns a range of iterators to the fields with the specified name. @param name The field name. @return A range of iterators to fields with the same name, otherwise an empty range. */ std::pair<const_iterator, const_iterator> equal_range(field name) const; /** Returns a range of iterators to the fields with the specified name. @param name The field name. @return A range of iterators to fields with the same name, otherwise an empty range. */ std::pair<const_iterator, const_iterator> equal_range(string_view name) const; //-------------------------------------------------------------------------- // // Observers // //-------------------------------------------------------------------------- /// Returns a copy of the key comparison function key_compare key_comp() const { return key_compare{}; } protected: /** Returns the request-method string. @note Only called for requests. */ string_view get_method_impl() const; /** Returns the request-target string. @note Only called for requests. */ string_view get_target_impl() const; /** Returns the response reason-phrase string. @note Only called for responses. */ string_view get_reason_impl() const; /** Returns the chunked Transfer-Encoding setting */ bool get_chunked_impl() const; /** Returns the keep-alive setting */ bool get_keep_alive_impl(unsigned version) const; /** Returns `true` if the Content-Length field is present. */ bool has_content_length_impl() const; /** Set or clear the method string. @note Only called for requests. */ void set_method_impl(string_view s); /** Set or clear the target string. @note Only called for requests. */ void set_target_impl(string_view s); /** Set or clear the reason string. @note Only called for responses. */ void set_reason_impl(string_view s); /** Adjusts the chunked Transfer-Encoding value */ void set_chunked_impl(bool value); /** Sets or clears the Content-Length field */ void set_content_length_impl( boost::optional<std::uint64_t> const& value); /** Adjusts the Connection field */ void set_keep_alive_impl( unsigned version, bool keep_alive); private: template<class OtherAlloc> friend class basic_fields; element& new_element(field name, string_view sname, string_view value); void delete_element(element& e); void set_element(element& e); void realloc_string(string_view& dest, string_view s); void realloc_target( string_view& dest, string_view s); template<class OtherAlloc> void copy_all(basic_fields<OtherAlloc> const&); void clear_all(); void delete_list(); void move_assign(basic_fields&, std::true_type); void move_assign(basic_fields&, std::false_type); void copy_assign(basic_fields const&, std::true_type); void copy_assign(basic_fields const&, std::false_type); void swap(basic_fields& other, std::true_type); void swap(basic_fields& other, std::false_type); set_t set_; list_t list_; string_view method_; string_view target_or_reason_; }; /// A typical HTTP header fields container using fields = basic_fields<std::allocator<char>>; } // http } // beast } // boost #include <boost/beast/http/impl/fields.hpp> #endif PK PP�[C�H��d �d http/write.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_WRITE_HPP #define BOOST_BEAST_HTTP_WRITE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/serializer.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/beast/http/detail/chunk_encode.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/asio/async_result.hpp> #include <iosfwd> #include <limits> #include <memory> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { /** Write part of a message to a stream using a serializer. This function is used to write part of a message to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li One or more bytes have been transferred. @li The function @ref serializer::is_done returns `true` @li An error occurs on the stream. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The amount of data actually transferred is controlled by the behavior of the underlying stream, subject to the buffer size limit of the serializer obtained or set through a call to @ref serializer::limit. Setting a limit and performing bounded work helps applications set reasonable timeouts. It also allows application-level flow control to function correctly. For example when using a TCP/IP based stream. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @return The number of bytes written to the stream. @throws system_error Thrown on failure. @see serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_some( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr); /** Write part of a message to a stream using a serializer. This function is used to write part of a message to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li One or more bytes have been transferred. @li The function @ref serializer::is_done returns `true` @li An error occurs on the stream. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The amount of data actually transferred is controlled by the behavior of the underlying stream, subject to the buffer size limit of the serializer obtained or set through a call to @ref serializer::limit. Setting a limit and performing bounded work helps applications set reasonable timeouts. It also allows application-level flow control to function correctly. For example when using a TCP/IP based stream. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @param ec Set to indicate what error occurred, if any. @return The number of bytes written to the stream. @see async_write_some, serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_some( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec); /** Write part of a message to a stream asynchronously using a serializer. This function is used to write part of a message to a stream asynchronously using a caller-provided HTTP/1 serializer. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li One or more bytes have been transferred. @li The function @ref serializer::is_done returns `true` @li An error occurs on the stream. This operation is implemented in terms of zero or more calls to the stream's `async_write_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other writes until this operation completes. The amount of data actually transferred is controlled by the behavior of the underlying stream, subject to the buffer size limit of the serializer obtained or set through a call to @ref serializer::limit. Setting a limit and performing bounded work helps applications set reasonable timeouts. It also allows application-level flow control to function correctly. For example when using a TCP/IP based stream. @param stream The stream to which the data is to be written. The type must support the <em>AsyncWriteStream</em> concept. @param sr The serializer to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the number of bytes written to the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see serializer */ template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type<AsyncWriteStream>>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_some( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler = net::default_completion_token_t< executor_type<AsyncWriteStream>>{}); //------------------------------------------------------------------------------ /** Write a header to a stream using a serializer. This function is used to write a header to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li The function @ref serializer::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @return The number of bytes written to the stream. @throws system_error Thrown on failure. @note The implementation will call @ref serializer::split with the value `true` on the serializer passed in. @see serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_header( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr); /** Write a header to a stream using a serializer. This function is used to write a header to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li The function @ref serializer::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @param ec Set to indicate what error occurred, if any. @return The number of bytes written to the stream. @note The implementation will call @ref serializer::split with the value `true` on the serializer passed in. @see serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write_header( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec); /** Write a header to a stream asynchronously using a serializer. This function is used to write a header to a stream asynchronously using a caller-provided HTTP/1 serializer. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The function @ref serializer::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of zero or more calls to the stream's `async_write_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other writes until this operation completes. @param stream The stream to which the data is to be written. The type must support the <em>AsyncWriteStream</em> concept. @param sr The serializer to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the number of bytes written to the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The implementation will call @ref serializer::split with the value `true` on the serializer passed in. @see serializer */ template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type<AsyncWriteStream>>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write_header( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler = net::default_completion_token_t< executor_type<AsyncWriteStream>>{}); //------------------------------------------------------------------------------ /** Write a complete message to a stream using a serializer. This function is used to write a complete message to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li The function @ref serializer::is_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @return The number of bytes written to the stream. @throws system_error Thrown on failure. @see serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr); /** Write a complete message to a stream using a serializer. This function is used to write a complete message to a stream using a caller-provided HTTP/1 serializer. The call will block until one of the following conditions is true: @li The function @ref serializer::is_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param sr The serializer to use. @param ec Set to the error, if any occurred. @return The number of bytes written to the stream. @see serializer */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> std::size_t write( SyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, error_code& ec); /** Write a complete message to a stream asynchronously using a serializer. This function is used to write a complete message to a stream asynchronously using a caller-provided HTTP/1 serializer. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The function @ref serializer::is_done returns `true` @li An error occurs. This operation is implemented in terms of zero or more calls to the stream's `async_write_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other writes until this operation completes. @param stream The stream to which the data is to be written. The type must support the <em>AsyncWriteStream</em> concept. @param sr The serializer to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the number of bytes written to the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see serializer */ template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type<AsyncWriteStream>>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, serializer<isRequest, Body, Fields>& sr, WriteHandler&& handler = net::default_completion_token_t< executor_type<AsyncWriteStream>>{}); //------------------------------------------------------------------------------ /** Write a complete message to a stream. This function is used to write a complete message to a stream using HTTP/1. The call will block until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `true`. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param msg The message to write. @return The number of bytes written to the stream. @throws system_error Thrown on failure. @see message */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> #if BOOST_BEAST_DOXYGEN std::size_t #else typename std::enable_if< is_mutable_body_writer<Body>::value, std::size_t>::type #endif write( SyncWriteStream& stream, message<isRequest, Body, Fields>& msg); /** Write a complete message to a stream. This function is used to write a complete message to a stream using HTTP/1. The call will block until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `false`. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param msg The message to write. @return The number of bytes written to the stream. @throws system_error Thrown on failure. @see message */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> #if BOOST_BEAST_DOXYGEN std::size_t #else typename std::enable_if< ! is_mutable_body_writer<Body>::value, std::size_t>::type #endif write( SyncWriteStream& stream, message<isRequest, Body, Fields> const& msg); /** Write a complete message to a stream. This function is used to write a complete message to a stream using HTTP/1. The call will block until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `true`. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param msg The message to write. @param ec Set to the error, if any occurred. @return The number of bytes written to the stream. @see message */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> #if BOOST_BEAST_DOXYGEN std::size_t #else typename std::enable_if< is_mutable_body_writer<Body>::value, std::size_t>::type #endif write( SyncWriteStream& stream, message<isRequest, Body, Fields>& msg, error_code& ec); /** Write a complete message to a stream. This function is used to write a complete message to a stream using HTTP/1. The call will block until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `write_some` function. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `false`. @param stream The stream to which the data is to be written. The type must support the <em>SyncWriteStream</em> concept. @param msg The message to write. @param ec Set to the error, if any occurred. @return The number of bytes written to the stream. @see message */ template< class SyncWriteStream, bool isRequest, class Body, class Fields> #if BOOST_BEAST_DOXYGEN std::size_t #else typename std::enable_if< ! is_mutable_body_writer<Body>::value, std::size_t>::type #endif write( SyncWriteStream& stream, message<isRequest, Body, Fields> const& msg, error_code& ec); /** Write a complete message to a stream asynchronously. This function is used to write a complete message to a stream asynchronously using HTTP/1. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of zero or more calls to the stream's `async_write_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other writes until this operation completes. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `true`. @param stream The stream to which the data is to be written. The type must support the <em>AsyncWriteStream</em> concept. @param msg The message to write. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the number of bytes written to the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see message */ template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type<AsyncWriteStream>>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, message<isRequest, Body, Fields>& msg, WriteHandler&& handler = net::default_completion_token_t< executor_type<AsyncWriteStream>>{} #ifndef BOOST_BEAST_DOXYGEN , typename std::enable_if< is_mutable_body_writer<Body>::value>::type* = 0 #endif ); /** Write a complete message to a stream asynchronously. This function is used to write a complete message to a stream asynchronously using HTTP/1. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The entire message is written. @li An error occurs. This operation is implemented in terms of zero or more calls to the stream's `async_write_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other writes until this operation completes. The algorithm will use a temporary @ref serializer with an empty chunk decorator to produce buffers. @note This function only participates in overload resolution if @ref is_mutable_body_writer for <em>Body</em> returns `false`. @param stream The stream to which the data is to be written. The type must support the <em>AsyncWriteStream</em> concept. @param msg The message to write. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the number of bytes written to the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @see message */ template< class AsyncWriteStream, bool isRequest, class Body, class Fields, BOOST_BEAST_ASYNC_TPARAM2 WriteHandler = net::default_completion_token_t< executor_type<AsyncWriteStream>>> BOOST_BEAST_ASYNC_RESULT2(WriteHandler) async_write( AsyncWriteStream& stream, message<isRequest, Body, Fields> const& msg, WriteHandler&& handler = net::default_completion_token_t< executor_type<AsyncWriteStream>>{} #ifndef BOOST_BEAST_DOXYGEN , typename std::enable_if< ! is_mutable_body_writer<Body>::value>::type* = 0 #endif ); //------------------------------------------------------------------------------ /** Serialize an HTTP/1 header to a `std::ostream`. The function converts the header to its HTTP/1 serialized representation and stores the result in the output stream. @param os The output stream to write to. @param msg The message fields to write. */ template<bool isRequest, class Fields> std::ostream& operator<<(std::ostream& os, header<isRequest, Fields> const& msg); /** Serialize an HTTP/1 message to a `std::ostream`. The function converts the message to its HTTP/1 serialized representation and stores the result in the output stream. The implementation will automatically perform chunk encoding if the contents of the message indicate that chunk encoding is required. @param os The output stream to write to. @param msg The message to write. */ template<bool isRequest, class Body, class Fields> std::ostream& operator<<(std::ostream& os, message<isRequest, Body, Fields> const& msg); } // http } // beast } // boost #include <boost/beast/http/impl/write.hpp> #endif PK PP�[@ɥ0 http/vector_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_VECTOR_BODY_HPP #define BOOST_BEAST_HTTP_VECTOR_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> #include <cstdint> #include <limits> #include <memory> #include <stdexcept> #include <string> #include <utility> namespace boost { namespace beast { namespace http { /** A <em>Body</em> using `std::vector` This body uses `std::vector` as a memory-based container for holding message payloads. Messages using this body type may be serialized and parsed. */ template<class T, class Allocator = std::allocator<T>> struct vector_body { private: static_assert(sizeof(T) == 1, "T requirements not met"); public: /** The type of container used for the body This determines the type of @ref message::body when this body type is used with a message container. */ using value_type = std::vector<T, Allocator>; /** Returns the payload size of the body When this body is used with @ref message::prepare_payload, the Content-Length will be set to the payload size, and any chunked Transfer-Encoding will be removed. */ static std::uint64_t size(value_type const& body) { return body.size(); } /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional< std::uint64_t> const& length, error_code& ec) { if(length) { if(*length > body_.max_size()) { ec = error::buffer_overflow; return; } body_.reserve(beast::detail::clamp(*length)); } ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { auto const n = buffer_bytes(buffers); auto const len = body_.size(); if (n > body_.max_size() - len) { ec = error::buffer_overflow; return 0; } body_.resize(len + n); ec = {}; return net::buffer_copy(net::buffer( &body_[0] + len, n), buffers); } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer { value_type const& body_; public: using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const& b) : body_(b) { } void init(error_code& ec) { ec = {}; } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { ec = {}; return {{const_buffers_type{ body_.data(), body_.size()}, false}}; } }; #endif }; } // http } // beast } // boost #endif PK PP�[�:;� http/string_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_STRING_BODY_HPP #define BOOST_BEAST_HTTP_STRING_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/core/buffers_range.hpp> #include <boost/beast/core/detail/clamp.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> #include <cstdint> #include <limits> #include <memory> #include <stdexcept> #include <string> #include <utility> namespace boost { namespace beast { namespace http { /** A <em>Body</em> using `std::basic_string` This body uses `std::basic_string` as a memory-based container for holding message payloads. Messages using this body type may be serialized and parsed. */ template< class CharT, class Traits = std::char_traits<CharT>, class Allocator = std::allocator<CharT>> struct basic_string_body { private: static_assert( std::is_integral<CharT>::value && sizeof(CharT) == 1, "CharT requirements not met"); public: /** The type of container used for the body This determines the type of @ref message::body when this body type is used with a message container. */ using value_type = std::basic_string<CharT, Traits, Allocator>; /** Returns the payload size of the body When this body is used with @ref message::prepare_payload, the Content-Length will be set to the payload size, and any chunked Transfer-Encoding will be removed. */ static std::uint64_t size(value_type const& body) { return body.size(); } /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional< std::uint64_t> const& length, error_code& ec) { if(length) { if(*length > body_.max_size()) { ec = error::buffer_overflow; return; } body_.reserve(beast::detail::clamp(*length)); } ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { auto const extra = buffer_bytes(buffers); auto const size = body_.size(); if (extra > body_.max_size() - size) { ec = error::buffer_overflow; return 0; } body_.resize(size + extra); ec = {}; CharT* dest = &body_[size]; for(auto b : beast::buffers_range_ref(buffers)) { Traits::copy(dest, static_cast< CharT const*>(b.data()), b.size()); dest += b.size(); } return extra; } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer { value_type const& body_; public: using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const& b) : body_(b) { } void init(error_code& ec) { ec = {}; } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { ec = {}; return {{const_buffers_type{ body_.data(), body_.size()}, false}}; } }; #endif }; /// A <em>Body</em> using `std::string` using string_body = basic_string_body<char>; } // http } // beast } // boost #endif PK PP�[z�5 5 http/error.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_ERROR_HPP #define BOOST_BEAST_HTTP_ERROR_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> namespace boost { namespace beast { namespace http { /// Error codes returned from HTTP algorithms and operations. enum class error { /** The end of the stream was reached. This error is returned when attempting to read HTTP data, and the stream returns the error `net::error::eof` before any octets corresponding to a new HTTP message have been received. */ end_of_stream = 1, /** The incoming message is incomplete. This happens when the end of stream is reached during parsing and some octets have been received, but not the entire message. */ partial_message, /** Additional buffers are required. This error is returned during parsing when additional octets are needed. The caller should append more data to the existing buffer and retry the parse operaetion. */ need_more, /** An unexpected body was encountered during parsing. This error is returned when attempting to parse body octets into a message container which has the @ref empty_body body type. @see empty_body */ unexpected_body, /** Additional buffers are required. This error is returned under the following conditions: @li During serialization when using @ref buffer_body. The caller should update the body to point to a new buffer or indicate that there are no more octets in the body. @li During parsing when using @ref buffer_body. The caller should update the body to point to a new storage area to receive additional body octets. */ need_buffer, /** The end of a chunk was reached */ end_of_chunk, /** Buffer maximum exceeded. This error is returned when reading HTTP content into a dynamic buffer, and the operation would exceed the maximum size of the buffer. */ buffer_overflow, /** Header limit exceeded. The parser detected an incoming message header which exceeded a configured limit. */ header_limit, /** Body limit exceeded. The parser detected an incoming message body which exceeded a configured limit. */ body_limit, /** A memory allocation failed. When basic_fields throws std::bad_alloc, it is converted into this error by @ref parser. */ bad_alloc, // // (parser errors) // /// The line ending was malformed bad_line_ending, /// The method is invalid. bad_method, /// The request-target is invalid. bad_target, /// The HTTP-version is invalid. bad_version, /// The status-code is invalid. bad_status, /// The reason-phrase is invalid. bad_reason, /// The field name is invalid. bad_field, /// The field value is invalid. bad_value, /// The Content-Length is invalid. bad_content_length, /// The Transfer-Encoding is invalid. bad_transfer_encoding, /// The chunk syntax is invalid. bad_chunk, /// The chunk extension is invalid. bad_chunk_extension, /// An obs-fold exceeded an internal limit. bad_obs_fold, /** The parser is stale. This happens when attempting to re-use a parser that has already completed parsing a message. Programs must construct a new parser for each message. This can be easily done by storing the parser in an boost or std::optional container. */ stale_parser, /** The message body is shorter than expected. This error is returned by @ref file_body when an unexpected unexpected end-of-file condition is encountered while trying to read from the file. */ short_read }; } // http } // beast } // boost #include <boost/beast/http/impl/error.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/error.ipp> #endif #endif PK PP�[�Q&t- - http/span_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_SPAN_BODY_HPP #define BOOST_BEAST_HTTP_SPAN_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/core/span.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace http { /** A <em>Body</em> using @ref span This body uses @ref span as a memory-based container for holding message payloads. The container represents a non-owning reference to a contiguous area of memory. Messages using this body type may be serialized and parsed. Unlike @ref buffer_body, only one buffer may be provided during a parse or serialize operation. */ template<class T> struct span_body { private: static_assert( std::is_trivial<T>::value && std::is_standard_layout<T>::value, "POD requirements not met"); public: /** The type of container used for the body This determines the type of @ref message::body when this body type is used with a message container. */ using value_type = span<T>; /** Returns the payload size of the body When this body is used with @ref message::prepare_payload, the Content-Length will be set to the payload size, and any chunked Transfer-Encoding will be removed. */ static std::uint64_t size(value_type const& body) { return body.size(); } /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional< std::uint64_t> const& length, error_code& ec) { if(length && *length > body_.size()) { ec = error::buffer_overflow; return; } ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { auto const n = buffer_bytes(buffers); auto const len = body_.size(); if(n > len) { ec = error::buffer_overflow; return 0; } ec = {}; net::buffer_copy(net::buffer( body_.data(), n), buffers); body_ = value_type{ body_.data() + n, body_.size() - n}; return n; } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer { value_type const& body_; public: using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const& b) : body_(b) { } void init(error_code& ec) { ec = {}; } boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec) { ec = {}; return {{ { body_.data(), body_.size() * sizeof(typename value_type::value_type)}, false}}; } }; #endif }; } // http } // beast } // boost #endif PK PP�[`���j7 j7 http/parser.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_PARSER_HPP #define BOOST_BEAST_HTTP_PARSER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/basic_parser.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <functional> #include <memory> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { /** An HTTP/1 parser for producing a message. This class uses the basic HTTP/1 wire format parser to convert a series of octets into a @ref message using the @ref basic_fields container to represent the fields. @tparam isRequest Indicates whether a request or response will be parsed. @tparam Body The type used to represent the body. This must meet the requirements of <em>Body</em>. @tparam Allocator The type of allocator used with the @ref basic_fields container. @note A new instance of the parser is required for each message. */ template< bool isRequest, class Body, class Allocator = std::allocator<char>> class parser : public basic_parser<isRequest> { static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_reader<Body>::value, "BodyReader type requirements not met"); template<bool, class, class> friend class parser; message<isRequest, Body, basic_fields<Allocator>> m_; typename Body::reader rd_; bool rd_inited_ = false; bool used_ = false; std::function<void( std::uint64_t, string_view, error_code&)> cb_h_; std::function<std::size_t( std::uint64_t, string_view, error_code&)> cb_b_; public: /// The type of message returned by the parser using value_type = message<isRequest, Body, basic_fields<Allocator>>; /// Destructor ~parser() = default; /// Constructor (disallowed) parser(parser const&) = delete; /// Assignment (disallowed) parser& operator=(parser const&) = delete; /// Constructor (disallowed) parser(parser&& other) = delete; /// Constructor parser(); /** Constructor @param args Optional arguments forwarded to the @ref http::message constructor. @note This function participates in overload resolution only if the first argument is not a @ref parser. */ #if BOOST_BEAST_DOXYGEN template<class... Args> explicit parser(Args&&... args); #else template<class Arg1, class... ArgN, class = typename std::enable_if< ! detail::is_parser<typename std::decay<Arg1>::type>::value>::type> explicit parser(Arg1&& arg1, ArgN&&... argn); #endif /** Construct a parser from another parser, changing the Body type. This constructs a new parser by move constructing the header from another parser with a different body type. The constructed-from parser must not have any parsed body octets or initialized <em>BodyReader</em>, otherwise an exception is generated. @par Example @code // Deferred body type commitment request_parser<empty_body> req0; ... request_parser<string_body> req{std::move(req0)}; @endcode If an exception is thrown, the state of the constructed-from parser is undefined. @param parser The other parser to construct from. After this call returns, the constructed-from parser may only be destroyed. @param args Optional arguments forwarded to the message constructor. @throws std::invalid_argument Thrown when the constructed-from parser has already initialized a body reader. @note This function participates in overload resolution only if the other parser uses a different body type. */ #if BOOST_BEAST_DOXYGEN template<class OtherBody, class... Args> #else template<class OtherBody, class... Args, class = typename std::enable_if< ! std::is_same<Body, OtherBody>::value>::type> #endif explicit parser(parser<isRequest, OtherBody, Allocator>&& parser, Args&&... args); /** Returns the parsed message. Depending on the parser's progress, parts of this object may be incomplete. */ value_type const& get() const { return m_; } /** Returns the parsed message. Depending on the parser's progress, parts of this object may be incomplete. */ value_type& get() { return m_; } /** Returns ownership of the parsed message. Ownership is transferred to the caller. Depending on the parser's progress, parts of this object may be incomplete. @par Requires @ref value_type is @b MoveConstructible */ value_type release() { static_assert(std::is_move_constructible<decltype(m_)>::value, "MoveConstructible requirements not met"); return std::move(m_); } /** Set a callback to be invoked on each chunk header. The callback will be invoked once for every chunk in the message payload, as well as once for the last chunk. The invocation happens after the chunk header is available but before any body octets have been parsed. The extensions are provided in raw, validated form, use @ref chunk_extensions::parse to parse the extensions into a structured container for easier access. The implementation type-erases the callback without requiring a dynamic allocation. For this reason, the callback object is passed by a non-constant reference. @par Example @code auto callback = [](std::uint64_t size, string_view extensions, error_code& ec) { //... }; parser.on_chunk_header(callback); @endcode @param cb The function to set, which must be invocable with this equivalent signature: @code void on_chunk_header( std::uint64_t size, // Size of the chunk, zero for the last chunk string_view extensions, // The chunk-extensions in raw form error_code& ec); // May be set by the callback to indicate an error @endcode */ template<class Callback> void on_chunk_header(Callback& cb) { // Callback may not be constant, caller is responsible for // managing the lifetime of the callback. Copies are not made. BOOST_STATIC_ASSERT(! std::is_const<Callback>::value); // Can't set the callback after receiving any chunk data! BOOST_ASSERT(! rd_inited_); cb_h_ = std::ref(cb); } /** Set a callback to be invoked on chunk body data The provided function object will be invoked one or more times to provide buffers corresponding to the chunk body for the current chunk. The callback receives the number of octets remaining in this chunk body including the octets in the buffer provided. The callback must return the number of octets actually consumed. Any octets not consumed will be presented again in a subsequent invocation of the callback. The implementation type-erases the callback without requiring a dynamic allocation. For this reason, the callback object is passed by a non-constant reference. @par Example @code auto callback = [](std::uint64_t remain, string_view body, error_code& ec) { //... }; parser.on_chunk_body(callback); @endcode @param cb The function to set, which must be invocable with this equivalent signature: @code std::size_t on_chunk_header( std::uint64_t remain, // Octets remaining in this chunk, includes `body` string_view body, // A buffer holding some or all of the remainder of the chunk body error_code& ec); // May be set by the callback to indicate an error @endcode */ template<class Callback> void on_chunk_body(Callback& cb) { // Callback may not be constant, caller is responsible for // managing the lifetime of the callback. Copies are not made. BOOST_STATIC_ASSERT(! std::is_const<Callback>::value); // Can't set the callback after receiving any chunk data! BOOST_ASSERT(! rd_inited_); cb_b_ = std::ref(cb); } private: parser(std::true_type); parser(std::false_type); template<class OtherBody, class... Args, class = typename std::enable_if< ! std::is_same<Body, OtherBody>::value>::type> parser( std::true_type, parser<isRequest, OtherBody, Allocator>&& parser, Args&&... args); template<class OtherBody, class... Args, class = typename std::enable_if< ! std::is_same<Body, OtherBody>::value>::type> parser( std::false_type, parser<isRequest, OtherBody, Allocator>&& parser, Args&&... args); template<class Arg1, class... ArgN, class = typename std::enable_if< ! detail::is_parser<typename std::decay<Arg1>::type>::value>::type> explicit parser(Arg1&& arg1, std::true_type, ArgN&&... argn); template<class Arg1, class... ArgN, class = typename std::enable_if< ! detail::is_parser<typename std::decay<Arg1>::type>::value>::type> explicit parser(Arg1&& arg1, std::false_type, ArgN&&... argn); void on_request_impl( verb method, string_view method_str, string_view target, int version, error_code& ec, std::true_type) { // If this assert goes off, it means you tried to re-use a // parser after it was done reading a message. This is not // allowed, you need to create a new parser for each message. // The easiest way to do that is to store the parser in // an optional object. BOOST_ASSERT(! used_); if(used_) { ec = error::stale_parser; return; } used_ = true; m_.target(target); if(method != verb::unknown) m_.method(method); else m_.method_string(method_str); m_.version(version); } void on_request_impl( verb, string_view, string_view, int, error_code&, std::false_type) { } void on_request_impl( verb method, string_view method_str, string_view target, int version, error_code& ec) override { this->on_request_impl( method, method_str, target, version, ec, std::integral_constant<bool, isRequest>{}); } void on_response_impl( int code, string_view reason, int version, error_code& ec, std::true_type) { // If this assert goes off, it means you tried to re-use a // parser after it was done reading a message. This is not // allowed, you need to create a new parser for each message. // The easiest way to do that is to store the parser in // an optional object. BOOST_ASSERT(! used_); if(used_) { ec = error::stale_parser; return; } used_ = true; m_.result(code); m_.version(version); m_.reason(reason); } void on_response_impl( int, string_view, int, error_code&, std::false_type) { } void on_response_impl( int code, string_view reason, int version, error_code& ec) override { this->on_response_impl( code, reason, version, ec, std::integral_constant<bool, ! isRequest>{}); } void on_field_impl( field name, string_view name_string, string_view value, error_code&) override { m_.insert(name, name_string, value); } void on_header_impl(error_code& ec) override { ec = {}; } void on_body_init_impl( boost::optional<std::uint64_t> const& content_length, error_code& ec) override { rd_.init(content_length, ec); rd_inited_ = true; } std::size_t on_body_impl( string_view body, error_code& ec) override { return rd_.put(net::buffer( body.data(), body.size()), ec); } void on_chunk_header_impl( std::uint64_t size, string_view extensions, error_code& ec) override { if(cb_h_) return cb_h_(size, extensions, ec); } std::size_t on_chunk_body_impl( std::uint64_t remain, string_view body, error_code& ec) override { if(cb_b_) return cb_b_(remain, body, ec); return rd_.put(net::buffer( body.data(), body.size()), ec); } void on_finish_impl( error_code& ec) override { rd_.finish(ec); } }; /// An HTTP/1 parser for producing a request message. template<class Body, class Allocator = std::allocator<char>> using request_parser = parser<true, Body, Allocator>; /// An HTTP/1 parser for producing a response message. template<class Body, class Allocator = std::allocator<char>> using response_parser = parser<false, Body, Allocator>; } // http } // beast } // boost #include <boost/beast/http/impl/parser.hpp> #endif PK PP�[�Pj��m �m http/message.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_MESSAGE_HPP #define BOOST_BEAST_HTTP_MESSAGE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/fields.hpp> #include <boost/beast/http/verb.hpp> #include <boost/beast/http/status.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/beast/core/string.hpp> #include <boost/core/empty_value.hpp> #include <boost/mp11/integer_sequence.hpp> #include <boost/assert.hpp> #include <boost/optional.hpp> #include <boost/throw_exception.hpp> #include <memory> #include <stdexcept> #include <string> #include <tuple> #include <utility> namespace boost { namespace beast { namespace http { /** A container for an HTTP request or response header. This container is derived from the `Fields` template type. To understand all of the members of this class it is necessary to view the declaration for the `Fields` type. When using the default fields container, those declarations are in @ref fields. Newly constructed header objects have version set to HTTP/1.1. Newly constructed response objects also have result code set to @ref status::ok. A `header` includes the start-line and header-fields. */ #if BOOST_BEAST_DOXYGEN template<bool isRequest, class Fields = fields> class header : public Fields #else template<bool isRequest, class Fields = fields> class header; template<class Fields> class header<true, Fields> : public Fields #endif { public: static_assert(is_fields<Fields>::value, "Fields type requirements not met"); /// Indicates if the header is a request or response. #if BOOST_BEAST_DOXYGEN using is_request = std::integral_constant<bool, isRequest>; #else using is_request = std::true_type; #endif /// The type representing the fields. using fields_type = Fields; /// Constructor header() = default; /// Constructor header(header&&) = default; /// Constructor header(header const&) = default; /// Assignment header& operator=(header&&) = default; /// Assignment header& operator=(header const&) = default; /** Return the HTTP-version. This holds both the major and minor version numbers, using these formulas: @code unsigned major = version / 10; unsigned minor = version % 10; @endcode Newly constructed headers will use HTTP/1.1 by default. */ unsigned version() const noexcept { return version_; } /** Set the HTTP-version. This holds both the major and minor version numbers, using these formulas: @code unsigned major = version / 10; unsigned minor = version % 10; @endcode Newly constructed headers will use HTTP/1.1 by default. @param value The version number to use */ void version(unsigned value) noexcept { BOOST_ASSERT(value > 0 && value < 100); version_ = value; } /** Return the request-method verb. If the request-method is not one of the recognized verbs, @ref verb::unknown is returned. Callers may use @ref method_string to retrieve the exact text. @note This function is only available when `isRequest == true`. @see method_string */ verb method() const; /** Set the request-method. This function will set the method for requests to a known verb. @param v The request method verb to set. This may not be @ref verb::unknown. @throws std::invalid_argument when `v == verb::unknown`. @note This function is only available when `isRequest == true`. */ void method(verb v); /** Return the request-method as a string. @note This function is only available when `isRequest == true`. @see method */ string_view method_string() const; /** Set the request-method. This function will set the request-method a known verb if the string matches, otherwise it will store a copy of the passed string. @param s A string representing the request-method. @note This function is only available when `isRequest == true`. */ void method_string(string_view s); /** Returns the request-target string. The request target string returned is the same string which was received from the network or stored. In particular, it will contain url-encoded characters and should follow the syntax rules for URIs used with HTTP. @note This function is only available when `isRequest == true`. */ string_view target() const; /** Set the request-target string. It is the caller's responsibility to ensure that the request target string follows the syntax rules for URIs used with HTTP. In particular, reserved or special characters must be url-encoded. The implementation does not perform syntax checking on the passed string. @param s A string representing the request-target. @note This function is only available when `isRequest == true`. */ void target(string_view s); // VFALCO Don't rearrange these declarations or // ifdefs, or else the documentation will break. /** Constructor @param args Arguments forwarded to the `Fields` base class constructor. @note This constructor participates in overload resolution if and only if the first parameter is not convertible to @ref header, @ref verb, or @ref status. */ #if BOOST_BEAST_DOXYGEN template<class... Args> explicit header(Args&&... args); #else template<class Arg1, class... ArgN, class = typename std::enable_if< ! std::is_convertible<typename std::decay<Arg1>::type, header>::value && ! std::is_convertible<typename std::decay<Arg1>::type, verb>::value && ! std::is_convertible<typename std::decay<Arg1>::type, status>::value >::type> explicit header(Arg1&& arg1, ArgN&&... argn); private: template<bool, class, class> friend class message; template<class T> friend void swap(header<true, T>& m1, header<true, T>& m2); template<class... FieldsArgs> header( verb method, string_view target_, unsigned version_value, FieldsArgs&&... fields_args) : Fields(std::forward<FieldsArgs>(fields_args)...) , method_(method) { version(version_value); target(target_); } unsigned version_ = 11; verb method_ = verb::unknown; }; /** A container for an HTTP request or response header. A `header` includes the start-line and header-fields. */ template<class Fields> class header<false, Fields> : public Fields { public: static_assert(is_fields<Fields>::value, "Fields type requirements not met"); /// Indicates if the header is a request or response. using is_request = std::false_type; /// The type representing the fields. using fields_type = Fields; /// Constructor. header() = default; /// Constructor header(header&&) = default; /// Constructor header(header const&) = default; /// Assignment header& operator=(header&&) = default; /// Assignment header& operator=(header const&) = default; /** Constructor @param args Arguments forwarded to the `Fields` base class constructor. @note This constructor participates in overload resolution if and only if the first parameter is not convertible to @ref header, @ref verb, or @ref status. */ template<class Arg1, class... ArgN, class = typename std::enable_if< ! std::is_convertible<typename std::decay<Arg1>::type, header>::value && ! std::is_convertible<typename std::decay<Arg1>::type, verb>::value && ! std::is_convertible<typename std::decay<Arg1>::type, status>::value >::type> explicit header(Arg1&& arg1, ArgN&&... argn); /** Return the HTTP-version. This holds both the major and minor version numbers, using these formulas: @code unsigned major = version / 10; unsigned minor = version % 10; @endcode Newly constructed headers will use HTTP/1.1 by default. */ unsigned version() const noexcept { return version_; } /** Set the HTTP-version. This holds both the major and minor version numbers, using these formulas: @code unsigned major = version / 10; unsigned minor = version % 10; @endcode Newly constructed headers will use HTTP/1.1 by default. @param value The version number to use */ void version(unsigned value) noexcept { BOOST_ASSERT(value > 0 && value < 100); version_ = value; } #endif /** The response status-code result. If the actual status code is not a known code, this function returns @ref status::unknown. Use @ref result_int to return the raw status code as a number. @note This member is only available when `isRequest == false`. */ status result() const; /** Set the response status-code. @param v The code to set. @note This member is only available when `isRequest == false`. */ void result(status v); /** Set the response status-code as an integer. This sets the status code to the exact number passed in. If the number does not correspond to one of the known status codes, the function @ref result will return @ref status::unknown. Use @ref result_int to obtain the original raw status-code. @param v The status-code integer to set. @throws std::invalid_argument if `v > 999`. */ void result(unsigned v); /** The response status-code expressed as an integer. This returns the raw status code as an integer, even when that code is not in the list of known status codes. @note This member is only available when `isRequest == false`. */ unsigned result_int() const; /** Return the response reason-phrase. The reason-phrase is obsolete as of rfc7230. @note This function is only available when `isRequest == false`. */ string_view reason() const; /** Set the response reason-phrase (deprecated) This function sets a custom reason-phrase to a copy of the string passed in. Normally it is not necessary to set the reason phrase on an outgoing response object; the implementation will automatically use the standard reason text for the corresponding status code. To clear a previously set custom phrase, pass an empty string. This will restore the default standard reason text based on the status code used when serializing. The reason-phrase is obsolete as of rfc7230. @param s The string to use for the reason-phrase. @note This function is only available when `isRequest == false`. */ void reason(string_view s); private: #if ! BOOST_BEAST_DOXYGEN template<bool, class, class> friend class message; template<class T> friend void swap(header<false, T>& m1, header<false, T>& m2); template<class... FieldsArgs> header( status result, unsigned version_value, FieldsArgs&&... fields_args) : Fields(std::forward<FieldsArgs>(fields_args)...) , result_(result) { version(version_value); } unsigned version_ = 11; status result_ = status::ok; #endif }; /// A typical HTTP request header template<class Fields = fields> using request_header = header<true, Fields>; /// A typical HTTP response header template<class Fields = fields> using response_header = header<false, Fields>; #if defined(BOOST_MSVC) // Workaround for MSVC bug with private base classes namespace detail { template<class T> using value_type_t = typename T::value_type; } // detail #endif /** A container for a complete HTTP message. This container is derived from the `Fields` template type. To understand all of the members of this class it is necessary to view the declaration for the `Fields` type. When using the default fields container, those declarations are in @ref fields. A message can be a request or response, depending on the `isRequest` template argument value. Requests and responses have different types; functions may be overloaded based on the type if desired. The `Body` template argument type determines the model used to read or write the content body of the message. Newly constructed messages objects have version set to HTTP/1.1. Newly constructed response objects also have result code set to @ref status::ok. @tparam isRequest `true` if this represents a request, or `false` if this represents a response. Some class data members are conditionally present depending on this value. @tparam Body A type meeting the requirements of Body. @tparam Fields The type of container used to hold the field value pairs. */ template<bool isRequest, class Body, class Fields = fields> class message : public header<isRequest, Fields> #if ! BOOST_BEAST_DOXYGEN , boost::empty_value< typename Body::value_type> #endif { public: /// The base class used to hold the header portion of the message. using header_type = header<isRequest, Fields>; /** The type providing the body traits. The @ref message::body member will be of type `body_type::value_type`. */ using body_type = Body; /// Constructor message() = default; /// Constructor message(message&&) = default; /// Constructor message(message const&) = default; /// Assignment message& operator=(message&&) = default; /// Assignment message& operator=(message const&) = default; /** Constructor @param h The header to move construct from. @param body_args Optional arguments forwarded to the `body` constructor. */ template<class... BodyArgs> explicit message(header_type&& h, BodyArgs&&... body_args); /** Constructor. @param h The header to copy construct from. @param body_args Optional arguments forwarded to the `body` constructor. */ template<class... BodyArgs> explicit message(header_type const& h, BodyArgs&&... body_args); /** Constructor @param method The request-method to use. @param target The request-target. @param version The HTTP-version. @note This function is only available when `isRequest == true`. */ #if BOOST_BEAST_DOXYGEN message(verb method, string_view target, unsigned version); #else template<class Version, class = typename std::enable_if<isRequest && std::is_convertible<Version, unsigned>::value>::type> message(verb method, string_view target, Version version); #endif /** Constructor @param method The request-method to use. @param target The request-target. @param version The HTTP-version. @param body_arg An argument forwarded to the `body` constructor. @note This function is only available when `isRequest == true`. */ #if BOOST_BEAST_DOXYGEN template<class BodyArg> message(verb method, string_view target, unsigned version, BodyArg&& body_arg); #else template<class Version, class BodyArg, class = typename std::enable_if<isRequest && std::is_convertible<Version, unsigned>::value>::type> message(verb method, string_view target, Version version, BodyArg&& body_arg); #endif /** Constructor @param method The request-method to use. @param target The request-target. @param version The HTTP-version. @param body_arg An argument forwarded to the `body` constructor. @param fields_arg An argument forwarded to the `Fields` constructor. @note This function is only available when `isRequest == true`. */ #if BOOST_BEAST_DOXYGEN template<class BodyArg, class FieldsArg> message(verb method, string_view target, unsigned version, BodyArg&& body_arg, FieldsArg&& fields_arg); #else template<class Version, class BodyArg, class FieldsArg, class = typename std::enable_if<isRequest && std::is_convertible<Version, unsigned>::value>::type> message(verb method, string_view target, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg); #endif /** Constructor @param result The status-code for the response. @param version The HTTP-version. @note This member is only available when `isRequest == false`. */ #if BOOST_BEAST_DOXYGEN message(status result, unsigned version); #else template<class Version, class = typename std::enable_if<! isRequest && std::is_convertible<Version, unsigned>::value>::type> message(status result, Version version); #endif /** Constructor @param result The status-code for the response. @param version The HTTP-version. @param body_arg An argument forwarded to the `body` constructor. @note This member is only available when `isRequest == false`. */ #if BOOST_BEAST_DOXYGEN template<class BodyArg> message(status result, unsigned version, BodyArg&& body_arg); #else template<class Version, class BodyArg, class = typename std::enable_if<! isRequest && std::is_convertible<Version, unsigned>::value>::type> message(status result, Version version, BodyArg&& body_arg); #endif /** Constructor @param result The status-code for the response. @param version The HTTP-version. @param body_arg An argument forwarded to the `body` constructor. @param fields_arg An argument forwarded to the `Fields` base class constructor. @note This member is only available when `isRequest == false`. */ #if BOOST_BEAST_DOXYGEN template<class BodyArg, class FieldsArg> message(status result, unsigned version, BodyArg&& body_arg, FieldsArg&& fields_arg); #else template<class Version, class BodyArg, class FieldsArg, class = typename std::enable_if<! isRequest && std::is_convertible<Version, unsigned>::value>::type> message(status result, Version version, BodyArg&& body_arg, FieldsArg&& fields_arg); #endif /** Constructor The header and body are default-constructed. */ explicit message(std::piecewise_construct_t); /** Construct a message. @param body_args A tuple forwarded as a parameter pack to the body constructor. */ template<class... BodyArgs> message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args); /** Construct a message. @param body_args A tuple forwarded as a parameter pack to the body constructor. @param fields_args A tuple forwarded as a parameter pack to the `Fields` constructor. */ template<class... BodyArgs, class... FieldsArgs> message(std::piecewise_construct_t, std::tuple<BodyArgs...> body_args, std::tuple<FieldsArgs...> fields_args); /// Returns the header portion of the message header_type const& base() const { return *this; } /// Returns the header portion of the message header_type& base() { return *this; } /// Returns `true` if the chunked Transfer-Encoding is specified bool chunked() const { return this->get_chunked_impl(); } /** Set or clear the chunked Transfer-Encoding This function will set or remove the "chunked" transfer encoding as the last item in the list of encodings in the field. If the result of removing the chunked token results in an empty string, the field is erased. The Content-Length field is erased unconditionally. */ void chunked(bool value); /** Returns `true` if the Content-Length field is present. This function inspects the fields and returns `true` if the Content-Length field is present. The properties of the body are not checked, this only looks for the field. */ bool has_content_length() const { return this->has_content_length_impl(); } /** Set or clear the Content-Length field This function adjusts the Content-Length field as follows: @li If `value` specifies a value, the Content-Length field is set to the value. Otherwise @li The Content-Length field is erased. If "chunked" token appears as the last item in the Transfer-Encoding field it is unconditionally removed. @param value The value to set for Content-Length. */ void content_length(boost::optional<std::uint64_t> const& value); /** Returns `true` if the message semantics indicate keep-alive The value depends on the version in the message, which must be set to the final value before this function is called or else the return value is unreliable. */ bool keep_alive() const { return this->get_keep_alive_impl(this->version()); } /** Set the keep-alive message semantic option This function adjusts the Connection field to indicate whether or not the connection should be kept open after the corresponding response. The result depends on the version set on the message, which must be set to the final value before making this call. @param value `true` if the connection should persist. */ void keep_alive(bool value) { this->set_keep_alive_impl(this->version(), value); } /** Returns `true` if the message semantics require an end of file. For HTTP requests, this function returns the logical NOT of a call to @ref keep_alive. For HTTP responses, this function returns the logical NOT of a call to @ref keep_alive if any of the following are true: @li @ref has_content_length would return `true` @li @ref chunked would return `true` @li @ref result returns @ref status::no_content @li @ref result returns @ref status::not_modified @li @ref result returns any informational status class (100 to 199) Otherwise, the function returns `true`. @see https://tools.ietf.org/html/rfc7230#section-3.3 */ bool need_eof() const { return need_eof(typename header_type::is_request{}); } /** Returns the payload size of the body in octets if possible. This function invokes the <em>Body</em> algorithm to measure the number of octets in the serialized body container. If there is no body, this will return zero. Otherwise, if the body exists but is not known ahead of time, `boost::none` is returned (usually indicating that a chunked Transfer-Encoding will be used). @note The value of the Content-Length field in the message is not inspected. */ boost::optional<std::uint64_t> payload_size() const; /** Prepare the message payload fields for the body. This function will adjust the Content-Length and Transfer-Encoding field values based on the properties of the body. @par Example @code request<string_body> req{verb::post, "/"}; req.set(field::user_agent, "Beast"); req.body() = "Hello, world!"; req.prepare_payload(); @endcode */ void prepare_payload() { prepare_payload(typename header_type::is_request{}); } /// Returns the body #if BOOST_BEAST_DOXYGEN || ! defined(BOOST_MSVC) typename body_type::value_type& #else detail::value_type_t<Body>& #endif body()& noexcept { return this->boost::empty_value< typename Body::value_type>::get(); } /// Returns the body #if BOOST_BEAST_DOXYGEN || ! defined(BOOST_MSVC) typename body_type::value_type&& #else detail::value_type_t<Body>&& #endif body()&& noexcept { return std::move( this->boost::empty_value< typename Body::value_type>::get()); } /// Returns the body #if BOOST_BEAST_DOXYGEN || ! defined(BOOST_MSVC) typename body_type::value_type const& #else detail::value_type_t<Body> const& #endif body() const& noexcept { return this->boost::empty_value< typename Body::value_type>::get(); } private: static_assert(is_body<Body>::value, "Body type requirements not met"); template< class... BodyArgs, std::size_t... IBodyArgs> message( std::piecewise_construct_t, std::tuple<BodyArgs...>& body_args, mp11::index_sequence<IBodyArgs...>) : boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>( std::get<IBodyArgs>(body_args))...) { boost::ignore_unused(body_args); } template< class... BodyArgs, class... FieldsArgs, std::size_t... IBodyArgs, std::size_t... IFieldsArgs> message( std::piecewise_construct_t, std::tuple<BodyArgs...>& body_args, std::tuple<FieldsArgs...>& fields_args, mp11::index_sequence<IBodyArgs...>, mp11::index_sequence<IFieldsArgs...>) : header_type(std::forward<FieldsArgs>( std::get<IFieldsArgs>(fields_args))...) , boost::empty_value< typename Body::value_type>(boost::empty_init_t(), std::forward<BodyArgs>( std::get<IBodyArgs>(body_args))...) { boost::ignore_unused(body_args); boost::ignore_unused(fields_args); } bool need_eof(std::true_type) const { return ! keep_alive(); } bool need_eof(std::false_type) const; boost::optional<std::uint64_t> payload_size(std::true_type) const { return Body::size(this->body()); } boost::optional<std::uint64_t> payload_size(std::false_type) const { return boost::none; } void prepare_payload(std::true_type); void prepare_payload(std::false_type); }; /// A typical HTTP request template<class Body, class Fields = fields> using request = message<true, Body, Fields>; /// A typical HTTP response template<class Body, class Fields = fields> using response = message<false, Body, Fields>; //------------------------------------------------------------------------------ #if BOOST_BEAST_DOXYGEN /** Swap two header objects. @par Requirements `Fields` is @b Swappable. */ template<bool isRequest, class Fields> void swap( header<isRequest, Fields>& m1, header<isRequest, Fields>& m2); #endif /** Swap two message objects. @par Requirements: `Body::value_type` and `Fields` are @b Swappable. */ template<bool isRequest, class Body, class Fields> void swap( message<isRequest, Body, Fields>& m1, message<isRequest, Body, Fields>& m2); } // http } // beast } // boost #include <boost/beast/http/impl/message.hpp> #endif PK PP�[���H H http/detail/type_traits.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_TYPE_TRAITS_HPP #define BOOST_BEAST_HTTP_DETAIL_TYPE_TRAITS_HPP #include <boost/beast/core/detail/type_traits.hpp> #include <boost/optional.hpp> #include <cstdint> namespace boost { namespace beast { namespace http { template<bool isRequest, class Fields> class header; template<bool, class, class> class message; template<bool isRequest, class Body, class Fields> class parser; namespace detail { template<class T> class is_header_impl { template<bool b, class F> static std::true_type check( header<b, F> const*); static std::false_type check(...); public: using type = decltype(check((T*)0)); }; template<class T> using is_header = typename is_header_impl<T>::type; template<class T> struct is_parser : std::false_type {}; template<bool isRequest, class Body, class Fields> struct is_parser<parser<isRequest, Body, Fields>> : std::true_type {}; struct fields_model { struct writer; string_view method() const; string_view reason() const; string_view target() const; protected: string_view get_method_impl() const; string_view get_target_impl() const; string_view get_reason_impl() const; bool get_chunked_impl() const; bool get_keep_alive_impl(unsigned) const; bool has_content_length_impl() const; void set_method_impl(string_view); void set_target_impl(string_view); void set_reason_impl(string_view); void set_chunked_impl(bool); void set_content_length_impl(boost::optional<std::uint64_t>); void set_keep_alive_impl(unsigned, bool); }; template<class T, class = beast::detail::void_t<>> struct has_value_type : std::false_type {}; template<class T> struct has_value_type<T, beast::detail::void_t< typename T::value_type > > : std::true_type {}; /** Determine if a <em>Body</em> type has a size This metafunction is equivalent to `std::true_type` if Body contains a static member function called `size`. */ template<class T, class = void> struct is_body_sized : std::false_type {}; template<class T> struct is_body_sized<T, beast::detail::void_t< typename T::value_type, decltype( std::declval<std::uint64_t&>() = T::size(std::declval<typename T::value_type const&>()) )>> : std::true_type {}; template<class T> struct is_fields_helper : T { template<class U = is_fields_helper> static auto f1(int) -> decltype( std::declval<string_view&>() = std::declval<U const&>().get_method_impl(), std::true_type()); static auto f1(...) -> std::false_type; using t1 = decltype(f1(0)); template<class U = is_fields_helper> static auto f2(int) -> decltype( std::declval<string_view&>() = std::declval<U const&>().get_target_impl(), std::true_type()); static auto f2(...) -> std::false_type; using t2 = decltype(f2(0)); template<class U = is_fields_helper> static auto f3(int) -> decltype( std::declval<string_view&>() = std::declval<U const&>().get_reason_impl(), std::true_type()); static auto f3(...) -> std::false_type; using t3 = decltype(f3(0)); template<class U = is_fields_helper> static auto f4(int) -> decltype( std::declval<bool&>() = std::declval<U const&>().get_chunked_impl(), std::true_type()); static auto f4(...) -> std::false_type; using t4 = decltype(f4(0)); template<class U = is_fields_helper> static auto f5(int) -> decltype( std::declval<bool&>() = std::declval<U const&>().get_keep_alive_impl( std::declval<unsigned>()), std::true_type()); static auto f5(...) -> std::false_type; using t5 = decltype(f5(0)); template<class U = is_fields_helper> static auto f6(int) -> decltype( std::declval<bool&>() = std::declval<U const&>().has_content_length_impl(), std::true_type()); static auto f6(...) -> std::false_type; using t6 = decltype(f6(0)); template<class U = is_fields_helper> static auto f7(int) -> decltype( void(std::declval<U&>().set_method_impl(std::declval<string_view>())), std::true_type()); static auto f7(...) -> std::false_type; using t7 = decltype(f7(0)); template<class U = is_fields_helper> static auto f8(int) -> decltype( void(std::declval<U&>().set_target_impl(std::declval<string_view>())), std::true_type()); static auto f8(...) -> std::false_type; using t8 = decltype(f8(0)); template<class U = is_fields_helper> static auto f9(int) -> decltype( void(std::declval<U&>().set_reason_impl(std::declval<string_view>())), std::true_type()); static auto f9(...) -> std::false_type; using t9 = decltype(f9(0)); template<class U = is_fields_helper> static auto f10(int) -> decltype( void(std::declval<U&>().set_chunked_impl(std::declval<bool>())), std::true_type()); static auto f10(...) -> std::false_type; using t10 = decltype(f10(0)); template<class U = is_fields_helper> static auto f11(int) -> decltype( void(std::declval<U&>().set_content_length_impl( std::declval<boost::optional<std::uint64_t>>())), std::true_type()); static auto f11(...) -> std::false_type; using t11 = decltype(f11(0)); template<class U = is_fields_helper> static auto f12(int) -> decltype( void(std::declval<U&>().set_keep_alive_impl( std::declval<unsigned>(), std::declval<bool>())), std::true_type()); static auto f12(...) -> std::false_type; using t12 = decltype(f12(0)); using type = std::integral_constant<bool, t1::value && t2::value && t3::value && t4::value && t5::value && t6::value && t7::value && t8::value && t9::value && t10::value && t11::value && t12::value>; }; } // detail } // http } // beast } // boost #endif PK PP�[ۡ� 7 7 http/detail/rfc7230.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_RFC7230_IPP #define BOOST_BEAST_HTTP_DETAIL_RFC7230_IPP #include <boost/beast/core/string.hpp> #include <iterator> #include <utility> namespace boost { namespace beast { namespace http { namespace detail { bool is_digit(char c) { return c >= '0' && c <= '9'; } char is_alpha(char c) { static char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 32 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 48 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, // 80 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, // 112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 128 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 192 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 208 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } char is_text(char c) { // TEXT = <any OCTET except CTLs, but including LWS> static char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 144 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 176 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 208 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } char is_token_char(char c) { /* tchar = "!" | "#" | "$" | "%" | "&" | "'" | "*" | "+" | "-" | "." | "^" | "_" | "`" | "|" | "~" | DIGIT | ALPHA */ static char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, // 32 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, // 48 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 1, // 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1, 0, // 112 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 128 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 144 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 160 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 176 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 192 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 208 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 224 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } char is_qdchar(char c) { /* qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text */ static char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, // 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 144 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 176 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 208 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } char is_qpchar(char c) { /* quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) obs-text = %x80-FF */ static char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 144 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 176 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 208 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } // converts to lower case, // returns 0 if not a valid text char // char to_value_char(char c) { // TEXT = <any OCTET except CTLs, but including LWS> static unsigned char constexpr tab[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, // 32 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, // 48 64, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, // 64 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 91, 92, 93, 94, 95, // 80 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, // 96 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 0, // 112 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, // 128 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, // 144 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, // 160 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 191, // 176 192, 193, 194, 195, 196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, // 192 208, 209, 210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223, // 208 224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237, 238, 239, // 224 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250, 251, 252, 253, 254, 255 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return static_cast<char>(tab[static_cast<unsigned char>(c)]); } // VFALCO TODO Make this return unsigned? std::int8_t unhex(char c) { static signed char constexpr tab[] = { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 0 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 16 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 32 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, -1, -1, -1, -1, -1, -1, // 48 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 64 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 80 -1, 10, 11, 12, 13, 14, 15, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 96 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 112 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 128 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 144 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 160 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 176 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 192 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 208 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, // 224 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 // 240 }; BOOST_STATIC_ASSERT(sizeof(tab) == 256); return tab[static_cast<unsigned char>(c)]; } template <class ForwardIt> void skip_ows(ForwardIt& it, ForwardIt end) { while(it != end) { if(*it != ' ' && *it != '\t') break; ++it; } } template <class ForwardIt> void skip_token(ForwardIt& it, ForwardIt last) { while(it != last && is_token_char(*it)) ++it; } string_view trim(string_view s) { auto first = s.begin(); auto last = s.end(); skip_ows(first, last); while(first != last) { auto const c = *std::prev(last); if(c != ' ' && c != '\t') break; --last; } if(first == last) return {}; return {&*first, static_cast<std::size_t>(last - first)}; } BOOST_BEAST_DECL void param_iter:: increment() { /* param-list = *( OWS ";" OWS param ) param = token OWS [ "=" OWS ( token / quoted-string ) ] quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) obs-text = %x80-FF */ auto const err = [&] { it = first; }; v.first = {}; v.second = {}; detail::skip_ows(it, last); first = it; if(it == last) return err(); if(*it != ';') return err(); ++it; detail::skip_ows(it, last); if(it == last) return err(); // param if(! detail::is_token_char(*it)) return err(); auto const p0 = it; skip_token(++it, last); auto const p1 = it; v.first = { &*p0, static_cast<std::size_t>(p1 - p0) }; detail::skip_ows(it, last); if(it == last) return; if(*it == ';') return; if(*it != '=') return err(); ++it; detail::skip_ows(it, last); if(it == last) return; if(*it == '"') { // quoted-string auto const p2 = it; ++it; for(;;) { if(it == last) return err(); auto c = *it++; if(c == '"') break; if(detail::is_qdchar(c)) continue; if(c != '\\') return err(); if(it == last) return err(); c = *it++; if(! detail::is_qpchar(c)) return err(); } v.second = { &*p2, static_cast<std::size_t>(it - p2) }; } else { // token if(! detail::is_token_char(*it)) return err(); auto const p2 = it; skip_token(++it, last); v.second = { &*p2, static_cast<std::size_t>(it - p2) }; } } bool opt_token_list_policy::operator()(value_type& v, char const*& it, string_view s) const { v = {}; auto need_comma = it != s.data(); for(;;) { detail::skip_ows(it, (s.data() + s.size())); if(it == (s.data() + s.size())) { it = nullptr; return true; } auto const c = *it; if(detail::is_token_char(c)) { if(need_comma) return false; auto const p0 = it; for(;;) { ++it; if(it == (s.data() + s.size())) break; if(! detail::is_token_char(*it)) break; } v = string_view{p0, static_cast<std::size_t>(it - p0)}; return true; } if(c != ',') return false; need_comma = false; ++it; } } } // detail } // http } // beast } // boost #endif // BOOST_BEAST_HTTP_DETAIL_RFC7230_IPP PK PP�[L�J� � ! http/detail/basic_parsed_list.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_BASIC_PARSED_LIST_HPP #define BOOST_BEAST_HTTP_DETAIL_BASIC_PARSED_LIST_HPP #include <boost/beast/core/string.hpp> #include <boost/core/empty_value.hpp> #include <cstddef> #include <iterator> namespace boost { namespace beast { namespace http { namespace detail { /** A list parser which presents the sequence as a container. */ template<class Policy> class basic_parsed_list { string_view s_; public: /// The type of policy this list uses for parsing. using policy_type = Policy; /// The type of each element in the list. using value_type = typename Policy::value_type; /// A constant iterator to a list element. #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else class const_iterator; #endif class const_iterator : private boost::empty_value<Policy> { basic_parsed_list const* list_ = nullptr; char const* it_ = nullptr; typename Policy::value_type v_; bool error_ = false; public: using value_type = typename Policy::value_type; using reference = value_type const&; using pointer = value_type const*; using difference_type = std::ptrdiff_t; using iterator_category = std::forward_iterator_tag; const_iterator() = default; bool operator==( const_iterator const& other) const { return other.list_ == list_ && other.it_ == it_; } bool operator!=( const_iterator const& other) const { return ! (*this == other); } reference operator*() const { return v_; } const_iterator& operator++() { increment(); return *this; } const_iterator operator++(int) { auto temp = *this; ++(*this); return temp; } bool error() const { return error_; } private: friend class basic_parsed_list; const_iterator( basic_parsed_list const& list, bool at_end) : list_(&list) , it_(at_end ? nullptr : list.s_.data()) { if(! at_end) increment(); } void increment() { if(! this->get()( v_, it_, list_->s_)) { it_ = nullptr; error_ = true; } } }; /// Construct a list from a string explicit basic_parsed_list(string_view s) : s_(s) { } /// Return a const iterator to the beginning of the list const_iterator begin() const; /// Return a const iterator to the end of the list const_iterator end() const; /// Return a const iterator to the beginning of the list const_iterator cbegin() const; /// Return a const iterator to the end of the list const_iterator cend() const; }; template<class Policy> inline auto basic_parsed_list<Policy>:: begin() const -> const_iterator { return const_iterator{*this, false}; } template<class Policy> inline auto basic_parsed_list<Policy>:: end() const -> const_iterator { return const_iterator{*this, true}; } template<class Policy> inline auto basic_parsed_list<Policy>:: cbegin() const -> const_iterator { return const_iterator{*this, false}; } template<class Policy> inline auto basic_parsed_list<Policy>:: cend() const -> const_iterator { return const_iterator{*this, true}; } } // detail } // http } // beast } // boost #endif PK PP�[��꓾ � http/detail/rfc7230.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_RFC7230_HPP #define BOOST_BEAST_HTTP_DETAIL_RFC7230_HPP #include <boost/beast/core/string.hpp> #include <iterator> #include <utility> namespace boost { namespace beast { namespace http { namespace detail { BOOST_BEAST_DECL bool is_digit(char c); BOOST_BEAST_DECL char is_alpha(char c); BOOST_BEAST_DECL char is_text(char c); BOOST_BEAST_DECL char is_token_char(char c); BOOST_BEAST_DECL char is_qdchar(char c); BOOST_BEAST_DECL char is_qpchar(char c); // converts to lower case, // returns 0 if not a valid text char // BOOST_BEAST_DECL char to_value_char(char c); // VFALCO TODO Make this return unsigned? BOOST_BEAST_DECL std::int8_t unhex(char c); BOOST_BEAST_DECL string_view trim(string_view s); struct param_iter { using iter_type = string_view::const_iterator; iter_type it; iter_type first; iter_type last; std::pair<string_view, string_view> v; bool empty() const { return first == it; } BOOST_BEAST_DECL void increment(); }; /* #token = [ ( "," / token ) *( OWS "," [ OWS token ] ) ] */ struct opt_token_list_policy { using value_type = string_view; BOOST_BEAST_DECL bool operator()(value_type& v, char const*& it, string_view s) const; }; } // detail } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/detail/rfc7230.ipp> #endif #endif PK PP�[�6r r http/detail/chunk_encode.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP #define BOOST_BEAST_HTTP_DETAIL_CHUNK_ENCODE_HPP #include <boost/beast/http/type_traits.hpp> #include <boost/asio/buffer.hpp> #include <algorithm> #include <array> #include <cstddef> #include <memory> namespace boost { namespace beast { namespace http { namespace detail { struct chunk_extensions { virtual ~chunk_extensions() = default; virtual net::const_buffer str() = 0; }; template<class ChunkExtensions> struct chunk_extensions_impl : chunk_extensions { ChunkExtensions ext_; chunk_extensions_impl(ChunkExtensions&& ext) noexcept : ext_(std::move(ext)) { } chunk_extensions_impl(ChunkExtensions const& ext) : ext_(ext) { } net::const_buffer str() override { auto const s = ext_.str(); return {s.data(), s.size()}; } }; template<class T, class = void> struct is_chunk_extensions : std::false_type {}; template<class T> struct is_chunk_extensions<T, beast::detail::void_t<decltype( std::declval<string_view&>() = std::declval<T&>().str() )>> : std::true_type { }; //------------------------------------------------------------------------------ /** A buffer sequence containing a chunk-encoding header */ class chunk_size { template<class OutIter> static OutIter to_hex(OutIter last, std::size_t n) { if(n == 0) { *--last = '0'; return last; } while(n) { *--last = "0123456789abcdef"[n&0xf]; n>>=4; } return last; } struct sequence { net::const_buffer b; char data[1 + 2 * sizeof(std::size_t)]; explicit sequence(std::size_t n) { char* it0 = data + sizeof(data); auto it = to_hex(it0, n); b = {it, static_cast<std::size_t>(it0 - it)}; } }; std::shared_ptr<sequence> sp_; public: using value_type = net::const_buffer; using const_iterator = value_type const*; chunk_size(chunk_size const& other) = default; /** Construct a chunk header @param n The number of octets in this chunk. */ chunk_size(std::size_t n) : sp_(std::make_shared<sequence>(n)) { } const_iterator begin() const { return &sp_->b; } const_iterator end() const { return begin() + 1; } }; //------------------------------------------------------------------------------ /// Returns a buffer sequence holding a CRLF for chunk encoding inline net::const_buffer const& chunk_crlf() { static net::const_buffer const cb{"\r\n", 2}; return cb; } /// Returns a buffer sequence holding a final chunk header inline net::const_buffer const& chunk_last() { static net::const_buffer const cb{"0\r\n", 3}; return cb; } //------------------------------------------------------------------------------ #if 0 template<class = void> struct chunk_crlf_iter_type { class value_type { char const s[2] = {'\r', '\n'}; public: value_type() = default; operator net::const_buffer() const { return {s, sizeof(s)}; } }; static value_type value; }; template<class T> typename chunk_crlf_iter_type<T>::value_type chunk_crlf_iter_type<T>::value; using chunk_crlf_iter = chunk_crlf_iter_type<void>; #endif //------------------------------------------------------------------------------ struct chunk_size0 { using value_type = net::const_buffer; using const_iterator = value_type const*; const_iterator begin() const { return &chunk_last(); } const_iterator end() const { return begin() + 1; } }; //------------------------------------------------------------------------------ template<class T, bool = is_fields<T>::value> struct buffers_or_fields { using type = typename T::writer::const_buffers_type; }; template<class T> struct buffers_or_fields<T, false> { using type = T; }; } // detail } // http } // beast } // boost #endif PK PP�[Ӂ� � http/detail/basic_parser.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_HPP #define BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_HPP #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/char_buffer.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/detail/rfc7230.hpp> #include <boost/config.hpp> #include <boost/version.hpp> #include <cstddef> #include <utility> namespace boost { namespace beast { namespace http { namespace detail { struct basic_parser_base { // limit on the size of the obs-fold buffer // // https://stackoverflow.com/questions/686217/maximum-on-http-header-values // static std::size_t constexpr max_obs_fold = 4096; enum class state { nothing_yet = 0, start_line, fields, body0, body, body_to_eof0, body_to_eof, chunk_header0, chunk_header, chunk_body, complete }; static bool is_digit(char c) { return static_cast<unsigned char>(c-'0') < 10; } static bool is_print(char c) { return static_cast<unsigned char>(c-32) < 95; } BOOST_BEAST_DECL static char const* trim_front(char const* it, char const* end); BOOST_BEAST_DECL static char const* trim_back( char const* it, char const* first); static string_view make_string(char const* first, char const* last) { return {first, static_cast< std::size_t>(last - first)}; } //-------------------------------------------------------------------------- BOOST_BEAST_DECL static bool is_pathchar(char c); BOOST_BEAST_DECL static bool unhex(unsigned char& d, char c); BOOST_BEAST_DECL static std::pair<char const*, bool> find_fast( char const* buf, char const* buf_end, char const* ranges, size_t ranges_size); BOOST_BEAST_DECL static char const* find_eol( char const* it, char const* last, error_code& ec); BOOST_BEAST_DECL static char const* find_eom(char const* p, char const* last); //-------------------------------------------------------------------------- BOOST_BEAST_DECL static char const* parse_token_to_eol( char const* p, char const* last, char const*& token_last, error_code& ec); BOOST_BEAST_DECL static bool parse_dec(string_view s, std::uint64_t& v); BOOST_BEAST_DECL static bool parse_hex(char const*& it, std::uint64_t& v); BOOST_BEAST_DECL static bool parse_crlf(char const*& it); BOOST_BEAST_DECL static void parse_method( char const*& it, char const* last, string_view& result, error_code& ec); BOOST_BEAST_DECL static void parse_target( char const*& it, char const* last, string_view& result, error_code& ec); BOOST_BEAST_DECL static void parse_version( char const*& it, char const* last, int& result, error_code& ec); BOOST_BEAST_DECL static void parse_status( char const*& it, char const* last, unsigned short& result, error_code& ec); BOOST_BEAST_DECL static void parse_reason( char const*& it, char const* last, string_view& result, error_code& ec); BOOST_BEAST_DECL static void parse_field( char const*& p, char const* last, string_view& name, string_view& value, beast::detail::char_buffer<max_obs_fold>& buf, error_code& ec); BOOST_BEAST_DECL static void parse_chunk_extensions( char const*& it, char const* last, error_code& ec); }; } // detail } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/detail/basic_parser.ipp> #endif #endif PK PP�[���#K #K http/detail/basic_parser.ippnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_IPP #define BOOST_BEAST_HTTP_DETAIL_BASIC_PARSER_IPP #include <boost/beast/http/detail/basic_parser.hpp> #include <limits> namespace boost { namespace beast { namespace http { namespace detail { char const* basic_parser_base:: trim_front(char const* it, char const* end) { while(it != end) { if(*it != ' ' && *it != '\t') break; ++it; } return it; } char const* basic_parser_base:: trim_back( char const* it, char const* first) { while(it != first) { auto const c = it[-1]; if(c != ' ' && c != '\t') break; --it; } return it; } bool basic_parser_base:: is_pathchar(char c) { // VFALCO This looks the same as the one below... // TEXT = <any OCTET except CTLs, and excluding LWS> static bool constexpr tab[256] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 16 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 32 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 48 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 64 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 80 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 96 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, // 112 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 128 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 144 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 160 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 176 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 192 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 208 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, // 224 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 // 240 }; return tab[static_cast<unsigned char>(c)]; } bool basic_parser_base:: unhex(unsigned char& d, char c) { static signed char constexpr tab[256] = { -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 0 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 16 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 32 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,-1,-1,-1,-1,-1,-1, // 48 -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 64 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 80 -1,10,11,12,13,14,15,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 96 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 112 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 128 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 144 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 160 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 176 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 192 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 208 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1, // 224 -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1 // 240 }; d = static_cast<unsigned char>( tab[static_cast<unsigned char>(c)]); return d != static_cast<unsigned char>(-1); } //-------------------------------------------------------------------------- std::pair<char const*, bool> basic_parser_base:: find_fast( char const* buf, char const* buf_end, char const* ranges, size_t ranges_size) { bool found = false; boost::ignore_unused(buf_end, ranges, ranges_size); return {buf, found}; } // VFALCO Can SIMD help this? char const* basic_parser_base:: find_eol( char const* it, char const* last, error_code& ec) { for(;;) { if(it == last) { ec = {}; return nullptr; } if(*it == '\r') { if(++it == last) { ec = {}; return nullptr; } if(*it != '\n') { ec = error::bad_line_ending; return nullptr; } ec = {}; return ++it; } // VFALCO Should we handle the legacy case // for lines terminated with a single '\n'? ++it; } } bool basic_parser_base:: parse_dec( string_view s, std::uint64_t& v) { char const* it = s.data(); char const* last = it + s.size(); if(it == last) return false; std::uint64_t tmp = 0; do { if((! is_digit(*it)) || tmp > (std::numeric_limits<std::uint64_t>::max)() / 10) return false; tmp *= 10; std::uint64_t const d = *it - '0'; if((std::numeric_limits<std::uint64_t>::max)() - tmp < d) return false; tmp += d; } while(++it != last); v = tmp; return true; } bool basic_parser_base:: parse_hex(char const*& it, std::uint64_t& v) { unsigned char d; if(! unhex(d, *it)) return false; std::uint64_t tmp = 0; do { if(tmp > (std::numeric_limits<std::uint64_t>::max)() / 16) return false; tmp *= 16; if((std::numeric_limits<std::uint64_t>::max)() - tmp < d) return false; tmp += d; } while(unhex(d, *++it)); v = tmp; return true; } char const* basic_parser_base:: find_eom(char const* p, char const* last) { for(;;) { if(p + 4 > last) return nullptr; if(p[3] != '\n') { if(p[3] == '\r') ++p; else p += 4; } else if(p[2] != '\r') { p += 4; } else if(p[1] != '\n') { p += 2; } else if(p[0] != '\r') { p += 2; } else { return p + 4; } } } //-------------------------------------------------------------------------- char const* basic_parser_base:: parse_token_to_eol( char const* p, char const* last, char const*& token_last, error_code& ec) { for(;; ++p) { if(p >= last) { ec = error::need_more; return p; } if(BOOST_UNLIKELY(! is_print(*p))) if((BOOST_LIKELY(static_cast< unsigned char>(*p) < '\040') && BOOST_LIKELY(*p != 9)) || BOOST_UNLIKELY(*p == 127)) goto found_control; } found_control: if(BOOST_LIKELY(*p == '\r')) { if(++p >= last) { ec = error::need_more; return last; } if(*p++ != '\n') { ec = error::bad_line_ending; return last; } token_last = p - 2; } #if 0 // VFALCO This allows `\n` by itself // to terminate a line else if(*p == '\n') { token_last = p; ++p; } #endif else { // invalid character return nullptr; } return p; } bool basic_parser_base:: parse_crlf(char const*& it) { if( it[0] != '\r' || it[1] != '\n') return false; it += 2; return true; } void basic_parser_base:: parse_method( char const*& it, char const* last, string_view& result, error_code& ec) { // parse token SP auto const first = it; for(;; ++it) { if(it + 1 > last) { ec = error::need_more; return; } if(! detail::is_token_char(*it)) break; } if(it + 1 > last) { ec = error::need_more; return; } if(*it != ' ') { ec = error::bad_method; return; } if(it == first) { // cannot be empty ec = error::bad_method; return; } result = make_string(first, it++); } void basic_parser_base:: parse_target( char const*& it, char const* last, string_view& result, error_code& ec) { // parse target SP auto const first = it; for(;; ++it) { if(it + 1 > last) { ec = error::need_more; return; } if(! is_pathchar(*it)) break; } if(it + 1 > last) { ec = error::need_more; return; } if(*it != ' ') { ec = error::bad_target; return; } if(it == first) { // cannot be empty ec = error::bad_target; return; } result = make_string(first, it++); } void basic_parser_base:: parse_version( char const*& it, char const* last, int& result, error_code& ec) { if(it + 8 > last) { ec = error::need_more; return; } if(*it++ != 'H') { ec = error::bad_version; return; } if(*it++ != 'T') { ec = error::bad_version; return; } if(*it++ != 'T') { ec = error::bad_version; return; } if(*it++ != 'P') { ec = error::bad_version; return; } if(*it++ != '/') { ec = error::bad_version; return; } if(! is_digit(*it)) { ec = error::bad_version; return; } result = 10 * (*it++ - '0'); if(*it++ != '.') { ec = error::bad_version; return; } if(! is_digit(*it)) { ec = error::bad_version; return; } result += *it++ - '0'; } void basic_parser_base:: parse_status( char const*& it, char const* last, unsigned short& result, error_code& ec) { // parse 3(digit) SP if(it + 4 > last) { ec = error::need_more; return; } if(! is_digit(*it)) { ec = error::bad_status; return; } result = 100 * (*it++ - '0'); if(! is_digit(*it)) { ec = error::bad_status; return; } result += 10 * (*it++ - '0'); if(! is_digit(*it)) { ec = error::bad_status; return; } result += *it++ - '0'; if(*it++ != ' ') { ec = error::bad_status; return; } } void basic_parser_base:: parse_reason( char const*& it, char const* last, string_view& result, error_code& ec) { auto const first = it; char const* token_last = nullptr; auto p = parse_token_to_eol( it, last, token_last, ec); if(ec) return; if(! p) { ec = error::bad_reason; return; } result = make_string(first, token_last); it = p; } void basic_parser_base:: parse_field( char const*& p, char const* last, string_view& name, string_view& value, beast::detail::char_buffer<max_obs_fold>& buf, error_code& ec) { /* header-field = field-name ":" OWS field-value OWS field-name = token field-value = *( field-content / obs-fold ) field-content = field-vchar [ 1*( SP / HTAB ) field-vchar ] field-vchar = VCHAR / obs-text obs-fold = CRLF 1*( SP / HTAB ) ; obsolete line folding ; see Section 3.2.4 token = 1*<any CHAR except CTLs or separators> CHAR = <any US-ASCII character (octets 0 - 127)> sep = "(" | ")" | "<" | ">" | "@" | "," | ";" | ":" | "\" | <"> | "/" | "[" | "]" | "?" | "=" | "{" | "}" | SP | HT */ static char const* is_token = "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\1\0\1\1\1\1\1\0\0\1\1\0\1\1\0\1\1\1\1\1\1\1\1\1\1\0\0\0\0\0\0" "\0\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\0\0\1\1" "\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\1\0\1\0\1\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0" "\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"; // name BOOST_ALIGNMENT(16) static const char ranges1[] = "\x00 " /* control chars and up to SP */ "\"\"" /* 0x22 */ "()" /* 0x28,0x29 */ ",," /* 0x2c */ "//" /* 0x2f */ ":@" /* 0x3a-0x40 */ "[]" /* 0x5b-0x5d */ "{\377"; /* 0x7b-0xff */ auto first = p; bool found; std::tie(p, found) = find_fast( p, last, ranges1, sizeof(ranges1)-1); if(! found && p >= last) { ec = error::need_more; return; } for(;;) { if(*p == ':') break; if(! is_token[static_cast< unsigned char>(*p)]) { ec = error::bad_field; return; } ++p; if(p >= last) { ec = error::need_more; return; } } if(p == first) { // empty name ec = error::bad_field; return; } name = make_string(first, p); ++p; // eat ':' char const* token_last = nullptr; for(;;) { // eat leading ' ' and '\t' for(;;++p) { if(p + 1 > last) { ec = error::need_more; return; } if(! (*p == ' ' || *p == '\t')) break; } // parse to CRLF first = p; p = parse_token_to_eol(p, last, token_last, ec); if(ec) return; if(! p) { ec = error::bad_value; return; } // Look 1 char past the CRLF to handle obs-fold. if(p + 1 > last) { ec = error::need_more; return; } token_last = trim_back(token_last, first); if(*p != ' ' && *p != '\t') { value = make_string(first, token_last); return; } ++p; if(token_last != first) break; } buf.clear(); if (!buf.try_append(first, token_last)) { ec = error::header_limit; return; } BOOST_ASSERT(! buf.empty()); for(;;) { // eat leading ' ' and '\t' for(;;++p) { if(p + 1 > last) { ec = error::need_more; return; } if(! (*p == ' ' || *p == '\t')) break; } // parse to CRLF first = p; p = parse_token_to_eol(p, last, token_last, ec); if(ec) return; if(! p) { ec = error::bad_value; return; } // Look 1 char past the CRLF to handle obs-fold. if(p + 1 > last) { ec = error::need_more; return; } token_last = trim_back(token_last, first); if(first != token_last) { if (!buf.try_push_back(' ') || !buf.try_append(first, token_last)) { ec = error::header_limit; return; } } if(*p != ' ' && *p != '\t') { value = {buf.data(), buf.size()}; return; } ++p; } } void basic_parser_base:: parse_chunk_extensions( char const*& it, char const* last, error_code& ec) { /* chunk-ext = *( BWS ";" BWS chunk-ext-name [ BWS "=" BWS chunk-ext-val ] ) BWS = *( SP / HTAB ) ; "Bad White Space" chunk-ext-name = token chunk-ext-val = token / quoted-string token = 1*tchar quoted-string = DQUOTE *( qdtext / quoted-pair ) DQUOTE qdtext = HTAB / SP / "!" / %x23-5B ; '#'-'[' / %x5D-7E ; ']'-'~' / obs-text quoted-pair = "\" ( HTAB / SP / VCHAR / obs-text ) obs-text = %x80-FF https://www.rfc-editor.org/errata_search.php?rfc=7230&eid=4667 */ loop: if(it == last) { ec = error::need_more; return; } if(*it != ' ' && *it != '\t' && *it != ';') return; // BWS if(*it == ' ' || *it == '\t') { for(;;) { ++it; if(it == last) { ec = error::need_more; return; } if(*it != ' ' && *it != '\t') break; } } // ';' if(*it != ';') { ec = error::bad_chunk_extension; return; } semi: ++it; // skip ';' // BWS for(;;) { if(it == last) { ec = error::need_more; return; } if(*it != ' ' && *it != '\t') break; ++it; } // chunk-ext-name if(! detail::is_token_char(*it)) { ec = error::bad_chunk_extension; return; } for(;;) { ++it; if(it == last) { ec = error::need_more; return; } if(! detail::is_token_char(*it)) break; } // BWS [ ";" / "=" ] { bool bws; if(*it == ' ' || *it == '\t') { for(;;) { ++it; if(it == last) { ec = error::need_more; return; } if(*it != ' ' && *it != '\t') break; } bws = true; } else { bws = false; } if(*it == ';') goto semi; if(*it != '=') { if(bws) ec = error::bad_chunk_extension; return; } ++it; // skip '=' } // BWS for(;;) { if(it == last) { ec = error::need_more; return; } if(*it != ' ' && *it != '\t') break; ++it; } // chunk-ext-val if(*it != '"') { // token if(! detail::is_token_char(*it)) { ec = error::bad_chunk_extension; return; } for(;;) { ++it; if(it == last) { ec = error::need_more; return; } if(! detail::is_token_char(*it)) break; } } else { // quoted-string for(;;) { ++it; if(it == last) { ec = error::need_more; return; } if(*it == '"') break; if(*it == '\\') { ++it; if(it == last) { ec = error::need_more; return; } } } ++it; } goto loop; } } // detail } // http } // beast } // boost #endif PK PP�[F�9��0 �0 http/serializer.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_SERIALIZER_HPP #define BOOST_BEAST_HTTP_SERIALIZER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/buffers_prefix.hpp> #include <boost/beast/core/buffers_suffix.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/core/detail/variant.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/chunk_encode.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> namespace boost { namespace beast { namespace http { /** Provides buffer oriented HTTP message serialization functionality. An object of this type is used to serialize a complete HTTP message into a sequence of octets. To use this class, construct an instance with the message to be serialized. The implementation will automatically perform chunk encoding if the contents of the message indicate that chunk encoding is required. Chunked output produced by the serializer never contains chunk extensions or trailers, and the location of chunk boundaries is not specified. If callers require chunk extensions, trailers, or control over the exact contents of each chunk they should use the serializer to write just the message header, and then assume control over serializing the chunked payload by using the chunk buffer sequence types @ref chunk_body, @ref chunk_crlf, @ref chunk_header, and @ref chunk_last. @tparam isRequest `true` if the message is a request. @tparam Body The body type of the message. @tparam Fields The type of fields in the message. */ template< bool isRequest, class Body, class Fields = fields> class serializer { public: static_assert(is_body<Body>::value, "Body type requirements not met"); static_assert(is_body_writer<Body>::value, "BodyWriter type requirements not met"); /** The type of message this serializer uses This may be const or non-const depending on the implementation of the corresponding <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using value_type = __implementation_defined__; #else using value_type = typename std::conditional< std::is_constructible<typename Body::writer, header<isRequest, Fields>&, typename Body::value_type&>::value && ! std::is_constructible<typename Body::writer, header<isRequest, Fields> const&, typename Body::value_type const&>::value, message<isRequest, Body, Fields>, message<isRequest, Body, Fields> const>::type; #endif private: enum { do_construct = 0, do_init = 10, do_header_only = 20, do_header = 30, do_body = 40, do_init_c = 50, do_header_only_c = 60, do_header_c = 70, do_body_c = 80, do_final_c = 90, #ifndef BOOST_BEAST_NO_BIG_VARIANTS do_body_final_c = 100, do_all_c = 110, #endif do_complete = 120 }; void fwrinit(std::true_type); void fwrinit(std::false_type); template<std::size_t, class Visit> void do_visit(error_code& ec, Visit& visit); using writer = typename Body::writer; using cb1_t = buffers_suffix<typename Fields::writer::const_buffers_type>; // header using pcb1_t = buffers_prefix_view<cb1_t const&>; using cb2_t = buffers_suffix<buffers_cat_view< typename Fields::writer::const_buffers_type,// header typename writer::const_buffers_type>>; // body using pcb2_t = buffers_prefix_view<cb2_t const&>; using cb3_t = buffers_suffix< typename writer::const_buffers_type>; // body using pcb3_t = buffers_prefix_view<cb3_t const&>; using cb4_t = buffers_suffix<buffers_cat_view< typename Fields::writer::const_buffers_type,// header detail::chunk_size, // chunk-size net::const_buffer, // chunk-ext chunk_crlf, // crlf typename writer::const_buffers_type, // body chunk_crlf>>; // crlf using pcb4_t = buffers_prefix_view<cb4_t const&>; using cb5_t = buffers_suffix<buffers_cat_view< detail::chunk_size, // chunk-header net::const_buffer, // chunk-ext chunk_crlf, // crlf typename writer::const_buffers_type, // body chunk_crlf>>; // crlf using pcb5_t = buffers_prefix_view<cb5_t const&>; using cb6_t = buffers_suffix<buffers_cat_view< detail::chunk_size, // chunk-header net::const_buffer, // chunk-size chunk_crlf, // crlf typename writer::const_buffers_type, // body chunk_crlf, // crlf net::const_buffer, // chunk-final net::const_buffer, // trailers chunk_crlf>>; // crlf using pcb6_t = buffers_prefix_view<cb6_t const&>; using cb7_t = buffers_suffix<buffers_cat_view< typename Fields::writer::const_buffers_type,// header detail::chunk_size, // chunk-size net::const_buffer, // chunk-ext chunk_crlf, // crlf typename writer::const_buffers_type, // body chunk_crlf, // crlf net::const_buffer, // chunk-final net::const_buffer, // trailers chunk_crlf>>; // crlf using pcb7_t = buffers_prefix_view<cb7_t const&>; using cb8_t = buffers_suffix<buffers_cat_view< net::const_buffer, // chunk-final net::const_buffer, // trailers chunk_crlf>>; // crlf using pcb8_t = buffers_prefix_view<cb8_t const&>; value_type& m_; writer wr_; boost::optional<typename Fields::writer> fwr_; beast::detail::variant< cb1_t, cb2_t, cb3_t, cb4_t, cb5_t ,cb6_t, cb7_t, cb8_t> v_; beast::detail::variant< pcb1_t, pcb2_t, pcb3_t, pcb4_t, pcb5_t ,pcb6_t, pcb7_t, pcb8_t> pv_; std::size_t limit_ = (std::numeric_limits<std::size_t>::max)(); int s_ = do_construct; bool split_ = false; bool header_done_ = false; bool more_ = false; public: /// Constructor serializer(serializer&&) = default; /// Constructor serializer(serializer const&) = default; /// Assignment serializer& operator=(serializer const&) = delete; /** Constructor The implementation guarantees that the message passed on construction will not be accessed until the first call to @ref next. This allows the message to be lazily created. For example, if the header is filled in before serialization. @param msg A reference to the message to serialize, which must remain valid for the lifetime of the serializer. Depending on the type of Body used, this may or may not be a `const` reference. @note This function participates in overload resolution only if Body::writer is constructible from a `const` message reference. */ explicit serializer(value_type& msg); /// Returns the message being serialized value_type& get() { return m_; } /// Returns the serialized buffer size limit std::size_t limit() { return limit_; } /** Set the serialized buffer size limit This function adjusts the limit on the maximum size of the buffers passed to the visitor. The new size limit takes effect in the following call to @ref next. The default is no buffer size limit. @param limit The new buffer size limit. If this number is zero, the size limit is removed. */ void limit(std::size_t limit) { limit_ = limit > 0 ? limit : (std::numeric_limits<std::size_t>::max)(); } /** Returns `true` if we will pause after writing the complete header. */ bool split() { return split_; } /** Set whether the header and body are written separately. When the split feature is enabled, the implementation will write only the octets corresponding to the serialized header first. If the header has already been written, this function will have no effect on output. */ void split(bool v) { split_ = v; } /** Return `true` if serialization of the header is complete. This function indicates whether or not all buffers containing serialized header octets have been retrieved. */ bool is_header_done() { return header_done_; } /** Return `true` if serialization is complete. The operation is complete when all octets corresponding to the serialized representation of the message have been successfully retrieved. */ bool is_done() { return s_ == do_complete; } /** Returns the next set of buffers in the serialization. This function will attempt to call the `visit` function object with a <em>ConstBufferSequence</em> of unspecified type representing the next set of buffers in the serialization of the message represented by this object. If there are no more buffers in the serialization, the visit function will not be called. In this case, no error will be indicated, and the function @ref is_done will return `true`. @param ec Set to the error, if any occurred. @param visit The function to call. The equivalent function signature of this object must be: @code template<class ConstBufferSequence> void visit(error_code&, ConstBufferSequence const&); @endcode The function is not copied, if no error occurs it will be invoked before the call to @ref next returns. */ template<class Visit> void next(error_code& ec, Visit&& visit); /** Consume buffer octets in the serialization. This function should be called after one or more octets contained in the buffers provided in the prior call to @ref next have been used. After a call to @ref consume, callers should check the return value of @ref is_done to determine if the entire message has been serialized. @param n The number of octets to consume. This number must be greater than zero and no greater than the number of octets in the buffers provided in the prior call to @ref next. */ void consume(std::size_t n); /** Provides low-level access to the associated <em>BodyWriter</em> This function provides access to the instance of the writer associated with the body and created by the serializer upon construction. The behavior of accessing this object is defined by the specification of the particular writer and its associated body. @return A reference to the writer. */ writer& writer_impl() { return wr_; } }; /// A serializer for HTTP/1 requests template<class Body, class Fields = fields> using request_serializer = serializer<true, Body, Fields>; /// A serializer for HTTP/1 responses template<class Body, class Fields = fields> using response_serializer = serializer<false, Body, Fields>; } // http } // beast } // boost #include <boost/beast/http/impl/serializer.hpp> #endif PK PP�[����# �# http/rfc7230.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_RFC7230_HPP #define BOOST_BEAST_HTTP_RFC7230_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/http/detail/rfc7230.hpp> #include <boost/beast/http/detail/basic_parsed_list.hpp> namespace boost { namespace beast { namespace http { /** A list of parameters in an HTTP extension field value. This container allows iteration of the parameter list in an HTTP extension. The parameter list is a series of name/value pairs with each pair starting with a semicolon. The value is optional. If a parsing error is encountered while iterating the string, the behavior of the container will be as if a string containing only characters up to but excluding the first invalid character was used to construct the list. @par BNF @code param-list = *( OWS ";" OWS param ) param = token OWS [ "=" OWS ( token / quoted-string ) ] @endcode To use this class, construct with the string to be parsed and then use @ref begin and @ref end, or range-for to iterate each item: @par Example @code for(auto const& param : param_list{";level=9;no_context_takeover;bits=15"}) { std::cout << ";" << param.first; if(! param.second.empty()) std::cout << "=" << param.second; std::cout << "\n"; } @endcode */ class param_list { string_view s_; public: /** The type of each element in the list. The first string in the pair is the name of the parameter, and the second string in the pair is its value (which may be empty). */ using value_type = std::pair<string_view, string_view>; /// A constant iterator to the list #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else class const_iterator; #endif /// Default constructor. param_list() = default; /** Construct a list. @param s A string containing the list contents. The string must remain valid for the lifetime of the container. */ explicit param_list(string_view s) : s_(s) { } /// Return a const iterator to the beginning of the list const_iterator begin() const; /// Return a const iterator to the end of the list const_iterator end() const; /// Return a const iterator to the beginning of the list const_iterator cbegin() const; /// Return a const iterator to the end of the list const_iterator cend() const; }; //------------------------------------------------------------------------------ /** A list of extensions in a comma separated HTTP field value. This container allows iteration of the extensions in an HTTP field value. The extension list is a comma separated list of token parameter list pairs. If a parsing error is encountered while iterating the string, the behavior of the container will be as if a string containing only characters up to but excluding the first invalid character was used to construct the list. @par BNF @code ext-list = *( "," OWS ) ext *( OWS "," [ OWS ext ] ) ext = token param-list param-list = *( OWS ";" OWS param ) param = token OWS [ "=" OWS ( token / quoted-string ) ] @endcode To use this class, construct with the string to be parsed and then use @ref begin and @ref end, or range-for to iterate each item: @par Example @code for(auto const& ext : ext_list{"none, 7z;level=9, zip;no_context_takeover;bits=15"}) { std::cout << ext.first << "\n"; for(auto const& param : ext.second) { std::cout << ";" << param.first; if(! param.second.empty()) std::cout << "=" << param.second; std::cout << "\n"; } } @endcode */ class ext_list { using iter_type = string_view::const_iterator; string_view s_; public: /** The type of each element in the list. The first element of the pair is the extension token, and the second element of the pair is an iterable container holding the extension's name/value parameters. */ using value_type = std::pair<string_view, param_list>; /// A constant iterator to the list #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else class const_iterator; #endif /** Construct a list. @param s A string containing the list contents. The string must remain valid for the lifetime of the container. */ explicit ext_list(string_view s) : s_(s) { } /// Return a const iterator to the beginning of the list const_iterator begin() const; /// Return a const iterator to the end of the list const_iterator end() const; /// Return a const iterator to the beginning of the list const_iterator cbegin() const; /// Return a const iterator to the end of the list const_iterator cend() const; /** Find a token in the list. @param s The token to find. A case-insensitive comparison is used. @return An iterator to the matching token, or `end()` if no token exists. */ BOOST_BEAST_DECL const_iterator find(string_view const& s); /** Return `true` if a token is present in the list. @param s The token to find. A case-insensitive comparison is used. */ BOOST_BEAST_DECL bool exists(string_view const& s); }; //------------------------------------------------------------------------------ /** A list of tokens in a comma separated HTTP field value. This container allows iteration of a list of items in a header field value. The input is a comma separated list of tokens. If a parsing error is encountered while iterating the string, the behavior of the container will be as if a string containing only characters up to but excluding the first invalid character was used to construct the list. @par BNF @code token-list = *( "," OWS ) token *( OWS "," [ OWS token ] ) @endcode To use this class, construct with the string to be parsed and then use @ref begin and @ref end, or range-for to iterate each item: @par Example @code for(auto const& token : token_list{"apple, pear, banana"}) std::cout << token << "\n"; @endcode */ class token_list { using iter_type = string_view::const_iterator; string_view s_; public: /// The type of each element in the token list. using value_type = string_view; /// A constant iterator to the list #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else class const_iterator; #endif /** Construct a list. @param s A string containing the list contents. The string must remain valid for the lifetime of the container. */ explicit token_list(string_view s) : s_(s) { } /// Return a const iterator to the beginning of the list const_iterator begin() const; /// Return a const iterator to the end of the list const_iterator end() const; /// Return a const iterator to the beginning of the list const_iterator cbegin() const; /// Return a const iterator to the end of the list const_iterator cend() const; /** Return `true` if a token is present in the list. @param s The token to find. A case-insensitive comparison is used. */ BOOST_BEAST_DECL bool exists(string_view const& s); }; /** A list of tokens in a comma separated HTTP field value. This container allows iteration of a list of items in a header field value. The input is a comma separated list of tokens. If a parsing error is encountered while iterating the string, the behavior of the container will be as if a string containing only characters up to but excluding the first invalid character was used to construct the list. @par BNF @code token-list = *( "," OWS ) token *( OWS "," [ OWS token ] ) @endcode To use this class, construct with the string to be parsed and then use `begin` and `end`, or range-for to iterate each item: @par Example @code for(auto const& token : token_list{"apple, pear, banana"}) std::cout << token << "\n"; @endcode */ using opt_token_list = detail::basic_parsed_list< detail::opt_token_list_policy>; /** Returns `true` if a parsed list is parsed without errors. This function iterates a single pass through a parsed list and returns `true` if there were no parsing errors, else returns `false`. */ template<class Policy> bool validate_list(detail::basic_parsed_list< Policy> const& list); } // http } // beast } // boost #include <boost/beast/http/impl/rfc7230.hpp> #endif PK PP�[+� V V http/chunk_encode.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_CHUNK_ENCODE_HPP #define BOOST_BEAST_HTTP_CHUNK_ENCODE_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffers_cat.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/beast/http/detail/chunk_encode.hpp> #include <boost/asio/buffer.hpp> #include <memory> #include <type_traits> namespace boost { namespace beast { namespace http { /** A chunked encoding crlf This implements a <em>ConstBufferSequence</em> holding the CRLF (`"\r\n"`) used as a delimiter in a @em chunk. To use this class, pass an instance of it to a stream algorithm as the buffer sequence: @code // writes "\r\n" net::write(stream, chunk_crlf{}); @endcode @see https://tools.ietf.org/html/rfc7230#section-4.1 */ struct chunk_crlf { /// Constructor chunk_crlf() = default; //----- /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using value_type = __implementation_defined__; #else using value_type = net::const_buffer; #endif /// Required for <em>ConstBufferSequence</em> using const_iterator = value_type const*; /// Required for <em>ConstBufferSequence</em> chunk_crlf(chunk_crlf const&) = default; /// Required for <em>ConstBufferSequence</em> const_iterator begin() const { static net::const_buffer const cb{"\r\n", 2}; return &cb; } /// Required for <em>ConstBufferSequence</em> const_iterator end() const { return begin() + 1; } }; //------------------------------------------------------------------------------ /** A @em chunk header This implements a <em>ConstBufferSequence</em> representing the header of a @em chunk. The serialized format is as follows: @code chunk-header = 1*HEXDIG chunk-ext CRLF chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string @endcode The chunk extension is optional. After the header and chunk body have been serialized, it is the callers responsibility to also serialize the final CRLF (`"\r\n"`). This class allows the caller to emit piecewise chunk bodies, by first serializing the chunk header using this class and then serializing the chunk body in a series of one or more calls to a stream write operation. To use this class, pass an instance of it to a stream algorithm as the buffer sequence: @code // writes "400;x\r\n" net::write(stream, chunk_header{1024, "x"}); @endcode @see https://tools.ietf.org/html/rfc7230#section-4.1 */ class chunk_header { using view_type = buffers_cat_view< detail::chunk_size, // chunk-size net::const_buffer, // chunk-extensions chunk_crlf>; // CRLF std::shared_ptr< detail::chunk_extensions> exts_; view_type view_; public: /** Constructor This constructs a buffer sequence representing a @em chunked-body size and terminating CRLF (`"\r\n"`) with no chunk extensions. @param size The size of the chunk body that follows. The value must be greater than zero. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ explicit chunk_header(std::size_t size); /** Constructor This constructs a buffer sequence representing a @em chunked-body size and terminating CRLF (`"\r\n"`) with provided chunk extensions. @param size The size of the chunk body that follows. The value must be greater than zero. @param extensions The chunk extensions string. This string must be formatted correctly as per rfc7230, using this BNF syntax: @code chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string @endcode The data pointed to by this string view must remain valid for the lifetime of any operations performed on the object. @see https://tools.ietf.org/html/rfc7230#section-4.1.1 */ chunk_header( std::size_t size, string_view extensions); /** Constructor This constructs a buffer sequence representing a @em chunked-body size and terminating CRLF (`"\r\n"`) with provided chunk extensions. The default allocator is used to provide storage for the extensions object. @param size The size of the chunk body that follows. The value must be greater than zero. @param extensions The chunk extensions object. The expression `extensions.str()` must be valid, and the return type must be convertible to @ref string_view. This object will be copied or moved as needed to ensure that the chunk header object retains ownership of the buffers provided by the chunk extensions object. @note This function participates in overload resolution only if @b ChunkExtensions meets the requirements stated above. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ template<class ChunkExtensions #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< detail::is_chunk_extensions< ChunkExtensions>::value>::type #endif > chunk_header( std::size_t size, ChunkExtensions&& extensions); /** Constructor This constructs a buffer sequence representing a @em chunked-body size and terminating CRLF (`"\r\n"`) with provided chunk extensions. The specified allocator is used to provide storage for the extensions object. @param size The size of the chunk body that follows. The value be greater than zero. @param extensions The chunk extensions object. The expression `extensions.str()` must be valid, and the return type must be convertible to @ref string_view. This object will be copied or moved as needed to ensure that the chunk header object retains ownership of the buffers provided by the chunk extensions object. @param allocator The allocator to provide storage for the moved or copied extensions object. @note This function participates in overload resolution only if @b ChunkExtensions meets the requirements stated above. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ template<class ChunkExtensions, class Allocator #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< detail::is_chunk_extensions< ChunkExtensions>::value>::type #endif > chunk_header( std::size_t size, ChunkExtensions&& extensions, Allocator const& allocator); //----- /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using value_type = __implementation_defined__; #else using value_type = typename view_type::value_type; #endif /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else using const_iterator = typename view_type::const_iterator; #endif /// Required for <em>ConstBufferSequence</em> chunk_header(chunk_header const&) = default; /// Required for <em>ConstBufferSequence</em> const_iterator begin() const { return view_.begin(); } /// Required for <em>ConstBufferSequence</em> const_iterator end() const { return view_.end(); } }; //------------------------------------------------------------------------------ /** A @em chunk This implements a <em>ConstBufferSequence</em> representing a @em chunk. The serialized format is as follows: @code chunk = chunk-size [ chunk-ext ] CRLF chunk-data CRLF chunk-size = 1*HEXDIG chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string chunk-data = 1*OCTET ; a sequence of chunk-size octets @endcode The chunk extension is optional. To use this class, pass an instance of it to a stream algorithm as the buffer sequence. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ template<class ConstBufferSequence> class chunk_body { using view_type = buffers_cat_view< detail::chunk_size, // chunk-size net::const_buffer, // chunk-extensions chunk_crlf, // CRLF ConstBufferSequence, // chunk-body chunk_crlf>; // CRLF std::shared_ptr< detail::chunk_extensions> exts_; view_type view_; public: /** Constructor This constructs buffers representing a complete @em chunk with no chunk extensions and having the size and contents of the specified buffer sequence. @param buffers A buffer sequence representing the chunk body. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid while this object is in use. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ explicit chunk_body( ConstBufferSequence const& buffers); /** Constructor This constructs buffers representing a complete @em chunk with the passed chunk extensions and having the size and contents of the specified buffer sequence. @param buffers A buffer sequence representing the chunk body. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid while this object is in use. @param extensions The chunk extensions string. This string must be formatted correctly as per rfc7230, using this BNF syntax: @code chunk-ext = *( ";" chunk-ext-name [ "=" chunk-ext-val ] ) chunk-ext-name = token chunk-ext-val = token / quoted-string @endcode The data pointed to by this string view must remain valid for the lifetime of any operations performed on the object. @see https://tools.ietf.org/html/rfc7230#section-4.1.1 */ chunk_body( ConstBufferSequence const& buffers, string_view extensions); /** Constructor This constructs buffers representing a complete @em chunk with the passed chunk extensions and having the size and contents of the specified buffer sequence. The default allocator is used to provide storage for the extensions object. @param buffers A buffer sequence representing the chunk body. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid while this object is in use. @param extensions The chunk extensions object. The expression `extensions.str()` must be valid, and the return type must be convertible to @ref string_view. This object will be copied or moved as needed to ensure that the chunk header object retains ownership of the buffers provided by the chunk extensions object. @note This function participates in overload resolution only if @b ChunkExtensions meets the requirements stated above. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ template<class ChunkExtensions #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< ! std::is_convertible<typename std::decay< ChunkExtensions>::type, string_view>::value>::type #endif > chunk_body( ConstBufferSequence const& buffers, ChunkExtensions&& extensions); /** Constructor This constructs buffers representing a complete @em chunk with the passed chunk extensions and having the size and contents of the specified buffer sequence. The specified allocator is used to provide storage for the extensions object. @param buffers A buffer sequence representing the chunk body. Although the buffers object may be copied as necessary, ownership of the underlying memory blocks is retained by the caller, which must guarantee that they remain valid while this object is in use. @param extensions The chunk extensions object. The expression `extensions.str()` must be valid, and the return type must be convertible to @ref string_view. This object will be copied or moved as needed to ensure that the chunk header object retains ownership of the buffers provided by the chunk extensions object. @param allocator The allocator to provide storage for the moved or copied extensions object. @note This function participates in overload resolution only if @b ChunkExtensions meets the requirements stated above. @see https://tools.ietf.org/html/rfc7230#section-4.1 */ template<class ChunkExtensions, class Allocator #if ! BOOST_BEAST_DOXYGEN , class = typename std::enable_if< ! std::is_convertible<typename std::decay< ChunkExtensions>::type, string_view>::value>::type #endif > chunk_body( ConstBufferSequence const& buffers, ChunkExtensions&& extensions, Allocator const& allocator); //----- /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using value_type = __implementation_defined__; #else using value_type = typename view_type::value_type; #endif /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else using const_iterator = typename view_type::const_iterator; #endif /// Required for <em>ConstBufferSequence</em> const_iterator begin() const { return view_.begin(); } /// Required for <em>ConstBufferSequence</em> const_iterator end() const { return view_.end(); } }; //------------------------------------------------------------------------------ /** A chunked-encoding last chunk */ template<class Trailer = chunk_crlf> class chunk_last { static_assert( is_fields<Trailer>::value || net::is_const_buffer_sequence<Trailer>::value, "Trailer requirements not met"); using buffers_type = typename detail::buffers_or_fields<Trailer>::type; using view_type = buffers_cat_view< detail::chunk_size0, // "0\r\n" buffers_type>; // Trailer (includes CRLF) template<class Allocator> buffers_type prepare(Trailer const& trailer, Allocator const& alloc); buffers_type prepare(Trailer const& trailer, std::true_type); buffers_type prepare(Trailer const& trailer, std::false_type); std::shared_ptr<void> sp_; view_type view_; public: /** Constructor The last chunk will have an empty trailer */ chunk_last(); /** Constructor @param trailer The trailer to use. This may be a type meeting the requirements of either Fields or ConstBufferSequence. If it is a ConstBufferSequence, the trailer must be formatted correctly as per rfc7230 including a CRLF on its own line to denote the end of the trailer. */ explicit chunk_last(Trailer const& trailer); /** Constructor @param trailer The trailer to use. This type must meet the requirements of Fields. @param allocator The allocator to use for storing temporary data associated with the serialized trailer buffers. */ #if BOOST_BEAST_DOXYGEN template<class Allocator> chunk_last(Trailer const& trailer, Allocator const& allocator); #else template<class DeducedTrailer, class Allocator, class = typename std::enable_if< is_fields<DeducedTrailer>::value>::type> chunk_last( DeducedTrailer const& trailer, Allocator const& allocator); #endif //----- /// Required for <em>ConstBufferSequence</em> chunk_last(chunk_last const&) = default; /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using value_type = __implementation_defined__; #else using value_type = typename view_type::value_type; #endif /// Required for <em>ConstBufferSequence</em> #if BOOST_BEAST_DOXYGEN using const_iterator = __implementation_defined__; #else using const_iterator = typename view_type::const_iterator; #endif /// Required for <em>ConstBufferSequence</em> const_iterator begin() const { return view_.begin(); } /// Required for <em>ConstBufferSequence</em> const_iterator end() const { return view_.end(); } }; //------------------------------------------------------------------------------ /** A set of chunk extensions This container stores a set of chunk extensions suited for use with @ref chunk_header and @ref chunk_body. The container may be iterated to access the extensions in their structured form. Meets the requirements of ChunkExtensions */ template<class Allocator> class basic_chunk_extensions { std::basic_string<char, std::char_traits<char>, Allocator> s_; std::basic_string<char, std::char_traits<char>, Allocator> range_; template<class FwdIt> FwdIt do_parse(FwdIt it, FwdIt last, error_code& ec); void do_insert(string_view name, string_view value); public: /** The type of value when iterating. The first element of the pair is the name, and the second element is the value which may be empty. The value is stored in its raw representation, without quotes or escapes. */ using value_type = std::pair<string_view, string_view>; class const_iterator; /// Constructor basic_chunk_extensions() = default; /// Constructor basic_chunk_extensions(basic_chunk_extensions&&) = default; /// Constructor basic_chunk_extensions(basic_chunk_extensions const&) = default; /** Constructor @param allocator The allocator to use for storing the serialized extension */ explicit basic_chunk_extensions(Allocator const& allocator) : s_(allocator) { } /** Clear the chunk extensions This preserves the capacity of the internal string used to hold the serialized representation. */ void clear() { s_.clear(); } /** Parse a set of chunk extensions Any previous extensions will be cleared */ void parse(string_view s, error_code& ec); /** Insert an extension name with an empty value @param name The name of the extension */ void insert(string_view name); /** Insert an extension value @param name The name of the extension @param value The value to insert. Depending on the contents, the serialized extension may use a quoted string. */ void insert(string_view name, string_view value); /// Return the serialized representation of the chunk extension string_view str() const { return s_; } const_iterator begin() const; const_iterator end() const; }; //------------------------------------------------------------------------------ /// A set of chunk extensions using chunk_extensions = basic_chunk_extensions<std::allocator<char>>; /** Returns a @ref chunk_body This functions constructs and returns a complete @ref chunk_body for a chunk body represented by the specified buffer sequence. @param buffers The buffers representing the chunk body. @param args Optional arguments passed to the @ref chunk_body constructor. @note This function is provided as a notational convenience to omit specification of the class template arguments. */ template<class ConstBufferSequence, class... Args> auto make_chunk( ConstBufferSequence const& buffers, Args&&... args) -> chunk_body<ConstBufferSequence> { return chunk_body<ConstBufferSequence>( buffers, std::forward<Args>(args)...); } /** Returns a @ref chunk_last @note This function is provided as a notational convenience to omit specification of the class template arguments. */ inline chunk_last<chunk_crlf> make_chunk_last() { return chunk_last<chunk_crlf>{}; } /** Returns a @ref chunk_last This function construct and returns a complete @ref chunk_last for a last chunk containing the specified trailers. @param trailer A ConstBufferSequence or @note This function is provided as a notational convenience to omit specification of the class template arguments. @param args Optional arguments passed to the @ref chunk_last constructor. */ template<class Trailer, class... Args> chunk_last<Trailer> make_chunk_last( Trailer const& trailer, Args&&... args) { return chunk_last<Trailer>{ trailer, std::forward<Args>(args)...}; } } // http } // beast } // boost #include <boost/beast/http/impl/chunk_encode.hpp> #endif PK PP�[��D�(7 (7 http/basic_file_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_BASIC_FILE_BODY_HPP #define BOOST_BEAST_HTTP_BASIC_FILE_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/file_base.hpp> #include <boost/beast/http/message.hpp> #include <boost/assert.hpp> #include <boost/optional.hpp> #include <algorithm> #include <cstdio> #include <cstdint> #include <utility> namespace boost { namespace beast { namespace http { //[example_http_file_body_1 /** A message body represented by a file on the filesystem. Messages with this type have bodies represented by a file on the file system. When parsing a message using this body type, the data is stored in the file pointed to by the path, which must be writable. When serializing, the implementation will read the file and present those octets as the body content. This may be used to serve content from a directory as part of a web service. @tparam File The implementation to use for accessing files. This type must meet the requirements of <em>File</em>. */ template<class File> struct basic_file_body { // Make sure the type meets the requirements static_assert(is_file<File>::value, "File type requirements not met"); /// The type of File this body uses using file_type = File; // Algorithm for storing buffers when parsing. class reader; // Algorithm for retrieving buffers when serializing. class writer; // The type of the @ref message::body member. class value_type; /** Returns the size of the body @param body The file body to use */ static std::uint64_t size(value_type const& body); }; //] //[example_http_file_body_2 /** The type of the @ref message::body member. Messages declared using `basic_file_body` will have this type for the body member. This rich class interface allow the file to be opened with the file handle maintained directly in the object, which is attached to the message. */ template<class File> class basic_file_body<File>::value_type { // This body container holds a handle to the file // when it is open, and also caches the size when set. friend class reader; friend class writer; friend struct basic_file_body; // This represents the open file File file_; // The cached file size std::uint64_t file_size_ = 0; public: /** Destructor. If the file is open, it is closed first. */ ~value_type() = default; /// Constructor value_type() = default; /// Constructor value_type(value_type&& other) = default; /// Move assignment value_type& operator=(value_type&& other) = default; /// Return the file File& file() { return file_; } /// Returns `true` if the file is open bool is_open() const { return file_.is_open(); } /// Returns the size of the file if open std::uint64_t size() const { return file_size_; } /// Close the file if open void close(); /** Open a file at the given path with the specified mode @param path The utf-8 encoded path to the file @param mode The file mode to use @param ec Set to the error, if any occurred */ void open(char const* path, file_mode mode, error_code& ec); /** Set the open file This function is used to set the open file. Any previously set file will be closed. @param file The file to set. The file must be open or else an error occurs @param ec Set to the error, if any occurred */ void reset(File&& file, error_code& ec); }; template<class File> void basic_file_body<File>:: value_type:: close() { error_code ignored; file_.close(ignored); } template<class File> void basic_file_body<File>:: value_type:: open(char const* path, file_mode mode, error_code& ec) { // Open the file file_.open(path, mode, ec); if(ec) return; // Cache the size file_size_ = file_.size(ec); if(ec) { close(); return; } } template<class File> void basic_file_body<File>:: value_type:: reset(File&& file, error_code& ec) { // First close the file if open if(file_.is_open()) { error_code ignored; file_.close(ignored); } // Take ownership of the new file file_ = std::move(file); // Cache the size file_size_ = file_.size(ec); } // This is called from message::payload_size template<class File> std::uint64_t basic_file_body<File>:: size(value_type const& body) { // Forward the call to the body return body.size(); } //] //[example_http_file_body_3 /** Algorithm for retrieving buffers when serializing. Objects of this type are created during serialization to extract the buffers representing the body. */ template<class File> class basic_file_body<File>::writer { value_type& body_; // The body we are reading from std::uint64_t remain_; // The number of unread bytes char buf_[4096]; // Small buffer for reading public: // The type of buffer sequence returned by `get`. // using const_buffers_type = net::const_buffer; // Constructor. // // `h` holds the headers of the message we are // serializing, while `b` holds the body. // // Note that the message is passed by non-const reference. // This is intentional, because reading from the file // changes its "current position" which counts makes the // operation logically not-const (although it is bitwise // const). // // The BodyWriter concept allows the writer to choose // whether to take the message by const reference or // non-const reference. Depending on the choice, a // serializer constructed using that body type will // require the same const or non-const reference to // construct. // // Readers which accept const messages usually allow // the same body to be serialized by multiple threads // concurrently, while readers accepting non-const // messages may only be serialized by one thread at // a time. // template<bool isRequest, class Fields> writer(header<isRequest, Fields>& h, value_type& b); // Initializer // // This is called before the body is serialized and // gives the writer a chance to do something that might // need to return an error code. // void init(error_code& ec); // This function is called zero or more times to // retrieve buffers. A return value of `boost::none` // means there are no more buffers. Otherwise, // the contained pair will have the next buffer // to serialize, and a `bool` indicating whether // or not there may be additional buffers. boost::optional<std::pair<const_buffers_type, bool>> get(error_code& ec); }; //] //[example_http_file_body_4 // Here we just stash a reference to the path for later. // Rather than dealing with messy constructor exceptions, // we save the things that might fail for the call to `init`. // template<class File> template<bool isRequest, class Fields> basic_file_body<File>:: writer:: writer(header<isRequest, Fields>& h, value_type& b) : body_(b) { boost::ignore_unused(h); // The file must already be open BOOST_ASSERT(body_.file_.is_open()); // Get the size of the file remain_ = body_.file_size_; } // Initializer template<class File> void basic_file_body<File>:: writer:: init(error_code& ec) { // The error_code specification requires that we // either set the error to some value, or set it // to indicate no error. // // We don't do anything fancy so set "no error" ec = {}; } // This function is called repeatedly by the serializer to // retrieve the buffers representing the body. Our strategy // is to read into our buffer and return it until we have // read through the whole file. // template<class File> auto basic_file_body<File>:: writer:: get(error_code& ec) -> boost::optional<std::pair<const_buffers_type, bool>> { // Calculate the smaller of our buffer size, // or the amount of unread data in the file. auto const amount = remain_ > sizeof(buf_) ? sizeof(buf_) : static_cast<std::size_t>(remain_); // Handle the case where the file is zero length if(amount == 0) { // Modify the error code to indicate success // This is required by the error_code specification. // // NOTE We use the existing category instead of calling // into the library to get the generic category because // that saves us a possibly expensive atomic operation. // ec = {}; return boost::none; } // Now read the next buffer auto const nread = body_.file_.read(buf_, amount, ec); if(ec) return boost::none; if (nread == 0) { ec = error::short_read; return boost::none; } // Make sure there is forward progress BOOST_ASSERT(nread != 0); BOOST_ASSERT(nread <= remain_); // Update the amount remaining based on what we got remain_ -= nread; // Return the buffer to the caller. // // The second element of the pair indicates whether or // not there is more data. As long as there is some // unread bytes, there will be more data. Otherwise, // we set this bool to `false` so we will not be called // again. // ec = {}; return {{ const_buffers_type{buf_, nread}, // buffer to return. remain_ > 0 // `true` if there are more buffers. }}; } //] //[example_http_file_body_5 /** Algorithm for storing buffers when parsing. Objects of this type are created during parsing to store incoming buffers representing the body. */ template<class File> class basic_file_body<File>::reader { value_type& body_; // The body we are writing to public: // Constructor. // // This is called after the header is parsed and // indicates that a non-zero sized body may be present. // `h` holds the received message headers. // `b` is an instance of `basic_file_body`. // template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&h, value_type& b); // Initializer // // This is called before the body is parsed and // gives the reader a chance to do something that might // need to return an error code. It informs us of // the payload size (`content_length`) which we can // optionally use for optimization. // void init(boost::optional<std::uint64_t> const&, error_code& ec); // This function is called one or more times to store // buffer sequences corresponding to the incoming body. // template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec); // This function is called when writing is complete. // It is an opportunity to perform any final actions // which might fail, in order to return an error code. // Operations that might fail should not be attempted in // destructors, since an exception thrown from there // would terminate the program. // void finish(error_code& ec); }; //] //[example_http_file_body_6 // We don't do much in the reader constructor since the // file is already open. // template<class File> template<bool isRequest, class Fields> basic_file_body<File>:: reader:: reader(header<isRequest, Fields>& h, value_type& body) : body_(body) { boost::ignore_unused(h); } template<class File> void basic_file_body<File>:: reader:: init( boost::optional<std::uint64_t> const& content_length, error_code& ec) { // The file must already be open for writing BOOST_ASSERT(body_.file_.is_open()); // We don't do anything with this but a sophisticated // application might check available space on the device // to see if there is enough room to store the body. boost::ignore_unused(content_length); // The error_code specification requires that we // either set the error to some value, or set it // to indicate no error. // // We don't do anything fancy so set "no error" ec = {}; } // This will get called one or more times with body buffers // template<class File> template<class ConstBufferSequence> std::size_t basic_file_body<File>:: reader:: put(ConstBufferSequence const& buffers, error_code& ec) { // This function must return the total number of // bytes transferred from the input buffers. std::size_t nwritten = 0; // Loop over all the buffers in the sequence, // and write each one to the file. for(auto it = net::buffer_sequence_begin(buffers); it != net::buffer_sequence_end(buffers); ++it) { // Write this buffer to the file net::const_buffer buffer = *it; nwritten += body_.file_.write( buffer.data(), buffer.size(), ec); if(ec) return nwritten; } // Indicate success // This is required by the error_code specification ec = {}; return nwritten; } // Called after writing is done when there's no error. template<class File> void basic_file_body<File>:: reader:: finish(error_code& ec) { // This has to be cleared before returning, to // indicate no error. The specification requires it. ec = {}; } //] #if ! BOOST_BEAST_DOXYGEN // operator<< is not supported for file_body template<bool isRequest, class File, class Fields> std::ostream& operator<<(std::ostream&, message< isRequest, basic_file_body<File>, Fields> const&) = delete; #endif } // http } // beast } // boost #endif PK PP�[Ώ��� � http/read.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_READ_HPP #define BOOST_BEAST_HTTP_READ_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/stream_traits.hpp> #include <boost/beast/http/basic_parser.hpp> #include <boost/beast/http/message.hpp> #include <boost/asio/async_result.hpp> namespace boost { namespace beast { namespace http { //------------------------------------------------------------------------------ /** Read part of a message from a stream using a parser. This function is used to read part of a message from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li A call to @ref basic_parser::put with a non-empty buffer sequence is successful. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @return The number of bytes transferred from the stream. @throws system_error Thrown on failure. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_some( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser); /** Read part of a message from a stream using a parser. This function is used to read part of a message from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li A call to @ref basic_parser::put with a non-empty buffer sequence is successful. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must support the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @param ec Set to the error, if any occurred. @return The number of bytes transferred from the stream. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_some( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec); /** Read part of a message asynchronously from a stream using a parser. This function is used to asynchronously read part of a message from a stream into an instance of @ref basic_parser. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li A call to @ref basic_parser::put with a non-empty buffer sequence is successful. @li An error occurs. This operation is implemented in terms of zero or more calls to the next layer's `async_read_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other reads until this operation completes. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>AsyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. The object must remain valid at least until the handler is called; ownership is not transferred. @param parser The parser to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the total number of bytes transferred from the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The completion handler will receive as a parameter the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. */ template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type<AsyncReadStream>>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_some( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler = net::default_completion_token_t< executor_type<AsyncReadStream>>{}); //------------------------------------------------------------------------------ /** Read a complete message header from a stream using a parser. This function is used to read a complete message header from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li @ref basic_parser::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @return The number of bytes transferred from the stream. @throws system_error Thrown on failure. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `false` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_header( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser); /** Read a complete message header from a stream using a parser. This function is used to read a complete message header from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li @ref basic_parser::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @param ec Set to the error, if any occurred. @return The number of bytes transferred from the stream. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `false` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read_header( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec); /** Read a complete message header asynchronously from a stream using a parser. This function is used to asynchronously read a complete message header from a stream into an instance of @ref basic_parser. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li @ref basic_parser::is_header_done returns `true` @li An error occurs. This operation is implemented in terms of zero or more calls to the next layer's `async_read_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other reads until this operation completes. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>AsyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. The object must remain valid at least until the handler is called; ownership is not transferred. @param parser The parser to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the total number of bytes transferred from the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The completion handler will receive as a parameter the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `false` on the parser passed in. */ template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type<AsyncReadStream>>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read_header( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler = net::default_completion_token_t< executor_type<AsyncReadStream>>{}); //------------------------------------------------------------------------------ /** Read a complete message from a stream using a parser. This function is used to read a complete message from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li @ref basic_parser::is_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @return The number of bytes transferred from the stream. @throws system_error Thrown on failure. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser); /** Read a complete message from a stream using a parser. This function is used to read a complete message from a stream into an instance of @ref basic_parser. The call will block until one of the following conditions is true: @li @ref basic_parser::is_done returns `true` @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param parser The parser to use. @param ec Set to the error, if any occurred. @return The number of bytes transferred from the stream. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, error_code& ec); /** Read a complete message asynchronously from a stream using a parser. This function is used to asynchronously read a complete message from a stream into an instance of @ref basic_parser. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li @ref basic_parser::is_done returns `true` @li An error occurs. This operation is implemented in terms of zero or more calls to the next layer's `async_read_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other reads until this operation completes. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>AsyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. The object must remain valid at least until the handler is called; ownership is not transferred. @param parser The parser to use. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the total number of bytes transferred from the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The completion handler will receive as a parameter the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class AsyncReadStream, class DynamicBuffer, bool isRequest, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type<AsyncReadStream>>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, basic_parser<isRequest>& parser, ReadHandler&& handler = net::default_completion_token_t< executor_type<AsyncReadStream>>{}); //------------------------------------------------------------------------------ /** Read a complete message from a stream. This function is used to read a complete message from a stream into an instance of @ref message. The call will block until one of the following conditions is true: @li The entire message is read in. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param msg The container in which to store the message contents. This message container should not have previous contents, otherwise the behavior is undefined. The type must be meet the <em>MoveAssignable</em> and <em>MoveConstructible</em> requirements. @return The number of bytes transferred from the stream. @throws system_error Thrown on failure. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg); /** Read a complete message from a stream. This function is used to read a complete message from a stream into an instance of @ref message. The call will block until one of the following conditions is true: @li The entire message is read in. @li An error occurs. This operation is implemented in terms of one or more calls to the stream's `read_some` function. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>SyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. @param msg The container in which to store the message contents. This message container should not have previous contents, otherwise the behavior is undefined. The type must be meet the <em>MoveAssignable</em> and <em>MoveConstructible</em> requirements. @param ec Set to the error, if any occurred. @return The number of bytes transferred from the stream. @note The function returns the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class SyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator> std::size_t read( SyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg, error_code& ec); /** Read a complete message asynchronously from a stream. This function is used to asynchronously read a complete message from a stream into an instance of @ref message. The function call always returns immediately. The asynchronous operation will continue until one of the following conditions is true: @li The entire message is read in. @li An error occurs. This operation is implemented in terms of zero or more calls to the next layer's `async_read_some` function, and is known as a <em>composed operation</em>. The program must ensure that the stream performs no other reads until this operation completes. The implementation may read additional bytes from the stream that lie past the end of the message being read. These additional bytes are stored in the dynamic buffer, which must be preserved for subsequent reads. If the end of file error is received while reading from the stream, then the error returned from this function will be: @li @ref error::end_of_stream if no bytes were parsed, or @li @ref error::partial_message if any bytes were parsed but the message was incomplete, otherwise: @li A successful result. The next attempt to read will return @ref error::end_of_stream @param stream The stream from which the data is to be read. The type must meet the <em>AsyncReadStream</em> requirements. @param buffer Storage for additional bytes read by the implementation from the stream. This is both an input and an output parameter; on entry, the parser will be presented with any remaining data in the dynamic buffer's readable bytes sequence first. The type must meet the <em>DynamicBuffer</em> requirements. The object must remain valid at least until the handler is called; ownership is not transferred. @param msg The container in which to store the message contents. This message container should not have previous contents, otherwise the behavior is undefined. The type must be meet the <em>MoveAssignable</em> and <em>MoveConstructible</em> requirements. The object must remain valid at least until the handler is called; ownership is not transferred. @param handler The completion handler to invoke when the operation completes. The implementation takes ownership of the handler by performing a decay-copy. The equivalent function signature of the handler must be: @code void handler( error_code const& error, // result of operation std::size_t bytes_transferred // the total number of bytes transferred from the stream ); @endcode Regardless of whether the asynchronous operation completes immediately or not, the handler will not be invoked from within this function. Invocation of the handler will be performed in a manner equivalent to using `net::post`. @note The completion handler will receive as a parameter the total number of bytes transferred from the stream. This may be zero for the case where there is sufficient pre-existing message data in the dynamic buffer. The implementation will call @ref basic_parser::eager with the value `true` on the parser passed in. */ template< class AsyncReadStream, class DynamicBuffer, bool isRequest, class Body, class Allocator, BOOST_BEAST_ASYNC_TPARAM2 ReadHandler = net::default_completion_token_t< executor_type<AsyncReadStream>>> BOOST_BEAST_ASYNC_RESULT2(ReadHandler) async_read( AsyncReadStream& stream, DynamicBuffer& buffer, message<isRequest, Body, basic_fields<Allocator>>& msg, ReadHandler&& handler = net::default_completion_token_t< executor_type<AsyncReadStream>>{}); } // http } // beast } // boost #include <boost/beast/http/impl/read.hpp> #endif PK PP�[Ќ @�[ �[ http/basic_parser.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_BASIC_PARSER_HPP #define BOOST_BEAST_HTTP_BASIC_PARSER_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/error.hpp> #include <boost/beast/core/string.hpp> #include <boost/beast/http/field.hpp> #include <boost/beast/http/verb.hpp> #include <boost/beast/http/detail/basic_parser.hpp> #include <boost/asio/buffer.hpp> #include <boost/optional.hpp> #include <boost/assert.hpp> #include <limits> #include <memory> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { /** A parser for decoding HTTP/1 wire format messages. This parser is designed to efficiently parse messages in the HTTP/1 wire format. It allocates no memory when input is presented as a single contiguous buffer, and uses minimal state. It will handle chunked encoding and it understands the semantics of the Connection, Content-Length, and Upgrade fields. The parser is optimized for the case where the input buffer sequence consists of a single contiguous buffer. The @ref beast::basic_flat_buffer class is provided, which guarantees that the input sequence of the stream buffer will be represented by exactly one contiguous buffer. To ensure the optimum performance of the parser, use @ref beast::basic_flat_buffer with HTTP algorithms such as @ref read, @ref read_some, @ref async_read, and @ref async_read_some. Alternatively, the caller may use custom techniques to ensure that the structured portion of the HTTP message (header or chunk header) is contained in a linear buffer. The interface to the parser uses virtual member functions. To use this class, derive your type from @ref basic_parser. When bytes are presented, the implementation will make a series of zero or more calls to virtual functions, which the derived class must implement. Every virtual function must be provided by the derived class, or else a compilation error will be generated. The implementation will make sure that `ec` is clear before each virtual function is invoked. If a virtual function sets an error, it is propagated out of the parser to the caller. @tparam isRequest A `bool` indicating whether the parser will be presented with request or response message. @note If the parser encounters a field value with obs-fold longer than 4 kilobytes in length, an error is generated. */ template<bool isRequest> class basic_parser : private detail::basic_parser_base { boost::optional<std::uint64_t> body_limit_ = boost::optional<std::uint64_t>( default_body_limit(is_request{})); // max payload body std::uint64_t len_ = 0; // size of chunk or body std::uint64_t len0_ = 0; // content length if known std::unique_ptr<char[]> buf_; // temp storage std::size_t buf_len_ = 0; // size of buf_ std::size_t skip_ = 0; // resume search here std::uint32_t header_limit_ = 8192; // max header size unsigned short status_ = 0; // response status state state_ = state::nothing_yet; // initial state unsigned f_ = 0; // flags // limit on the size of the stack flat buffer static std::size_t constexpr max_stack_buffer = 8192; // Message will be complete after reading header static unsigned constexpr flagSkipBody = 1<< 0; // Consume input buffers across semantic boundaries static unsigned constexpr flagEager = 1<< 1; // The parser has read at least one byte static unsigned constexpr flagGotSome = 1<< 2; // Message semantics indicate a body is expected. // cleared if flagSkipBody set // static unsigned constexpr flagHasBody = 1<< 3; static unsigned constexpr flagHTTP11 = 1<< 4; static unsigned constexpr flagNeedEOF = 1<< 5; static unsigned constexpr flagExpectCRLF = 1<< 6; static unsigned constexpr flagConnectionClose = 1<< 7; static unsigned constexpr flagConnectionUpgrade = 1<< 8; static unsigned constexpr flagConnectionKeepAlive = 1<< 9; static unsigned constexpr flagContentLength = 1<< 10; static unsigned constexpr flagChunked = 1<< 11; static unsigned constexpr flagUpgrade = 1<< 12; static unsigned constexpr flagFinalChunk = 1<< 13; static constexpr std::uint64_t default_body_limit(std::true_type) { // limit for requests return 1 * 1024 * 1024; // 1MB } static constexpr std::uint64_t default_body_limit(std::false_type) { // limit for responses return 8 * 1024 * 1024; // 8MB } template<bool OtherIsRequest> friend class basic_parser; friend class basic_parser_test; protected: /// Default constructor basic_parser() = default; /** Move constructor @note After the move, the only valid operation on the moved-from object is destruction. */ basic_parser(basic_parser &&) = default; /// Move assignment basic_parser& operator=(basic_parser &&) = default; public: /// `true` if this parser parses requests, `false` for responses. using is_request = std::integral_constant<bool, isRequest>; /// Destructor virtual ~basic_parser() = default; /// Copy constructor basic_parser(basic_parser const&) = delete; /// Copy assignment basic_parser& operator=(basic_parser const&) = delete; /// Returns `true` if the parser has received at least one byte of input. bool got_some() const { return state_ != state::nothing_yet; } /** Returns `true` if the message is complete. The message is complete after the full header is prduced and one of the following is true: @li The skip body option was set. @li The semantics of the message indicate there is no body. @li The semantics of the message indicate a body is expected, and the entire body was parsed. */ bool is_done() const { return state_ == state::complete; } /** Returns `true` if a the parser has produced the full header. */ bool is_header_done() const { return state_ > state::fields; } /** Returns `true` if the message is an upgrade message. @note The return value is undefined unless @ref is_header_done would return `true`. */ bool upgrade() const { return (f_ & flagConnectionUpgrade) != 0; } /** Returns `true` if the last value for Transfer-Encoding is "chunked". @note The return value is undefined unless @ref is_header_done would return `true`. */ bool chunked() const { return (f_ & flagChunked) != 0; } /** Returns `true` if the message has keep-alive connection semantics. This function always returns `false` if @ref need_eof would return `false`. @note The return value is undefined unless @ref is_header_done would return `true`. */ bool keep_alive() const; /** Returns the optional value of Content-Length if known. @note The return value is undefined unless @ref is_header_done would return `true`. */ boost::optional<std::uint64_t> content_length() const; /** Returns the remaining content length if known If the message header specifies a Content-Length, the return value will be the number of bytes remaining in the payload body have not yet been parsed. @note The return value is undefined unless @ref is_header_done would return `true`. */ boost::optional<std::uint64_t> content_length_remaining() const; /** Returns `true` if the message semantics require an end of file. Depending on the contents of the header, the parser may require and end of file notification to know where the end of the body lies. If this function returns `true` it will be necessary to call @ref put_eof when there will never be additional data from the input. */ bool need_eof() const { return (f_ & flagNeedEOF) != 0; } /** Set the limit on the payload body. This function sets the maximum allowed size of the payload body, before any encodings except chunked have been removed. Depending on the message semantics, one of these cases will apply: @li The Content-Length is specified and exceeds the limit. In this case the result @ref error::body_limit is returned immediately after the header is parsed. @li The Content-Length is unspecified and the chunked encoding is not specified as the last encoding. In this case the end of message is determined by the end of file indicator on the associated stream or input source. If a sufficient number of body payload octets are presented to the parser to exceed the configured limit, the parse fails with the result @ref error::body_limit @li The Transfer-Encoding specifies the chunked encoding as the last encoding. In this case, when the number of payload body octets produced by removing the chunked encoding exceeds the configured limit, the parse fails with the result @ref error::body_limit. Setting the limit after any body octets have been parsed results in undefined behavior. The default limit is 1MB for requests and 8MB for responses. @param v An optional integral value representing the body limit. If this is equal to `boost::none`, then the body limit is disabled. */ void body_limit(boost::optional<std::uint64_t> v) { body_limit_ = v; } /** Set a limit on the total size of the header. This function sets the maximum allowed size of the header including all field name, value, and delimiter characters and also including the CRLF sequences in the serialized input. If the end of the header is not found within the limit of the header size, the error @ref error::header_limit is returned by @ref put. Setting the limit after any header octets have been parsed results in undefined behavior. */ void header_limit(std::uint32_t v) { header_limit_ = v; } /// Returns `true` if the eager parse option is set. bool eager() const { return (f_ & flagEager) != 0; } /** Set the eager parse option. Normally the parser returns after successfully parsing a structured element (header, chunk header, or chunk body) even if there are octets remaining in the input. This is necessary when attempting to parse the header first, or when the caller wants to inspect information which may be invalidated by subsequent parsing, such as a chunk extension. The `eager` option controls whether the parser keeps going after parsing structured element if there are octets remaining in the buffer and no error occurs. This option is automatically set or cleared during certain stream operations to improve performance with no change in functionality. The default setting is `false`. @param v `true` to set the eager parse option or `false` to disable it. */ void eager(bool v) { if(v) f_ |= flagEager; else f_ &= ~flagEager; } /// Returns `true` if the skip parse option is set. bool skip() const { return (f_ & flagSkipBody) != 0; } /** Set the skip parse option. This option controls whether or not the parser expects to see an HTTP body, regardless of the presence or absence of certain fields such as Content-Length or a chunked Transfer-Encoding. Depending on the request, some responses do not carry a body. For example, a 200 response to a CONNECT request from a tunneling proxy, or a response to a HEAD request. In these cases, callers may use this function inform the parser that no body is expected. The parser will consider the message complete after the header has been received. @param v `true` to set the skip body option or `false` to disable it. @note This function must called before any bytes are processed. */ void skip(bool v); /** Write a buffer sequence to the parser. This function attempts to incrementally parse the HTTP message data stored in the caller provided buffers. Upon success, a positive return value indicates that the parser made forward progress, consuming that number of bytes. In some cases there may be an insufficient number of octets in the input buffer in order to make forward progress. This is indicated by the code @ref error::need_more. When this happens, the caller should place additional bytes into the buffer sequence and call @ref put again. The error code @ref error::need_more is special. When this error is returned, a subsequent call to @ref put may succeed if the buffers have been updated. Otherwise, upon error the parser may not be restarted. @param buffers An object meeting the requirements of <em>ConstBufferSequence</em> that represents the next chunk of message data. If the length of this buffer sequence is one, the implementation will not allocate additional memory. The class @ref beast::basic_flat_buffer is provided as one way to meet this requirement @param ec Set to the error, if any occurred. @return The number of octets consumed in the buffer sequence. The caller should remove these octets even if the error is set. */ template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec); #if ! BOOST_BEAST_DOXYGEN std::size_t put(net::const_buffer buffer, error_code& ec); #endif /** Inform the parser that the end of stream was reached. In certain cases, HTTP needs to know where the end of the stream is. For example, sometimes servers send responses without Content-Length and expect the client to consume input (for the body) until EOF. Callbacks and errors will still be processed as usual. This is typically called when a read from the underlying stream object sets the error code to `net::error::eof`. @note Only valid after parsing a complete header. @param ec Set to the error, if any occurred. */ void put_eof(error_code& ec); protected: /** Called after receiving the request-line. This virtual function is invoked after receiving a request-line when parsing HTTP requests. It can only be called when `isRequest == true`. @param method The verb enumeration. If the method string is not one of the predefined strings, this value will be @ref verb::unknown. @param method_str The unmodified string representing the verb. @param target The request-target. @param version The HTTP-version. This will be 10 for HTTP/1.0, and 11 for HTTP/1.1. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_request_impl( verb method, string_view method_str, string_view target, int version, error_code& ec) = 0; /** Called after receiving the status-line. This virtual function is invoked after receiving a status-line when parsing HTTP responses. It can only be called when `isRequest == false`. @param code The numeric status code. @param reason The reason-phrase. Note that this value is now obsolete, and only provided for historical or diagnostic purposes. @param version The HTTP-version. This will be 10 for HTTP/1.0, and 11 for HTTP/1.1. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_response_impl( int code, string_view reason, int version, error_code& ec) = 0; /** Called once for each complete field in the HTTP header. This virtual function is invoked for each field that is received while parsing an HTTP message. @param name The known field enum value. If the name of the field is not recognized, this value will be @ref field::unknown. @param name_string The exact name of the field as received from the input, represented as a string. @param value A string holding the value of the field. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_field_impl( field name, string_view name_string, string_view value, error_code& ec) = 0; /** Called once after the complete HTTP header is received. This virtual function is invoked once, after the complete HTTP header is received while parsing a message. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_header_impl(error_code& ec) = 0; /** Called once before the body is processed. This virtual function is invoked once, before the content body is processed (but after the complete header is received). @param content_length A value representing the content length in bytes if the length is known (this can include a zero length). Otherwise, the value will be `boost::none`. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_body_init_impl( boost::optional<std::uint64_t> const& content_length, error_code& ec) = 0; /** Called each time additional data is received representing the content body. This virtual function is invoked for each piece of the body which is received while parsing of a message. This function is only used when no chunked transfer encoding is present. @param body A string holding the additional body contents. This may contain nulls or unprintable characters. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. @see on_chunk_body_impl */ virtual std::size_t on_body_impl( string_view body, error_code& ec) = 0; /** Called each time a new chunk header of a chunk encoded body is received. This function is invoked each time a new chunk header is received. The function is only used when the chunked transfer encoding is present. @param size The size of this chunk, in bytes. @param extensions A string containing the entire chunk extensions. This may be empty, indicating no extensions are present. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_chunk_header_impl( std::uint64_t size, string_view extensions, error_code& ec) = 0; /** Called each time additional data is received representing part of a body chunk. This virtual function is invoked for each piece of the body which is received while parsing of a message. This function is only used when no chunked transfer encoding is present. @param remain The number of bytes remaining in this chunk. This includes the contents of passed `body`. If this value is zero, then this represents the final chunk. @param body A string holding the additional body contents. This may contain nulls or unprintable characters. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. @return This function should return the number of bytes actually consumed from the `body` value. Any bytes that are not consumed on this call will be presented in a subsequent call. @see on_body_impl */ virtual std::size_t on_chunk_body_impl( std::uint64_t remain, string_view body, error_code& ec) = 0; /** Called once when the complete message is received. This virtual function is invoked once, after successfully parsing a complete HTTP message. @param ec An output parameter which the function may set to indicate an error. The error will be clear before this function is invoked. */ virtual void on_finish_impl(error_code& ec) = 0; private: boost::optional<std::uint64_t> content_length_unchecked() const; template<class ConstBufferSequence> std::size_t put_from_stack( std::size_t size, ConstBufferSequence const& buffers, error_code& ec); void maybe_need_more( char const* p, std::size_t n, error_code& ec); void parse_start_line( char const*& p, char const* last, error_code& ec, std::true_type); void parse_start_line( char const*& p, char const* last, error_code& ec, std::false_type); void parse_fields( char const*& p, char const* last, error_code& ec); void finish_header( error_code& ec, std::true_type); void finish_header( error_code& ec, std::false_type); void parse_body(char const*& p, std::size_t n, error_code& ec); void parse_body_to_eof(char const*& p, std::size_t n, error_code& ec); void parse_chunk_header(char const*& p, std::size_t n, error_code& ec); void parse_chunk_body(char const*& p, std::size_t n, error_code& ec); void do_field(field f, string_view value, error_code& ec); }; } // http } // beast } // boost #include <boost/beast/http/impl/basic_parser.hpp> #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/basic_parser.ipp> #endif #endif PK PP�[�?� 9 9 http/buffer_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_BUFFER_BODY_HPP #define BOOST_BEAST_HTTP_BUFFER_BODY_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/buffer_traits.hpp> #include <boost/beast/http/error.hpp> #include <boost/beast/http/message.hpp> #include <boost/beast/http/type_traits.hpp> #include <boost/optional.hpp> #include <type_traits> #include <utility> namespace boost { namespace beast { namespace http { /** A <em>Body</em> using a caller provided buffer Messages using this body type may be serialized and parsed. To use this class, the caller must initialize the members of @ref buffer_body::value_type to appropriate values before each call to read or write during a stream operation. */ struct buffer_body { /// The type of the body member when used in a message. struct value_type { /** A pointer to a contiguous area of memory of @ref size octets, else `nullptr`. @par When Serializing If this is `nullptr` and `more` is `true`, the error @ref error::need_buffer will be returned from @ref serializer::get Otherwise, the serializer will use the memory pointed to by `data` having `size` octets of valid storage as the next buffer representing the body. @par When Parsing If this is `nullptr`, the error @ref error::need_buffer will be returned from @ref parser::put. Otherwise, the parser will store body octets into the memory pointed to by `data` having `size` octets of valid storage. After octets are stored, the `data` and `size` members are adjusted: `data` is incremented to point to the next octet after the data written, while `size` is decremented to reflect the remaining space at the memory location pointed to by `data`. */ void* data = nullptr; /** The number of octets in the buffer pointed to by @ref data. @par When Serializing If `data` is `nullptr` during serialization, this value is ignored. Otherwise, it represents the number of valid body octets pointed to by `data`. @par When Parsing The value of this field will be decremented during parsing to indicate the number of remaining free octets in the buffer pointed to by `data`. When it reaches zero, the parser will return @ref error::need_buffer, indicating to the caller that the values of `data` and `size` should be updated to point to a new memory buffer. */ std::size_t size = 0; /** `true` if this is not the last buffer. @par When Serializing If this is `true` and `data` is `nullptr`, the error @ref error::need_buffer will be returned from @ref serializer::get @par When Parsing This field is not used during parsing. */ bool more = true; }; /** The algorithm for parsing the body Meets the requirements of <em>BodyReader</em>. */ #if BOOST_BEAST_DOXYGEN using reader = __implementation_defined__; #else class reader { value_type& body_; public: template<bool isRequest, class Fields> explicit reader(header<isRequest, Fields>&, value_type& b) : body_(b) { } void init(boost::optional<std::uint64_t> const&, error_code& ec) { ec = {}; } template<class ConstBufferSequence> std::size_t put(ConstBufferSequence const& buffers, error_code& ec) { if(! body_.data) { ec = error::need_buffer; return 0; } auto const bytes_transferred = net::buffer_copy(net::buffer( body_.data, body_.size), buffers); body_.data = static_cast<char*>( body_.data) + bytes_transferred; body_.size -= bytes_transferred; if(bytes_transferred == buffer_bytes(buffers)) ec = {}; else ec = error::need_buffer; return bytes_transferred; } void finish(error_code& ec) { ec = {}; } }; #endif /** The algorithm for serializing the body Meets the requirements of <em>BodyWriter</em>. */ #if BOOST_BEAST_DOXYGEN using writer = __implementation_defined__; #else class writer { bool toggle_ = false; value_type const& body_; public: using const_buffers_type = net::const_buffer; template<bool isRequest, class Fields> explicit writer(header<isRequest, Fields> const&, value_type const& b) : body_(b) { } void init(error_code& ec) { ec = {}; } boost::optional< std::pair<const_buffers_type, bool>> get(error_code& ec) { if(toggle_) { if(body_.more) { toggle_ = false; ec = error::need_buffer; } else { ec = {}; } return boost::none; } if(body_.data) { ec = {}; toggle_ = true; return {{const_buffers_type{ body_.data, body_.size}, body_.more}}; } if(body_.more) ec = error::need_buffer; else ec = {}; return boost::none; } }; #endif }; #if ! BOOST_BEAST_DOXYGEN // operator<< is not supported for buffer_body template<bool isRequest, class Fields> std::ostream& operator<<(std::ostream& os, message<isRequest, buffer_body, Fields> const& msg) = delete; #endif } // http } // beast } // boost #endif PK PP�[�6l� � http/dynamic_body.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_DYNAMIC_BODY_HPP #define BOOST_BEAST_HTTP_DYNAMIC_BODY_HPP #include <boost/beast/core/multi_buffer.hpp> #include <boost/beast/http/basic_dynamic_body.hpp> namespace boost { namespace beast { namespace http { /** A dynamic message body represented by a @ref multi_buffer Meets the requirements of <em>Body</em>. */ using dynamic_body = basic_dynamic_body<multi_buffer>; } // http } // beast } // boost #endif PK PP�[�t��% �% http/field.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_FIELD_HPP #define BOOST_BEAST_HTTP_FIELD_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <iosfwd> namespace boost { namespace beast { namespace http { enum class field : unsigned short { unknown = 0, a_im, accept, accept_additions, accept_charset, accept_datetime, accept_encoding, accept_features, accept_language, accept_patch, accept_post, accept_ranges, access_control, access_control_allow_credentials, access_control_allow_headers, access_control_allow_methods, access_control_allow_origin, access_control_expose_headers, access_control_max_age, access_control_request_headers, access_control_request_method, age, allow, alpn, also_control, alt_svc, alt_used, alternate_recipient, alternates, apparently_to, apply_to_redirect_ref, approved, archive, archived_at, article_names, article_updates, authentication_control, authentication_info, authentication_results, authorization, auto_submitted, autoforwarded, autosubmitted, base, bcc, body, c_ext, c_man, c_opt, c_pep, c_pep_info, cache_control, caldav_timezones, cancel_key, cancel_lock, cc, close, comments, compliance, connection, content_alternative, content_base, content_description, content_disposition, content_duration, content_encoding, content_features, content_id, content_identifier, content_language, content_length, content_location, content_md5, content_range, content_return, content_script_type, content_style_type, content_transfer_encoding, content_type, content_version, control, conversion, conversion_with_loss, cookie, cookie2, cost, dasl, date, date_received, dav, default_style, deferred_delivery, delivery_date, delta_base, depth, derived_from, destination, differential_id, digest, discarded_x400_ipms_extensions, discarded_x400_mts_extensions, disclose_recipients, disposition_notification_options, disposition_notification_to, distribution, dkim_signature, dl_expansion_history, downgraded_bcc, downgraded_cc, downgraded_disposition_notification_to, downgraded_final_recipient, downgraded_from, downgraded_in_reply_to, downgraded_mail_from, downgraded_message_id, downgraded_original_recipient, downgraded_rcpt_to, downgraded_references, downgraded_reply_to, downgraded_resent_bcc, downgraded_resent_cc, downgraded_resent_from, downgraded_resent_reply_to, downgraded_resent_sender, downgraded_resent_to, downgraded_return_path, downgraded_sender, downgraded_to, ediint_features, eesst_version, encoding, encrypted, errors_to, etag, expect, expires, expiry_date, ext, followup_to, forwarded, from, generate_delivery_report, getprofile, hobareg, host, http2_settings, if_, if_match, if_modified_since, if_none_match, if_range, if_schedule_tag_match, if_unmodified_since, im, importance, in_reply_to, incomplete_copy, injection_date, injection_info, jabber_id, keep_alive, keywords, label, language, last_modified, latest_delivery_time, lines, link, list_archive, list_help, list_id, list_owner, list_post, list_subscribe, list_unsubscribe, list_unsubscribe_post, location, lock_token, man, max_forwards, memento_datetime, message_context, message_id, message_type, meter, method_check, method_check_expires, mime_version, mmhs_acp127_message_identifier, mmhs_authorizing_users, mmhs_codress_message_indicator, mmhs_copy_precedence, mmhs_exempted_address, mmhs_extended_authorisation_info, mmhs_handling_instructions, mmhs_message_instructions, mmhs_message_type, mmhs_originator_plad, mmhs_originator_reference, mmhs_other_recipients_indicator_cc, mmhs_other_recipients_indicator_to, mmhs_primary_precedence, mmhs_subject_indicator_codes, mt_priority, negotiate, newsgroups, nntp_posting_date, nntp_posting_host, non_compliance, obsoletes, opt, optional, optional_www_authenticate, ordering_type, organization, origin, original_encoded_information_types, original_from, original_message_id, original_recipient, original_sender, original_subject, originator_return_address, overwrite, p3p, path, pep, pep_info, pics_label, position, posting_version, pragma, prefer, preference_applied, prevent_nondelivery_report, priority, privicon, profileobject, protocol, protocol_info, protocol_query, protocol_request, proxy_authenticate, proxy_authentication_info, proxy_authorization, proxy_connection, proxy_features, proxy_instruction, public_, public_key_pins, public_key_pins_report_only, range, received, received_spf, redirect_ref, references, referer, referer_root, relay_version, reply_by, reply_to, require_recipient_valid_since, resent_bcc, resent_cc, resent_date, resent_from, resent_message_id, resent_reply_to, resent_sender, resent_to, resolution_hint, resolver_location, retry_after, return_path, safe, schedule_reply, schedule_tag, sec_fetch_dest, sec_fetch_mode, sec_fetch_site, sec_fetch_user, sec_websocket_accept, sec_websocket_extensions, sec_websocket_key, sec_websocket_protocol, sec_websocket_version, security_scheme, see_also, sender, sensitivity, server, set_cookie, set_cookie2, setprofile, sio_label, sio_label_history, slug, soapaction, solicitation, status_uri, strict_transport_security, subject, subok, subst, summary, supersedes, surrogate_capability, surrogate_control, tcn, te, timeout, title, to, topic, trailer, transfer_encoding, ttl, ua_color, ua_media, ua_pixels, ua_resolution, ua_windowpixels, upgrade, urgency, uri, user_agent, variant_vary, vary, vbr_info, version, via, want_digest, warning, www_authenticate, x_archived_at, x_device_accept, x_device_accept_charset, x_device_accept_encoding, x_device_accept_language, x_device_user_agent, x_frame_options, x_mittente, x_pgp_sig, x_ricevuta, x_riferimento_message_id, x_tiporicevuta, x_trasporto, x_verificasicurezza, x400_content_identifier, x400_content_return, x400_content_type, x400_mts_identifier, x400_originator, x400_received, x400_recipients, x400_trace, xref }; /** Convert a field enum to a string. @param f The field to convert */ BOOST_BEAST_DECL string_view to_string(field f); /** Attempt to convert a string to a field enum. The string comparison is case-insensitive. @return The corresponding field, or @ref field::unknown if no known field matches. */ BOOST_BEAST_DECL field string_to_field(string_view s); /// Write the text for a field name to an output stream. BOOST_BEAST_DECL std::ostream& operator<<(std::ostream& os, field f); } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/field.ipp> #endif #endif PK PP�[ʚ��D D http/status.hppnu �[��� // // Copyright (c) 2016-2019 Vinnie Falco (vinnie dot falco at gmail dot com) // // Distributed under the Boost Software License, Version 1.0. (See accompanying // file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) // // Official repository: https://github.com/boostorg/beast // #ifndef BOOST_BEAST_HTTP_STATUS_HPP #define BOOST_BEAST_HTTP_STATUS_HPP #include <boost/beast/core/detail/config.hpp> #include <boost/beast/core/string.hpp> #include <iosfwd> namespace boost { namespace beast { namespace http { enum class status : unsigned { /** An unknown status-code. This value indicates that the value for the status code is not in the list of commonly recognized status codes. Callers interested in the exactly value should use the interface which provides the raw integer. */ unknown = 0, continue_ = 100, /** Switching Protocols This status indicates that a request to switch to a new protocol was accepted and applied by the server. A successful response to a WebSocket Upgrade HTTP request will have this code. */ switching_protocols = 101, processing = 102, ok = 200, created = 201, accepted = 202, non_authoritative_information = 203, no_content = 204, reset_content = 205, partial_content = 206, multi_status = 207, already_reported = 208, im_used = 226, multiple_choices = 300, moved_permanently = 301, found = 302, see_other = 303, not_modified = 304, use_proxy = 305, temporary_redirect = 307, permanent_redirect = 308, bad_request = 400, unauthorized = 401, payment_required = 402, forbidden = 403, not_found = 404, method_not_allowed = 405, not_acceptable = 406, proxy_authentication_required = 407, request_timeout = 408, conflict = 409, gone = 410, length_required = 411, precondition_failed = 412, payload_too_large = 413, uri_too_long = 414, unsupported_media_type = 415, range_not_satisfiable = 416, expectation_failed = 417, misdirected_request = 421, unprocessable_entity = 422, locked = 423, failed_dependency = 424, upgrade_required = 426, precondition_required = 428, too_many_requests = 429, request_header_fields_too_large = 431, connection_closed_without_response = 444, unavailable_for_legal_reasons = 451, client_closed_request = 499, internal_server_error = 500, not_implemented = 501, bad_gateway = 502, service_unavailable = 503, gateway_timeout = 504, http_version_not_supported = 505, variant_also_negotiates = 506, insufficient_storage = 507, loop_detected = 508, not_extended = 510, network_authentication_required = 511, network_connect_timeout_error = 599 }; /** Represents the class of a status-code. */ enum class status_class : unsigned { /// Unknown status-class unknown = 0, /// The request was received, continuing processing. informational = 1, /// The request was successfully received, understood, and accepted. successful = 2, /// Further action needs to be taken in order to complete the request. redirection = 3, /// The request contains bad syntax or cannot be fulfilled. client_error = 4, /// The server failed to fulfill an apparently valid request. server_error = 5, }; /** Converts the integer to a known status-code. If the integer does not match a known status code, @ref status::unknown is returned. */ BOOST_BEAST_DECL status int_to_status(unsigned v); /** Convert an integer to a status_class. @param v The integer representing a status code. @return The status class. If the integer does not match a known status class, @ref status_class::unknown is returned. */ BOOST_BEAST_DECL status_class to_status_class(unsigned v); /** Convert a status_code to a status_class. @param v The status code to convert. @return The status class. */ BOOST_BEAST_DECL status_class to_status_class(status v); /** Returns the obsolete reason-phrase text for a status code. @param v The status code to use. */ BOOST_BEAST_DECL string_view obsolete_reason(status v); /// Outputs the standard reason phrase of a status code to a stream. BOOST_BEAST_DECL std::ostream& operator<<(std::ostream&, status); } // http } // beast } // boost #ifdef BOOST_BEAST_HEADER_ONLY #include <boost/beast/http/impl/status.ipp> #endif #endif PK OP�[�*��G G zlib.hppnu �[��� PK OP�[h��z z core.hppnu �[��� PK OP�[�[�� � 1 zlib/zlib.hppnu �[��� PK OP�[��W� � zlib/impl/error.ippnu �[��� PK OP�[��� � �- zlib/impl/error.hppnu �[��� PK OP�[q�V� 6 zlib/error.hppnu �[��� PK OP�[��.� .� mF zlib/detail/inflate_stream.ippnu �[��� PK OP�[��Lj � �� zlib/detail/window.hppnu �[��� PK OP�[ ��?. . �� zlib/detail/deflate_stream.ippnu �[��� PK OP�[��G��f �f 3 zlib/detail/deflate_stream.hppnu �[��� PK OP�[<�9��$ �$ zi zlib/detail/inflate_stream.hppnu �[��� PK OP�[̔��e e �� zlib/detail/bitstream.hppnu �[��� PK OP�[�7!\� � R� zlib/detail/ranges.hppnu �[��� PK OP�[�� ,? ,? E� zlib/deflate_stream.hppnu �[��� PK OP�[䶔�) �) �� zlib/inflate_stream.hppnu �[��� PK OP�[�b� � & � _experimental/unit_test/suite_info.hppnu �[��� PK OP�[|8-�� � " � _experimental/unit_test/amount.hppnu �[��� PK OP�[8�d)< )< ! �# _experimental/unit_test/suite.hppnu �[��� PK OP�[6��e e & P` _experimental/unit_test/suite_list.hppnu �[��� PK OP�[���5U U # h _experimental/unit_test/dstream.hppnu �[��� PK OP�[�Oռ� � ! �r _experimental/unit_test/match.hppnu �[��� PK OP�[� PW� � # ρ _experimental/unit_test/results.hppnu �[��� PK OP�[e;u�d d ) �� _experimental/unit_test/global_suites.hppnu �[��� PK OP�[�䴻 � " x� _experimental/unit_test/runner.hppnu �[��� PK OP�[ ")�� � 2 �� _experimental/unit_test/detail/const_container.hppnu �[��� PK OP�[�is� � $ m� _experimental/unit_test/reporter.hppnu �[��� PK OP�[�a�"� � j� _experimental/unit_test/main.ippnu �[��� PK OP�[Τ�v� � $ �� _experimental/unit_test/recorder.hppnu �[��� PK OP�[�(�4 4 ! �� _experimental/test/impl/error.ippnu �[��� PK OP�[N]�3 �3 " ^� _experimental/test/impl/stream.hppnu �[��� PK OP�[�ޒ� � & m _experimental/test/impl/fail_count.ippnu �[��� PK OP�[oz�� ! � _experimental/test/impl/error.hppnu �[��� PK OP�[�ac�� � " $ _experimental/test/impl/stream.ippnu �[��� PK OP�[��� � A _experimental/test/handler.hppnu �[��� PK OP�[�k��{H {H TR _experimental/test/stream.hppnu �[��� PK OP�[���uj j � _experimental/test/tcp.hppnu �[��� PK OP�[�ȧ�� � У _experimental/test/error.hppnu �[��� PK OP�[e �� � ! � _experimental/test/fail_count.hppnu �[��� PK OP�[��+ �+ ! � _experimental/http/icy_stream.hppnu �[��� PK OP�[|�5�( �( & 9� _experimental/http/impl/icy_stream.hppnu �[��� PK OP�[�b�D(] (] ssl/ssl_stream.hppnu �[��� PK OP�[�Y�/� � |a websocket.hppnu �[��� PK OP�[8 Rc c �d http.hppnu �[��� PK OP�[zR� � ;j version.hppnu �[��� PK OP�[.{��4 4 sm src.hppnu �[��� PK OP�[,Hl��n �n �v websocket/impl/write.hppnu �[��� PK OP�[���G. . �� websocket/impl/error.ippnu �[��� PK OP�[.vUi i � websocket/impl/stream.hppnu �[��� PK OP�[��Y�� � � websocket/impl/error.hppnu �[��� PK OP�[�z�k: k: �# websocket/impl/close.hppnu �[��� PK OP�[�2�� � ^^ websocket/impl/rfc6455.hppnu �[��� PK OP�[Ms�N� N� �b websocket/impl/read.hppnu �[��� PK OP�[.%��Jp Jp 20 websocket/impl/stream_impl.hppnu �[��� PK OP�[ \�< - - ʠ websocket/impl/handshake.hppnu �[��� PK OP�[*ϧ+ + 3� websocket/impl/teardown.hppnu �[��� PK OP�[�dj|#H #H �� websocket/impl/accept.hppnu �[��� PK OP�[��� � - websocket/impl/ssl.hppnu �[��� PK OP�[j��) �) J7 websocket/impl/ping.hppnu �[��� PK OP�[,$E�� �� a websocket/stream.hppnu �[��� PK OP�[ �� � �� websocket/stream_fwd.hppnu �[��� PK OP�[*���M M � websocket/error.hppnu �[��� PK OP�[�"�� � S websocket/detail/type_traits.hppnu �[��� PK OP�[��[�/ / % websocket/detail/frame.hppnu �[��� PK OP�[s��� � �. websocket/detail/soft_mutex.hppnu �[��� PK OP�[>�q# # �7 websocket/detail/service.hppnu �[��� PK OP�[l���C1 C1 > websocket/detail/impl_base.hppnu �[��� PK OP�[9�� � " �o websocket/detail/pmd_extension.hppnu �[��� PK OP�[)5�U� � �z websocket/detail/mask.ippnu �[��� PK OP�[_��� � �� websocket/detail/hybi13.ippnu �[��� PK OP�[�łsP P �� websocket/detail/hybi13.hppnu �[��� PK PP�[t�F�$ $ ! B� websocket/detail/utf8_checker.hppnu �[��� PK PP�[�2F� � �� websocket/detail/prng.ippnu �[��� PK PP�[(���% �% ! � websocket/detail/utf8_checker.ippnu �[��� PK PP�[8N��% �% " �� websocket/detail/pmd_extension.ippnu �[��� PK PP�[� 7�F F �� websocket/detail/mask.hppnu �[��� PK PP�[��, , v� websocket/detail/service.ippnu �[��� PK PP�[x�� � � websocket/detail/prng.hppnu �[��� PK PP�[n�]�7 7 � websocket/detail/decorator.hppnu �[��� PK PP�[���s s a websocket/rfc6455.hppnu �[��� PK PP�[��"�d d 3 websocket/option.hppnu �[��� PK PP�[�g �9 websocket/stream_base.hppnu �[��� PK PP�[6�f�' ' O websocket/teardown.hppnu �[��� PK PP�[��\ xe websocket/ssl.hppnu �[��� PK PP�[�)��� � �o ssl.hppnu �[��� PK PP�[�#W.� .� �q core/basic_stream.hppnu �[��� PK PP�[�y��L L 5J core/bind_handler.hppnu �[��� PK PP�[�t끘 � �Z core/file_win32.hppnu �[��� PK PP�[�a�^�r �r �k core/impl/basic_stream.hppnu �[��� PK PP�[�t� � �� core/impl/string.ippnu �[��� PK PP�[�� 2� � �� core/impl/error.ippnu �[��� PK PP�[���k� � �� core/impl/static_buffer.ippnu �[��� PK PP�[2I'�� � i� core/impl/saved_handler.hppnu �[��� PK PP�[~2 |. |. z core/impl/flat_buffer.hppnu �[��� PK PP�[�v��z) z) ?8 core/impl/buffers_cat.hppnu �[��� PK PP�[Y�.o� � b core/impl/flat_static_buffer.ippnu �[��� PK PP�[Tn�U5 5 4i core/impl/async_base.hppnu �[��� PK PP�[�F'Z Z �w core/impl/error.hppnu �[��� PK PP�[���*�& �& N{ core/impl/file_win32.ippnu �[��� PK PP�[TvLxi i �� core/impl/buffers_suffix.hppnu �[��� PK PP�[:Y��� � ?� core/impl/flat_static_buffer.hppnu �[��� PK PP�[Gm!�o o �� core/impl/saved_handler.ippnu �[��� PK PP�[���� @� core/impl/static_buffer.hppnu �[��� PK PP�[#�;�> > �� core/impl/buffers_adaptor.hppnu �[��� PK PP�[�/ / � core/impl/buffers_prefix.hppnu �[��� PK PP�[�B��� � q core/impl/file_posix.ippnu �[��� PK PP�[�8�� " �; core/impl/buffered_read_stream.hppnu �[��� PK PP�[e�Rv�w �w #X core/impl/multi_buffer.hppnu �[��� PK PP�[2�-��7 �7 � core/impl/static_string.hppnu �[��� PK PP�[D��¿ � 9 core/impl/file_stdio.ippnu �[��� PK PP�[��%vv v @ core/impl/flat_stream.hppnu �[��� PK PP�[#t�� � �? core/impl/read_size.hppnu �[��� PK PP�[2��Hf f H core/impl/string_param.hppnu �[��� PK PP�[�# � � �P core/ostream.hppnu �[��� PK PP�[f�9K� � }[ core/saved_handler.hppnu �[��� PK PP�[� <vC< C< �j core/flat_buffer.hppnu �[��� PK PP�[��P�7 7 � core/buffers_cat.hppnu �[��� PK PP�[ag�U U �� core/tcp_stream.hppnu �[��� PK PP�[�� �s s )� core/buffers_range.hppnu �[��� PK PP�[-x�@ @ �� core/stream_traits.hppnu �[��� PK PP�[�=�d]g ]g 7 core/async_base.hppnu �[��� PK PP�[(D\b� � �p core/string.hppnu �[��� PK PP�[<�XnY nY �x core/detect_ssl.hppnu �[��� PK PP�[tx��� � \� core/error.hppnu �[��� PK PP�[ܕ�]� � k� core/buffers_suffix.hppnu �[��� PK PP�[kQv} } 5� core/buffer_traits.hppnu �[��� PK PP�[�P��� � � core/buffers_to_string.hppnu �[��� PK PP�[݊��D D , core/string_type.hppnu �[��� PK PP�[�b��" " � core/flat_static_buffer.hppnu �[��� PK PP�[��9� � 0 core/make_printable.hppnu �[��� PK PP�[�h�pC! C! ;; core/static_buffer.hppnu �[��� PK PP�[�9��! ! �\ core/detail/buffer.hppnu �[��� PK PP�[R�꒱ � +d core/detail/allocator.hppnu �[��� PK PP�[`�� � %h core/detail/type_traits.hppnu �[��� PK PP�[Ty��* �* Ks core/detail/bind_handler.hppnu �[��� PK PP�[�w#Yh h # f� core/detail/remap_post_to_defer.hppnu �[��� PK PP�[Gw0# !� core/detail/char_buffer.hppnu �[��� PK PP�[ `�� � % � core/detail/impl/temporary_buffer.ippnu �[��� PK PP�[���{P P � core/detail/impl/read.hppnu �[��� PK PP�[ 7�W� � ! y� core/detail/bind_continuation.hppnu �[��� PK PP�[�)�\ \ z� core/detail/ostream.hppnu �[��� PK PP�[%���; ; � core/detail/work_guard.hppnu �[��� PK PP�[j�>D D �� core/detail/config.hppnu �[��� PK PP�[�1 � � , core/detail/stream_traits.hppnu �[��� PK PP�[l�>0� � e core/detail/async_base.hppnu �[��� PK PP�[�ƴ6� � 4 core/detail/string.hppnu �[��� PK PP�[�&� � � core/detail/cpu_info.hppnu �[��� PK PP�[LZ��� � ?% core/detail/static_const.hppnu �[��� PK PP�[v�G G * core/detail/chacha.hppnu �[��� PK PP�[Î�G� � �: core/detail/clamp.hppnu �[��� PK PP�[Ll{�/ / �? core/detail/buffer_traits.hppnu �[��� PK PP�[5v�^X X (H core/detail/sha1.hppnu �[��� PK PP�[r��-> > �N core/detail/sha1.ippnu �[��� PK PP�[l��� � % Fn core/detail/bind_default_executor.hppnu �[��� PK PP�[�Y�v F{ core/detail/base64.ippnu �[��� PK PP�[� f �� core/detail/variant.hppnu �[��� PK PP�[v�n�` ` � core/detail/is_invocable.hppnu �[��� PK PP�[��1�� � �� core/detail/base64.hppnu �[��� PK PP�[���$ $ �� core/detail/read.hppnu �[��� PK PP�[,���" " �� core/detail/get_io_context.hppnu �[��� PK PP�[/2 d d " C� core/detail/win32_unicode_path.hppnu �[��� PK PP�[R�|L L �� core/detail/buffers_pair.hppnu �[��� PK PP�[ nW� � �� core/detail/tuple.hppnu �[��� PK PP�[ �y�p p h core/detail/buffers_ref.hppnu �[��� PK PP�[�D抰 � # core/detail/varint.hppnu �[��� PK PP�[d�-CR R core/detail/service_base.hppnu �[��� PK PP�[>�I^ ^ � core/detail/stream_base.hppnu �[��� PK PP�[���� � ` core/detail/static_string.hppnu �[��� PK PP�[���Ÿ � �+ core/detail/pcg.hppnu �[��� PK PP�[הGW ~1 core/detail/flat_stream.hppnu �[��� PK PP�[�p�� � H9 core/detail/static_ostream.hppnu �[��� PK PP�[}BK K lE core/detail/temporary_buffer.hppnu �[��� PK PP�['���[ [ % L core/detail/buffers_range_adaptor.hppnu �[��� PK PP�["��0* * �V core/role.hppnu �[��� PK PP�[H�� \ core/buffers_adaptor.hppnu �[��� PK PP�[yU��� � �v core/span.hppnu �[��� PK PP�[c�r�� � Չ core/file_base.hppnu �[��� PK PP�[���� �� core/buffers_prefix.hppnu �[��� PK PP�[�z�ye. e. �� core/buffered_read_stream.hppnu �[��� PK PP�[�(b� �� core/file.hppnu �[��� PK PP�[8�7�F �F �� core/multi_buffer.hppnu �[��� PK PP�[��xd xd 0 core/static_string.hppnu �[��� PK PP�[��Js~ ~ ܔ core/file_posix.hppnu �[��� PK PP�[�&l�;1 ;1 �� core/flat_stream.hppnu �[��� PK PP�[P��;� � � core/rate_policy.hppnu �[��� PK PP�[2�m P� core/file_stdio.hppnu �[��� PK PP�[��4 4 �� core/read_size.hppnu �[��� PK PP�[���� � core/string_param.hppnu �[��� PK PP�[}B��� � � http/type_traits.hppnu �[��� PK PP�[դ7I I �) http/verb.hppnu �[��� PK PP�[�)�0� � ?9 http/empty_body.hppnu �[��� PK PP�[� ��7 7 8E http/impl/rfc7230.ippnu �[��� PK PP�[�� �j �j �V http/impl/fields.hppnu �[��� PK PP�[C��B�e �e ~� http/impl/write.hppnu �[��� PK PP�[� � �' http/impl/error.ippnu �[��� PK PP�[�2�C� � �3 http/impl/error.hppnu �[��� PK PP�[��� � 7 http/impl/parser.hppnu �[��� PK PP�[���( ( �< http/impl/message.hppnu �[��� PK PP�[,ȁ��< �< Be http/impl/field.ippnu �[��� PK PP�[o��B( B( W� http/impl/serializer.hppnu �[��� PK PP�[c�pY Y �� http/impl/rfc7230.hppnu �[��� PK PP�[��ݽ@ �@ � http/impl/chunk_encode.hppnu �[��� PK PP�[eo��4K 4K �% http/impl/read.hppnu �[��� PK PP�[�P�� � �p http/impl/basic_parser.hppnu �[��� PK PP�[�}}"# "# �y http/impl/status.ippnu �[��� PK PP�[���4 <� http/impl/fields.ippnu �[��� PK PP�[���. . �� http/impl/verb.ippnu �[��� PK PP�[�Y���> �> �� http/impl/file_body_win32.hppnu �[��� PK PP�[ @�L �L http/impl/basic_parser.ippnu �[��� PK PP�[9 � >Q http/file_body.hppnu �[��� PK PP�[F��- U http/basic_dynamic_body.hppnu �[��� PK PP�[W`�pQ Q Me http/fields.hppnu �[��� PK PP�[C�H��d �d �� http/write.hppnu �[��� PK PP�[@ɥ0 � http/vector_body.hppnu �[��� PK PP�[�:;� , http/string_body.hppnu �[��� PK PP�[z�5 5 U> http/error.hppnu �[��� PK PP�[�Q&t- - �O http/span_body.hppnu �[��� PK PP�[`���j7 j7 7` http/parser.hppnu �[��� PK PP�[�Pj��m �m � http/message.hppnu �[��� PK PP�[���H H � http/detail/type_traits.hppnu �[��� PK PP�[ۡ� 7 7 k http/detail/rfc7230.ippnu �[��� PK PP�[L�J� � ! �U http/detail/basic_parsed_list.hppnu �[��� PK PP�[��꓾ � f http/detail/rfc7230.hppnu �[��� PK PP�[�6r r m http/detail/chunk_encode.hppnu �[��� PK PP�[Ӂ� � �~ http/detail/basic_parser.hppnu �[��� PK PP�[���#K #K �� http/detail/basic_parser.ippnu �[��� PK PP�[F�9��0 �0 $� http/serializer.hppnu �[��� PK PP�[����# �# http/rfc7230.hppnu �[��� PK PP�[+� V V 10 http/chunk_encode.hppnu �[��� PK PP�[��D�(7 (7 �� http/basic_file_body.hppnu �[��� PK PP�[Ώ��� � � http/read.hppnu �[��� PK PP�[Ќ @�[ �[ 3@ http/basic_parser.hppnu �[��� PK PP�[�?� 9 9 "� http/buffer_body.hppnu �[��� PK PP�[�6l� � �� http/dynamic_body.hppnu �[��� PK PP�[�t��% �% ˸ http/field.hppnu �[��� PK PP�[ʚ��D D �� http/status.hppnu �[��� PK � � Q �
| ver. 1.6 |
Github
|
.
| PHP 8.2.30 | ??????????? ?????????: 0.06 |
proxy
|
phpinfo
|
???????????