diff --git a/.gitignore b/.gitignore index c1ce24a1d..2e1ad6af0 100644 --- a/.gitignore +++ b/.gitignore @@ -34,6 +34,9 @@ *.deps *.cache *.dirstamp +*.swp +*.orig +*.rej bin config* @@ -41,6 +44,10 @@ Makefile build-aux test_tmp_* libtool +docs/reference* +docs/*.html +docs/*.png +docs/*-ref.rst .DS_Store .idea diff --git a/include/libtorrent/aux_/session_impl.hpp b/include/libtorrent/aux_/session_impl.hpp index 0c119d58d..003e3ca32 100644 --- a/include/libtorrent/aux_/session_impl.hpp +++ b/include/libtorrent/aux_/session_impl.hpp @@ -240,7 +240,7 @@ namespace libtorrent bool is_posting_torrent_updates() const override { return m_posting_torrent_updates; } // this is set while the session is building the // torrent status update message - bool m_posting_torrent_updates; + bool m_posting_torrent_updates = false; #endif void reopen_listen_sockets(); @@ -744,7 +744,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_POOL_ALLOCATOR // this pool is used to allocate and recycle send // buffers from. - boost::pool<> m_send_buffers; + boost::pool<> m_send_buffers{send_buffer_size_impl}; #endif io_service& m_io_service; @@ -766,7 +766,7 @@ namespace libtorrent // the client. This is the offset into m_alert_pointers where the next // alert is. If this is greater than or equal to m_alert_pointers.size() // it means we need to request new alerts from the main thread. - mutable int m_alert_pointer_pos; + mutable int m_alert_pointer_pos = 0; #endif // handles disk io requests asynchronously @@ -787,7 +787,7 @@ namespace libtorrent bandwidth_manager m_upload_rate; // the peer class that all peers belong to by default - peer_class_t m_global_class; + peer_class_t m_global_class = 0; // the peer class all TCP peers belong to by default // all tcp peer connections are subject to these @@ -796,10 +796,10 @@ namespace libtorrent // throttle TCP that passes over the internet // bottleneck (i.e. modem) to avoid starving out // uTP connections. - peer_class_t m_tcp_peer_class; + peer_class_t m_tcp_peer_class = 0; // peer class for local peers - peer_class_t m_local_peer_class; + peer_class_t m_local_peer_class = 0; tracker_manager m_tracker_manager; torrent_map m_torrents; @@ -865,12 +865,12 @@ namespace libtorrent // in this session. queue positions are packed (i.e. there // are no gaps). If there are no torrents with queue positions // this is -1. - int m_max_queue_pos; + int m_max_queue_pos = -1; // the key is an id that is used to identify the // client with the tracker only. It is randomized // at startup - int m_key; + int m_key = 0; // the addresses or device names of the interfaces we are supposed to // listen on. if empty, it means that we should let the os decide @@ -904,10 +904,10 @@ namespace libtorrent // when as a socks proxy is used for peers, also // listen for incoming connections on a socks connection boost::shared_ptr m_socks_listen_socket; - std::uint16_t m_socks_listen_port; + std::uint16_t m_socks_listen_port = 0; // round-robin index into m_outgoing_interfaces - mutable std::uint8_t m_interface_index; + mutable std::uint8_t m_interface_index = 0; void open_new_incoming_socks_connection(); @@ -929,30 +929,30 @@ namespace libtorrent // unchoke_interval and the unchoke set is // recomputed. // TODO: replace this by a proper asio timer - int m_unchoke_time_scaler; + int m_unchoke_time_scaler = 0; // this is used to decide when to recalculate which // torrents to keep queued and which to activate // TODO: replace this by a proper asio timer - int m_auto_manage_time_scaler; + int m_auto_manage_time_scaler = 0; // works like unchoke_time_scaler but it // is only decreased when the unchoke set // is recomputed, and when it reaches zero, // the optimistic unchoke is moved to another peer. // TODO: replace this by a proper asio timer - int m_optimistic_unchoke_time_scaler; + int m_optimistic_unchoke_time_scaler = 0; // works like unchoke_time_scaler. Each time // it reaches 0, and all the connections are // used, the worst connection will be disconnected // from the torrent with the most peers - int m_disconnect_time_scaler; + int m_disconnect_time_scaler = 90; // when this scaler reaches zero, it will // scrape one of the auto managed, paused, // torrents. - int m_auto_scrape_time_scaler; + int m_auto_scrape_time_scaler = 180; // statistics gathered from all torrents. stat m_stat; @@ -964,8 +964,8 @@ namespace libtorrent virtual void sent_syn(bool ipv6) override; virtual void received_synack(bool ipv6) override; - int m_peak_up_rate; - int m_peak_down_rate; + int m_peak_up_rate = 0; + int m_peak_down_rate = 0; void on_tick(error_code const& e); @@ -1005,13 +1005,14 @@ namespace libtorrent // when outgoing_ports is configured, this is the // port we'll bind the next outgoing socket to - mutable int m_next_port; + mutable int m_next_port = 0; #ifndef TORRENT_DISABLE_DHT std::unique_ptr m_dht_storage; boost::shared_ptr m_dht; dht_settings m_dht_settings; - dht::dht_storage_constructor_type m_dht_storage_constructor; + dht::dht_storage_constructor_type m_dht_storage_constructor + = dht::dht_default_storage_constructor; // these are used when starting the DHT // (and bootstrapping it), and then erased @@ -1031,11 +1032,11 @@ namespace libtorrent // compared to this number, the DHT announce interval // is updated again. This especially matters for // small numbers. - int m_dht_interval_update_torrents; + int m_dht_interval_update_torrents = 0; // the number of DHT router lookups there are currently outstanding. As // long as this is > 0, we'll postpone starting the DHT - int m_outstanding_router_lookups; + int m_outstanding_router_lookups = 0; #endif void send_udp_packet_hostname(char const* hostname @@ -1065,7 +1066,7 @@ namespace libtorrent // the number of torrent connection boosts // connections that have been made this second // this is deducted from the connect speed - int m_boost_connections; + int m_boost_connections = 0; boost::shared_ptr m_natpmp; boost::shared_ptr m_upnp; @@ -1133,18 +1134,18 @@ namespace libtorrent // m_torrent_lists[torrent_want_peers_downloading] // (which is a list of torrent pointers with all // torrents that want peers and are downloading) - int m_next_downloading_connect_torrent; - int m_next_finished_connect_torrent; + int m_next_downloading_connect_torrent = 0; + int m_next_finished_connect_torrent = 0; // this is the number of attempts of connecting to // peers we have given to downloading torrents. // when this gets high enough, we try to connect // a peer from a finished torrent - int m_download_connect_attempts; + int m_download_connect_attempts = 0; // index into m_torrent_lists[torrent_want_scrape] referring // to the next torrent to auto-scrape - int m_next_scrape_torrent; + int m_next_scrape_torrent = 0; #if TORRENT_USE_INVARIANT_CHECKS void check_invariant() const; @@ -1163,7 +1164,7 @@ namespace libtorrent // this keeps the timers more accurate over time // as a kind of "leap second" to adjust for the // accumulated error - std::uint16_t m_tick_residual; + std::uint16_t m_tick_residual = 0; #ifndef TORRENT_DISABLE_LOGGING virtual void session_log(char const* fmt, ...) const override TORRENT_FORMAT(2,3); @@ -1189,29 +1190,29 @@ namespace libtorrent // this is true whenever we have posted a deferred-disk job // it means we don't need to post another one - bool m_deferred_submit_disk_jobs; + bool m_deferred_submit_disk_jobs = false; // this is set to true when a torrent auto-manage // event is triggered, and reset whenever the message // is delivered and the auto-manage is executed. // there should never be more than a single pending auto-manage // message in-flight at any given time. - bool m_pending_auto_manage; + bool m_pending_auto_manage = false; // this is also set to true when triggering an auto-manage // of the torrents. However, if the normal auto-manage // timer comes along and executes the auto-management, // this is set to false, which means the triggered event // no longer needs to execute the auto-management. - bool m_need_auto_manage; + bool m_need_auto_manage = false; // set to true when the session object // is being destructed and the thread // should exit - bool m_abort; + bool m_abort = false; // is true if the session is paused - bool m_paused; + bool m_paused = false; // this is a list of peer connections who have been // corked (i.e. their network socket) and needs to be diff --git a/include/libtorrent/bt_peer_connection.hpp b/include/libtorrent/bt_peer_connection.hpp index 930a9338a..9b87ebbfe 100644 --- a/include/libtorrent/bt_peer_connection.hpp +++ b/include/libtorrent/bt_peer_connection.hpp @@ -327,7 +327,7 @@ public: private: - enum state_t + enum class state_t : std::uint8_t { #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) read_pe_dhkey = 0, @@ -351,7 +351,7 @@ private: }; // state of on_receive. one of the enums in state_t - std::uint8_t m_state; + state_t m_state = state_t::read_protocol_identifier; // this is set to true if the handshake from // the peer indicated that it supports the @@ -440,23 +440,23 @@ private: #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) // used to disconnect peer if sync points are not found within // the maximum number of bytes - int m_sync_bytes_read; + int m_sync_bytes_read = 0; #endif #ifndef TORRENT_DISABLE_EXTENSIONS // the message ID for upload only message // 0 if not supported - std::uint8_t m_upload_only_id; + std::uint8_t m_upload_only_id = 0; // the message ID for holepunch messages - std::uint8_t m_holepunch_id; + std::uint8_t m_holepunch_id = 0; // the message ID for don't-have message - std::uint8_t m_dont_have_id; + std::uint8_t m_dont_have_id = 0; // the message ID for share mode message // 0 if not supported - std::uint8_t m_share_mode_id; + std::uint8_t m_share_mode_id = 0; std::weak_ptr m_ut_pex; @@ -464,7 +464,7 @@ private: #endif #if TORRENT_USE_ASSERTS - bool m_in_constructor; + bool m_in_constructor = true; #endif }; diff --git a/include/libtorrent/peer_connection.hpp b/include/libtorrent/peer_connection.hpp index 414165469..442a8b9ff 100644 --- a/include/libtorrent/peer_connection.hpp +++ b/include/libtorrent/peer_connection.hpp @@ -60,6 +60,7 @@ POSSIBILITY OF SUCH DAMAGE. #include "libtorrent/io_service_fwd.hpp" #include "libtorrent/receive_buffer.hpp" #include "libtorrent/aux_/allocating_handler.hpp" +#include "libtorrent/aux_/time.hpp" #include "libtorrent/debug.hpp" #include "libtorrent/span.hpp" @@ -888,33 +889,33 @@ namespace libtorrent // the time when we last got a part of a // piece packet from this peer - time_point m_last_piece; + time_point m_last_piece = aux::time_now(); // the time we sent a request to // this peer the last time - time_point m_last_request; + time_point m_last_request = aux::time_now(); // the time we received the last // piece request from the peer - time_point m_last_incoming_request; + time_point m_last_incoming_request = min_time(); // the time when we unchoked this peer - time_point m_last_unchoke; + time_point m_last_unchoke = aux::time_now(); // if we're unchoked by this peer, this // was the time - time_point m_last_unchoked; + time_point m_last_unchoked = aux::time_now(); // the time we last choked this peer. min_time() in // case we never unchoked it - time_point m_last_choke; + time_point m_last_choke = min_time(); // timeouts - time_point m_last_receive; - time_point m_last_sent; + time_point m_last_receive = aux::time_now(); + time_point m_last_sent = aux::time_now(); // the last time we filled our send buffer with payload // this is used for timeouts - time_point m_last_sent_payload; + time_point m_last_sent_payload = aux::time_now(); // the time when the first entry in the request queue was requested. Used // for request timeout. it doesn't necessarily represent the time when a @@ -923,31 +924,31 @@ namespace libtorrent // Once we get that response, we set it to the current time. // for more information, see the blog post at: // http://blog.libtorrent.org/2011/11/block-request-time-outs/ - time_point m_requested; + time_point m_requested = aux::time_now(); // a timestamp when the remote download rate // was last updated - time_point m_remote_dl_update; + time_point m_remote_dl_update = aux::time_now(); // the time when async_connect was called // or when the incoming connection was established - time_point m_connect; + time_point m_connect = aux::time_now(); // the time when this peer sent us a not_interested message // the last time. - time_point m_became_uninterested; + time_point m_became_uninterested = aux::time_now(); // the time when we sent a not_interested message to // this peer the last time. - time_point m_became_uninteresting; + time_point m_became_uninteresting = aux::time_now(); // the total payload download bytes // at the last unchoke round. This is used to // measure the number of bytes transferred during // an unchoke cycle, to unchoke peers the more bytes // they sent us - std::int64_t m_downloaded_at_last_round; - std::int64_t m_uploaded_at_last_round; + std::int64_t m_downloaded_at_last_round = 0; + std::int64_t m_uploaded_at_last_round = 0; // this is the number of bytes we had uploaded the // last time this peer was unchoked. This does not @@ -955,19 +956,19 @@ namespace libtorrent // track upload across rounds, for the full duration of // the peer being unchoked. Specifically, it's used // for the round-robin unchoke algorithm. - std::int64_t m_uploaded_at_last_unchoke; + std::int64_t m_uploaded_at_last_unchoke = 0; // the number of payload bytes downloaded last second tick - std::int32_t m_downloaded_last_second; + std::int32_t m_downloaded_last_second = 0; // the number of payload bytes uploaded last second tick - std::int32_t m_uploaded_last_second; + std::int32_t m_uploaded_last_second = 0; // the number of bytes that the other // end has to send us in order to respond // to all outstanding piece requests we // have sent to it - int m_outstanding_bytes; + int m_outstanding_bytes = 0; aux::handler_storage m_read_handler_storage; aux::handler_storage m_write_handler_storage; @@ -998,11 +999,11 @@ namespace libtorrent // the time when this peer last saw a complete copy // of this torrent - time_t m_last_seen_complete; + time_t m_last_seen_complete = 0; // the block we're currently receiving. Or // (-1, -1) if we're not receiving one - piece_block m_receiving_block; + piece_block m_receiving_block = piece_block::invalid; // the local endpoint for this peer, i.e. our address // and our port. If this is set for outgoing connections @@ -1029,7 +1030,7 @@ namespace libtorrent // the number of outstanding bytes expected // to be received by extensions - int m_extension_outstanding_bytes; + int m_extension_outstanding_bytes = 0; // the number of time critical requests // queued up in the m_request_queue that @@ -1039,18 +1040,18 @@ namespace libtorrent // requests and take the previous requests // into account without submitting it all // immediately - int m_queued_time_critical; + int m_queued_time_critical = 0; // the number of bytes we are currently reading // from disk, that will be added to the send // buffer as soon as they complete - int m_reading_bytes; + int m_reading_bytes = 0; // options used for the piece picker. These flags will // be augmented with flags controlled by other settings // like sequential download etc. These are here to // let plugins control flags that should always be set - int m_picker_options; + int m_picker_options = 0; // the number of invalid piece-requests // we have got from this peer. If the request @@ -1059,30 +1060,30 @@ namespace libtorrent // peer is waiting for those pieces. // we can then clear its download queue // by sending choke, unchoke. - int m_num_invalid_requests; + int m_num_invalid_requests = 0; // if [0] is -1, superseeding is not active. If it is >= 0 // this is the piece that is available to this peer. Only // these two pieces can be downloaded from us by this peer. // This will remain the current piece for this peer until // another peer sends us a have message for this piece - int m_superseed_piece[2]; + int m_superseed_piece[2] = {-1, -1}; // pieces downloaded since last second // timer timeout; used for determining // approx download rate - int m_remote_pieces_dled; + int m_remote_pieces_dled = 0; // approximate peer download rate - int m_remote_dl_rate; + int m_remote_dl_rate = 0; // the number of bytes send to the disk-io // thread that hasn't yet been completely written. - int m_outstanding_writing_bytes; + int m_outstanding_writing_bytes = 0; // max transfer rates seen on this peer - int m_download_rate_peak; - int m_upload_rate_peak; + int m_download_rate_peak = 0; + int m_upload_rate_peak = 0; // when using the BitTyrant choker, this is our // estimated reciprocation rate. i.e. the rate @@ -1091,12 +1092,12 @@ namespace libtorrent int m_est_reciprocation_rate; // stop sending data after this many bytes, INT_MAX = inf - int m_send_barrier; + int m_send_barrier = INT_MAX; // the number of request we should queue up // at the remote end. // TODO: 2 rename this target queue size - std::uint16_t m_desired_queue_size; + std::uint16_t m_desired_queue_size = 4; // if set to non-zero, this peer will always prefer // to request entire n pieces, rather than blocks. @@ -1104,14 +1105,14 @@ namespace libtorrent // if it is 0, the download rate limit setting // will be used to determine if whole pieces // are preferred. - std::uint8_t m_prefer_contiguous_blocks; + std::uint8_t m_prefer_contiguous_blocks = 0; // this is the number of times this peer has had // a request rejected because of a disk I/O failure. // once this reaches a certain threshold, the // peer is disconnected in order to avoid infinite // loops of consistent failures - std::uint8_t m_disk_read_failures; + std::uint8_t m_disk_read_failures = 0; // this is used in seed mode whenever we trigger a hash check // for a piece, before we read it. It's used to throttle @@ -1229,15 +1230,15 @@ namespace libtorrent #if TORRENT_USE_ASSERTS public: - bool m_in_constructor; - bool m_disconnect_started; - bool m_initialized; - int m_in_use; - int m_received_in_piece; - bool m_destructed; + bool m_in_constructor = true; + bool m_disconnect_started = false; + bool m_initialized = false; + int m_in_use = 1337; + int m_received_in_piece = 0; + bool m_destructed = false; // this is true while there is an outstanding // async write job on the socket - bool m_socket_is_writing; + bool m_socket_is_writing = false; bool is_single_thread() const; #endif }; diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp index 69790e051..cab23744a 100644 --- a/include/libtorrent/torrent.hpp +++ b/include/libtorrent/torrent.hpp @@ -1147,8 +1147,8 @@ namespace libtorrent // all time totals of uploaded and downloaded payload // stored in resume data - std::int64_t m_total_uploaded; - std::int64_t m_total_downloaded; + std::int64_t m_total_uploaded = 0; + std::int64_t m_total_downloaded = 0; // if this pointer is 0, the torrent is in // a state where the metadata hasn't been @@ -1289,14 +1289,14 @@ namespace libtorrent // it was completed. If the torrent isn't yet // completed, m_completed_time is 0 time_t m_added_time; - time_t m_completed_time; + time_t m_completed_time = 0; // this was the last time _we_ saw a seed in this swarm - time_t m_last_seen_complete; + time_t m_last_seen_complete = 0; // this is the time last any of our peers saw a seed // in this swarm - time_t m_swarm_last_seen_complete; + time_t m_swarm_last_seen_complete = 0; // keep a copy if the info-hash here, so it can be accessed from multiple // threads, and be cheap to access from the client @@ -1317,7 +1317,7 @@ namespace libtorrent private: // m_num_verified = m_verified.count() - std::uint32_t m_num_verified; + std::uint32_t m_num_verified = 0; // this timestamp is kept in session-time, to // make it fit in 16 bits @@ -1335,23 +1335,23 @@ namespace libtorrent // if we're a seed, this is the session time // timestamp of when we became one - std::uint16_t m_became_seed; + std::uint16_t m_became_seed = 0; // if we're finished, this is the session time // timestamp of when we finished - std::uint16_t m_became_finished; + std::uint16_t m_became_finished = 0; // when checking, this is the first piece we have not // issued a hash job for - int m_checking_piece; + int m_checking_piece = 0; // the number of pieces we completed the check of - int m_num_checked_pieces; + int m_num_checked_pieces = 0; // the number of async. operations that need this torrent // loaded in RAM. having a refcount > 0 prevents it from // being unloaded. - int m_refcount; + int m_refcount = 0; // if the error ocurred on a file, this is the index of that file // there are a few special cases, when this is negative. See @@ -1359,15 +1359,15 @@ namespace libtorrent int m_error_file; // the average time it takes to download one time critical piece - std::uint32_t m_average_piece_time; + std::uint32_t m_average_piece_time = 0; // the average piece download time deviation - std::uint32_t m_piece_time_deviation; + std::uint32_t m_piece_time_deviation = 0; // the number of bytes that has been // downloaded that failed the hash-test - std::uint32_t m_total_failed_bytes; - std::uint32_t m_total_redundant_bytes; + std::uint32_t m_total_failed_bytes = 0; + std::uint32_t m_total_redundant_bytes = 0; // the sequence number for this torrent, this is a // monotonically increasing number for each added torrent @@ -1375,14 +1375,14 @@ namespace libtorrent // for torrents who have a bandwidth limit, this is != 0 // and refers to a peer_class in the session. - std::uint16_t m_peer_class; + std::uint16_t m_peer_class = 0; // of all peers in m_connections, this is the number // of peers that are outgoing and still waiting to // complete the connection. This is used to possibly // kick out these connections when we get incoming // connections (if we've reached the connection limit) - std::uint16_t m_num_connecting; + std::uint16_t m_num_connecting = 0; // ============================== // The following members are specifically @@ -1393,7 +1393,7 @@ namespace libtorrent // the session time timestamp of when we entered upload mode // if we're currently in upload-mode - std::uint16_t m_upload_mode_time; + std::uint16_t m_upload_mode_time = 0; // true when this torrent should announce to // trackers @@ -1434,7 +1434,7 @@ namespace libtorrent unsigned int m_active_time:24; // the index to the last tracker that worked - std::int8_t m_last_working_tracker; + std::int8_t m_last_working_tracker = -1; // ---- @@ -1586,16 +1586,16 @@ namespace libtorrent // the timestamp of the last piece passed for this torrent specified in // session_time. This is signed because it must be able to represent time // before the session started - std::int16_t m_last_download; + std::int16_t m_last_download = (std::numeric_limits::min)(); // the number of peer connections to seeds. This should be the same as // counting the peer connections that say true for is_seed() - std::uint16_t m_num_seeds; + std::uint16_t m_num_seeds = 0; // the timestamp of the last byte uploaded from this torrent specified in // session_time. This is signed because it must be able to represent time // before the session started. - std::int16_t m_last_upload; + std::int16_t m_last_upload = (std::numeric_limits::min)(); // ---- @@ -1627,7 +1627,7 @@ namespace libtorrent // the timestamp of the last scrape request to one of the trackers in // this torrent specified in session_time. This is signed because it must // be able to represent time before the session started - std::int16_t m_last_scrape; + std::int16_t m_last_scrape = (std::numeric_limits::min)(); // ---- @@ -1637,8 +1637,8 @@ namespace libtorrent #if TORRENT_USE_ASSERTS // set to true when torrent is start()ed. It may only be started once - bool m_was_started; - bool m_outstanding_check_files; + bool m_was_started = false; + bool m_outstanding_check_files = false; #endif }; diff --git a/src/bt_peer_connection.cpp b/src/bt_peer_connection.cpp index 89e7b5bd4..e921dccd4 100644 --- a/src/bt_peer_connection.cpp +++ b/src/bt_peer_connection.cpp @@ -156,7 +156,6 @@ namespace libtorrent bt_peer_connection::bt_peer_connection(peer_connection_args const& pack , peer_id const& pid) : peer_connection(pack) - , m_state(read_protocol_identifier) , m_supports_extensions(false) , m_supports_dht_port(false) , m_supports_fast(false) @@ -169,20 +168,6 @@ namespace libtorrent , m_recv_buffer(peer_connection::m_recv_buffer) #endif , m_our_peer_id(pid) -#if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) - , m_sync_bytes_read(0) -#endif -#ifndef TORRENT_DISABLE_EXTENSIONS - , m_upload_only_id(0) - , m_holepunch_id(0) -#endif -#ifndef TORRENT_DISABLE_EXTENSIONS - , m_dont_have_id(0) - , m_share_mode_id(0) -#endif -#if TORRENT_USE_ASSERTS - , m_in_constructor(true) -#endif { #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "CONSTRUCT", "bt_peer_connection"); @@ -262,7 +247,7 @@ namespace libtorrent write_pe1_2_dhkey(); if (is_disconnecting()) return; - m_state = read_pe_dhkey; + m_state = state_t::read_pe_dhkey; m_recv_buffer.reset(dh_key_len); setup_receive(); } @@ -284,7 +269,7 @@ namespace libtorrent write_pe1_2_dhkey(); if (is_disconnecting()) return; - m_state = read_pe_dhkey; + m_state = state_t::read_pe_dhkey; m_recv_buffer.reset(dh_key_len); setup_receive(); } @@ -324,7 +309,11 @@ namespace libtorrent // we're still waiting to fully handshake with this peer. At the end of // the handshake we'll send the bitfield and dht port anyway. It's too // early to do now - if (m_state < read_packet_size) return; + if (static_cast(m_state) + < static_cast(state_t::read_packet_size)) + { + return; + } // connections that are still in the handshake // will send their bitfield when the handshake @@ -859,7 +848,7 @@ namespace libtorrent span recv_buffer = m_recv_buffer.get(); // are we currently receiving a 'piece' message? - if (m_state != read_packet + if (m_state != state_t::read_packet || int(recv_buffer.size()) <= 9 || recv_buffer[0] != msg_piece) return boost::optional(); @@ -2074,7 +2063,7 @@ namespace libtorrent // if we have not received the other peer's extension bits yet, how do we // know whether to send a have-all or have-none? - TORRENT_ASSERT(m_state >= read_peer_id); + TORRENT_ASSERT(m_state >= state_t::read_peer_id); boost::shared_ptr t = associated_torrent().lock(); TORRENT_ASSERT(t); @@ -2575,7 +2564,7 @@ namespace libtorrent // m_state is set to read_pe_dhkey in initial state // (read_protocol_identifier) for incoming, or in constructor // for outgoing - if (m_state == read_pe_dhkey) + if (m_state == state_t::read_pe_dhkey) { received_bytes(0, int(bytes_transferred)); @@ -2609,7 +2598,7 @@ namespace libtorrent if (is_outgoing()) { - m_state = read_pe_syncvc; + m_state = state_t::read_pe_syncvc; write_pe3_sync(); // initial payload is the standard handshake, this is @@ -2626,7 +2615,7 @@ namespace libtorrent else { // already written dh key - m_state = read_pe_synchash; + m_state = state_t::read_pe_synchash; // synchash,skeyhash,vc,crypto_provide,len(pad),pad,encrypt(handshake) m_recv_buffer.reset(20+20+8+4+2+0+handshake_len); } @@ -2635,7 +2624,7 @@ namespace libtorrent } // cannot fall through into - if (m_state == read_pe_synchash) + if (m_state == state_t::read_pe_synchash) { TORRENT_ASSERT(!m_encrypted); TORRENT_ASSERT(!m_rc4_encrypted); @@ -2702,7 +2691,7 @@ namespace libtorrent , "sync point (hash) found at offset %d" , int(m_sync_bytes_read + bytes_processed - 20)); #endif - m_state = read_pe_skey_vc; + m_state = state_t::read_pe_skey_vc; // skey,vc - 28 bytes m_sync_hash.reset(); int transferred_used = int(bytes_processed - int(recv_buffer.size()) + bytes_transferred); @@ -2713,7 +2702,7 @@ namespace libtorrent } } - if (m_state == read_pe_skey_vc) + if (m_state == state_t::read_pe_skey_vc) { received_bytes(0, int(bytes_transferred)); bytes_transferred = 0; @@ -2773,12 +2762,12 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "ENCRYPTION", "verification constant found"); #endif - m_state = read_pe_cryptofield; + m_state = state_t::read_pe_cryptofield; m_recv_buffer.reset(4 + 2); } // cannot fall through into - if (m_state == read_pe_syncvc) + if (m_state == state_t::read_pe_syncvc) { TORRENT_ASSERT(is_outgoing()); TORRENT_ASSERT(!m_encrypted); @@ -2849,12 +2838,12 @@ namespace libtorrent // delete verification constant m_sync_vc.reset(); - m_state = read_pe_cryptofield; + m_state = state_t::read_pe_cryptofield; // fall through } } - if (m_state == read_pe_cryptofield) // local/remote + if (m_state == state_t::read_pe_cryptofield) // local/remote { TORRENT_ASSERT(!m_encrypted); TORRENT_ASSERT(!m_rc4_encrypted); @@ -2942,7 +2931,7 @@ namespace libtorrent return; } - m_state = read_pe_pad; + m_state = state_t::read_pe_pad; if (!is_outgoing()) m_recv_buffer.reset(len_pad + 2); // len(IA) at the end of pad else @@ -2955,14 +2944,14 @@ namespace libtorrent switch_send_crypto(m_rc4); switch_recv_crypto(m_rc4); } - m_state = init_bt_handshake; + m_state = state_t::init_bt_handshake; } else m_recv_buffer.reset(len_pad); } } - if (m_state == read_pe_pad) + if (m_state == state_t::read_pe_pad) { TORRENT_ASSERT(!m_encrypted); received_bytes(0, int(bytes_transferred)); @@ -3001,11 +2990,11 @@ namespace libtorrent switch_send_crypto(m_rc4); switch_recv_crypto(m_rc4); } - m_state = init_bt_handshake; + m_state = state_t::init_bt_handshake; } else { - m_state = read_pe_ia; + m_state = state_t::read_pe_ia; m_recv_buffer.reset(len_ia); } } @@ -3018,11 +3007,11 @@ namespace libtorrent switch_send_crypto(m_rc4); switch_recv_crypto(m_rc4); } - m_state = init_bt_handshake; + m_state = state_t::init_bt_handshake; } } - if (m_state == read_pe_ia) + if (m_state == state_t::read_pe_ia) { received_bytes(0, int(bytes_transferred)); bytes_transferred = 0; @@ -3051,11 +3040,11 @@ namespace libtorrent } m_rc4.reset(); - m_state = read_protocol_identifier; + m_state = state_t::read_protocol_identifier; m_recv_buffer.cut(0, 20); } - if (m_state == init_bt_handshake) + if (m_state == state_t::init_bt_handshake) { received_bytes(0, int(bytes_transferred)); bytes_transferred = 0; @@ -3076,7 +3065,7 @@ namespace libtorrent m_rc4.reset(); // payload stream, start with 20 handshake bytes - m_state = read_protocol_identifier; + m_state = state_t::read_protocol_identifier; m_recv_buffer.reset(20); // encrypted portion of handshake completed, toggle @@ -3094,7 +3083,7 @@ namespace libtorrent #endif // #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) - if (m_state == read_protocol_identifier) + if (m_state == state_t::read_protocol_identifier) { received_bytes(0, int(bytes_transferred)); bytes_transferred = 0; @@ -3148,7 +3137,7 @@ namespace libtorrent #ifndef TORRENT_DISABLE_LOGGING peer_log(peer_log_alert::info, "ENCRYPTION", "attempting encrypted connection"); #endif - m_state = read_pe_dhkey; + m_state = state_t::read_pe_dhkey; m_recv_buffer.cut(0, dh_key_len); TORRENT_ASSERT(!m_recv_buffer.packet_finished()); return; @@ -3160,7 +3149,7 @@ namespace libtorrent else { #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) - TORRENT_ASSERT(m_state != read_pe_dhkey); + TORRENT_ASSERT(m_state != state_t::read_pe_dhkey); if (!is_outgoing() && m_settings.get_int(settings_pack::in_enc_policy) @@ -3178,12 +3167,12 @@ namespace libtorrent #endif } - m_state = read_info_hash; + m_state = state_t::read_info_hash; m_recv_buffer.reset(28); } // fall through - if (m_state == read_info_hash) + if (m_state == state_t::read_info_hash) { received_bytes(0, int(bytes_transferred)); bytes_transferred = 0; @@ -3264,12 +3253,12 @@ namespace libtorrent if (is_disconnecting()) return; - m_state = read_peer_id; + m_state = state_t::read_peer_id; m_recv_buffer.reset(20); } // fall through - if (m_state == read_peer_id) + if (m_state == state_t::read_peer_id) { TORRENT_ASSERT(m_sent_handshake); received_bytes(0, int(bytes_transferred)); @@ -3410,7 +3399,7 @@ namespace libtorrent } } - m_state = read_packet_size; + m_state = state_t::read_packet_size; m_recv_buffer.reset(5); TORRENT_ASSERT(!m_recv_buffer.packet_finished()); @@ -3418,7 +3407,7 @@ namespace libtorrent } // cannot fall through into - if (m_state == read_packet_size) + if (m_state == state_t::read_packet_size) { // Make sure this is not fallen though into TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); @@ -3457,20 +3446,20 @@ namespace libtorrent incoming_keepalive(); if (is_disconnecting()) return; // keepalive message - m_state = read_packet_size; + m_state = state_t::read_packet_size; m_recv_buffer.cut(4, 5); return; } if (int(recv_buffer.size()) < 5) return; - m_state = read_packet; + m_state = state_t::read_packet; m_recv_buffer.cut(4, packet_size); recv_buffer = m_recv_buffer.get(); TORRENT_ASSERT(int(recv_buffer.size()) == 1); TORRENT_ASSERT(bytes_transferred == 1); } - if (m_state == read_packet) + if (m_state == state_t::read_packet) { TORRENT_ASSERT(recv_buffer.begin() == m_recv_buffer.get().begin()); TORRENT_ASSERT(recv_buffer.size() == m_recv_buffer.get().size()); @@ -3486,7 +3475,7 @@ namespace libtorrent #endif if (dispatch_message(int(bytes_transferred))) { - m_state = read_packet_size; + m_state = state_t::read_packet_size; m_recv_buffer.reset(5); } @@ -3587,7 +3576,7 @@ namespace libtorrent boost::shared_ptr t = associated_torrent().lock(); #if !defined(TORRENT_DISABLE_ENCRYPTION) && !defined(TORRENT_DISABLE_EXTENSIONS) - TORRENT_ASSERT( (bool(m_state != read_pe_dhkey) || m_dh_key_exchange.get()) + TORRENT_ASSERT( (bool(m_state != state_t::read_pe_dhkey) || m_dh_key_exchange.get()) || !is_outgoing()); TORRENT_ASSERT(!m_rc4_encrypted || (!m_encrypted && m_rc4) diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp index c7b7f3829..7d9b7b2f1 100644 --- a/src/peer_connection.cpp +++ b/src/peer_connection.cpp @@ -110,7 +110,6 @@ namespace libtorrent } #endif - // outbound connection peer_connection::peer_connection(peer_connection_args const& pack) : peer_connection_hot_members(pack.tor, *pack.ses, *pack.sett) , m_socket(pack.s) @@ -123,42 +122,6 @@ namespace libtorrent , m_allocator(*pack.allocator) , m_ios(*pack.ios) , m_work(m_ios) - , m_last_piece(aux::time_now()) - , m_last_request(aux::time_now()) - , m_last_incoming_request(min_time()) - , m_last_unchoke(aux::time_now()) - , m_last_unchoked(aux::time_now()) - , m_last_choke(min_time()) - , m_last_receive(aux::time_now()) - , m_last_sent(aux::time_now()) - , m_last_sent_payload(aux::time_now()) - , m_requested(min_time()) - , m_remote_dl_update(aux::time_now()) - , m_connect(aux::time_now()) - , m_became_uninterested(aux::time_now()) - , m_became_uninteresting(aux::time_now()) - , m_downloaded_at_last_round(0) - , m_uploaded_at_last_round(0) - , m_uploaded_at_last_unchoke(0) - , m_downloaded_last_second(0) - , m_uploaded_last_second(0) - , m_outstanding_bytes(0) - , m_last_seen_complete(0) - , m_receiving_block(piece_block::invalid) - , m_extension_outstanding_bytes(0) - , m_queued_time_critical(0) - , m_reading_bytes(0) - , m_picker_options(0) - , m_num_invalid_requests(0) - , m_remote_pieces_dled(0) - , m_remote_dl_rate(0) - , m_outstanding_writing_bytes(0) - , m_download_rate_peak(0) - , m_upload_rate_peak(0) - , m_send_barrier(INT_MAX) - , m_desired_queue_size(4) - , m_prefer_contiguous_blocks(0) - , m_disk_read_failures(0) , m_outstanding_piece_verification(0) , m_outgoing(!pack.tor.expired()) , m_received_listen_port(false) @@ -178,15 +141,6 @@ namespace libtorrent , m_has_metadata(true) , m_exceeded_limit(false) , m_slow_start(true) -#if TORRENT_USE_ASSERTS - , m_in_constructor(true) - , m_disconnect_started(false) - , m_initialized(false) - , m_in_use(1337) - , m_received_in_piece(0) - , m_destructed(false) - , m_socket_is_writing(false) -#endif { m_counters.inc_stats_counter(counters::num_tcp_peers + m_socket->type() - 1); @@ -195,8 +149,6 @@ namespace libtorrent else if (m_connecting) m_counters.inc_stats_counter(counters::num_peers_half_open); - m_superseed_piece[0] = -1; - m_superseed_piece[1] = -1; boost::shared_ptr t = m_torrent.lock(); // if t is nullptr, we better not be connecting, since // we can't decrement the connecting counter @@ -5866,10 +5818,11 @@ namespace libtorrent disconnect(ec, op_sock_read); return; } - - account_received_bytes(bytes); - - bytes_transferred += bytes; + else + { + account_received_bytes(bytes); + bytes_transferred += bytes; + } } } diff --git a/src/session_impl.cpp b/src/session_impl.cpp index 9ff26eb2f..46da70087 100644 --- a/src/session_impl.cpp +++ b/src/session_impl.cpp @@ -305,26 +305,15 @@ namespace aux { #endif session_impl::session_impl(io_service& ios) - : -#ifndef TORRENT_DISABLE_POOL_ALLOCATOR - m_send_buffers(send_buffer_size()) - , -#endif - m_io_service(ios) + : m_io_service(ios) #ifdef TORRENT_USE_OPENSSL , m_ssl_ctx(m_io_service, boost::asio::ssl::context::sslv23) #endif , m_alerts(m_settings.get_int(settings_pack::alert_queue_size), alert::all_categories) -#ifndef TORRENT_NO_DEPRECATE - , m_alert_pointer_pos(0) -#endif , m_disk_thread(m_io_service, m_stats_counters , static_cast(this)) , m_download_rate(peer_connection::download_channel) , m_upload_rate(peer_connection::upload_channel) - , m_global_class(0) - , m_tcp_peer_class(0) - , m_local_peer_class(0) , m_tracker_manager( std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4) , std::bind(&session_impl::send_udp_packet_hostname, this, _1, _2, _3, _4, _5) @@ -336,31 +325,16 @@ namespace aux { #endif ) , m_work(io_service::work(m_io_service)) - , m_max_queue_pos(-1) - , m_key(0) #if TORRENT_USE_I2P , m_i2p_conn(m_io_service) #endif - , m_socks_listen_port(0) - , m_interface_index(0) - , m_unchoke_time_scaler(0) - , m_auto_manage_time_scaler(0) - , m_optimistic_unchoke_time_scaler(0) - , m_disconnect_time_scaler(90) - , m_auto_scrape_time_scaler(180) - , m_peak_up_rate(0) - , m_peak_down_rate(0) , m_created(clock_type::now()) , m_last_tick(m_created) , m_last_second_tick(m_created - milliseconds(900)) , m_last_choke(m_created) , m_last_auto_manage(m_created) - , m_next_port(0) #ifndef TORRENT_DISABLE_DHT - , m_dht_storage_constructor(dht::dht_default_storage_constructor) , m_dht_announce_timer(m_io_service) - , m_dht_interval_update_torrents(0) - , m_outstanding_router_lookups(0) #endif , m_utp_socket_manager( std::bind(&session_impl::send_udp_packet, this, false, _1, _2, _3, _4) @@ -375,25 +349,10 @@ namespace aux { , m_settings, m_stats_counters , &m_ssl_ctx) #endif - , m_boost_connections(0) , m_timer(m_io_service) , m_lsd_announce_timer(m_io_service) , m_host_resolver(m_io_service) - , m_next_downloading_connect_torrent(0) - , m_next_finished_connect_torrent(0) - , m_download_connect_attempts(0) - , m_next_scrape_torrent(0) - , m_tick_residual(0) - , m_deferred_submit_disk_jobs(false) - , m_pending_auto_manage(false) - , m_need_auto_manage(false) - , m_abort(false) - , m_paused(false) { -#if TORRENT_USE_ASSERTS - m_posting_torrent_updates = false; -#endif - update_time_now(); } @@ -447,9 +406,6 @@ namespace aux { m_peer_class_type_filter.add(peer_class_type_filter::ssl_tcp_socket, m_tcp_peer_class); m_peer_class_type_filter.add(peer_class_type_filter::i2p_socket, m_tcp_peer_class); - // TODO: there's no rule here to make uTP connections not have the global or - // local rate limits apply to it. This used to be the default. - #ifndef TORRENT_DISABLE_LOGGING session_log("config: %s version: %s revision: %s" @@ -471,7 +427,6 @@ namespace aux { #ifndef TORRENT_DISABLE_LOGGING session_log(" max connections: %d", m_settings.get_int(settings_pack::connections_limit)); session_log(" max files: %d", max_files); - session_log(" generated peer ID: %s", m_peer_id.to_string().c_str()); #endif diff --git a/src/torrent.cpp b/src/torrent.cpp index 65c4f5b37..64e3a54ce 100644 --- a/src/torrent.cpp +++ b/src/torrent.cpp @@ -183,8 +183,6 @@ namespace libtorrent , add_torrent_params const& p , sha1_hash const& info_hash) : torrent_hot_members(ses, p, block_size, session_paused) - , m_total_uploaded(0) - , m_total_downloaded(0) , m_tracker_timer(ses.get_io_service()) , m_inactivity_timer(ses.get_io_service()) , m_trackerid(p.trackerid) @@ -197,27 +195,11 @@ namespace libtorrent , m_stats_counters(ses.stats_counters()) , m_storage_constructor(p.storage) , m_added_time(time(nullptr)) - , m_completed_time(0) - , m_last_seen_complete(0) - , m_swarm_last_seen_complete(0) , m_info_hash(info_hash) - , m_num_verified(0) , m_last_saved_resume(ses.session_time()) , m_started(ses.session_time()) - , m_became_seed(0) - , m_became_finished(0) - , m_checking_piece(0) - , m_num_checked_pieces(0) - , m_refcount(0) , m_error_file(torrent_status::error_file_none) - , m_average_piece_time(0) - , m_piece_time_deviation(0) - , m_total_failed_bytes(0) - , m_total_redundant_bytes(0) , m_sequence_number(seq) - , m_peer_class(0) - , m_num_connecting(0) - , m_upload_mode_time(0) , m_announce_to_trackers((p.flags & add_torrent_params::flag_paused) == 0) , m_announce_to_lsd((p.flags & add_torrent_params::flag_paused) == 0) , m_has_incoming(false) @@ -226,7 +208,6 @@ namespace libtorrent , m_announcing(false) , m_waiting_tracker(false) , m_active_time(0) - , m_last_working_tracker(-1) , m_finished_time(0) , m_sequential_download(false) , m_auto_sequential(false) @@ -254,20 +235,12 @@ namespace libtorrent , m_deleted(false) , m_pinned((p.flags & add_torrent_params::flag_pinned) != 0) , m_should_be_loaded(true) - , m_last_download((std::numeric_limits::min)()) - , m_num_seeds(0) - , m_last_upload((std::numeric_limits::min)()) , m_auto_managed((p.flags & add_torrent_params::flag_auto_managed) != 0) , m_current_gauge_state(no_gauge_state) , m_moving_storage(false) , m_inactive(false) , m_downloaded(0xffffff) - , m_last_scrape((std::numeric_limits::min)()) , m_progress_ppm(0) -#if TORRENT_USE_ASSERTS - , m_was_started(false) - , m_outstanding_check_files(false) -#endif { // we cannot log in the constructor, because it relies on shared_from_this // being initialized, which happens after the constructor returns.