torrenter 0.0.6 → 0.0.7

data/lib/torrenter/setup.rb

@@ -1,10 +0,0 @@
-require 'bencode'
-require 'pry'
-require 'digest/sha1'
-require './lib/torrenter/torrent_reader.rb'
-require './lib/torrenter/udp_tracker.rb'
-require './lib/torrenter/http_tracker.rb'
-
-stream = BEncode.load_file('thrones.torrent')
-reader = TorrentReader.new(stream)
-binding.pry

data/lib/torrenter/test_msg.rb

@@ -1,166 +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)
-    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
-      when CHOKE      
-        choke_message
-      when HANDSHAKE
-        process_handshake
-      end
-    end
-  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
-    if buffer_length?
-      if buffer_complete?
-        pack_buffer
-      end
-
-      diff = @remaining - @blocks.join('').bytesize
-      if diff < BLOCK
-        request_message(diff)
-      else
-        request_message
-      end
-    end
-    recv_data
-  end
-
-  def mark_complete
-    @blocks = []
-    @piece_index[@index] = :downloaded
-  end
-
-  def last_piece?
-    @remaining
-  end
-
-  def piece_complete?
-    piece_size == @piece_length
-  end
-
-  def buffer_size
-    @buffer[13..-1].bytesize
-  end
-
-  def pack_buffer
-    @blocks << @buffer.slice!(13..-1)
-    @buffer.clear
-  end
-
-  def buffer_complete?
-    (@buffer.length - 13) == BLOCK || (@buffer.length - 13) == @remaining
-  end
-
-  # will need a last piece sort of thing inserted in here
-
-  def piece_full?
-    @blocks.join('').size == @piece_len
-  end
-
-  def piece_size
-    @blocks.join('').bytesize + (@buffer.bytesize - 13)
-  end
-
-  def process_handshake
-    @buffer.slice!(0..67) if hash_check?
-  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 Errno::ETIMEDOUT
-      @peer_state = false
-    rescue *EXCEPTIONS
-      ''
-    rescue IO::EAGAINWaitReadable
-      ''
-    end
-  end
-end

data/lib/torrenter/test_reactor.rb

@@ -1,219 +0,0 @@
-module Torrenter
-  class Reactor < Torrenter::TorrentReader
-
-    attr_accessor :master_index
-    def initialize(peers, stream)
-      super(stream)
-      @peers         = peers
-      @master_index  = Array.new(sha_hashes.bytesize / 20) { :free }
-      @time_counter  = 0
-      @time          = Time.now.to_i
-      @byte_counter  = 0
-    end
-
-    def check_for_existing_data
-      # if the torrent data file is not present, one will be created
-      IO.write($data_dump, '', 0) unless File.file?($data_dump)
-
-      0.upto(@master_index.size - 1) do |n|
-        # this needs to get changed in order to account for 
-        # the last piece not being equal to the piece_length
-        data = IO.read($data_dump, piece_length, n * piece_length) || ''
-        # binding.pry
-        if verified?(n, data)
-          @master_index[n] = :downloaded
-          @byte_counter += data.bytesize
-        end
-      end
-      puts "#{@master_index.count(:downloaded)} pieces downloaded"
-    end
-
-    def verified?(loc, piece)
-      Digest::SHA1.digest(piece) == sha_hashes[loc * 20..(loc * 20) + 19]
-    end
-
-    def finished?
-      @master_index.all? { |index| index == :downloaded }
-    end
-
-    def connect_peers
-      @peers.each { |peer| peer.connect if active_peers.size < 8 }
-    end
-
-    # sends the handshake messages.
-
-    def message_reactor
-      @peers.each { |peer| peer.connect if active_peers.length < 8 }
-      if !finished?
-        peer.state(@master_index) do |loc, buf|
-          
-        end
-      end
-    end
-
-    def piece_indices
-      active_peers.select { |peer| peer.piece_index }
-        .map { |peer| peer.piece_index }
-    end
-
-    def tally
-      @master_index.map.with_index do |p,i| 
-        p == :free ? piece_indices.map { |x| x[i] } : []
-      end
-    end
-
-    def piece_select(peer, limit=1)
-      binding.pry if @master_index.count(:free) == 1
-      puts "#{peer.ip} picking a piece"
-      piece_index = peer.piece_index
-      @tally = tally
-      index = nil
-
-      loop do
-        if limit == active_peers.size + 1
-          index = piece_index.index(:free)
-          break
-        elsif index.is_a?(Integer)
-          break
-        end
-        i = 0
-        loop do
-          break if i > piece_index.size - 1|| !index.nil?
-          if @tally[i].count(:free) == limit && piece_index[i] == :free
-            index = i
-          else
-            i += 1
-          end
-        end
-
-        limit += 1 if index.nil?
-      end
-
-      if index
-        @master_index[index] = :downloading
-        peer.request_piece(index)
-        p index
-        return index
-      else
-        binding.pry
-      end
-    end
-
-    def show_status
-      if (Time.now.to_i - @time) == 1
-        system('clear')
-        puts "#{download_bar} \n Downloading #{$data_dump[/(.+)(?=torrent-data)/]} at #{real} KB/sec with #{pieces_left} pieces left to download"
-        puts "and #{data_remaining} MB remaining ------ #{active_peers.size} connected."
-      end
-    end
-
-    def remaining
-      total_file_size - @byte_counter
-    end
-
-    def select_index(index)
-      poo = @master_index.map.with_index do |peer,index|
-        active_peers.map { |x| x.piece_index[index] }
-      end
-    end
-
-    def peer_indices
-      active_peers.map { |peer| peer.piece_index }
-    end
-
-    def data_remaining
-      (total_file_size - @byte_counter).fdiv(1024).fdiv(1024).round(2)
-    end
-
-    def pieces_left
-      @master_index.count(:free)
-    end
-
-    def real
-      @time_counter.fdiv(1024).round(1)
-    end
-
-    def reattempt_disconnected_peer
-      disconnected_peers.sample.connect
-    end
-
-    def disconnected_peers
-      @peers.select { |peer| !peer.connected? }
-    end
-
-    def pack_piece(peer)
-      IO.write($data_dump, peer.piece_data, piece_length * peer.index)
-    end
-
-    def indices
-      @master_index.map do |piece|
-        if piece == :free
-          0
-        elsif piece == :downloaded
-          1
-        else
-          get_status @master_index.index(piece)
-        end
-      end
-    end
-
-    def get_status(i)
-      peer = @peers.find { |peer| peer.piece_index[i] == :downloading }
-      (peer.buffer.bytesize + peer.piece_size).fdiv(@piece_length)
-    end
-
-    def active_peers
-      @peers.select { |peer| peer.peer_state }
-    end
-
-    def index_percentages
-      active_peers.map do |peer|
-        size = peer.buffer.bytesize + peer.piece_size
-        [peer.index, (size.fdiv @piece_length) * 100]
-      end
-    end
-
-    def download_bar
-      ("\u2588" * pieces(:downloaded)) + ("\u2593" * pieces(:downloading)) + (" " * pieces(:free)) + " %#{pieces(:downloaded)} downloaded "
-    end
-
-    def pieces(type)
-      (@master_index.count(type).fdiv(@master_index.size) * 100).round
-    end
-
-    def seperate_data_dump_into_files
-      folder = $data_dump[/.+(?=\.torrent-data)/]
-
-      if multiple_files?
-        offset = 0
-
-        file_list.each do |file|
-
-          length =  file['length']
-          filename = file['path'].pop
-
-          if multiple_sub_folders?(file)
-            subfolders = file['path'].join("/")
-            folder = folder + "/" + subfolders
-            FileUtils.mkdir_p("#{folder}", force: true)
-          end
-
-          File.open("#{folder}/#{filename}", 'a+') { |data| data << IO.read($data_dump, length, offset) }
-          offset += length
-        end
-      else
-        FileUtils.mkdir("#{folder}")
-        File.open("#{folder}/#{file_list['name']}", 'w') { |data| data << File.read($data_dump) }
-      end
-      File.delete($data_dump)
-    end
-
-    def multiple_sub_folders?(file)
-      file['path'].size > 1
-    end
-
-    def multiple_files?
-      file_list.is_a?(Array)
-    end
-  end
-end

data/lib/torrenter/udp_tracker.rb

@@ -1,96 +0,0 @@
-module Torrenter
-  class UDPTracker < TorrentReader
-
-    attr_reader :socket, :response
-
-    def initialize(tracker, stream)
-      super(stream)
-      @url           = tracker[/(?<=udp\:\/\/).+(?=\:\d+)/]
-      @port          = tracker[/\d+$/].to_i
-      @socket        = UDPSocket.new
-      @connection_id = [0x41727101980].pack("Q>")
-    end
-
-    def connect
-      @transaction_id = [rand(1000)].pack("I>")
-      @socket.connect(ip_addr, @port)
-      begin
-        send_msg(connect_msg)
-        read_response
-      rescue
-        false
-      end
-    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] == action(1)
-
-      peer_list(@response)
-    end
-
-    def parse_announce
-      if @response[4..7] == @transaction_id
-        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
-      end
-    end
-
-    def read_response
-      begin
-        @response = @socket.recv(1028)
-      rescue Exception => e
-        e
-      end
-    end
-
-    def connect_match?
-      data[0] == (action(0) + @transaction_id + @connection_id)
-    end
-
-    def announce_input
-      @connection_id + action(1) + @transaction_id + info_hash + PEER_ID
-    end
-
-    def connect_msg
-      @connection_id + action(0) + @transaction_id
-    end
-
-    def action(n)
-      [n].pack("I>")
-    end
-
-    def announce_msg
-      @connection_id + action(1) + @transaction_id + info_hash + PEER_ID + [0].pack("Q>") + [0].pack("Q>") + [0].pack("Q>") + action(0) + action(0) + action(0) + action(-1) + [@socket.addr[1]].pack(">S")
-    end
-  end
-end