rubytorrent 0.3

data/lib/rubytorrent/server.rb

@@ -0,0 +1,166 @@
+## server.rb -- make/receive and handshake all new peer connections.
+## Copyright 2004 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require 'socket'
+require "rubytorrent/tracker"
+require "rubytorrent/controller"
+require "rubytorrent/peer"
+
+module RubyTorrent
+
+## The Server coordinates all Packages available on the machine. It
+## instantiates one Controller for each Package. It's also responsible
+## for the creation of all TCP connections---it sets up the TCP
+## socket, receives incoming connections, validates handshakes, and
+## hands them off to the appropriate Controller; it also creates
+## outgoing connections (typically at Controllers' requests) and sends
+## the handshake.
+class Server
+  attr_reader :port, :id, :http_proxy
+
+  VERSION = 0
+  PORT_RANGE=(6881 .. 6889)
+
+  def initialize(hostname=nil, port=nil, http_proxy=ENV["http_proxy"])
+    @http_proxy = http_proxy
+    @server = nil
+    if port.nil?
+      @port = PORT_RANGE.detect do |p|
+        begin
+          @server = TCPServer.new(hostname, p)
+          @port = p
+        rescue Errno::EADDRINUSE
+          @server = nil
+        end
+        !@server.nil?
+      end
+      raise Errno::EADDRINUSE, "ports #{PORT_RANGE}" unless @port
+    else
+      @server = TCPServer.new(hostname, port)
+      @port = port
+    end
+
+    @id = "rubytor" + VERSION.chr + (1 .. 12).map { |x| rand(256).chr }.join
+    @controllers = {}
+  end
+
+  def ip; @server.addr[3]; end
+
+  def add_torrent(mi, package, dlratelim=nil, ulratelim=nil)
+    @controllers[mi.info.sha1] = Controller.new(self, package, mi.info.sha1, mi.trackers, dlratelim, ulratelim, @http_proxy)
+    @controllers[mi.info.sha1].start
+  end
+
+  def add_connection(name, cont, socket)
+    begin
+      shake_hands(socket, cont.info_hash)
+      peer = PeerConnection.new(name, cont, socket, cont.package)
+      cont.add_peer peer
+    rescue ProtocolError => e
+      socket.close rescue nil
+    end
+  end
+
+  def start
+    @shutdown = false
+    @thread = Thread.new do
+      begin
+        while !@shutdown; receive; end
+      rescue IOError, StandardError
+        rt_warning "**** socket receive error, retrying"
+        sleep 5
+        retry
+      end
+    end
+    self
+  end
+
+  def shutdown
+    return if @shutdown
+    @shutdown = true
+    @server.close rescue nil
+
+    @thread.join(0.2)
+    @controllers.each { |hash, cont| cont.shutdown }
+    self
+  end
+
+  def to_s
+    "<#{self.class}: port #{port}, peer_id #{@id.inspect}>"
+  end
+
+  private
+
+  def receive # blocking
+    ssocket = @server.accept
+    Thread.new do
+      socket = ssocket
+
+      begin
+        rt_debug "<= incoming connection from #{socket.peeraddr[2]}:#{socket.peeraddr[1]}"
+        hash, peer_id = shake_hands(socket, nil)
+        cont = @controllers[hash]
+        peer = PeerConnection.new("#{socket.peeraddr[2]}:#{socket.peeraddr[1]}", cont, socket, cont.package)
+        cont.add_peer peer
+      rescue SystemCallError, ProtocolError => e
+        rt_debug "killing incoming connection: #{e}"
+        socket.close rescue nil
+      end
+    end
+  end
+
+  ## if info_hash is nil here, the socket is treated as an incoming
+  ## connection---it will wait for the peer's info_hash and respond
+  ## with the same if it corresponds to a current download, otherwise
+  ## it will raise a ProtocolError.
+  ##
+  ## if info_hash is not nil, the socket is treated as an outgoing
+  ## connection, and it will send the info_hash immediately.
+  def shake_hands(sock, info_hash)
+#    rt_debug "initiating #{(info_hash.nil? ? 'incoming' : 'outgoing')} handshake..."
+    sock.send("\023BitTorrent protocol\0\0\0\0\0\0\0\0", 0);
+    sock.send("#{info_hash}#{@id}", 0) unless info_hash.nil?
+
+    len = sock.recv(1)[0]
+#    rt_debug "length #{len.inspect}"
+    raise ProtocolError, "invalid handshake length byte #{len.inspect}" unless len == 19
+
+    name = sock.recv(19)
+#    rt_debug "name #{name.inspect}"
+    raise ProtocolError, "invalid handshake protocol string #{name.inspect}" unless name == "BitTorrent protocol"
+
+    reserved = sock.recv(8)
+#    rt_debug "reserved: #{reserved.inspect}" 
+   # ignore for now
+
+    their_hash = sock.recv(20)
+#    rt_debug "their info hash: #{their_hash.inspect}"
+
+    if info_hash.nil?
+      raise ProtocolError, "client requests package we don't have: hash=#{their_hash.inspect}" unless @controllers.has_key? their_hash
+      info_hash = their_hash
+      sock.send("#{info_hash}#{@id}", 0)
+    else
+      raise ProtocolError, "mismatched info hashes: us=#{info_hash.inspect}, them=#{their_hash.inspect}" unless info_hash == their_hash
+    end
+
+    peerid = sock.recv(20)
+#    rt_debug "peer id: #{peerid.inspect}"
+    raise ProtocolError, "connected to self" if peerid == @id
+
+#    rt_debug "== handshake complete =="
+    [info_hash, peerid]
+  end
+end
+
+end

data/lib/rubytorrent/tracker.rb

@@ -0,0 +1,225 @@
+## tracker.rb -- bittorrent tracker protocol.
+## Copyright 2004 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require 'open-uri'
+require 'timeout'
+require "rubytorrent"
+
+module RubyTorrent
+
+module HashAddition
+  def +(o)
+    ret = self.dup
+    o.each { |k, v| ret[k] = v }
+    ret
+  end
+end
+
+## am i insane or does 'uniq' not use == or === for some insane
+## reason? wtf is that about?
+module ArrayUniq2
+  def uniq2
+    ret = []
+    each { |x| ret.push x unless ret.member? x }
+    ret
+  end
+end
+
+class TrackerResponsePeer
+  attr_writer :tried
+
+  def initialize(dict=nil)
+    @s = TypedStruct.new do |s|
+      s.field :peer_id => String, :ip => String, :port => Integer
+      s.required :ip, :port
+      s.label :peer_id => "peer id"
+    end
+
+    @s.parse(dict) unless dict.nil?
+    @connected = false
+    @tried = false
+  end
+
+  def tried?; @tried; end
+
+  def method_missing(meth, *args)
+    @s.send(meth, *args)
+  end
+
+  def ==(o); (self.ip == o.ip) && (self.port == o.port); end
+
+  def to_s
+    %{<#{self.class}: ip=#{self.ip}, port=#{self.port}>}
+  end
+end
+
+class TrackerResponse
+  def initialize(dict=nil)
+    @s = TypedStruct.new do |s|
+      s.field :interval => Integer, :complete => Integer,
+              :incomplete => Integer, :peers => TrackerResponsePeer
+      s.array :peers
+      s.required :peers #:interval, :complete, :incomplete, :peers
+      s.coerce :peers => lambda { |x| make_peers x }
+    end
+
+    @s.parse(dict) unless dict.nil?
+
+    peers.extend ArrayShuffle
+  end
+
+  def method_missing(meth, *args)
+    @s.send(meth, *args)
+  end
+
+  private
+
+  def make_peers(x)
+    case x
+    when Array
+      x.map { |e| TrackerResponsePeer.new e }.extend(ArrayUniq2).uniq2
+    when String
+      x.unpack("a6" * (x.length / 6)).map do |y|
+        TrackerResponsePeer.new({"ip" => (0..3).map { |i| y[i] }.join('.'),
+                                 "port" => (y[4] << 8) + y[5] })
+      end.extend(ArrayUniq2).uniq2
+    else
+      raise "don't know how to make peers array from #{x.class}"
+    end
+  end
+end
+
+class TrackerError < StandardError; end
+
+class TrackerConnection
+  attr_reader :port, :left, :peer_id, :last_conn_time, :url, :in_force_refresh
+  attr_accessor :uploaded, :downloaded, :left, :numwant
+
+  def initialize(url, info_hash, length, port, peer_id, ip=nil, numwant=50, http_proxy=ENV["http_proxy"])
+    @url = url
+    @hash = info_hash
+    @length = length
+    @port = port
+    @uploaded = @downloaded = @left = 0
+    @ip = ip
+    @numwant = numwant
+    @peer_id = peer_id
+    @http_proxy = http_proxy
+    @state = :stopped
+    @sent_completed = false
+    @last_conn_time = nil
+    @tracker_data = nil
+    @compact = true
+    @in_force_refresh = false
+  end
+
+  def already_completed; @sent_completed = true; end
+  def sent_completed?; @sent_completed; end
+
+  def started
+    return unless @state == :stopped
+    @state = :started
+    @tracker_data = send_tracker "started"
+    self
+  end
+
+  def stopped
+    return unless @state == :started
+    @state = :stopped
+    @tracker_data = send_tracker "stopped"
+    self
+  end
+  
+  def completed
+    return if @sent_completed
+    @tracker_data = send_tracker "completed"
+    @sent_completed = true
+    self
+  end
+
+  def refresh
+    return unless (Time.now - @last_conn_time) >= (interval || 0)
+    @tracker_data = send_tracker nil
+  end
+
+  def force_refresh
+    return if @in_force_refresh
+    @in_force_refresh = true
+    @tracker_data = send_tracker nil
+    @in_force_refresh = false
+  end
+
+  [:interval, :seeders, :leechers, :peers].each do |m|
+    class_eval %{
+      def #{m}
+        if @tracker_data then @tracker_data.#{m} else nil end
+      end
+    }
+  end
+
+  private
+
+  def send_tracker(event)
+    resp = nil
+    if @compact
+      resp = get_tracker_response({ :event => event, :compact => 1 })
+      if resp["failure reason"]
+        @compact = false
+      end
+    end
+       
+    resp = get_tracker_response({ :event => event }) unless resp
+    raise TrackerError, "tracker reports error: #{resp['failure reason']}" if resp["failure reason"]
+    
+    TrackerResponse.new(resp)
+  end
+
+  def get_tracker_response(opts)
+    target = @url.dup
+    opts.extend HashAddition
+    opts += {:info_hash => @hash, :peer_id => @peer_id,
+      :port => @port, :uploaded => @uploaded, :downloaded => @downloaded,
+      :left => @left, :numwant => @numwant, :ip => @ip}
+    target.query = opts.map do |k, v|
+      unless v.nil?
+        ek = URI.escape(k.to_s) # sigh
+        ev = URI.escape(v.to_s, /[^a-zA-Z0-9]/)
+        "#{ek}=#{ev}"
+      end
+    end.compact.join "&"
+
+    rt_debug "connecting to #{target.to_s} ..."
+
+    ret = nil
+    begin
+      target.open(:proxy => @http_proxy) do |resp|
+        BStream.new(resp).each do |e|
+          if ret.nil?
+            ret = e
+          else
+            raise TrackerError, "don't understand tracker response (too many objects)"
+          end
+        end
+      end
+    rescue SocketError, EOFError, OpenURI::HTTPError, RubyTorrent::TrackerError, Timeout::Error, SystemCallError, NoMethodError => e
+      raise TrackerError, e.message
+    end
+    @last_conn_time = Time.now
+
+    raise TrackerError, "empty tracker response" if ret.nil?
+    raise TrackerError, "don't understand tracker response (not a dict)" unless ret.kind_of? ::Hash
+    ret
+  end
+end
+
+end

data/lib/rubytorrent/typedstruct.rb

@@ -0,0 +1,132 @@
+## typedstruct.rb -- type-checking struct, for bencoded objects.
+## Copyright 2004 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require "rubytorrent/bencoding"
+
+module RubyTorrent
+
+module ArrayToH
+  def to_h
+    inject({}) { |h, (k, v)| h[k] = v; h } # found this neat trick on the internet
+  end
+end
+
+module HashMapHash
+  def map_hash
+    a = map { |k, v| yield k, v }.extend(ArrayToH).to_h
+  end
+end
+
+class TypedStructError < StandardError; end
+
+## type-checking struct meant for easy translation from and to
+## bencoded dicts.
+class TypedStruct
+  attr_accessor :dirty
+  attr_reader :fields # writer below
+
+  def initialize
+    @required = {}
+    @label = {}
+    @coerce = {}
+    @field = {}
+    @array = {}
+    @dirty = false
+    @values = {}
+
+    yield self if block_given?
+
+    @field.each do |f, type|
+      @required[f] ||= false
+      @label[f] ||= f.to_s
+      @array[f] ||= false
+    end
+  end
+
+  def method_missing(meth, *args)
+    if meth.to_s =~ /^(.*?)=$/
+#      p [meth, args]
+
+      f = $1.intern
+      raise ArgumentError, "no such value #{f}" unless @field.has_key? f
+
+      type = @field[f]
+      o = args[0]
+      if @array[f]
+        raise TypeError, "for #{f}, expecting Array, got #{o.class}" unless o.kind_of? ::Array
+        o.each { |e| raise TypeError, "for elements of #{f}, expecting #{type}, got #{e.class}" unless e.kind_of? type }
+        @values[f] = o
+        @dirty = true
+      else
+        raise TypeError, "for #{f}, expecting #{type}, got #{o.class}" unless o.kind_of? type
+        @values[f] = o
+        @dirty = true
+      end
+    else
+      raise ArgumentError, "no such value #{meth}" unless @field.has_key? meth
+#      p [meth, @values[meth]]
+
+      @values[meth]
+    end
+  end
+
+  [:required, :array].each do |f|
+    class_eval %{
+      def #{f}(*args)
+        args.each do |x|
+          raise %q{unknown field "\#{x}" in #{f} list} unless @field[x]
+          @#{f}[x] = true
+        end
+      end
+    }
+  end
+
+  [:field , :label, :coerce].each do |f|
+    class_eval %{
+      def #{f}(hash)
+        hash.each { |k, v| @#{f}[k] = v }
+      end
+    }
+  end
+
+  ## given a Hash from a bencoded dict, parses it according to the
+  ## rules you've set up with field, required, label, etc.
+  def parse(dict)
+    @required.each do |f, reqd|
+      flabel = @label[f]
+      raise TypedStructError, "missing required parameter #{flabel} (dict has #{dict.keys.join(', ')})" if reqd && !(dict.member? flabel)
+
+      if dict.member? flabel
+        v = dict[flabel]
+        if @coerce.member? f
+          v = @coerce[f][v]
+        end
+        if @array[f]
+          raise TypeError, "for #{flabel}, expecting Array, got #{v.class} instead" unless v.kind_of? ::Array
+        end
+        self.send("#{f}=", v)
+      end
+    end
+
+    ## disabled the following line as applications seem to put tons of
+    ## weird fields in their .torrent files.
+    # dict.each { |k, v| raise TypedStructError, %{unknown field "#{k}"} unless @field.member?(k.to_sym) || @label.values.member?(k) }
+  end
+
+  def to_bencoding
+    @required.each { |f, reqd| raise ArgumentError, "missing required parameter #{f}" if reqd && self.send(f).nil? }
+    @field.extend(HashMapHash).map_hash { |f, type| [@label[f], self.send(f)] }.to_bencoding
+  end
+end
+
+end