diff --git a/include/libtorrent/aux_/io.hpp b/include/libtorrent/aux_/io.hpp index 01ef60f99..eb95bee77 100644 --- a/include/libtorrent/aux_/io.hpp +++ b/include/libtorrent/aux_/io.hpp @@ -72,6 +72,40 @@ namespace libtorrent { namespace aux view = view.subspan(sizeof(T)); } + template + inline typename std::enable_if::type + write_impl(std::uint8_t val, span& view) + { + view[0] = val; + view = view.subspan(1); + } + + template + inline typename std::enable_if::type + write_impl(std::int8_t val, span& view) + { + view[0] = val; + view = view.subspan(1); + } + + template + inline typename std::enable_if::type + read_impl(span& view, type) + { + std::uint8_t ret = static_cast(view[0]); + view = view.subspan(1); + return ret; + } + + template + inline typename std::enable_if::type + read_impl(span& view, type) + { + std::uint8_t ret = static_cast(view[0]); + view = view.subspan(1); + return ret; + } + // -- adaptors template @@ -153,4 +187,3 @@ namespace libtorrent { namespace aux }} #endif // TORRENT_AUX_IO_HPP_INCLUDED - diff --git a/include/libtorrent/bloom_filter.hpp b/include/libtorrent/bloom_filter.hpp index 3a71e2e24..142f52b91 100644 --- a/include/libtorrent/bloom_filter.hpp +++ b/include/libtorrent/bloom_filter.hpp @@ -33,8 +33,7 @@ POSSIBILITY OF SUCH DAMAGE. #ifndef TORRENT_BLOOM_FILTER_HPP_INCLUDED #define TORRENT_BLOOM_FILTER_HPP_INCLUDED -#include "libtorrent/peer_id.hpp" // for sha1_hash -#include "libtorrent/config.hpp" // for sha1_hash +#include "libtorrent/sha1_hash.hpp" #include // for log() #include @@ -77,5 +76,4 @@ namespace libtorrent } -#endif - +#endif // TORRENT_BLOOM_FILTER_HPP_INCLUDED diff --git a/include/libtorrent/bt_peer_connection.hpp b/include/libtorrent/bt_peer_connection.hpp index 25acd6677..c11815a8f 100644 --- a/include/libtorrent/bt_peer_connection.hpp +++ b/include/libtorrent/bt_peer_connection.hpp @@ -161,8 +161,8 @@ namespace libtorrent #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) // next_barrier, buffers-to-prepend virtual - std::tuple> - hit_send_barrier(span iovec) override; + std::tuple>> + hit_send_barrier(span> iovec) override; #endif virtual void get_specific_peer_info(peer_info& p) const override; diff --git a/include/libtorrent/buffer.hpp b/include/libtorrent/buffer.hpp index b439885e1..e436ff221 100644 --- a/include/libtorrent/buffer.hpp +++ b/include/libtorrent/buffer.hpp @@ -59,13 +59,6 @@ namespace libtorrent { } } - // TODO: eventually move this file to aux_ or create a new one - namespace aux - { - using mutable_buffer = span; - using const_buffer = span; - } - // the buffer is allocated once and cannot be resized. The size() may be // larger than requested, in case the underlying allocator over allocated. In // order to "grow" an allocation, create a new buffer and initialize it by @@ -75,36 +68,6 @@ class buffer { public: - struct const_interval - { - const_interval(char const* b, char const* e) - : begin(b) - , end(e) - {} - - char operator[](int index) const - { - TORRENT_ASSERT(begin + index < end); - return begin[index]; - } - - bool operator==(const const_interval& p_interval) - { - return begin == p_interval.begin - && end == p_interval.end; - } - - int left() const - { - TORRENT_ASSERT(end >= begin); - TORRENT_ASSERT(end - begin < (std::numeric_limits::max)()); - return int(end - begin); - } - - char const* begin; - char const* end; - }; - // allocate an uninitialized buffer of the specified size buffer(std::size_t size = 0) { diff --git a/include/libtorrent/chained_buffer.hpp b/include/libtorrent/chained_buffer.hpp index 5e3f0c64d..55bf47d40 100644 --- a/include/libtorrent/chained_buffer.hpp +++ b/include/libtorrent/chained_buffer.hpp @@ -112,7 +112,7 @@ namespace libtorrent void clear(); - void build_mutable_iovec(int bytes, std::vector& vec); + void build_mutable_iovec(int bytes, std::vector>& vec); ~chained_buffer(); diff --git a/include/libtorrent/extensions.hpp b/include/libtorrent/extensions.hpp index db34b5c5a..cc39299fd 100644 --- a/include/libtorrent/extensions.hpp +++ b/include/libtorrent/extensions.hpp @@ -464,12 +464,12 @@ namespace libtorrent // received. The purpose of this is to allow early disconnects for invalid // messages and for reporting progress of receiving large messages. virtual bool on_extended(int /*length*/, int /*msg*/, - buffer::const_interval /*body*/) + span /*body*/) { return false; } // this is not called for web seeds virtual bool on_unknown_message(int /*length*/, int /*msg*/, - buffer::const_interval /*body*/) + span /*body*/) { return false; } // called when a piece that this peer participated in either diff --git a/include/libtorrent/pe_crypto.hpp b/include/libtorrent/pe_crypto.hpp index 4ef02c66c..df6c658db 100644 --- a/include/libtorrent/pe_crypto.hpp +++ b/include/libtorrent/pe_crypto.hpp @@ -99,8 +99,8 @@ namespace libtorrent struct encryption_handler { - std::tuple> - encrypt(span iovec); + std::tuple>> + encrypt(span> iovec); int decrypt(crypto_receive_buffer& recv_buffer , std::size_t& bytes_transferred); @@ -144,10 +144,10 @@ namespace libtorrent void set_incoming_key(unsigned char const* key, int len) override; void set_outgoing_key(unsigned char const* key, int len) override; - std::tuple> - encrypt(span buf) override; + std::tuple>> + encrypt(span> buf) override; - void decrypt(span buf + void decrypt(span> buf , int& consume , int& produce , int& packet_size) override; diff --git a/include/libtorrent/peer_connection.hpp b/include/libtorrent/peer_connection.hpp index d72685d8c..8bc5e9cb4 100644 --- a/include/libtorrent/peer_connection.hpp +++ b/include/libtorrent/peer_connection.hpp @@ -747,11 +747,11 @@ namespace libtorrent void send_piece_suggestions(int num); virtual - std::tuple> - hit_send_barrier(span /* iovec */) + std::tuple>> + hit_send_barrier(span> /* iovec */) { return std::make_tuple(INT_MAX - , span()); + , span>()); } void attach_to_torrent(sha1_hash const& ih); diff --git a/include/libtorrent/receive_buffer.hpp b/include/libtorrent/receive_buffer.hpp index a81549405..017d92277 100644 --- a/include/libtorrent/receive_buffer.hpp +++ b/include/libtorrent/receive_buffer.hpp @@ -85,8 +85,7 @@ struct TORRENT_EXTRA_EXPORT receive_buffer // return the interval between the start of the buffer to the read cursor. // This is the "current" packet. - // TODO: 3 use span - buffer::const_interval get() const; + span get() const; #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) // returns the buffer from the current packet start position to the last @@ -94,7 +93,7 @@ struct TORRENT_EXTRA_EXPORT receive_buffer span mutable_buffer(); // returns the last 'bytes' from the receive buffer - aux::mutable_buffer mutable_buffer(int bytes); + span mutable_buffer(int bytes); #endif // the purpose of this function is to free up and cut off all messages @@ -203,10 +202,9 @@ struct crypto_receive_buffer int advance_pos(int bytes); - // TODO: 3 use span - buffer::const_interval get() const; + span get() const; - aux::mutable_buffer mutable_buffer(std::size_t bytes); + span mutable_buffer(std::size_t bytes); private: // explicitly disallow assignment, to silence msvc warning diff --git a/src/bloom_filter.cpp b/src/bloom_filter.cpp index ca3789f9e..b52f45009 100644 --- a/src/bloom_filter.cpp +++ b/src/bloom_filter.cpp @@ -73,4 +73,3 @@ namespace libtorrent return ret; } } - diff --git a/src/bt_peer_connection.cpp b/src/bt_peer_connection.cpp index 6055393dc..147b02dff 100644 --- a/src/bt_peer_connection.cpp +++ b/src/bt_peer_connection.cpp @@ -62,6 +62,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/alert_types.hpp" #include "libtorrent/invariant_check.hpp" #include "libtorrent/io.hpp" +#include "libtorrent/aux_/io.hpp" #include "libtorrent/socket_io.hpp" #include "libtorrent/version.hpp" #include "libtorrent/extensions.hpp" @@ -606,7 +607,7 @@ namespace libtorrent #endif write_pe_vc_cryptofield(ptr, encrypt_size, crypto_provide, pad_size); - aux::mutable_buffer vec(ptr, encrypt_size); + span vec(ptr, encrypt_size); m_rc4->encrypt(vec); send_buffer(msg, sizeof(msg) - 512 + pad_size); } @@ -627,7 +628,7 @@ namespace libtorrent char msg[512 + 8 + 4 + 2]; write_pe_vc_cryptofield(msg, sizeof(msg), crypto_select, pad_size); - aux::mutable_buffer vec(msg, buf_size); + span vec(msg, buf_size); m_rc4->encrypt(vec); send_buffer(msg, buf_size); @@ -835,14 +836,14 @@ namespace libtorrent boost::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); // are we currently receiving a 'piece' message? if (m_state != read_packet - || recv_buffer.left() <= 9 + || int(recv_buffer.size()) <= 9 || recv_buffer[0] != msg_piece) return boost::optional(); - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; peer_request r; r.piece = detail::read_int32(ptr); r.start = detail::read_int32(ptr); @@ -856,7 +857,7 @@ namespace libtorrent p.piece_index = r.piece; p.block_index = r.start / t->block_size(); - p.bytes_downloaded = recv_buffer.left() - 9; + p.bytes_downloaded = int(recv_buffer.size()) - 9; p.full_block_bytes = r.length; return boost::optional(p); @@ -1015,9 +1016,9 @@ namespace libtorrent } if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; int const index = detail::read_int32(ptr); incoming_have(index); @@ -1048,10 +1049,10 @@ namespace libtorrent if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); bitfield bits; - bits.assign(recv_buffer.begin + 1 + bits.assign(recv_buffer.begin() + 1 , t->valid_metadata()?get_bitfield().size():(m_recv_buffer.packet_size()-1)*8); incoming_bitfield(bits); @@ -1074,10 +1075,10 @@ namespace libtorrent } if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); peer_request r; - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; r.piece = detail::read_int32(ptr); r.start = detail::read_int32(ptr); r.length = detail::read_int32(ptr); @@ -1095,12 +1096,12 @@ namespace libtorrent TORRENT_ASSERT(received >= 0); - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); int recv_pos = m_recv_buffer.pos(); // recv_buffer.end - recv_buffer.begin; boost::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); - bool const merkle = static_cast(recv_buffer.begin[0]) == 250; + bool const merkle = static_cast(recv_buffer.front()) == 250; if (merkle) { if (recv_pos == 1) @@ -1115,7 +1116,7 @@ namespace libtorrent } if (recv_pos >= 13) { - char const* ptr = recv_buffer.begin + 9; + char const* ptr = recv_buffer.begin() + 9; int const list_size = detail::read_int32(ptr); if (list_size > m_recv_buffer.packet_size() - 13) @@ -1153,7 +1154,7 @@ namespace libtorrent if (recv_pos >= header_size) { - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; p.piece = detail::read_int32(ptr); p.start = detail::read_int32(ptr); @@ -1224,7 +1225,7 @@ namespace libtorrent #endif bdecode_node hash_list; error_code ec; - if (bdecode(recv_buffer.begin + 13, recv_buffer.begin+ 13 + list_size + if (bdecode(recv_buffer.begin() + 13, recv_buffer.begin() + 13 + list_size , hash_list, ec) != 0) { disconnect(errors::invalid_hash_piece, op_bittorrent, 2); @@ -1259,7 +1260,7 @@ namespace libtorrent } } - incoming_piece(p, recv_buffer.begin + header_size); + incoming_piece(p, recv_buffer.begin() + header_size); } // ----------------------------- @@ -1279,10 +1280,10 @@ namespace libtorrent } if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); peer_request r; - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; r.piece = detail::read_int32(ptr); r.start = detail::read_int32(ptr); r.length = detail::read_int32(ptr); @@ -1307,9 +1308,9 @@ namespace libtorrent } if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; int listen_port = detail::read_uint16(ptr); incoming_dht_port(listen_port); @@ -1337,9 +1338,9 @@ namespace libtorrent if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; int const piece = detail::read_uint32(ptr); incoming_suggest(piece); } @@ -1383,10 +1384,10 @@ namespace libtorrent if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); peer_request r; - const char* ptr = recv_buffer.begin + 1; + const char* ptr = recv_buffer.begin() + 1; r.piece = detail::read_int32(ptr); r.start = detail::read_int32(ptr); r.length = detail::read_int32(ptr); @@ -1406,8 +1407,8 @@ namespace libtorrent } if (!m_recv_buffer.packet_finished()) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); - const char* ptr = recv_buffer.begin + 1; + span recv_buffer = m_recv_buffer.get(); + const char* ptr = recv_buffer.begin() + 1; int index = detail::read_int32(ptr); incoming_allowed_fast(index); @@ -1429,16 +1430,16 @@ namespace libtorrent // because we wouldn't be able to respond if (m_holepunch_id == 0) return; - buffer::const_interval recv_buffer = m_recv_buffer.get(); - TORRENT_ASSERT(*recv_buffer.begin == msg_extended); - ++recv_buffer.begin; - TORRENT_ASSERT(*recv_buffer.begin == holepunch_msg); - ++recv_buffer.begin; + span recv_buffer = m_recv_buffer.get(); + TORRENT_ASSERT(recv_buffer.front() == msg_extended); + recv_buffer = recv_buffer.subspan(1); + TORRENT_ASSERT(recv_buffer.front() == holepunch_msg); + recv_buffer = recv_buffer.subspan(1); - const char* ptr = recv_buffer.begin; + const char* ptr = recv_buffer.begin(); // ignore invalid messages - if (recv_buffer.left() < 2) return; + if (int(recv_buffer.size()) < 2) return; int const msg_type = detail::read_uint8(ptr); int const addr_type = detail::read_uint8(ptr); @@ -1447,7 +1448,7 @@ namespace libtorrent if (addr_type == 0) { - if (recv_buffer.left() < 2 + 4 + 2) return; + if (int(recv_buffer.size()) < 2 + 4 + 2) return; // IPv4 address ep = detail::read_v4_endpoint(ptr); } @@ -1455,7 +1456,7 @@ namespace libtorrent else if (addr_type == 1) { // IPv6 address - if (recv_buffer.left() < 2 + 18 + 2) return; + if (int(recv_buffer.size()) < 2 + 18 + 2) return; ep = detail::read_v6_endpoint(ptr); } #endif @@ -1634,13 +1635,13 @@ namespace libtorrent return; } - buffer::const_interval recv_buffer = m_recv_buffer.get(); - if (recv_buffer.left() < 2) return; + span recv_buffer = m_recv_buffer.get(); + if (int(recv_buffer.size()) < 2) return; - TORRENT_ASSERT(*recv_buffer.begin == msg_extended); - ++recv_buffer.begin; + TORRENT_ASSERT(recv_buffer.front() == msg_extended); + recv_buffer = recv_buffer.subspan(1); - int extended_id = detail::read_uint8(recv_buffer.begin); + int extended_id = aux::read_uint8(recv_buffer); if (extended_id == 0) { @@ -1660,7 +1661,7 @@ namespace libtorrent #endif return; } - bool ul = detail::read_uint8(recv_buffer.begin) != 0; + bool ul = aux::read_uint8(recv_buffer) != 0; #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::incoming_message, "UPLOAD_ONLY" , "%s", (ul?"true":"false")); @@ -1680,7 +1681,7 @@ namespace libtorrent #endif return; } - bool sm = detail::read_uint8(recv_buffer.begin) != 0; + bool sm = aux::read_uint8(recv_buffer) != 0; #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::incoming_message, "SHARE_MODE" , "%s", (sm?"true":"false")); @@ -1710,7 +1711,7 @@ namespace libtorrent #endif return; } - int piece = detail::read_uint32(recv_buffer.begin); + int piece = aux::read_uint32(recv_buffer); incoming_dont_have(piece); return; } @@ -1740,12 +1741,12 @@ namespace libtorrent boost::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); bdecode_node root; error_code ec; int pos; - int ret = bdecode(recv_buffer.begin + 2, recv_buffer.end, root, ec, &pos); + int ret = bdecode(recv_buffer.begin() + 2, recv_buffer.end(), root, ec, &pos); if (ret != 0 || ec || root.type() != bdecode_node::dict_t) { #ifndef TORRENT_DISABLE_LOGGING @@ -1859,9 +1860,9 @@ namespace libtorrent return false; } - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); - TORRENT_ASSERT(recv_buffer.left() >= 1); + TORRENT_ASSERT(int(recv_buffer.size()) >= 1); int packet_type = static_cast(recv_buffer[0]); if (m_settings.get_bool(settings_pack::support_merkle_torrents) @@ -1905,8 +1906,7 @@ namespace libtorrent , end(m_extensions.end()); i != end; ++i) { if ((*i)->on_unknown_message(m_recv_buffer.packet_size(), packet_type - , buffer::const_interval(recv_buffer.begin+1 - , recv_buffer.end))) + , recv_buffer.subspan(1))) return m_recv_buffer.packet_finished(); } #endif @@ -2549,7 +2549,7 @@ namespace libtorrent { boost::shared_ptr t = associated_torrent().lock(); - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) // m_state is set to read_pe_dhkey in initial state @@ -2562,7 +2562,8 @@ namespace libtorrent TORRENT_ASSERT(!m_encrypted); TORRENT_ASSERT(!m_rc4_encrypted); TORRENT_ASSERT(m_recv_buffer.packet_size() == dh_key_len); - TORRENT_ASSERT(recv_buffer == m_recv_buffer.get()); + TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); + TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); if (!m_recv_buffer.packet_finished()) return; @@ -2573,7 +2574,7 @@ namespace libtorrent // read dh key, generate shared secret m_dh_key_exchange->compute_secret( - reinterpret_cast(recv_buffer.begin)); + reinterpret_cast(recv_buffer.begin())); #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "ENCRYPTION", "received DH key"); @@ -2619,9 +2620,10 @@ namespace libtorrent TORRENT_ASSERT(!m_encrypted); TORRENT_ASSERT(!m_rc4_encrypted); TORRENT_ASSERT(!is_outgoing()); - TORRENT_ASSERT(recv_buffer == m_recv_buffer.get()); + TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); + TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); - if (recv_buffer.left() < 20) + if (int(recv_buffer.size()) < 20) { received_bytes(0, int(bytes_transferred)); @@ -2645,14 +2647,14 @@ namespace libtorrent } int const syncoffset = get_syncoffset(m_sync_hash->data(), 20 - , recv_buffer.begin, recv_buffer.left()); + , recv_buffer.begin(), int(recv_buffer.size())); // No sync if (syncoffset == -1) { received_bytes(0, int(bytes_transferred)); - std::size_t bytes_processed = recv_buffer.left() - 20; + std::size_t bytes_processed = int(recv_buffer.size()) - 20; m_sync_bytes_read += int(bytes_processed); if (m_sync_bytes_read >= 512) { @@ -2678,7 +2680,7 @@ namespace libtorrent m_state = read_pe_skey_vc; // skey,vc - 28 bytes m_sync_hash.reset(); - int transferred_used = int(bytes_processed - recv_buffer.left() + bytes_transferred); + int transferred_used = int(bytes_processed - int(recv_buffer.size()) + bytes_transferred); TORRENT_ASSERT(transferred_used <= int(bytes_transferred)); received_bytes(0, transferred_used); bytes_transferred -= transferred_used; @@ -2704,7 +2706,7 @@ namespace libtorrent TORRENT_ASSERT(!is_disconnecting()); - sha1_hash ih(recv_buffer.begin); + sha1_hash ih(recv_buffer.begin()); torrent const* ti = m_ses.find_encrypted_torrent(ih, m_dh_key_exchange->get_hash_xor_mask()); if (ti) @@ -2737,7 +2739,7 @@ namespace libtorrent rc4_decrypt(m_recv_buffer.mutable_buffer().subspan(20, 8)); const char sh_vc[] = {0,0,0,0, 0,0,0,0}; - if (!std::equal(sh_vc, sh_vc + 8, recv_buffer.begin + 20)) + if (!std::equal(sh_vc, sh_vc + 8, recv_buffer.begin() + 20)) { disconnect(errors::invalid_encryption_constant, op_encryption, 2); return; @@ -2756,9 +2758,10 @@ namespace libtorrent TORRENT_ASSERT(is_outgoing()); TORRENT_ASSERT(!m_encrypted); TORRENT_ASSERT(!m_rc4_encrypted); - TORRENT_ASSERT(recv_buffer == m_recv_buffer.get()); + TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); + TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); - if (recv_buffer.left() < 8) + if (int(recv_buffer.size()) < 8) { received_bytes(0, int(bytes_transferred)); if (m_recv_buffer.packet_finished()) @@ -2783,12 +2786,12 @@ namespace libtorrent TORRENT_ASSERT(m_sync_vc.get()); int const syncoffset = get_syncoffset(m_sync_vc.get(), 8 - , recv_buffer.begin, recv_buffer.left()); + , recv_buffer.begin(), int(recv_buffer.size())); // No sync if (syncoffset == -1) { - std::size_t bytes_processed = recv_buffer.left() - 8; + std::size_t bytes_processed = int(recv_buffer.size()) - 8; m_sync_bytes_read += int(bytes_processed); received_bytes(0, int(bytes_transferred)); @@ -2812,7 +2815,7 @@ namespace libtorrent , "sync point (verification constant) found at offset %d" , int(m_sync_bytes_read + bytes_processed - 8)); #endif - int transferred_used = int(bytes_processed - recv_buffer.left() + bytes_transferred); + int transferred_used = int(bytes_processed - int(recv_buffer.size()) + bytes_transferred); TORRENT_ASSERT(transferred_used <= int(bytes_transferred)); received_bytes(0, transferred_used); bytes_transferred -= transferred_used; @@ -2843,7 +2846,7 @@ namespace libtorrent recv_buffer = m_recv_buffer.get(); - std::uint32_t crypto_field = detail::read_uint32(recv_buffer.begin); + std::uint32_t crypto_field = aux::read_uint32(recv_buffer); #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "ENCRYPTION", "crypto %s : [%s%s ]" @@ -2907,7 +2910,7 @@ namespace libtorrent m_rc4_encrypted = true; } - int len_pad = detail::read_int16(recv_buffer.begin); + int len_pad = aux::read_int16(recv_buffer); if (len_pad < 0 || len_pad > 512) { disconnect(errors::invalid_pad_size, op_encryption, 2); @@ -2952,8 +2955,8 @@ namespace libtorrent if (!is_outgoing()) { - recv_buffer.begin += pad_size; - int len_ia = detail::read_int16(recv_buffer.begin); + recv_buffer = recv_buffer.subspan(pad_size); + int len_ia = aux::read_int16(recv_buffer); if (len_ia < 0) { @@ -3079,7 +3082,7 @@ namespace libtorrent const char protocol_string[] = "\x13" "BitTorrent protocol"; if (packet_size != 19 || - memcmp(recv_buffer.begin, protocol_string, 20) != 0) + memcmp(recv_buffer.begin(), protocol_string, 20) != 0) { #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) #ifndef TORRENT_DISABLE_LOGGING @@ -3183,7 +3186,7 @@ namespace libtorrent #endif #ifndef TORRENT_DISABLE_EXTENSIONS - std::memcpy(m_reserved_bits, recv_buffer.begin, 8); + std::memcpy(m_reserved_bits, recv_buffer.begin(), 8); if ((recv_buffer[5] & 0x10)) m_supports_extensions = true; #endif @@ -3202,7 +3205,7 @@ namespace libtorrent // now, we have to see if there's a torrent with the // info_hash we got from the peer sha1_hash info_hash; - std::copy(recv_buffer.begin + 8, recv_buffer.begin + 28 + std::copy(recv_buffer.begin() + 8, recv_buffer.begin() + 28 , info_hash.data()); attach_to_torrent(info_hash); @@ -3211,7 +3214,7 @@ namespace libtorrent else { // verify info hash - if (!std::equal(recv_buffer.begin + 8, recv_buffer.begin + 28 + if (!std::equal(recv_buffer.begin() + 8, recv_buffer.begin() + 28 , t->torrent_file().info_hash().data())) { #ifndef TORRENT_DISABLE_LOGGING @@ -3260,21 +3263,21 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING { char hex_pid[41]; - aux::to_hex(recv_buffer.begin, 20, hex_pid); + aux::to_hex(recv_buffer.begin(), 20, hex_pid); hex_pid[40] = 0; char ascii_pid[21]; ascii_pid[20] = 0; for (int i = 0; i != 20; ++i) { - if (is_print(recv_buffer.begin[i])) ascii_pid[i] = recv_buffer.begin[i]; + if (is_print(recv_buffer[i])) ascii_pid[i] = recv_buffer[i]; else ascii_pid[i] = '.'; } peer_log(peer_log_alert::incoming, "HANDSHAKE", "received peer_id: %s client: %s ascii: \"%s\"" - , hex_pid, identify_client(peer_id(recv_buffer.begin)).c_str(), ascii_pid); + , hex_pid, identify_client(peer_id(recv_buffer.begin())).c_str(), ascii_pid); } #endif peer_id pid; - std::copy(recv_buffer.begin, recv_buffer.begin + 20, pid.data()); + std::copy(recv_buffer.begin(), recv_buffer.begin() + 20, pid.data()); if (t->settings().get_bool(settings_pack::allow_multiple_connections_per_ip)) { @@ -3393,7 +3396,8 @@ namespace libtorrent if (m_state == read_packet_size) { // Make sure this is not fallen though into - TORRENT_ASSERT(recv_buffer == m_recv_buffer.get()); + TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); + TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); TORRENT_ASSERT(m_recv_buffer.packet_size() == 5); if (!t) return; @@ -3402,14 +3406,14 @@ namespace libtorrent // byte here, instead it's counted in the message // handler itself, for the specific message TORRENT_ASSERT(bytes_transferred <= 5); - int used_bytes = recv_buffer.left() > 4 ? int(bytes_transferred) - 1: int(bytes_transferred); + int used_bytes = int(recv_buffer.size()) > 4 ? int(bytes_transferred) - 1: int(bytes_transferred); received_bytes(0, used_bytes); bytes_transferred -= used_bytes; - if (recv_buffer.left() < 4) return; + if (int(recv_buffer.size()) < 4) return; TORRENT_ASSERT(bytes_transferred <= 1); - const char* ptr = recv_buffer.begin; + const char* ptr = recv_buffer.begin(); int packet_size = detail::read_int32(ptr); // don't accept packets larger than 1 MB @@ -3432,18 +3436,19 @@ namespace libtorrent m_recv_buffer.cut(4, 5); return; } - if (recv_buffer.left() < 5) return; + if (int(recv_buffer.size()) < 5) return; m_state = read_packet; m_recv_buffer.cut(4, packet_size); recv_buffer = m_recv_buffer.get(); - TORRENT_ASSERT(recv_buffer.left() == 1); + TORRENT_ASSERT(int(recv_buffer.size()) == 1); TORRENT_ASSERT(bytes_transferred == 1); } if (m_state == read_packet) { - TORRENT_ASSERT(recv_buffer == m_recv_buffer.get()); + TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); + TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); if (!t) { received_bytes(0, int(bytes_transferred)); @@ -3475,12 +3480,12 @@ namespace libtorrent } #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) - std::tuple> + std::tuple>> bt_peer_connection::hit_send_barrier( - span iovec) + span> iovec) { int next_barrier; - span out_iovec; + span> out_iovec; std::tie(next_barrier, out_iovec) = m_enc_handler.encrypt(iovec); #ifndef TORRENT_DISABLE_LOGGING if (next_barrier != 0) diff --git a/src/chained_buffer.cpp b/src/chained_buffer.cpp index e4d9c60d9..398ee1f16 100644 --- a/src/chained_buffer.cpp +++ b/src/chained_buffer.cpp @@ -151,7 +151,7 @@ namespace libtorrent return m_tmp_vec; } - void chained_buffer::build_mutable_iovec(int bytes, std::vector &vec) + void chained_buffer::build_mutable_iovec(int bytes, std::vector> &vec) { build_vec(bytes, vec); } diff --git a/src/http_seed_connection.cpp b/src/http_seed_connection.cpp index 33fd2c9ce..3ed0fbc62 100644 --- a/src/http_seed_connection.cpp +++ b/src/http_seed_connection.cpp @@ -120,7 +120,7 @@ namespace libtorrent } else { - int receive_buffer_size = m_recv_buffer.get().left() - m_parser.body_start(); + int receive_buffer_size = int(m_recv_buffer.get().size()) - m_parser.body_start(); // TODO: 1 in chunked encoding mode, this assert won't hold. // the chunk headers should be subtracted from the receive_buffer_size TORRENT_ASSERT_VAL(receive_buffer_size <= t->block_size(), receive_buffer_size); @@ -226,10 +226,10 @@ namespace libtorrent for (;;) { - buffer::const_interval recv_buffer = m_recv_buffer.get(); + span recv_buffer = m_recv_buffer.get(); if (bytes_transferred == 0) break; - TORRENT_ASSERT(recv_buffer.left() > 0); + TORRENT_ASSERT(int(recv_buffer.size()) > 0); TORRENT_ASSERT(!m_requests.empty()); if (m_requests.empty()) @@ -247,8 +247,8 @@ namespace libtorrent bool parse_error = false; int protocol = 0; int payload = 0; - std::tie(payload, protocol) = m_parser.incoming(span( - recv_buffer.begin, recv_buffer.left()), parse_error); + std::tie(payload, protocol) = m_parser.incoming( + recv_buffer, parse_error); received_bytes(0, protocol); bytes_transferred -= protocol; #if TORRENT_USE_ASSERTS @@ -262,9 +262,9 @@ namespace libtorrent return; } - TORRENT_ASSERT(recv_buffer.left() == 0 || *recv_buffer.begin == 'H'); + TORRENT_ASSERT(int(recv_buffer.size()) == 0 || recv_buffer.front() == 'H'); - TORRENT_ASSERT(recv_buffer.left() <= m_recv_buffer.packet_size()); + TORRENT_ASSERT(int(recv_buffer.size()) <= m_recv_buffer.packet_size()); // this means the entire status line hasn't been received yet if (m_parser.status_code() == -1) @@ -352,18 +352,18 @@ namespace libtorrent m_body_start = m_parser.body_start(); } - recv_buffer.begin += m_body_start; + recv_buffer = recv_buffer.subspan(m_body_start); // ========================= // === CHUNKED ENCODING === // ========================= while (m_parser.chunked_encoding() && m_chunk_pos >= 0 - && m_chunk_pos < recv_buffer.left()) + && m_chunk_pos < int(recv_buffer.size())) { int header_size = 0; std::int64_t chunk_size = 0; - span chunk_start(recv_buffer.begin + m_chunk_pos, recv_buffer.left() - m_chunk_pos); + span chunk_start(recv_buffer.begin() + m_chunk_pos, int(recv_buffer.size()) - m_chunk_pos); TORRENT_ASSERT(chunk_start[0] == '\r' || aux::is_hex(chunk_start.data(), 1)); bool ret = m_parser.parse_chunk_header(chunk_start, &chunk_size, &header_size); @@ -393,11 +393,11 @@ namespace libtorrent TORRENT_ASSERT(m_chunk_pos + m_body_start < INT_MAX); m_recv_buffer.cut(header_size, t->block_size() + 1024, int(m_chunk_pos + m_body_start)); recv_buffer = m_recv_buffer.get(); - recv_buffer.begin += m_body_start; + recv_buffer = recv_buffer.subspan(m_body_start); m_chunk_pos += chunk_size; if (chunk_size == 0) { - TORRENT_ASSERT(m_recv_buffer.get().left() < m_chunk_pos + m_body_start + 1 + TORRENT_ASSERT(int(m_recv_buffer.get().size()) < m_chunk_pos + m_body_start + 1 || m_recv_buffer.get()[int(m_chunk_pos + m_body_start)] == 'H' || (m_parser.chunked_encoding() && m_recv_buffer.get()[int(m_chunk_pos + m_body_start)] == '\r')); m_chunk_pos = -1; @@ -416,7 +416,7 @@ namespace libtorrent { if (!m_parser.finished()) return; - int retry_time = atol(std::string(recv_buffer.begin, recv_buffer.end).c_str()); + int retry_time = atol(std::string(recv_buffer.begin(), recv_buffer.end()).c_str()); if (retry_time <= 0) retry_time = 60; #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "CONNECT", "retrying in %d seconds", retry_time); @@ -431,20 +431,20 @@ namespace libtorrent // we only received the header, no data - if (recv_buffer.left() == 0) break; + if (int(recv_buffer.size()) == 0) break; - if (recv_buffer.left() < front_request.length) break; + if (int(recv_buffer.size()) < front_request.length) break; // if the response is chunked, we need to receive the last // terminating chunk and the tail headers before we can proceed if (m_parser.chunked_encoding() && m_chunk_pos >= 0) break; m_requests.pop_front(); - incoming_piece(front_request, recv_buffer.begin); + incoming_piece(front_request, recv_buffer.begin()); if (associated_torrent().expired()) return; int size_to_cut = m_body_start + front_request.length; - TORRENT_ASSERT(m_recv_buffer.get().left() < size_to_cut + 1 + TORRENT_ASSERT(int(m_recv_buffer.get().size()) < size_to_cut + 1 || m_recv_buffer.get()[size_to_cut] == 'H' || (m_parser.chunked_encoding() && m_recv_buffer.get()[size_to_cut] == '\r')); @@ -467,4 +467,3 @@ namespace libtorrent } } - diff --git a/src/pe_crypto.cpp b/src/pe_crypto.cpp index 0d32297ea..b51aee35e 100644 --- a/src/pe_crypto.cpp +++ b/src/pe_crypto.cpp @@ -101,21 +101,21 @@ namespace libtorrent m_xor_mask = hasher(req3).update(buffer).final(); } - std::tuple> + std::tuple>> encryption_handler::encrypt( - span iovec) + span> iovec) { TORRENT_ASSERT(!m_send_barriers.empty()); TORRENT_ASSERT(m_send_barriers.front().enc_handler); int to_process = m_send_barriers.front().next; - aux::mutable_buffer* bufs; + span* bufs; size_t num_bufs; bool need_destruct = false; if (to_process != INT_MAX) { - bufs = TORRENT_ALLOCA(aux::mutable_buffer, iovec.size()); + bufs = TORRENT_ALLOCA(span, iovec.size()); need_destruct = true; num_bufs = 0; for (int i = 0; to_process > 0 && i < iovec.size(); ++i) @@ -124,13 +124,13 @@ namespace libtorrent int const size = int(iovec[i].size()); if (to_process < size) { - new (&bufs[i]) aux::mutable_buffer( + new (&bufs[i]) span( iovec[i].data(), to_process); to_process = 0; } else { - new (&bufs[i]) aux::mutable_buffer(iovec[i]); + new (&bufs[i]) span(iovec[i]); to_process -= size; } } @@ -142,7 +142,7 @@ namespace libtorrent } int next_barrier = 0; - span out_iovec; + span> out_iovec; if (num_bufs != 0) { std::tie(next_barrier, out_iovec) @@ -198,7 +198,7 @@ namespace libtorrent int consume = 0; if (recv_buffer.crypto_packet_finished()) { - aux::mutable_buffer wr_buf = recv_buffer.mutable_buffer(bytes_transferred); + span wr_buf = recv_buffer.mutable_buffer(bytes_transferred); int packet_size = 0; int produce = int(bytes_transferred); m_dec_handler->decrypt(wr_buf, consume, produce, packet_size); @@ -244,7 +244,7 @@ namespace libtorrent { int consume = 0; int produce = 0; - std::vector wr_buf; + std::vector> wr_buf; crypto->decrypt(wr_buf, consume, produce, packet_size); TORRENT_ASSERT(wr_buf.empty()); TORRENT_ASSERT(consume == 0); @@ -272,7 +272,7 @@ namespace libtorrent int produce = 0; int packet_size = 0; char buf[1024]; - aux::mutable_buffer vec(buf, sizeof(buf)); + span vec(buf, sizeof(buf)); decrypt(vec, consume, produce, packet_size); } @@ -282,14 +282,14 @@ namespace libtorrent rc4_init(key, len, &m_rc4_outgoing); // Discard first 1024 bytes char buf[1024]; - aux::mutable_buffer vec(buf, sizeof(buf)); + span vec(buf, sizeof(buf)); encrypt(vec); } - std::tuple> - rc4_handler::encrypt(span bufs) + std::tuple>> + rc4_handler::encrypt(span> bufs) { - span empty; + span> empty; if (!m_encrypt) return std::make_tuple(0, empty); if (bufs.size() == 0) return std::make_tuple(0, empty); @@ -308,7 +308,7 @@ namespace libtorrent return std::make_tuple(bytes_processed, empty); } - void rc4_handler::decrypt(span bufs + void rc4_handler::decrypt(span> bufs , int& consume , int& produce , int& packet_size) diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index d3d4fcc8d..21bea3f1a 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -2497,8 +2497,8 @@ namespace libtorrent check_invariant(); #endif #if TORRENT_USE_ASSERTS - buffer::const_interval recv_buffer = m_recv_buffer.get(); - int recv_pos = recv_buffer.end - recv_buffer.begin; + span recv_buffer = m_recv_buffer.get(); + int recv_pos = recv_buffer.end() - recv_buffer.begin(); TORRENT_ASSERT(recv_pos >= 9); #endif @@ -5468,12 +5468,12 @@ namespace libtorrent if (m_send_barrier == 0) { - std::vector vec; + std::vector> vec; // limit outgoing crypto messages to 1MB int const send_bytes = (std::min)(m_send_buffer.size(), 1024*1024); m_send_buffer.build_mutable_iovec(send_bytes, vec); int next_barrier; - span inject_vec; + span> inject_vec; std::tie(next_barrier, inject_vec) = hit_send_barrier(vec); for (auto i = inject_vec.rbegin(); i != inject_vec.rend(); ++i) { diff --git a/src/receive_buffer.cpp b/src/receive_buffer.cpp index 92ddf410a..09dc3f6ec 100644 --- a/src/receive_buffer.cpp +++ b/src/receive_buffer.cpp @@ -136,17 +136,16 @@ void receive_buffer::cut(int const size, int const packet_size, int const offset m_packet_size = packet_size; } -buffer::const_interval receive_buffer::get() const +span receive_buffer::get() const { if (m_recv_buffer.empty()) { TORRENT_ASSERT(m_recv_pos == 0); - return buffer::const_interval(nullptr,nullptr); + return span(); } TORRENT_ASSERT(m_recv_start + m_recv_pos <= m_recv_buffer.size()); - return buffer::const_interval(&m_recv_buffer[0] + m_recv_start - , &m_recv_buffer[0] + m_recv_start + m_recv_pos); + return span(m_recv_buffer).subspan(m_recv_start, m_recv_pos); } #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) @@ -156,7 +155,7 @@ span receive_buffer::mutable_buffer() return span(m_recv_buffer).subspan(m_recv_start, m_recv_pos); } -aux::mutable_buffer receive_buffer::mutable_buffer(int const bytes) +span receive_buffer::mutable_buffer(int const bytes) { INVARIANT_CHECK; // bytes is the number of bytes we just received, and m_recv_pos has @@ -317,15 +316,15 @@ int crypto_receive_buffer::advance_pos(int bytes) return sub_transferred; } -buffer::const_interval crypto_receive_buffer::get() const +span crypto_receive_buffer::get() const { - buffer::const_interval recv_buffer = m_connection_buffer.get(); + span recv_buffer = m_connection_buffer.get(); if (m_recv_pos < m_connection_buffer.pos()) - recv_buffer.end = recv_buffer.begin + m_recv_pos; + recv_buffer = recv_buffer.subspan(0, m_recv_pos); return recv_buffer; } -aux::mutable_buffer crypto_receive_buffer::mutable_buffer( +span crypto_receive_buffer::mutable_buffer( std::size_t const bytes) { int const pending_decryption = (m_recv_pos != INT_MAX) diff --git a/src/ut_metadata.cpp b/src/ut_metadata.cpp index acd76641c..55d7e0c7c 100644 --- a/src/ut_metadata.cpp +++ b/src/ut_metadata.cpp @@ -315,7 +315,7 @@ namespace libtorrent { namespace } bool on_extended(int length - , int extended_msg, buffer::const_interval body) override + , int extended_msg, span body) override { if (extended_msg != 2) return false; if (m_message_index == 0) return false; @@ -333,7 +333,7 @@ namespace libtorrent { namespace if (!m_pc.packet_finished()) return true; int len; - entry msg = bdecode(body.begin, body.end, len); + entry msg = bdecode(body.begin(), body.end(), len); if (msg.type() != entry::dictionary_t) { #ifndef TORRENT_DISABLE_LOGGING @@ -369,14 +369,14 @@ namespace libtorrent { namespace case metadata_req: { if (!m_torrent.valid_metadata() - || piece < 0 || piece >= int(m_tp.get_metadata_size() + 16 * 1024 - 1)/(16*1024)) + || piece < 0 || piece >= (m_tp.get_metadata_size() + 16 * 1024 - 1) / (16 * 1024)) { #ifndef TORRENT_DISABLE_LOGGING m_pc.peer_log(peer_log_alert::info, "UT_METADATA" , "have: %d invalid piece %d metadata size: %d" , int(m_torrent.valid_metadata()), piece , m_torrent.valid_metadata() - ? int(m_tp.get_metadata_size()) : 0); + ? m_tp.get_metadata_size() : 0); #endif write_metadata_packet(metadata_dont_have, piece); return true; @@ -406,7 +406,7 @@ namespace libtorrent { namespace m_sent_requests.erase(i); entry const* total_size = msg.find_key("total_size"); - m_tp.received_metadata(*this, body.begin + len, body.left() - len, piece + m_tp.received_metadata(*this, body.begin() + len, int(body.size()) - len, piece , (total_size && total_size->type() == entry::int_t) ? total_size->integer() : 0); maybe_send_request(); } @@ -664,4 +664,3 @@ namespace libtorrent } #endif - diff --git a/src/ut_pex.cpp b/src/ut_pex.cpp index 545525c88..a6e2bc6d1 100644 --- a/src/ut_pex.cpp +++ b/src/ut_pex.cpp @@ -280,7 +280,7 @@ namespace libtorrent { namespace return true; } - bool on_extended(int length, int msg, buffer::const_interval body) override + bool on_extended(int length, int msg, span body) override { if (msg != extension_index) return false; if (m_message_index == 0) return false; @@ -291,7 +291,7 @@ namespace libtorrent { namespace return true; } - if (body.left() < length) return true; + if (int(body.size()) < length) return true; time_point now = aux::time_now(); if (now - seconds(60) < m_last_pex[0]) @@ -309,7 +309,7 @@ namespace libtorrent { namespace bdecode_node pex_msg; error_code ec; - int const ret = bdecode(body.begin, body.end, pex_msg, ec); + int const ret = bdecode(body.begin(), body.end(), pex_msg, ec); if (ret != 0 || pex_msg.type() != bdecode_node::dict_t) { m_pc.disconnect(errors::invalid_pex_message, op_bittorrent, 2); diff --git a/src/web_peer_connection.cpp b/src/web_peer_connection.cpp index 41dcedb74..8547e4da0 100644 --- a/src/web_peer_connection.cpp +++ b/src/web_peer_connection.cpp @@ -655,7 +655,7 @@ void web_peer_connection::on_receive(error_code const& error // in case the first file on this series of requests is a padfile // we need to handle it right now - span recv_buffer(m_recv_buffer.get().begin, m_recv_buffer.get().left()); + span recv_buffer = m_recv_buffer.get(); handle_padfile(); if (associated_torrent().expired()) return; @@ -927,7 +927,7 @@ void web_peer_connection::on_receive(error_code const& error done: // now, remove all the bytes we've processed from the receive buffer - m_recv_buffer.cut(recv_buffer.data() - m_recv_buffer.get().begin + m_recv_buffer.cut(recv_buffer.data() - m_recv_buffer.get().begin() , t->block_size() + request_size_overhead); } @@ -1087,4 +1087,3 @@ void web_peer_connection::handle_padfile() } } // libtorrent namespace - diff --git a/test/test_pe_crypto.cpp b/test/test_pe_crypto.cpp index 8edbf17a7..509bcc85e 100644 --- a/test/test_pe_crypto.cpp +++ b/test/test_pe_crypto.cpp @@ -62,9 +62,9 @@ void test_enc_handler(libtorrent::crypto_plugin& a, libtorrent::crypto_plugin& b using namespace libtorrent::aux; { - mutable_buffer iovec(&buf[0], buf_len); + lt::span iovec(&buf[0], buf_len); int next_barrier; - lt::span iovec_out; + lt::span> iovec_out; std::tie(next_barrier, iovec_out) = a.encrypt(iovec); TEST_CHECK(buf != cmp_buf); TEST_EQUAL(iovec_out.size(), 0); @@ -75,7 +75,7 @@ void test_enc_handler(libtorrent::crypto_plugin& a, libtorrent::crypto_plugin& b int consume = 0; int produce = buf_len; int packet_size = 0; - mutable_buffer iovec(&buf[0], buf_len); + lt::span iovec(&buf[0], buf_len); b.decrypt(iovec, consume, produce, packet_size); TEST_CHECK(buf == cmp_buf); TEST_EQUAL(consume, 0); @@ -84,9 +84,9 @@ void test_enc_handler(libtorrent::crypto_plugin& a, libtorrent::crypto_plugin& b } { - mutable_buffer iovec(&buf[0], buf_len); + lt::span iovec(&buf[0], buf_len); int next_barrier; - lt::span iovec_out; + lt::span> iovec_out; std::tie(next_barrier, iovec_out) = b.encrypt(iovec); TEST_EQUAL(iovec_out.size(), 0); TEST_CHECK(buf != cmp_buf); @@ -95,7 +95,7 @@ void test_enc_handler(libtorrent::crypto_plugin& a, libtorrent::crypto_plugin& b int consume = 0; int produce = buf_len; int packet_size = 0; - mutable_buffer iovec2(&buf[0], buf_len); + lt::span iovec2(&buf[0], buf_len); a.decrypt(iovec2, consume, produce, packet_size); TEST_CHECK(buf == cmp_buf); TEST_EQUAL(consume, 0); diff --git a/test/test_receive_buffer.cpp b/test/test_receive_buffer.cpp index 8290c6a76..52b9eb685 100644 --- a/test/test_receive_buffer.cpp +++ b/test/test_receive_buffer.cpp @@ -229,7 +229,7 @@ TORRENT_TEST(recv_buffer_mutable_buffers) b.cut(100, 1000); // packet size = 1000 packet_transferred = b.advance_pos(999); TEST_EQUAL(packet_transferred, 999); - aux::mutable_buffer vec = b.mutable_buffer(999); + span vec = b.mutable_buffer(999); // previous packet // |