webapp/handlers_tracker.py

   1 #!/usr/bin/python
   2
   3 import re
   4 import tornado.web
   5
   6 from backend.tracker import bencode, bdecode, encode_hex, decode_hex
   7 from handlers_base import *
   8
   9
  10 class TrackerIndexHandler(BaseHandler):
  11         def get(self):
  12                 releases = self.releases.get_all()
  13
  14                 limit = 5
  15                 releases = releases[:limit]
  16
  17                 self.render("tracker-torrents.html", releases=releases)
  18
  19
  20 class TrackerDetailHandler(BaseHandler):
  21         def get(self, torrent_hash):
  22                 file = self.releases.get_file_for_torrent_hash(torrent_hash)
  23
  24                 if not file:
  25                         raise tornado.web.HTTPError(404, "Could not find torrent file for hash: %s" % torrent_hash)
  26
  27                 peers = self.tracker.get_peers(torrent_hash)
  28
  29                 self.render("tracker-torrent-detail.html", release=file.release,
  30                         file=file, peers=peers)
  31
  32
  33 class TrackerDownloadHandler(BaseHandler):
  34         def get(self, torrent_hash):
  35                 file = self.releases.get_file_for_torrent_hash(torrent_hash)
  36
  37                 if not file:
  38                         raise tornado.web.HTTPError(404, "Could not find torrent file for hash: %s" % torrent_hash)
  39
  40                 # Redirect the user to the download redirector.
  41                 self.redirect("http://downloads.ipfire.org/%s.torrent" % file.filename)
  42
  43
  44 class TrackerBaseHandler(BaseHandler):
  45         def get_hexencoded_argument(self, name, all=False):
  46                 try:
  47                         arguments = self.request.arguments[name]
  48                 except KeyError:
  49                         return None
  50
  51                 arguments_new = []
  52                 for argument in arguments:
  53                         arguments_new.append(encode_hex(argument))
  54
  55                 arguments = arguments_new
  56
  57                 if all:
  58                         return arguments
  59
  60                 return arguments[0]
  61
  62         def send_tracker_error(self, error_message):
  63                 msg = bencode({"failure reason" : error_message })
  64                 self.finish(msg)
  65
  66
  67 class TrackerAnnounceHandler(TrackerBaseHandler):
  68         def prepare(self):
  69                 self.set_header("Content-Type", "text/plain")
  70
  71         def get_ipv6_address(self, default_port):
  72                 # Get the external IP address of the client.
  73                 addr = self.get_remote_ip()
  74
  75                 if ":" in addr:
  76                         return addr, default_port
  77
  78                 # IPv6
  79                 ipv6 = self.get_argument("ipv6", None)
  80                 if ipv6:
  81                         port = default_port
  82
  83                         m = re.match("^\[(.*)\]\:(\d)$", ipv6)
  84                         if m:
  85                                 ipv6, port = (m.group(1), m.group(2))
  86
  87                         return ipv6, port
  88
  89                 return None, None
  90
  91         def get_ipv4_address(self, default_port):
  92                 # Get the external IP address of the client.
  93                 addr = self.get_remote_ip()
  94
  95                 if not ":" in addr:
  96                         return addr, default_port
  97
  98                 # IPv4
  99                 ipv4 = self.get_argument("ipv4", None)
 100                 if ipv4:
 101                         return ipv4, default_port
 102
 103                 ip = self.get_argument("ip", None)
 104                 if ip:
 105                         return ip, default_port
 106
 107                 return None, None
 108
 109         def get_port(self):
 110                 # Get the port and check it for sanity
 111                 port = self.get_argument("port", None)
 112
 113                 try:
 114                         port = int(port)
 115
 116                         if port < 0 or port > 65535:
 117                                 raise ValueError
 118                 except (TypeError, ValueError):
 119                         port = None
 120
 121                 return port
 122
 123         def get(self):
 124                 # Get the info hash
 125                 info_hash = self.get_hexencoded_argument("info_hash")
 126                 if not info_hash:
 127                         self.send_tracker_error("Your client forgot to send your torrent's info_hash")
 128                         return
 129
 130                 # Get the peer id
 131                 peer_id = self.get_hexencoded_argument("peer_id")
 132
 133                 # Get the port and check it for sanity
 134                 port = self.get_port()
 135                 if not port:
 136                         self.send_tracker_error("Invalid port number or port number missing")
 137                         return
 138
 139                 addr_ipv6, port_ipv6 = self.get_ipv6_address(port)
 140                 addr_ipv4, port_ipv4 = self.get_ipv4_address(port)
 141
 142                 # Handle events
 143                 event = self.get_argument("event", None)
 144                 if event:
 145                         if not event in ("started", "stopped", "completed"):
 146                                 self.send_tracker_error("Got unknown event")
 147                                 return
 148
 149                         self.tracker.handle_event(event, peer_id, info_hash)
 150
 151                         if event == "stopped":
 152                                 return
 153
 154                 peer_info = {
 155                         "address6"   : addr_ipv6,
 156                         "port6"      : port_ipv6,
 157                         "address4"   : addr_ipv4,
 158                         "port4"      : port_ipv4,
 159                         "downloaded" : self.get_argument("downloaded", 0),
 160                         "uploaded"   : self.get_argument("uploaded", 0),
 161                         "left_data"  : self.get_argument("left", 0),
 162                 }
 163
 164                 self.tracker.update_peer(peer_id, info_hash, **peer_info)
 165
 166                 no_peer_id = self.get_argument("no_peer_id", False)
 167                 numwant = self.get_argument("numwant", self.tracker.numwant)
 168
 169                 peers = self.tracker.get_peers(info_hash, limit=numwant, no_peer_id=no_peer_id)
 170
 171                 response = bencode({
 172                         "tracker id"   : self.tracker.tracker_id,
 173                         "interval"     : self.tracker.interval,
 174                         "min interval" : self.tracker.min_interval,
 175                         "peers"        : peers,
 176                         "complete"     : self.tracker.complete(info_hash),
 177                         "incomplete"   : self.tracker.incomplete(info_hash),
 178                 })
 179                 self.finish(response)
 180
 181         def on_finish(self):
 182                 """
 183                         Cleanup after every request.
 184                 """
 185                 self.tracker.cleanup_peers()
 186
 187
 188 class TrackerScrapeHandler(TrackerBaseHandler):
 189         def get(self):
 190                 info_hashes = self.get_hexencoded_argument("info_hash", all=True)
 191
 192                 response = self.tracker.scrape(info_hashes)
 193
 194                 self.finish(bencode(response))