added assertions that the stats is updated properly when receiving and sending bytes on peer_connections

include/libtorrent/stat.hpp

@@ -253,6 +253,10 @@ namespace libtorrent
 		{ return m_stat[download_payload].counter(); }
 		size_type last_payload_uploaded() const
 		{ return m_stat[upload_payload].counter(); }
+		size_type last_protocol_downloaded() const
+		{ return m_stat[download_protocol].counter(); }
+		size_type last_protocol_uploaded() const
+		{ return m_stat[upload_protocol].counter(); }
 
 		// these are the channels we keep stats for
 		enum

src/bt_peer_connection.cpp

@@ -1364,8 +1364,19 @@ namespace libtorrent
 
 		TORRENT_ASSERT(m_message_handler[packet_type] != 0);
 
+#ifndef NDEBUG
+		size_type cur_payload_dl = m_statistics.last_payload_downloaded();
+		size_type cur_protocol_dl = m_statistics.last_protocol_downloaded();
+#endif
 		// call the correct handler for this packet type
 		(this->*m_message_handler[packet_type])(received);
+#ifndef NDEBUG
+		TORRENT_ASSERT(m_statistics.last_payload_downloaded() - cur_payload_dl >= 0);
+		TORRENT_ASSERT(m_statistics.last_protocol_downloaded() - cur_protocol_dl >= 0);
+		size_type stats_diff = m_statistics.last_payload_downloaded() - cur_payload_dl +
+			m_statistics.last_protocol_downloaded() - cur_protocol_dl;
+		TORRENT_ASSERT(stats_diff == received);
+#endif
 
 		return packet_finished();
 	}
@@ -1728,11 +1739,13 @@ namespace libtorrent
 	{
 		INVARIANT_CHECK;
 
-		if (error) return;
+		if (error)
-		boost::shared_ptr<torrent> t = associated_torrent().lock();
+		{
-
-		if (in_handshake()) 
 			m_statistics.received_bytes(0, bytes_transferred);
+			return;
+		}
+
+		boost::shared_ptr<torrent> t = associated_torrent().lock();
 	
 #ifndef TORRENT_DISABLE_ENCRYPTION
 		TORRENT_ASSERT(in_handshake() || !m_rc4_encrypted || m_encrypted);
@@ -1752,6 +1765,8 @@ namespace libtorrent
 		// for outgoing
 		if (m_state == read_pe_dhkey)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+
 			TORRENT_ASSERT(!m_encrypted);
 			TORRENT_ASSERT(!m_rc4_encrypted);
 			TORRENT_ASSERT(packet_size() == dh_key_len);
@@ -1821,6 +1836,8 @@ namespace libtorrent
 		   
  			if (recv_buffer.left() < 20)
 			{
+				m_statistics.received_bytes(0, bytes_transferred);
+
 				if (packet_finished())
 					disconnect("sync hash not found", 2);
 				return;
@@ -1844,6 +1861,8 @@ namespace libtorrent
 			// No sync 
 			if (syncoffset == -1)
 			{
+				m_statistics.received_bytes(0, bytes_transferred);
+
 				std::size_t bytes_processed = recv_buffer.left() - 20;
 				m_sync_bytes_read += bytes_processed;
 				if (m_sync_bytes_read >= 512)
@@ -1869,12 +1888,18 @@ namespace libtorrent
 				m_state = read_pe_skey_vc;
 				// skey,vc - 28 bytes
 				m_sync_hash.reset();
+				int transferred_used = bytes_processed - recv_buffer.left() + bytes_transferred;
+				TORRENT_ASSERT(transferred_used <= int(bytes_transferred));
+				m_statistics.received_bytes(0, transferred_used);
+				bytes_transferred -= transferred_used;
 				cut_receive_buffer(bytes_processed, 28);
 			}
 		}
 
 		if (m_state == read_pe_skey_vc)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+
 			TORRENT_ASSERT(!m_encrypted);
 			TORRENT_ASSERT(!m_rc4_encrypted);
 			TORRENT_ASSERT(!is_local());
@@ -1948,6 +1973,7 @@ namespace libtorrent
 			
 			if (recv_buffer.left() < 8)
 			{
+				m_statistics.received_bytes(0, bytes_transferred);
 				if (packet_finished())
 					disconnect("sync verification constant not found", 2);
 				return;
@@ -1972,13 +1998,16 @@ namespace libtorrent
 			{
 				std::size_t bytes_processed = recv_buffer.left() - 8;
 				m_sync_bytes_read += bytes_processed;
+				m_statistics.received_bytes(0, bytes_transferred);
+
 				if (m_sync_bytes_read >= 512)
 				{
 					disconnect("sync verification constant not found within 520 bytes", 2);
 					return;
 				}
 
-				cut_receive_buffer(bytes_processed, (std::min)(packet_size(), (512+8) - m_sync_bytes_read));
+				cut_receive_buffer(bytes_processed, (std::min)(packet_size()
+					, (512+8) - m_sync_bytes_read));
 
 				TORRENT_ASSERT(!packet_finished());
 				return;
@@ -1991,6 +2020,11 @@ namespace libtorrent
 				(*m_logger) << " sync point (verification constant) found at offset " 
 							<< m_sync_bytes_read + bytes_processed - 8 << "\n";
 #endif
+				int transferred_used = bytes_processed - recv_buffer.left() + bytes_transferred;
+				TORRENT_ASSERT(transferred_used <= int(bytes_transferred));
+				m_statistics.received_bytes(0, transferred_used);
+				bytes_transferred -= transferred_used;
+
 				cut_receive_buffer(bytes_processed, 4 + 2);
 
 				// delete verification constant
@@ -2005,6 +2039,8 @@ namespace libtorrent
 			TORRENT_ASSERT(!m_encrypted);
 			TORRENT_ASSERT(!m_rc4_encrypted);
 			TORRENT_ASSERT(packet_size() == 4+2);
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
 			
 			if (!packet_finished()) return;
 
@@ -2131,6 +2167,8 @@ namespace libtorrent
 		if (m_state == read_pe_pad)
 		{
 			TORRENT_ASSERT(!m_encrypted);
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
 			if (!packet_finished()) return;
 
 			int pad_size = is_local() ? packet_size() : packet_size() - 2;
@@ -2176,6 +2214,7 @@ namespace libtorrent
 
 		if (m_state == read_pe_ia)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
 			TORRENT_ASSERT(!is_local());
 			TORRENT_ASSERT(!m_encrypted);
 
@@ -2206,6 +2245,8 @@ namespace libtorrent
 
 		if (m_state == init_bt_handshake)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
 			TORRENT_ASSERT(m_encrypted);
 
 			// decrypt remaining received bytes
@@ -2246,6 +2287,8 @@ namespace libtorrent
 		
 		if (m_state == read_protocol_identifier)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
 			TORRENT_ASSERT(packet_size() == 20);
 
 			if (!packet_finished()) return;
@@ -2306,6 +2349,8 @@ namespace libtorrent
 		// fall through
 		if (m_state == read_info_hash)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
 			TORRENT_ASSERT(packet_size() == 28);
 
 			if (!packet_finished()) return;
@@ -2392,6 +2437,8 @@ namespace libtorrent
 		// fall through
 		if (m_state == read_peer_id)
 		{
+			m_statistics.received_bytes(0, bytes_transferred);
+			bytes_transferred = 0;
   			if (!t)
 			{
 				TORRENT_ASSERT(!packet_finished()); // TODO
@@ -2529,11 +2576,19 @@ namespace libtorrent
 		{
 			// Make sure this is not fallen though into
 			TORRENT_ASSERT(recv_buffer == receive_buffer());
+			TORRENT_ASSERT(packet_size() == 5);
 
 			if (!t) return;
-			m_statistics.received_bytes(0, bytes_transferred);
 
-			if (recv_buffer.left() < 4) return;
+			if (recv_buffer.left() < 4)
+			{
+				m_statistics.received_bytes(0, bytes_transferred);
+				return;
+			}
+			int transferred_used = 4 - recv_buffer.left() + bytes_transferred;
+			TORRENT_ASSERT(transferred_used <= int(bytes_transferred));
+			m_statistics.received_bytes(0, transferred_used);
+			bytes_transferred -= transferred_used;
 
 			const char* ptr = recv_buffer.begin;
 			int packet_size = detail::read_int32(ptr);
@@ -2541,6 +2596,7 @@ namespace libtorrent
 			// don't accept packets larger than 1 MB
 			if (packet_size > 1024*1024 || packet_size < 0)
 			{
+				m_statistics.received_bytes(0, bytes_transferred);
 				// packet too large
 				std::stringstream msg;
 				msg << "packet > 1 MB (" << (unsigned int)packet_size << " bytes)";
@@ -2550,11 +2606,12 @@ namespace libtorrent
 					
 			if (packet_size == 0)
 			{
+				m_statistics.received_bytes(0, bytes_transferred);
 				incoming_keepalive();
 				if (is_disconnecting()) return;
 				// keepalive message
 				m_state = read_packet_size;
-				cut_receive_buffer(4, 4);
+				cut_receive_buffer(4, 5);
 				return;
 			}
 			else
@@ -2563,7 +2620,7 @@ namespace libtorrent
 
 				m_state = read_packet;
 				cut_receive_buffer(4, packet_size);
-				bytes_transferred = 1;
+				TORRENT_ASSERT(bytes_transferred == 1);
 				recv_buffer = receive_buffer();
 				TORRENT_ASSERT(recv_buffer.left() == 1);
 			}
@@ -2594,7 +2651,11 @@ namespace libtorrent
 	{
 		INVARIANT_CHECK;
 
-		if (error) return;
+		if (error)
+		{
+			m_statistics.sent_bytes(0, bytes_transferred);
+			return;
+		}
 
 		// manage the payload markers
 		int amount_payload = 0;

src/peer_connection.cpp

@@ -3498,7 +3498,18 @@ namespace libtorrent
 			TORRENT_ASSERT(m_recv_pos <= int(m_recv_buffer.size()
 				+ m_disk_recv_buffer_size));
 
+#ifndef NDEBUG
+			size_type cur_payload_dl = m_statistics.last_payload_downloaded();
+			size_type cur_protocol_dl = m_statistics.last_protocol_downloaded();
+#endif
 			on_receive(error, bytes_transferred);
+#ifndef NDEBUG
+			TORRENT_ASSERT(m_statistics.last_payload_downloaded() - cur_payload_dl >= 0);
+			TORRENT_ASSERT(m_statistics.last_protocol_downloaded() - cur_protocol_dl >= 0);
+			size_type stats_diff = m_statistics.last_payload_downloaded() - cur_payload_dl +
+				m_statistics.last_protocol_downloaded() - cur_protocol_dl;
+			TORRENT_ASSERT(stats_diff == bytes_transferred);
+#endif
 
 			TORRENT_ASSERT(m_packet_size > 0);
 
@@ -3746,7 +3757,19 @@ namespace libtorrent
 
 		m_last_sent = time_now();
 
+#ifndef NDEBUG
+		size_type cur_payload_ul = m_statistics.last_payload_uploaded();
+		size_type cur_protocol_ul = m_statistics.last_protocol_uploaded();
+#endif
 		on_sent(error, bytes_transferred);
+#ifndef NDEBUG
+		TORRENT_ASSERT(m_statistics.last_payload_uploaded() - cur_payload_ul >= 0);
+		TORRENT_ASSERT(m_statistics.last_protocol_uploaded() - cur_protocol_ul >= 0);
+		size_type stats_diff = m_statistics.last_payload_uploaded() - cur_payload_ul
+			+ m_statistics.last_protocol_uploaded() - cur_protocol_ul;
+		TORRENT_ASSERT(stats_diff == bytes_transferred);
+#endif
+
 		fill_send_buffer();
 
 		setup_send();