torrenter 0.0.6 → 0.0.7

data/lib/torrenter/tracker/http_tracker.rb

@@ -0,0 +1,41 @@
+module Torrenter
+  class Tracker
+
+    attr_reader :response, :address
+
+    class HTTPTracker < Tracker
+      attr_reader :response
+      def initialize(url, params)
+        @address = URI(url)
+        @params  = params
+      end
+
+      def connect
+        @address.query = URI.encode_www_form(@params)
+        begin
+          @response = BEncode.load(Net::HTTP.get(@address))
+        rescue Exception => e
+          false
+        end
+
+        return self
+      end
+
+      def peer_list
+        format_peers(peers)
+      end
+
+      def connect_interval
+        @response['min interval']
+      end
+
+      def peers
+        @response['peers']
+      end
+
+      def connected?
+        @response
+      end
+    end
+  end
+end

data/lib/torrenter/tracker/udp_tracker.rb

@@ -0,0 +1,107 @@
+module Torrenter
+  class Tracker
+    class UDPTracker < Tracker
+
+      attr_reader :socket, :response, :interval
+
+      def initialize(tracker, params)
+        @url           = tracker[/(?<=udp\:\/\/).+(?=\:\d+)/]
+        @port          = tracker[/\d+$/].to_i
+        @socket        = UDPSocket.new
+        @connection_id = [0x41727101980].pack("Q>")
+        @params        = params
+      end
+
+      def interval?
+        interval % Time.now.to_i == 0
+      end
+
+      def segment(e, enc="I>")
+        [e].pack(enc)
+      end
+
+      def connect
+        @transaction_id = segment(rand(10000), "I>")
+        @socket.connect(ip_addr, @port)
+        begin
+          send_msg(connect_msg)
+          read_response
+          bound_peers
+        rescue
+          false
+        end
+        return self
+      end
+
+      def send_msg(msg)
+        begin
+          @socket.send(msg, 0)
+        rescue
+          false
+        end
+      end
+
+      def connected?
+        @response
+      end
+
+      def ip_addr
+        Socket.getaddrinfo(@url, @port)[0][3]
+      end
+
+      def bound_peers
+        @connection_id = @response[-8..-1]
+        @transaction_id = [rand(10000)].pack("I>")
+        send_msg(announce_msg)
+
+        read_response
+
+        parse_announce if @response[0..3] == segment(1)
+      end
+
+      def peer_list
+        format_peers(@response)
+      end
+
+      def parse_announce
+        if @response[4..7] == @transaction_id
+          @interval = @response[8..11].unpack("I>").first
+          res = @response.slice!(0..11)
+          @leechers = @response.slice!(0..3).unpack("I>").first
+          @seeders  = @response.slice!(0..3).unpack("I>").first
+        end
+      end
+
+      def send_message
+        begin
+          @socket.send(@msg, 0)
+        rescue *EXCEPTIONS
+        end
+      end
+
+      def read_response
+        begin
+          @response = @socket.recv(1028)
+        rescue Exception => e
+          e
+        end
+      end
+
+      def connect_match?
+        data[0] == (segment(0) + @transaction_id + @connection_id)
+      end
+
+      def announce_input
+        @connection_id + segment(1) + @transaction_id + @params[:info_hash] + PEER_ID
+      end
+
+      def connect_msg
+        @connection_id + segment(0) + @transaction_id
+      end
+
+      def announce_msg
+        announce_input + (segment(0, "Q>") * 3) + (segment(0) * 3) + segment(-1) + segment(@socket.addr[1], ">S")
+      end
+    end
+  end
+end

data/lib/torrenter/version.rb

@@ -1,3 +1,3 @@
 module Torrenter
-  VERSION = '0.0.6'
+  VERSION = '0.0.7'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torrenter
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - wismer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-05-26 00:00:00.000000000 Z
+date: 2014-07-08 00:00:00.000000000 Z
 dependencies: []
 description: BitTorrent Client written in Ruby
 email:
@@ -20,19 +20,17 @@ extra_rdoc_files: []
 files:
 - bin/torrenter
 - lib/torrenter.rb
-- lib/torrenter/file_creator.rb
-- lib/torrenter/http_tracker.rb
-- lib/torrenter/message/message_types.rb
-- lib/torrenter/message/messager.rb
+- lib/torrenter/constants.rb
 - lib/torrenter/peer.rb
-- lib/torrenter/peer_state.rb
+- lib/torrenter/peer/buffer_state.rb
 - lib/torrenter/reactor.rb
-- lib/torrenter/setup.rb
-- lib/torrenter/test_msg.rb
-- lib/torrenter/test_reactor.rb
 - lib/torrenter/torrent_reader.rb
+- lib/torrenter/torrent_reader/piece.rb
+- lib/torrenter/torrent_reader/piece_constructor.rb
+- lib/torrenter/torrent_reader/piece_index.rb
 - lib/torrenter/tracker.rb
-- lib/torrenter/udp_tracker.rb
+- lib/torrenter/tracker/http_tracker.rb
+- lib/torrenter/tracker/udp_tracker.rb
 - lib/torrenter/version.rb
 homepage: http://wismer.github.io
 licenses:

data/lib/torrenter/http_tracker.rb

@@ -1,44 +0,0 @@
-module Torrenter
-  class HTTPTracker < TorrentReader
-    attr_reader :response
-    def initialize(tracker, stream)
-      super(stream)
-      @address   = URI(tracker)
-    end
-
-    def connect
-      @address.query = URI.encode_www_form(tracker_params)
-      @response =
-        begin
-          BEncode.load(Net::HTTP.get(@address))
-        rescue
-          false
-        end
-    end
-
-    def connect_interval
-      @response['min_interval']
-    end
-
-    def address_hashes
-      @response['peers']
-    end
-
-    def tracker_params
-      {
-        :info_hash => info_hash,
-        :peer_id   => PEER_ID,
-        :left      => piece_length,
-        :pieces    => file_list
-      }
-    end
-
-    def bound_peers
-      peer_list(@response['peers'])
-    end
-
-    def connected?
-      @response
-    end
-  end
-end

data/lib/torrenter/message/messager.rb

@@ -1,164 +0,0 @@
-module Torrenter
-  # KEEP_ALIVE = "\x00\x00\x00\x00"
-  # BLOCK = 2**14
-  # these methods get mixed in with the Peer class as a way to help 
-  # organize and parse the byte-encoded data. The intention is to shorten
-  # and shrink the complexity of the Peer class.
-  # the following methods are responsible solely for data retrieval and data transmission
-
-  def state(master_index, remaining, &block)
-    @remaining = remaining
-
-    recv_data if @buffer.size <= 3
-    if @buffer[4].nil?
-      @buffer.slice!(0..3) if @buffer[0..3] == KEEP_ALIVE
-    else
-      @length    = @buffer[0..3].unpack("N*").last
-      @buffer_id = @buffer[4]
-      case @buffer_id
-      when BITFIELD
-        process_bitfield(master_index.size, clear_msg)
-      when HAVE
-        process_have(clear_msg)
-      when INTERESTED
-        @buffer = ''
-
-        return :interested
-      when PIECE
-        process_piece { block.call @blocks.join(''), @index }
-      when CHOKE      
-        choke_message
-      when HANDSHAKE
-        process_handshake
-      end
-    end
-  end
-
-  def completed?
-    piece_data.bytesize == @piece_length || piece_data.bytesize == @remaining
-  end
-
-  def piece_data
-    @blocks.join('')
-  end
-
-  def choke_message
-    @peer_state = false
-  end
-
-  def clear_msg
-    @buffer.slice!(0..@length + 3)  
-  end
-
-  def request_message(bytes=BLOCK)
-    @msg = "index: #{@index} offset: #{@blocks.size * BLOCK} bytes: #{bytes}"
-    send_data(pack(13) + "\x06" + pack(@index) + pack(@blocks.size * BLOCK) + pack(bytes))
-  end
-
-  def pack(msg)
-    [msg].pack("I>")
-  end
-
-  def process_bitfield(size, msg)
-    index = msg[5..-1].unpack("B#{size}").join.split('')
-    @piece_index = index.map { |bit| bit == '1' ? :free : :unavailable }
-    send_interested if @buffer.empty?
-  end
-
-  def process_have(msg)
-    @piece_index[msg[5..-1].unpack("C*").last] = :free
-    send_interested if @buffer.empty?
-  end
-
-  def request_piece(index)
-    @index = index
-    @piece_index[@index] = :downloading
-
-    request_message
-  end
-
-  def send_interested
-    send_data("\x00\x00\x00\x01\x02")
-  end
-
-  def buffer_length?
-    @buffer.bytesize >= @length + 4
-  end
-
-  def process_piece(&block)
-    binding.pry if @length < BLOCK
-    if buffer_length?
-      if buffer_complete?
-        pack_buffer
-      end
-
-      if @blocks.join('').bytesize < @piece_length
-        diff = @remaining - @blocks.join('').bytesize
-        if diff < BLOCK
-          request_message(diff)
-        else
-          request_message
-        end
-      end
-
-      block.call if completed?
-    end
-    recv_data
-  end
-
-  def mark_complete
-    @blocks = []
-    @piece_index[@index] = :downloaded
-  end
-
-  def pack_buffer
-    @blocks << @buffer.slice!(13..-1)
-    @buffer.clear
-  end
-
-  def buffer_complete?
-    (@buffer.bytesize - 13) == BLOCK || (@buffer.bytesize - 13) == @length - 9
-  end
-
-  # will need a last piece sort of thing inserted in here
-
-  def process_handshake
-    if hash_check?
-      @buffer.slice!(0..67) 
-    else
-      @peer_state = false
-    end
-  end
-
-  def hash_check?
-    @buffer[28..47] == @info_hash
-  end
-
-  def send_data(msg)
-    begin
-      Timeout::timeout(2) { @socket.sendmsg_nonblock(msg) }
-    rescue Timeout::Error
-      ''
-    rescue IO::EAGAINWaitReadable
-      ''
-    rescue *EXCEPTIONS
-      ''
-    rescue Errno::ETIMEDOUT
-      @peer_state = false
-    end
-  end
-
-  def recv_data(bytes=BLOCK)
-    begin
-      Timeout::timeout(5) { @buffer << @socket.recv_nonblock(bytes) }
-    rescue Timeout::Error
-      ''
-    rescue IO::EAGAINWaitReadable
-      ''
-    rescue *EXCEPTIONS
-      ''
-    rescue Errno::ETIMEDOUT
-      @peer_state = false
-    end
-  end
-end

data/lib/torrenter/peer_state.rb

@@ -1,57 +0,0 @@
-module Torrenter
-  # The buffer state should be responsible ONLY for the handling of non-metadata bytes.
-  # the messaging behavior should and ought to remain with the peer class, though
-  # in truth, it may be better if I didnt do that. 
-
-  # So, if the state of the buffer reaches a certain step in its process involving the piece
-  # the buffer state should be fired off. 
-
-  # instead of initialiazing it with the buffer, 
-
-  class BufferState
-
-    def intialize(socket)
-      @socket = socket
-      @buffer = ''
-    end
-
-    # include Torrenter
-
-    def state(buffer, master_index)
-      buffer_id = buffer[4]
-      if buffer_id.nil?
-        buffer.slice!(0..3)
-      else
-        @length = buffer[0..3].unpack("N>")
-        case buffer_id
-        when BITFIELD   then process_bitfield
-        when HAVE       then process_have
-        when INTERESTED then process_interested
-        when PIECE      then process_piece
-        when CHOKE      then choke_message
-        when HANDSHAKE  then process_handshake
-        end
-      end
-    end
-
-    def process_bitfield
-      
-    end
-
-    def process_have
-      
-    end
-
-    def process_piece
-      
-    end
-
-    def process_handshake
-      
-    end
-
-    def recv_data
-      
-    end
-  end
-end