added base class for peer_alerts and turned more alerts into peer_alerts with more information about the peer that generated it

include/libtorrent/alert_types.hpp

@@ -39,6 +39,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/peer_connection.hpp"
 #include "libtorrent/config.hpp"
 #include "libtorrent/assert.hpp"
+#include "libtorrent/identify_client.hpp"
 
 #include <boost/lexical_cast.hpp>
 
@@ -51,11 +52,51 @@ namespace libtorrent
 		{}
 		
 		virtual std::string message() const
-		{ return handle.is_valid()?handle.name():"- "; }
+		{ return handle.is_valid()?handle.name():" - "; }
 
 		torrent_handle handle;
 	};
 
+	struct TORRENT_EXPORT peer_alert: torrent_alert
+	{
+		peer_alert(torrent_handle const& h, tcp::endpoint const& ip_
+			, peer_id const& pid_)
+			: torrent_alert(h)
+			, ip(ip_)
+			, pid(pid_)
+		{}
+
+		const static int static_category = alert::peer_notification;
+		virtual int category() const { return static_category; }
+		virtual std::string message() const
+		{
+			error_code ec;
+			return torrent_alert::message() + " peer (" + ip.address().to_string(ec)
+				+ ", " + identify_client(pid) + ")";
+		}
+
+		tcp::endpoint ip;
+		peer_id pid;
+	};
+
+	struct TORRENT_EXPORT tracker_alert: torrent_alert
+	{
+		tracker_alert(torrent_handle const& h
+			, std::string const& url_)
+			: torrent_alert(h)
+			, url(url_)
+		{ assert(!url.empty()); }
+
+		const static int static_category = alert::tracker_notification;
+		virtual int category() const { return static_category; }
+		virtual std::string message() const
+		{
+			return torrent_alert::message() + " (" + url + ")";
+		}
+
+		std::string url;
+	};
+
 	struct TORRENT_EXPORT file_renamed_alert: torrent_alert
 	{
 		file_renamed_alert(torrent_handle const& h
@@ -139,25 +180,6 @@ namespace libtorrent
 		torrent_status::state_t state;
 	};
 
-	struct TORRENT_EXPORT tracker_alert: torrent_alert
-	{
-		tracker_alert(torrent_handle const& h
-			, std::string const& url_)
-			: torrent_alert(h)
-			, url(url_)
-		{ assert(!url.empty()); }
-
-		const static int static_category = alert::tracker_notification;
-		virtual int category() const { return static_category; }
-		virtual std::string message() const
-		{
-			return torrent_alert::message() + " (" + url + ")";
-		}
-
-
-		std::string url;
-	};
-
 	struct TORRENT_EXPORT tracker_error_alert: tracker_alert
 	{
 		tracker_error_alert(torrent_handle const& h
@@ -338,85 +360,60 @@ namespace libtorrent
 		int piece_index;
 	};
 
-	struct TORRENT_EXPORT peer_ban_alert: torrent_alert
+	struct TORRENT_EXPORT peer_ban_alert: peer_alert
 	{
-		peer_ban_alert(tcp::endpoint const& pip, torrent_handle h)
+		peer_ban_alert(torrent_handle h, tcp::endpoint const& ip
-			: torrent_alert(h)
+			, peer_id const& pid)
-			, ip(pip)
+			: peer_alert(h, ip, pid)
 		{}
 
 		virtual std::auto_ptr<alert> clone() const
 		{ return std::auto_ptr<alert>(new peer_ban_alert(*this)); }
 		virtual char const* what() const { return "peer banned"; }
-		const static int static_category = alert::peer_notification;
-		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
 			error_code ec;
-			return torrent_alert::message() + " banned peer "
+			return peer_alert::message() + " banned peer";
-				+ ip.address().to_string(ec);
 		}
-
-		tcp::endpoint ip;
 	};
 
-	struct TORRENT_EXPORT peer_unsnubbed_alert: torrent_alert
+	struct TORRENT_EXPORT peer_unsnubbed_alert: peer_alert
 	{
-		peer_unsnubbed_alert(torrent_handle const& h, tcp::endpoint const& ip_
+		peer_unsnubbed_alert(torrent_handle h, tcp::endpoint const& ip
-			, peer_id const& pid_)
+			, peer_id const& pid)
-			: torrent_alert(h)
+			: peer_alert(h, ip, pid)
-			, ip(ip_)
-			, pid(pid_)
 		{}
 
 		virtual std::auto_ptr<alert> clone() const
 		{ return std::auto_ptr<alert>(new peer_unsnubbed_alert(*this)); }
 		virtual char const* what() const { return "peer unsnubbed"; }
-		const static int static_category = alert::peer_notification;
-		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			error_code ec;
+			return peer_alert::message() + " peer unsnubbed";
-			return torrent_alert::message() + " peer unsnubbed: (" + ip.address().to_string(ec)
-				+ ")";
 		}
-
-		tcp::endpoint ip;
-		peer_id pid;
 	};
 
-	struct TORRENT_EXPORT peer_snubbed_alert: torrent_alert
+	struct TORRENT_EXPORT peer_snubbed_alert: peer_alert
 	{
-		peer_snubbed_alert(torrent_handle const& h, tcp::endpoint const& ip_
+		peer_snubbed_alert(torrent_handle h, tcp::endpoint const& ip
-			, peer_id const& pid_)
+			, peer_id const& pid)
-			: torrent_alert(h)
+			: peer_alert(h, ip, pid)
-			, ip(ip_)
-			, pid(pid_)
 		{}
 
 		virtual std::auto_ptr<alert> clone() const
 		{ return std::auto_ptr<alert>(new peer_snubbed_alert(*this)); }
 		virtual char const* what() const { return "peer snubbed"; }
-		const static int static_category = alert::peer_notification;
-		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			error_code ec;
+			return peer_alert::message() + " peer snubbed";
-			return torrent_alert::message() + " peer snubbed: (" + ip.address().to_string(ec)
-				+ ")";
 		}
-
-		tcp::endpoint ip;
-		peer_id pid;
 	};
 
-	struct TORRENT_EXPORT peer_error_alert: torrent_alert
+	struct TORRENT_EXPORT peer_error_alert: peer_alert
 	{
-		peer_error_alert(torrent_handle const& h, tcp::endpoint const& ip_
+		peer_error_alert(torrent_handle const& h, tcp::endpoint const& ip
-			, peer_id const& pid_, std::string const& msg_)
+			, peer_id const& pid, std::string const& msg_)
-			: torrent_alert(h)
+			: peer_alert(h, ip, pid)
-			, ip(ip_)
-			, pid(pid_)
 			, msg(msg_)
 		{}
 
@@ -428,19 +425,17 @@ namespace libtorrent
 		virtual std::string message() const
 		{
 			error_code ec;
-			return torrent_alert::message() + " peer error: (" + ip.address().to_string(ec)
+			return peer_alert::message() + " peer error: " + msg;
-				+ ") " + msg;
 		}
 
-		tcp::endpoint ip;
-		peer_id pid;
 		std::string msg;
 	};
 
-	struct TORRENT_EXPORT peer_connect_alert: torrent_alert
+	struct TORRENT_EXPORT peer_connect_alert: peer_alert
 	{
-		peer_connect_alert(torrent_handle const& h, tcp::endpoint const& ip_)
+		peer_connect_alert(torrent_handle h, tcp::endpoint const& ip
-			: torrent_alert(h), ip(ip_)
+			, peer_id const& pid)
+			: peer_alert(h, ip, pid)
 		{}
 
 		virtual std::auto_ptr<alert> clone() const
@@ -450,21 +445,15 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			error_code ec;
+			return peer_alert::message() + " connecting to peer";
-			return torrent_alert::message() + " connecting to peer "
-				+ ip.address().to_string(ec);
 		}
-
-		tcp::endpoint ip;
 	};
 
-	struct TORRENT_EXPORT peer_disconnected_alert: torrent_alert
+	struct TORRENT_EXPORT peer_disconnected_alert: peer_alert
 	{
-		peer_disconnected_alert(torrent_handle const& h, tcp::endpoint const& ip_
+		peer_disconnected_alert(torrent_handle const& h, tcp::endpoint const& ip
-			, peer_id const& pid_, std::string const& msg_)
+			, peer_id const& pid, std::string const& msg_)
-			: torrent_alert(h)
+			: peer_alert(h, ip, pid)
-			, ip(ip_)
-			, pid(pid_)
 			, msg(msg_)
 		{}
 
@@ -475,44 +464,32 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			error_code ec;
+			return peer_alert::message() + " disconnecting: " + msg;
-			return torrent_alert::message() + " disconnecting "
-				+ ip.address().to_string(ec) + ": " + msg;
 		}
 
-		tcp::endpoint ip;
-		peer_id pid;
 		std::string msg;
 	};
 
-	struct TORRENT_EXPORT invalid_request_alert: torrent_alert
+	struct TORRENT_EXPORT invalid_request_alert: peer_alert
 	{
-		invalid_request_alert(
+		invalid_request_alert(torrent_handle const& h, tcp::endpoint const& ip
-			peer_request const& r
+			, peer_id const& pid, peer_request const& r)
-			, torrent_handle const& h
+			: peer_alert(h, ip, pid)
-			, tcp::endpoint const& sender
-			, peer_id const& pid_)
-			: torrent_alert(h)
-			, ip(sender)
 			, request(r)
-			, pid(pid_)
 		{}
 
 		virtual std::auto_ptr<alert> clone() const
 		{ return std::auto_ptr<alert>(new invalid_request_alert(*this)); }
 		virtual char const* what() const { return "invalid piece request"; }
-		const static int static_category = alert::peer_notification;
-		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			error_code ec;
+			return peer_alert::message() + " peer sent an invalid piece request "
-			return torrent_alert::message() + " peer "
+				"( piece: " + boost::lexical_cast<std::string>(request.piece)
-				+ ip.address().to_string(ec) + " sent an invalid piece request";
+				+ " start: " + boost::lexical_cast<std::string>(request.start)
+				+ " len: " + boost::lexical_cast<std::string>(request.length) + ")";
 		}
 
-		tcp::endpoint ip;
 		peer_request request;
-		peer_id pid;
 	};
 
 	struct TORRENT_EXPORT torrent_finished_alert: torrent_alert
@@ -556,13 +533,11 @@ namespace libtorrent
 		}
 	};
 
-	struct TORRENT_EXPORT request_dropped_alert: torrent_alert
+	struct TORRENT_EXPORT request_dropped_alert: peer_alert
 	{
-		request_dropped_alert(
+		request_dropped_alert(const torrent_handle& h, tcp::endpoint const& ip
-			const torrent_handle& h
+			, peer_id const& pid, int block_num, int piece_num)
-			, int block_num
+			: peer_alert(h, ip, pid)
-			, int piece_num)
-			: torrent_alert(h)
 			, block_index(block_num)
 			, piece_index(piece_num)
 		{ TORRENT_ASSERT(block_index >= 0 && piece_index >= 0);}
@@ -578,19 +553,17 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			return torrent_alert::message() + " block "
+			return peer_alert::message() + " peer dropped block ( piece: "
-				+ boost::lexical_cast<std::string>(block_index) + " in piece "
+				+ boost::lexical_cast<std::string>(piece_index) + " block: "
-				+ boost::lexical_cast<std::string>(piece_index) + " was dropped by remote peer";
+				+ boost::lexical_cast<std::string>(block_index) + ")";
 		}
 	};
 
-	struct TORRENT_EXPORT block_timeout_alert: torrent_alert
+	struct TORRENT_EXPORT block_timeout_alert: peer_alert
 	{
-		block_timeout_alert(
+		block_timeout_alert(const torrent_handle& h, tcp::endpoint const& ip
-			const torrent_handle& h
+			, peer_id const& pid, int block_num, int piece_num)
-			, int block_num
+			: peer_alert(h, ip, pid)
-			, int piece_num)
-			: torrent_alert(h)
 			, block_index(block_num)
 			, piece_index(piece_num)
 		{ TORRENT_ASSERT(block_index >= 0 && piece_index >= 0);}
@@ -606,19 +579,17 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			return torrent_alert::message() + " timed out block "
+			return peer_alert::message() + " peer timed out request ( piece: "
-				+ boost::lexical_cast<std::string>(block_index) + " in piece "
+				+ boost::lexical_cast<std::string>(piece_index) + " block: "
-				+ boost::lexical_cast<std::string>(piece_index);
+				+ boost::lexical_cast<std::string>(block_index) + ")";
 		}
 	};
 
-	struct TORRENT_EXPORT block_finished_alert: torrent_alert
+	struct TORRENT_EXPORT block_finished_alert: peer_alert
 	{
-		block_finished_alert(
+		block_finished_alert(const torrent_handle& h, tcp::endpoint const& ip
-			const torrent_handle& h
+			, peer_id const& pid, int block_num, int piece_num)
-			, int block_num
+			: peer_alert(h, ip, pid)
-			, int piece_num)
-			: torrent_alert(h)
 			, block_index(block_num)
 			, piece_index(piece_num)
 		{ TORRENT_ASSERT(block_index >= 0 && piece_index >= 0);}
@@ -633,20 +604,17 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			return torrent_alert::message() + " block "
+			return peer_alert::message() + " block finished downloading ( piece: "
-				+ boost::lexical_cast<std::string>(block_index) + " in piece "
+				+ boost::lexical_cast<std::string>(piece_index) + " block: "
-				+ boost::lexical_cast<std::string>(piece_index) + " finished downloading";
+				+ boost::lexical_cast<std::string>(block_index) + ")";
 		}
 	};
 
-	struct TORRENT_EXPORT block_downloading_alert: torrent_alert
+	struct TORRENT_EXPORT block_downloading_alert: peer_alert
 	{
-		block_downloading_alert(
+		block_downloading_alert(const torrent_handle& h, tcp::endpoint const& ip
-			const torrent_handle& h
+			, peer_id const& pid, char const* speedmsg, int block_num, int piece_num)
-			, char const* speedmsg
+			: peer_alert(h, ip, pid)
-			, int block_num
-			, int piece_num)
-			: torrent_alert(h)
 			, peer_speedmsg(speedmsg)
 			, block_index(block_num)
 			, piece_index(piece_num)
@@ -663,9 +631,10 @@ namespace libtorrent
 		virtual int category() const { return static_category; }
 		virtual std::string message() const
 		{
-			return torrent_alert::message() + " requested block "
+			return peer_alert::message() + " requested block ( piece: "
-				+ boost::lexical_cast<std::string>(block_index) + " in piece "
+				+ boost::lexical_cast<std::string>(piece_index) + " block: "
-				+ boost::lexical_cast<std::string>(piece_index);
+				+ boost::lexical_cast<std::string>(block_index) + ") "
+				+ peer_speedmsg;
 		}
 	};
 

src/peer_connection.cpp

@@ -1381,8 +1381,8 @@ namespace libtorrent
 
 			if (t->alerts().should_post<invalid_request_alert>())
 			{
-				t->alerts().post_alert(invalid_request_alert(r
+				t->alerts().post_alert(invalid_request_alert(
-					, t->get_handle(), m_remote, m_peer_id));
+					t->get_handle(), m_remote, m_peer_id, r));
 			}
 		}
 	}
@@ -1554,7 +1554,7 @@ namespace libtorrent
 			{
 				if (m_ses.m_alerts.should_post<request_dropped_alert>())
 					m_ses.m_alerts.post_alert(request_dropped_alert(t->get_handle()
-						, i->block.block_index, i->block.piece_index));
+						, remote(), pid(), i->block.block_index, i->block.piece_index));
 				picker.abort_download(i->block);
 				i = m_download_queue.erase(i);
 			}
@@ -1664,7 +1664,7 @@ namespace libtorrent
 		if (t->alerts().should_post<block_finished_alert>())
 		{
 			t->alerts().post_alert(block_finished_alert(t->get_handle(), 
-				block_finished.block_index, block_finished.piece_index));
+				remote(), pid(), block_finished.block_index, block_finished.piece_index));
 		}
 
 		// did we just finish the piece?
@@ -1948,7 +1948,7 @@ namespace libtorrent
 		if (t->alerts().should_post<block_downloading_alert>())
 		{
 			t->alerts().post_alert(block_downloading_alert(t->get_handle(), 
-				speedmsg, block.block_index, block.piece_index));
+				remote(), pid(), speedmsg, block.block_index, block.piece_index));
 		}
 
 		m_request_queue.push_back(block);
@@ -2813,7 +2813,7 @@ namespace libtorrent
 			if (m_ses.m_alerts.should_post<block_timeout_alert>())
 			{
 				m_ses.m_alerts.post_alert(block_timeout_alert(t->get_handle()
-					, r.block_index, r.piece_index));
+					, remote(), pid(), r.block_index, r.piece_index));
 			}
 			m_download_queue.pop_back();
 		}
@@ -3424,7 +3424,7 @@ namespace libtorrent
 		if (t->alerts().should_post<peer_connect_alert>())
 		{
 			t->alerts().post_alert(peer_connect_alert(
-				t->get_handle(), m_remote));
+				t->get_handle(), remote(), pid()));
 		}
 	}
 	

src/torrent.cpp

@@ -1417,8 +1417,10 @@ namespace libtorrent
 				// ban it.
 				if (m_ses.m_alerts.should_post<peer_ban_alert>())
 				{
+					peer_id pid;
+					if (p->connection) pid = p->connection->pid();
 					m_ses.m_alerts.post_alert(peer_ban_alert(
-						p->ip, get_handle()));
+						get_handle(), p->ip, pid));
 				}
 
 				// mark the peer as banned