Respect "min interval" returned by the tracker for failed announces

src/torrent/tracker.cc

@@ -51,8 +51,8 @@ Tracker::Tracker(TrackerList* parent, const std::string& url, int flags) :
   m_group(0),
   m_url(url),
 
-  m_normal_interval(1800),
-  m_min_interval(600),
+  m_normal_interval(0),
+  m_min_interval(0),
 
   m_latest_event(EVENT_NONE),
   m_latest_new_peers(0),
@@ -104,14 +104,17 @@ Tracker::success_time_next() const {
   if (m_success_counter == 0)
     return 0;
 
-  return m_success_time_last + m_normal_interval;
+  return m_success_time_last + std::max(m_normal_interval, default_min_interval);
 }
 
 uint32_t
 Tracker::failed_time_next() const {
   if (m_failed_counter == 0)
     return 0;
 
+  if (m_min_interval > 0)
+    return m_failed_time_last + m_min_interval;
+
   return m_failed_time_last + (5 << std::min(m_failed_counter - 1, (uint32_t)6));
 }
 

src/torrent/tracker.h

@@ -36,6 +36,9 @@ class LIBTORRENT_EXPORT Tracker {
   static const int max_flag_size   = 0x10;
   static const int mask_base_flags = 0x10 - 1;
 
+  static const int default_min_interval = 600;
+  static const int default_normal_interval = 1800;
+
   virtual ~Tracker() {}
 
   int                 flags() const { return m_flags; }

src/torrent/tracker_controller.cc

@@ -393,10 +393,13 @@ tracker_next_timeout_promiscuous(Tracker* tracker) {
 
   int32_t interval;
 
-  if (tracker->failed_counter())
+  if (tracker->failed_counter()) {
     interval = 5 << std::min<int>(tracker->failed_counter() - 1, 6);
-  else
+    if (tracker->min_interval() > 0)
+      interval = std::max(interval, (int32_t)tracker->min_interval());
+  } else {
     interval = tracker->normal_interval();
+  }
 
   int32_t min_interval = std::max(tracker->min_interval(), (uint32_t)300);
   int32_t use_interval = std::min(interval, min_interval);

src/tracker/tracker_http.cc

@@ -258,12 +258,19 @@ TrackerHttp::receive_done() {
   if (!b.is_map())
     return receive_failed("Root not a bencoded map");
 
-  if (b.has_key("failure reason"))
+  if (b.has_key("failure reason")) {
+    if (m_latest_event != EVENT_SCRAPE)
+      process_bencode_response(b);
     return receive_failed("Failure reason \"" +
-			 (b.get_key("failure reason").is_string() ?
-			  b.get_key_string("failure reason") :
-			  std::string("failure reason not a string"))
-			 + "\"");
+                         (b.get_key("failure reason").is_string() ?
+                          b.get_key_string("failure reason") :
+                          std::string("failure reason not a string"))
+                         + "\"");
+  }
+
+  // If no failures, set intervals to defaults prior to processing
+  set_normal_interval(default_normal_interval);
+  set_min_interval(default_min_interval);
 
   if (m_latest_event == EVENT_SCRAPE)
     process_scrape(b);
@@ -287,7 +294,7 @@ TrackerHttp::receive_failed(std::string msg) {
 }
 
 void
-TrackerHttp::process_success(const Object& object) {
+TrackerHttp::process_bencode_response(const Object& object) {
   if (object.has_key_value("interval"))
     set_normal_interval(object.get_key_value("interval"));
 
@@ -305,6 +312,12 @@ TrackerHttp::process_success(const Object& object) {
 
   if (object.has_key_value("downloaded"))
     m_scrape_downloaded = std::max<int64_t>(object.get_key_value("downloaded"), 0);
+}
+
+
+void
+TrackerHttp::process_success(const Object& object) {
+  process_bencode_response(object);
 
   AddressList l;
 

src/tracker/tracker_http.h

@@ -68,8 +68,10 @@ class TrackerHttp : public Tracker {
   void                receive_done();
   void                receive_failed(std::string msg);
 
+  void                process_bencode_response(const Object& object);
   void                process_success(const Object& object);
   void                process_scrape(const Object& object);
+  void                process_failure(const Object& object);
 
   Http*               m_get;
   std::stringstream*  m_data;

src/tracker/tracker_udp.cc

@@ -384,6 +384,7 @@ TrackerUdp::process_announce_output() {
     return false;
 
   set_normal_interval(m_readBuffer->read_32());
+  set_min_interval(default_min_interval);
 
   m_scrape_incomplete = m_readBuffer->read_32(); // leechers
   m_scrape_complete   = m_readBuffer->read_32(); // seeders