/* Copyright (c) 2008, Arvid Norberg All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: * Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. * Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. * Neither the name of the author nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */ #include "test.hpp" #include "setup_transfer.hpp" #include "settings.hpp" #include "test_utils.hpp" #include "libtorrent/socket.hpp" #include "libtorrent/io.hpp" #include "libtorrent/aux_/alloca.hpp" // for use of private TORRENT_ALLOCA #include "libtorrent/time.hpp" #include "libtorrent/peer_info.hpp" #include "libtorrent/bdecode.hpp" #include "libtorrent/bencode.hpp" #include "libtorrent/entry.hpp" #include "libtorrent/torrent_info.hpp" #include "libtorrent/aux_/path.hpp" #include #include #include #include #include // for vsnprintf using namespace lt; using namespace std::placeholders; namespace { void log(char const* fmt, ...) { va_list v; va_start(v, fmt); char buf[1024]; #ifdef __clang__ #pragma clang diagnostic push #pragma clang diagnostic ignored "-Wformat-nonliteral" #endif std::vsnprintf(buf, sizeof(buf), fmt, v); #ifdef __clang__ #pragma clang diagnostic pop #endif va_end(v); std::printf("\x1b[1m\x1b[36m%s: %s\x1b[0m\n" , time_now_string(), buf); } void print_session_log(lt::session& ses) { print_alerts(ses, "ses", true); } int read_message(tcp::socket& s, span buffer) { using namespace lt::detail; error_code ec; boost::asio::read(s, boost::asio::buffer(buffer.data(), 4) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); return -1; } char const* ptr = buffer.data(); int const length = read_int32(ptr); if (length > buffer.size()) { log("message size: %d", length); TEST_ERROR("message size exceeds max limit"); return -1; } boost::asio::read(s, boost::asio::buffer(buffer.data(), std::size_t(length)) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); return -1; } return length; } void print_message(span buffer) { char const* message_name[] = {"choke", "unchoke", "interested", "not_interested" , "have", "bitfield", "request", "piece", "cancel", "dht_port", "", "", "" , "suggest_piece", "have_all", "have_none", "reject_request", "allowed_fast"}; std::stringstream message; char extra[300]; extra[0] = 0; if (buffer.empty()) { message << "keepalive"; } else { int const msg = buffer[0]; if (msg >= 0 && msg < int(sizeof(message_name)/sizeof(message_name[0]))) message << message_name[msg]; else if (msg == 20) message << "extension msg [" << int(buffer[1]) << "]"; else message << "unknown[" << msg << "]"; if (msg == 0x6 && buffer.size() == 13) { peer_request r; const char* ptr = buffer.data() + 1; r.piece = piece_index_t(detail::read_int32(ptr)); r.start = detail::read_int32(ptr); r.length = detail::read_int32(ptr); std::snprintf(extra, sizeof(extra), "p: %d s: %d l: %d" , static_cast(r.piece), r.start, r.length); } else if (msg == 0x11 && buffer.size() == 5) { const char* ptr = buffer.data() + 1; int index = detail::read_int32(ptr); std::snprintf(extra, sizeof(extra), "p: %d", index); } else if (msg == 20 && buffer.size() > 4 && buffer[1] == 0 ) { std::snprintf(extra, sizeof(extra), "%s" , print_entry(bdecode(buffer.subspan(2))).c_str()); } } log("<== %s %s", message.str().c_str(), extra); } void send_allow_fast(tcp::socket& s, int piece) { log("==> allow fast: %d", piece); using namespace lt::detail; char msg[] = "\0\0\0\x05\x11\0\0\0\0"; char* ptr = msg + 5; write_int32(piece, ptr); error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 9) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_suggest_piece(tcp::socket& s, int piece) { log("==> suggest piece: %d", piece); using namespace lt::detail; char msg[] = "\0\0\0\x05\x0d\0\0\0\0"; char* ptr = msg + 5; write_int32(piece, ptr); error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 9) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_keepalive(tcp::socket& s) { log("==> keepalive"); char msg[] = "\0\0\0\0"; error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 4) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_unchoke(tcp::socket& s) { log("==> unchoke"); char msg[] = "\0\0\0\x01\x01"; error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 5) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_have_all(tcp::socket& s) { log("==> have_all"); char msg[] = "\0\0\0\x01\x0e"; // have_all error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 5) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_have_none(tcp::socket& s) { log("==> have_none"); char msg[] = "\0\0\0\x01\x0f"; // have_none error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 5) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_bitfield(tcp::socket& s, char const* bits) { using namespace lt::detail; int num_pieces = int(strlen(bits)); int packet_size = (num_pieces+7)/8 + 5; TORRENT_ALLOCA(msg, char, packet_size); std::fill(msg.begin(), msg.end(), 0); char* ptr = msg.data(); write_int32(packet_size-4, ptr); write_int8(5, ptr); log("==> bitfield [%s]", bits); for (int i = 0; i < num_pieces; ++i) { ptr[i/8] |= (bits[i] == '1' ? 1 : 0) << i % 8; } error_code ec; boost::asio::write(s, boost::asio::buffer(msg.data(), std::size_t(msg.size())) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void do_handshake(tcp::socket& s, sha1_hash const& ih, char* buffer) { char handshake[] = "\x13" "BitTorrent protocol\0\0\0\0\0\x10\0\x04" " " // space for info-hash "aaaaaaaaaaaaaaaaaaaa"; // peer-id log("==> handshake"); error_code ec; std::memcpy(handshake + 28, ih.begin(), 20); boost::asio::write(s, boost::asio::buffer(handshake, sizeof(handshake) - 1) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); return; } // read handshake boost::asio::read(s, boost::asio::buffer(buffer, 68) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); return; } log("<== handshake"); TEST_CHECK(buffer[0] == 19); TEST_CHECK(std::memcmp(buffer + 1, "BitTorrent protocol", 19) == 0); char* extensions = buffer + 20; // check for fast extension support TEST_CHECK(extensions[7] & 0x4); // check for extension protocol support bool const lt_extension_protocol = (extensions[5] & 0x10) != 0; TEST_CHECK(lt_extension_protocol == true); // check for DHT support bool const dht_support = (extensions[7] & 0x1) != 0; #ifndef TORRENT_DISABLE_DHT TEST_CHECK(dht_support == true); #else TEST_CHECK(dht_support == false); #endif TEST_CHECK(std::memcmp(buffer + 28, ih.begin(), 20) == 0); } void send_extension_handshake(tcp::socket& s, entry const& e) { std::vector buf; // reserve space for the message header // uint32: packet-length // uint8: 20 (extension message) // uint8: 0 (handshake) buf.resize(4 + 1 + 1); bencode(std::back_inserter(buf), e); using namespace lt::detail; char* ptr = &buf[0]; write_uint32(int(buf.size()) - 4, ptr); write_uint8(20, ptr); write_uint8(0, ptr); error_code ec; boost::asio::write(s, boost::asio::buffer(&buf[0], buf.size()) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } void send_request(tcp::socket& s, peer_request req) { using namespace lt::detail; log("==> request %d (%d,%d)", static_cast(req.piece), req.start, req.length); char msg[] = "\0\0\0\x0d\x06 "; // have_none char* ptr = msg + 5; write_uint32(static_cast(req.piece), ptr); write_uint32(req.start, ptr); write_uint32(req.length, ptr); error_code ec; boost::asio::write(s, boost::asio::buffer(msg, 17) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } entry read_extension_handshake(tcp::socket& s, span recv_buffer) { for (;;) { int const len = read_message(s, recv_buffer); if (len == -1) { TEST_ERROR("failed to read message"); return entry(); } recv_buffer = recv_buffer.first(len); print_message(recv_buffer); if (len < 4) continue; int msg = recv_buffer[0]; if (msg != 20) continue; int extmsg = recv_buffer[1]; if (extmsg != 0) continue; return bdecode(recv_buffer.subspan(2)); } } #ifndef TORRENT_DISABLE_EXTENSIONS void send_ut_metadata_msg(tcp::socket& s, int ut_metadata_msg, int type, int piece) { std::vector buf; // reserve space for the message header // uint32: packet-length // uint8: 20 (extension message) // uint8: (ut_metadata) buf.resize(4 + 1 + 1); entry e; e["msg_type"] = type; e["piece"] = piece; bencode(std::back_inserter(buf), e); using namespace lt::detail; char* ptr = &buf[0]; write_uint32(int(buf.size()) - 4, ptr); write_uint8(20, ptr); write_uint8(ut_metadata_msg, ptr); log("==> ut_metadata [ type: %d piece: %d ]", type, piece); error_code ec; boost::asio::write(s, boost::asio::buffer(&buf[0], buf.size()) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); } entry read_ut_metadata_msg(tcp::socket& s, span recv_buffer) { for (;;) { int const len = read_message(s, recv_buffer); if (len == -1) { TEST_ERROR("failed to read message"); return entry(); } auto const buffer = recv_buffer.first(len); print_message(buffer); if (len < 4) continue; int const msg = buffer[0]; if (msg != 20) continue; int const extmsg = buffer[1]; if (extmsg != 1) continue; return bdecode(buffer.subspan(2)); } } #endif // TORRENT_DISABLE_EXTENSIONS std::shared_ptr setup_peer(tcp::socket& s, sha1_hash& ih , std::shared_ptr& ses, bool incoming = true , torrent_flags_t const flags = torrent_flags_t{} , torrent_handle* th = nullptr) { std::shared_ptr t = ::create_torrent(); ih = t->info_hash(); settings_pack sett = settings(); sett.set_str(settings_pack::listen_interfaces, "0.0.0.0:48900"); sett.set_bool(settings_pack::enable_upnp, false); sett.set_bool(settings_pack::enable_natpmp, false); sett.set_bool(settings_pack::enable_lsd, false); sett.set_bool(settings_pack::enable_dht, false); sett.set_int(settings_pack::in_enc_policy, settings_pack::pe_disabled); sett.set_int(settings_pack::out_enc_policy, settings_pack::pe_disabled); sett.set_bool(settings_pack::enable_outgoing_utp, false); sett.set_bool(settings_pack::enable_incoming_utp, false); #if TORRENT_ABI_VERSION == 1 sett.set_bool(settings_pack::rate_limit_utp, true); #endif ses.reset(new lt::session(sett, lt::session::add_default_plugins)); error_code ec; add_torrent_params p; p.flags &= ~torrent_flags::paused; p.flags &= ~torrent_flags::auto_managed; p.flags |= flags; p.ti = t; p.save_path = "./tmp1_fast"; remove("./tmp1_fast/temporary", ec); if (ec) log("remove(): %s", ec.message().c_str()); ec.clear(); torrent_handle ret = ses->add_torrent(p, ec); if (th) *th = ret; // wait for the torrent to be ready wait_for_downloading(*ses, "ses"); if (incoming) { s.connect(tcp::endpoint(address::from_string("127.0.0.1", ec), ses->listen_port()), ec); if (ec) TEST_ERROR(ec.message()); } else { tcp::acceptor l(s.get_io_service()); l.open(tcp::v4()); l.bind(tcp::endpoint(address_v4::from_string("127.0.0.1"), 0)); l.listen(); tcp::endpoint addr = l.local_endpoint(); ret.connect_peer(addr); print_session_log(*ses); l.accept(s); } print_session_log(*ses); return t; } } // anonymous namespace // makes sure that pieces that are allowed and then // rejected aren't requested again TORRENT_TEST(reject_fast) { std::cout << "\n === test reject ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); std::vector allowed_fast; allowed_fast.push_back(0); allowed_fast.push_back(1); allowed_fast.push_back(2); allowed_fast.push_back(3); std::for_each(allowed_fast.begin(), allowed_fast.end() , std::bind(&send_allow_fast, std::ref(s), _1)); print_session_log(*ses); while (!allowed_fast.empty()) { print_session_log(*ses); int const len = read_message(s, recv_buffer); if (len == -1) break; auto buffer = span(recv_buffer).first(len); print_message(buffer); int msg = buffer[0]; if (msg != 0x6) continue; using namespace lt::detail; char const* ptr = buffer.data() + 1; int const piece = read_int32(ptr); std::vector::iterator i = std::find(allowed_fast.begin() , allowed_fast.end(), piece); TEST_CHECK(i != allowed_fast.end()); if (i != allowed_fast.end()) allowed_fast.erase(i); // send reject request recv_buffer[0] = 0x10; error_code ec; log("==> reject"); boost::asio::write(s, boost::asio::buffer("\0\0\0\x0d", 4) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); break; } boost::asio::write(s, boost::asio::buffer(recv_buffer, 13) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); break; } } print_session_log(*ses); s.close(); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); } TORRENT_TEST(invalid_suggest) { std::cout << "\n === test suggest ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); // this is an invalid suggest message. We would not expect to receive a // request for that piece index. send_suggest_piece(s, -234); send_unchoke(s); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); int len = read_message(s, recv_buffer); auto buffer = span(recv_buffer).first(len); int idx = -1; while (len > 0) { if (buffer[0] == 6) { char const* ptr = buffer.data() + 1; idx = detail::read_int32(ptr); break; } len = read_message(s, recv_buffer); buffer = span(recv_buffer).first(len); } TEST_CHECK(idx != -234); TEST_CHECK(idx != -1); s.close(); } TORRENT_TEST(reject_suggest) { std::cout << "\n === test suggest ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); std::vector suggested; suggested.push_back(0); suggested.push_back(1); suggested.push_back(2); suggested.push_back(3); std::for_each(suggested.begin(), suggested.end() , std::bind(&send_suggest_piece, std::ref(s), _1)); print_session_log(*ses); send_unchoke(s); print_session_log(*ses); send_keepalive(s); print_session_log(*ses); int fail_counter = 100; while (!suggested.empty() && fail_counter > 0) { print_session_log(*ses); int const len = read_message(s, recv_buffer); if (len == -1) break; auto buffer = span(recv_buffer).first(len); print_message(buffer); int const msg = buffer[0]; fail_counter--; if (msg != 0x6) continue; using namespace lt::detail; char const* ptr = buffer.data() + 1; int const piece = read_int32(ptr); std::vector::iterator i = std::find(suggested.begin() , suggested.end(), piece); TEST_CHECK(i != suggested.end()); if (i != suggested.end()) suggested.erase(i); // send reject request recv_buffer[0] = 0x10; error_code ec; log("==> reject"); boost::asio::write(s, boost::asio::buffer("\0\0\0\x0d", 4) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); break; } boost::asio::write(s, boost::asio::buffer(recv_buffer, 13) , boost::asio::transfer_all(), ec); if (ec) { TEST_ERROR(ec.message()); break; } } print_session_log(*ses); TEST_CHECK(fail_counter > 0); s.close(); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); } TORRENT_TEST(suggest_order) { std::cout << "\n === test suggest ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); std::vector suggested; suggested.push_back(0); suggested.push_back(1); suggested.push_back(2); suggested.push_back(3); std::for_each(suggested.begin(), suggested.end() , std::bind(&send_suggest_piece, std::ref(s), _1)); print_session_log(*ses); send_unchoke(s); print_session_log(*ses); int fail_counter = 100; while (!suggested.empty() && fail_counter > 0) { print_session_log(*ses); int const len = read_message(s, recv_buffer); if (len == -1) break; auto const buffer = span(recv_buffer).first(len); print_message({recv_buffer, len}); int const msg = recv_buffer[0]; fail_counter--; // we're just interested in requests if (msg != 0x6) continue; using namespace lt::detail; char const* ptr = buffer.data() + 1; int const piece = read_int32(ptr); // make sure we receive the requests inverse order of sending the suggest // messages. The last suggest should be the highest priority int const expected_piece = suggested.back(); suggested.pop_back(); TEST_EQUAL(piece, expected_piece); } print_session_log(*ses); TEST_CHECK(fail_counter > 0); s.close(); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); } TORRENT_TEST(multiple_bitfields) { std::cout << "\n === test multiple bitfields ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); std::shared_ptr ti = setup_peer(s, ih, ses); print_session_log(*ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); std::string bitfield; bitfield.resize(std::size_t(ti->num_pieces()), '0'); send_bitfield(s, bitfield.c_str()); print_session_log(*ses); bitfield[0] = '1'; send_bitfield(s, bitfield.c_str()); print_session_log(*ses); bitfield[1] = '1'; send_bitfield(s, bitfield.c_str()); print_session_log(*ses); bitfield[2] = '1'; send_bitfield(s, bitfield.c_str()); print_session_log(*ses); s.close(); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); } TORRENT_TEST(multiple_have_all) { std::cout << "\n === test multiple have_all ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); std::shared_ptr ti = setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); send_have_all(s); print_session_log(*ses); send_have_none(s); print_session_log(*ses); send_have_all(s); print_session_log(*ses); s.close(); print_session_log(*ses); std::this_thread::sleep_for(lt::milliseconds(500)); print_session_log(*ses); } // makes sure that pieces that are lost are not requested TORRENT_TEST(dont_have) { using namespace lt::detail; std::cout << "\n === test dont_have ===\n" << std::endl; sha1_hash ih; torrent_handle th; std::shared_ptr ses; io_service ios; tcp::socket s(ios); std::shared_ptr ti = setup_peer(s, ih, ses, true , torrent_flags_t{}, &th); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); std::this_thread::sleep_for(lt::milliseconds(300)); print_session_log(*ses); std::vector pi; th.get_peer_info(pi); TEST_EQUAL(pi.size(), 1); if (pi.size() != 1) return; // at this point, the peer should be considered a seed TEST_CHECK(pi[0].flags & peer_info::seed); int lt_dont_have = 0; error_code ec; while (lt_dont_have == 0) { print_session_log(*ses); int const len = read_message(s, recv_buffer); if (len == -1) break; auto const buffer = span(recv_buffer).first(len); print_message(buffer); if (len == 0) continue; int const msg = buffer[0]; if (msg != 20) continue; int const ext_msg = buffer[1]; if (ext_msg != 0) continue; int pos = 0; ec.clear(); bdecode_node e = bdecode(buffer.subspan(2), ec, &pos); if (ec) { log("failed to parse extension handshake: %s at pos %d" , ec.message().c_str(), pos); } TEST_CHECK(!ec); log("extension handshake: %s", print_entry(e).c_str()); bdecode_node m = e.dict_find_dict("m"); TEST_CHECK(m); if (!m) return; bdecode_node dont_have = m.dict_find_int("lt_donthave"); TEST_CHECK(dont_have); if (!dont_have) return; lt_dont_have = int(dont_have.int_value()); } print_session_log(*ses); char* ptr = recv_buffer; write_uint32(6, ptr); write_uint8(20, ptr); write_uint8(lt_dont_have, ptr); write_uint32(3, ptr); boost::asio::write(s, boost::asio::buffer(recv_buffer, 10) , boost::asio::transfer_all(), ec); if (ec) TEST_ERROR(ec.message()); print_session_log(*ses); std::this_thread::sleep_for(lt::milliseconds(1000)); print_session_log(*ses); th.get_peer_info(pi); TEST_EQUAL(pi.size(), 1); if (pi.size() != 1) return; TEST_CHECK(!(pi[0].flags & peer_info::seed)); TEST_EQUAL(pi[0].pieces.count(), pi[0].pieces.size() - 1); TEST_EQUAL(pi[0].pieces[piece_index_t(3)], false); TEST_EQUAL(pi[0].pieces[piece_index_t(2)], true); TEST_EQUAL(pi[0].pieces[piece_index_t(1)], true); TEST_EQUAL(pi[0].pieces[piece_index_t(0)], true); print_session_log(*ses); } TORRENT_TEST(extension_handshake) { using namespace lt::detail; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); std::shared_ptr ti = setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); entry extensions; send_extension_handshake(s, extensions); extensions = read_extension_handshake(s, recv_buffer); std::cout << extensions << '\n'; // these extensions are built-in TEST_CHECK(extensions["m"]["lt_donthave"].integer() != 0); TEST_CHECK(extensions["m"]["share_mode"].integer() != 0); TEST_CHECK(extensions["m"]["upload_only"].integer() != 0); TEST_CHECK(extensions["m"]["ut_holepunch"].integer() != 0); // these require extensions to be enabled #ifndef TORRENT_DISABLE_EXTENSIONS TEST_CHECK(extensions["m"]["ut_metadata"].integer() != 0); TEST_CHECK(extensions["m"]["ut_pex"].integer() != 0); #endif } #ifndef TORRENT_DISABLE_EXTENSIONS // TEST metadata extension messages and edge cases // this tests sending a request for a metadata piece that's too high. This is // pos TORRENT_TEST(invalid_metadata_request) { using namespace lt::detail; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); std::shared_ptr ti = setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_all(s); print_session_log(*ses); entry extensions; extensions["m"]["ut_metadata"] = 1; send_extension_handshake(s, extensions); extensions = read_extension_handshake(s, recv_buffer); int ut_metadata = int(extensions["m"]["ut_metadata"].integer()); log("ut_metadata: %d", ut_metadata); // 0 = request // 1 = piece // 2 = dont-have // first send an invalid request send_ut_metadata_msg(s, ut_metadata, 0, 1); // then send a valid one. If we get a response to the second one, // we assume we were not disconnected because of the invalid one send_ut_metadata_msg(s, ut_metadata, 0, 0); entry ut_metadata_msg = read_ut_metadata_msg(s, recv_buffer); // the first response should be "dont-have" TEST_EQUAL(ut_metadata_msg["msg_type"].integer(), 2); TEST_EQUAL(ut_metadata_msg["piece"].integer(), 1); ut_metadata_msg = read_ut_metadata_msg(s, recv_buffer); // the second response should be the payload TEST_EQUAL(ut_metadata_msg["msg_type"].integer(), 1); TEST_EQUAL(ut_metadata_msg["piece"].integer(), 0); print_session_log(*ses); } #endif // TORRENT_DISABLE_EXTENSIONS TORRENT_TEST(invalid_request) { std::cout << "\n === test request ===\n" << std::endl; sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); send_have_none(s); peer_request req; req.piece = piece_index_t(124134235); req.start = 0; req.length = 0x4000; send_request(s, req); } namespace { void have_all_test(bool const incoming) { sha1_hash ih; std::shared_ptr ses; io_service ios; tcp::socket s(ios); setup_peer(s, ih, ses, incoming, torrent_flags::seed_mode); char recv_buffer[1000]; do_handshake(s, ih, recv_buffer); print_session_log(*ses); // expect to receive a have-all (not a bitfield) // since we advertised support for FAST extensions for (;;) { int const len = read_message(s, recv_buffer); if (len == -1) { TEST_ERROR("failed to receive have-all despite advertising support for FAST"); break; } auto const buffer = span(recv_buffer).first(len); print_message(buffer); int const msg = buffer[0]; if (msg == 0xe) // have-all { // success! break; } if (msg == 5) // bitfield { TEST_ERROR("received bitfield from seed despite advertising support for FAST"); break; } } } } // anonymous namespace TORRENT_TEST(outgoing_have_all) { std::cout << "\n === test outgoing have-all ===\n" << std::endl; have_all_test(true); } TORRENT_TEST(incoming_have_all) { std::cout << "\n === test outgoing have-all ===\n" << std::endl; have_all_test(false); } // TODO: test sending invalid requests (out of bound piece index, offsets and // sizes)