torrenter 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 473fad5c40e464ed097518df8cff579077b34072
+  data.tar.gz: 40ff8e80571d14cd92a32f2e7b1bad4658914a36
+SHA512:
+  metadata.gz: e2e4ae190b34baed37fd95981f33fc4b839fbdf6fa70381a71c4fcd25d75e23ae693ab9bb715a6c5da62dffddf9e7e33d4391ae3a7281734e09ea2696f4d7a32
+  data.tar.gz: 15d2962fb37e1b76c86f8f9cf98a6e01f421cc4c6d97ed56ece7d36077e7bea4bc970cec02ae0a39e640e2647971ee472342c5db91dc4ad7aa1e73b186a3349c

data/bin/torrenter

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'bencode'
+require 'net/http'
+require 'fileutils'
+require 'torrenter'
+file    = ARGV[0]
+$data_dump = "#{file}-data"
+Torrenter::Torrent.new.start(file)

data/lib/torrenter.rb

@@ -0,0 +1,16 @@
+require 'torrenter/message/messager'
+require 'torrenter/message/message_types'
+require 'torrenter/peer'
+require 'torrenter/reactor'
+require 'torrenter/udp'
+require 'torrenter/torrent_reader'
+module Torrenter
+  class Torrent
+    def start(file)
+      IO.write($data_dump, '', 0) if !File.exists?($data_dump)
+      stream  = BEncode.load_file(file)
+      peers   = Torrenter::TorrentReader.new(stream)
+      peers.determine_protocol
+    end
+  end
+end

data/lib/torrenter/message/message_types.rb

@@ -0,0 +1,12 @@
+module Torrenter
+  PEER_ID  = '-MATT16548651231825-'
+  BLOCK = 2**14
+  KEEP_ALIVE = "\x00\x00\x00\x00"
+  INTERESTED = "\x01"
+  HANDSHAKE  = "T"
+  HAVE       = "\x04"
+  BITFIELD   = "\x05"
+  PIECE      = "\a"
+  CHOKE      = "\x00"
+  PROTOCOL = "\x13BitTorrent protocol\x00\x00\x00\x00\x00\x00\x00\x00"
+end

data/lib/torrenter/message/messager.rb

@@ -0,0 +1,224 @@
+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 send_data(msg, opts={})
+    begin
+      Timeout::timeout(2) { @socket.sendmsg_nonblock(msg) }
+    rescue Timeout::Error
+      ''
+    rescue Errno::EADDRNOTAVAIL
+      ''
+    rescue Errno::ECONNREFUSED
+      ''
+    rescue Errno::EPIPE
+      ''
+    end
+  end
+
+  def recv_data(bytes=BLOCK, opts={})
+    begin
+      if opts[:peek]
+        Timeout::timeout(2) { @socket.recv_nonblock(4, Socket::MSG_PEEK) }
+      else
+        Timeout::timeout(2) { buffer << @socket.recv_nonblock(bytes) }
+      end
+    rescue Timeout::Error
+      ''
+    rescue Errno::EADDRNOTAVAIL
+      ''
+    rescue Errno::ECONNREFUSED
+      ''
+    rescue Errno::ECONNRESET
+      ''
+    rescue IO::EAGAINWaitReadable
+      ''
+    rescue Errno::ETIMEDOUT
+      @status = false
+      @buffer = ''
+    end
+  end
+
+  # the next few methods responsibility is for parsing the buffer. 
+  # They are responsible for the critical step of analyzing the buffer,
+  # checking for message consistency from the peer (and if it fails a test
+  # another message is sent out to attempt to fix the missing data)
+  
+
+  # parse message will be the gatekeeper. If the buffer is ever low in the READ part
+  # of the torrent program, then it knows more data may be required.
+  # It will also be responsble for EVERY new message that gets received, whether
+  # its in the download sequence of messaging or in the actual handshake, it will
+  # control it that way.
+
+  # for now, I'm assuming that at least the bitfield will be sent in full
+
+  def parse_bitfield
+    len = msg_len
+    buffer.slice!(0)
+    @piece_index = buffer.slice!(0...len).unpack("B#{sha_list.size}")
+      .first.split('')
+      .map { |bit| bit == '1' ? :available : :unavailable }
+  end
+
+  def send_interested
+    send_data("\x00\x00\x00\x01\x02")
+  end
+
+  def parse_have
+    if buffer[5..8].bytesize == 4
+      index = buffer[5..8].unpack("N*").first
+      @piece_index[index] = :available
+      buffer.slice!(0..8)
+    else
+      recv_data
+    end
+    send_interested if @buffer.empty?
+  end
+
+  # because ruby.
+
+  def parse_handshake
+    @buffer.slice!(0..67) if hash_match?
+  end
+
+  def hash_match?
+    @buffer.unpack("A*").first[28..47] == info_hash
+  end
+
+  # the negative 1 modifier is for factoring in the id
+
+  def msg_len
+    @buffer.slice!(0..3).unpack("N*").first - 1
+  end
+
+  def evaluate_index(master)
+    @requesting = 0
+    if @piece_index.any? { |chunk| chunk == :available }
+      @index = @piece_index.index(:available)
+      if master[@index] == :free
+        @piece_index[@index] = :downloading
+        master[@index] = :downloading
+      else
+        @piece_index[@index] = :downloaded
+        evaluate_index(master)
+      end
+    end
+  end
+
+  def modify_index(master)
+    master.each_with_index do |v,i|
+      if v == :downloaded
+        @piece_index[i] = :downloaded
+      end
+    end
+  end
+
+  def state(master, blocks)
+    @buffer_state = @buffer[4]
+    if buffer.bytesize <= 3 
+      recv_data
+    elsif buffer.bytesize == 4 && buffer[0..3] == KEEP_ALIVE
+      buffer.slice!(0..3)
+    else
+      # p @buffer[0..3].unp@buack("C*")
+      case @buffer[4]
+      when INTERESTED
+        buffer.slice!(0..4)
+        modify_index(master)
+        evaluate_index(master)
+        request_message
+      when HAVE
+        parse_have
+      when BITFIELD
+        parse_bitfield
+        send_interested if buffer.empty?
+      when PIECE
+        @length = buffer[0..3].unpack("N*").first + 4
+        if buffer.bytesize >= @length
+
+          buffer.slice!(0..12)
+          # the metadata is slireced off.
+          @offset += (@length - 13)
+          # buffer is reduced
+          pack_buffer
+          # that means the bytes for that block have been collected entirely.
+          # the buffer becomes empty
+          if pieces_remaining(master) > 1
+            if piece_size == @piece_len
+              pack_file(master)
+              evaluate_index(master)
+              request_message
+            else
+              request_message
+            end
+          elsif (File.size($data_dump) + piece_size) == total_file_size
+            pack_file(master)
+          else
+            if bytes_remaining >= BLOCK
+              request_message
+            else
+              request_message(bytes_remaining)
+            end
+          end
+        else
+          recv_data(@length - buffer.bytesize)
+        end
+        # piece
+      when CHOKE
+        buffer.slice!(0..3)
+        send_interested
+      when HANDSHAKE
+        parse_handshake
+      end
+    end
+  end
+
+  def pieces_remaining(master)
+    master.count(:downloading) + master.count(:free)
+  end
+
+  def bytes_remaining
+    (total_file_size - File.size($data_dump)) - piece_size
+  end
+
+  def piece_size
+    @block_map.join.bytesize
+  end
+
+  def pack_buffer
+    @block_map << @buffer.slice!(0...(@length - 13))
+  end
+
+  def pack_file(master)
+    data = @block_map.join
+    if piece_verified?(data)
+      IO.write($data_dump, data, @index * @offset)
+      master[@index] = :downloaded
+      @piece_index[@index] = :downloaded
+    else
+      master[@index] = :free
+      @piece_index[@index] = :downloaded
+    end
+    @block_map = []
+    @offset = 0
+  end
+
+  def piece_verified?(data)
+    Digest::SHA1.digest(data) == sha_list[@index]
+  end
+
+  def request_message(bytes=BLOCK)
+    @requesting += 1
+    send_data(pack(13) + "\x06" + pack(@index) + pack(@offset) + pack(bytes))
+  end
+
+  def pack(i)
+    [i].pack("I>")
+  end
+end

data/lib/torrenter/peer.rb

@@ -0,0 +1,62 @@
+# contains the peer information
+module Torrenter
+  class Peer
+    include Torrenter
+    # for non outside vars use the @ and remove them from
+
+    attr_reader :socket, :peer, :sha_list, :piece_len, :info_hash, :status
+    attr_accessor :piece_index, :offset, :buffer, :block_map
+
+
+    def initialize(peer, file_list, peer_info={})
+      @peer            = peer
+      @info_hash       = peer_info[:info_hash]
+      @piece_len       = peer_info[:piece_length]
+      @sha_list        = peer_info[:sha_list]
+      @piece_index     = peer_info[:piece_index]
+      @buffer          = ''
+      @block_map       = []
+      @offset          = 0
+      @file_list       = file_list
+      @status          = false
+    end
+
+    def total_file_size
+      if @file_list.is_a?(Array)
+        @file_list.map { |f| f['length'] }.inject { |x, y| x + y }
+      else
+        @file_list['length']
+      end
+    end
+
+    def connect
+      puts "\nConnecting to IP: #{peer[:ip]} PORT: #{peer[:port]}"
+      begin
+        Timeout::timeout(2) { @socket = TCPSocket.new(peer[:ip], peer[:port]) }
+      rescue Timeout::Error
+        puts "Timed out."
+      rescue Errno::EADDRNOTAVAIL
+        puts "Address not available."
+      rescue Errno::ECONNREFUSED
+        puts "Connection refused."
+      rescue Errno::ECONNRESET
+        puts "bastards."
+      end
+
+      if @socket
+        @socket.write(handshake)
+        @status = true
+      else
+        @status = false
+      end
+    end
+
+    def handshake
+      "#{PROTOCOL}#{@info_hash}#{PEER_ID}"
+    end
+
+    def msg_num
+      @buffer.slice!(0..3).unpack("N*").first
+    end
+  end
+end

data/lib/torrenter/reactor.rb

@@ -0,0 +1,105 @@
+module Torrenter
+  class Reactor
+    include Torrenter
+    def initialize(peers, sha_list, piece_length, file_list)
+      @peers        = peers
+      @master_index = Array.new(sha_list.size) { :free }
+      @blocks       = piece_length / BLOCK
+      @file_list    = file_list
+      @piece_length = piece_length
+      @sha_list     = sha_list
+      @data_size    = if file_list.is_a?(Array)
+                        file_list.map { |f| f['length'] }.inject { |x, y| x + y }
+                      else
+                        file_list['length']
+                      end
+    end
+
+    def modify_index
+      IO.write($data_dump, '', 0) unless File.exists?($data_dump)
+      file_size = File.size($data_dump)
+      0.upto(@sha_list.size - 1) do |n|
+        data = IO.read($data_dump, @piece_length, n * @piece_length) || ''
+        @master_index[n] = :downloaded if Digest::SHA1.digest(data) == @sha_list[n]
+      end
+      puts "#{@master_index.count(:downloaded)} pieces are downloaded already."
+    end
+
+    # sends the handshake messages.
+
+    def message_reactor(opts={})
+      modify_index
+      if !@master_index.all? { |index| index == :downloaded }
+        @peers.each { |peer| peer.connect }
+        loop do
+          break if @master_index.all? { |piece| piece == :downloaded }
+          @peers.each do |peer|
+            piece_count = @master_index.count(:downloaded)
+            if peer.status
+              peer.state(@master_index, @blocks) # unless peer.piece_index.all? { |piece| piece == :downloaded }
+              if @master_index.count(:downloaded) > piece_count
+                system("clear")
+                puts download_bar + "Downloading from #{active_peers} active peers"
+              end
+            elsif Time.now.to_i % 60 == 0
+              peer.connect
+            end
+          end
+        end
+        stop_downloading
+        seperate_data_dump_into_files
+      else
+        upload_data
+      end
+    end
+
+    def active_peers
+      @peers.select { |peer| peer.status }.size
+    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 stop_downloading
+      @peers.each { |peer| peer.piece_index.map { |piece| piece = :downloaded} }
+    end
+
+    def seperate_data_dump_into_files
+      if multiple_files?
+        offset = 0
+        folder =  $data_dump[/.+(?=\.torrent-data)/] || FileUtils.mkdir($data_dump[/.+(?=\.torrent-data)/]).join
+        @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
+        File.open("#{folder}/#{@file_list['name'].join}", '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/torrent_reader.rb

@@ -0,0 +1,137 @@
+require 'socket'
+require 'digest/sha1'
+require 'bencode'
+require 'pry'
+require 'fileutils'
+
+
+module Torrenter
+  class TorrentReader
+    attr_reader :stream
+    def initialize(stream)
+      @stream      = stream
+    end
+
+    def determine_protocol
+      trackers =  if @stream['announce-list']
+                    @stream['announce-list'].flatten << @stream['announce']
+                  else
+                    [@stream['announce']]
+                  end
+
+      @http_trackers = trackers.select { |tracker| tracker =~ /http\:\/\// }
+      @udp_trackers  = trackers.select { |tracker| tracker =~ /udp\:\/\//  }
+      # first try the http trackers...
+      
+      connect_to_http_tracker if @http_trackers.size > 0
+      connect_to_udp_tracker if @peers.nil?
+      peer_list
+      establish_reactor
+
+    end
+
+    def connect_to_http_tracker
+      @uri       = URI(@http_trackers.shift)
+      @uri.query = URI.encode_www_form(peer_hash)
+      @peers     = raw_peers
+    end
+
+    def connect_to_udp_tracker
+      @udp_trackers.map! do |udp|
+        port = udp[/\d+/]
+        udp.gsub!(/udp\:\/\/|\:\d+|\/announce/, '')
+        begin
+          ip = Socket.getaddrinfo(udp, 80)[0][3]
+          udp_socket = UDPConnection.new(ip, port.to_i, sha)
+          udp_socket.connect_to_udp_host
+        rescue SocketError
+          puts 'Unuseable UDP site'
+        end
+      end
+
+      while @peers.nil?
+        udp = @udp_trackers.shift
+        begin
+          @peers = udp.message_relay
+        rescue
+        end
+
+      end
+    end
+
+
+    # url gets reformatted to include query parameters
+
+    def raw_peers
+      begin
+        BEncode.load(Net::HTTP.get(@uri))['peers']
+      rescue
+        nil
+      end
+    end
+
+
+    def piece_length
+      stream['info']['piece length']
+    end
+
+    def sha
+      Digest::SHA1.digest(stream['info'].bencode)
+    end
+
+    # data stored as a hash in the order made necessary
+
+    def peer_hash
+      {
+        :info_hash => sha,
+        :peer_id   => PEER_ID,
+        :left      => piece_length,
+        :pieces    => stream['info']['files'] || stream['info']['name']
+      }
+    end
+
+    # Using the peers key of the torrent file, the hex-encoded data gets reinterpreted as ips addresses.
+
+    def peer_list
+      ip_list = []
+      until @peers.empty?
+        ip_list << { ip: @peers.slice!(0..3).bytes.join('.'), port: @peers.slice!(0..1).unpack("S>").first }
+      end
+
+      @peers = ip_list.map { |peer| Peer.new(peer, file_list, peer_info) }
+    end
+
+    def sha_list
+      n, e = 0, 20
+      list = []
+      until stream['info']['pieces'].bytesize < e
+        list << stream['info']['pieces'].byteslice(n...e)
+        n += 20
+        e += 20
+      end
+      list
+    end
+
+    def peer_info
+      {
+        :info_hash    => sha,
+        :piece_length => piece_length,
+        :sha_list     => sha_list,
+        :piece_index  => Array.new(sha_list.size) { false }
+      }
+    end
+
+    def file_list
+      stream['info']['files'] || stream['info']
+    end
+
+    def establish_reactor
+      react = Reactor.new(@peers, sha_list, piece_length, file_list)
+      begin
+        react.message_reactor
+      end
+    end
+  end
+end
+
+

data/lib/torrenter/udp.rb

@@ -0,0 +1,87 @@
+module Torrenter
+  class UDPConnection
+    attr_reader :sender, :response
+    def initialize(ip, port, info_hash)
+      @ip             = ip
+      @port           = port
+      @sender         = UDPSocket.new
+      @t              = rand(10000)
+      @connection_id  = [0x41727101980].pack("Q>")
+      @transaction_id = [@t].pack("I>")
+      @info_hash      = info_hash
+    end
+
+    def connect_to_udp_host
+      begin
+        @sender.connect(@ip, @port)
+        return self
+      rescue
+        false
+      end
+    end
+
+    def message_relay
+      @sender.send(connect_msg, 0)
+      read_response
+      if @response
+        @connection_id = @response[-8..-1]
+        @transaction_id = [rand(10000)].pack("I>")
+        @sender.send(announce_msg, 0)
+      end
+
+      read_response
+      
+      if @response
+        parse_announce if @response[0..3] == action(1)
+        return @response
+      end
+    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
+        @sender.send(@msg, 0)
+      rescue
+      end
+    end
+
+    def read_response
+      begin
+        @response = @sender.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 port
+      @sender.addr[1]
+    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) + [port].pack(">S")
+    end
+  end
+end

data/lib/torrenter/version.rb

@@ -0,0 +1,3 @@
+module Torrenter
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,54 @@
+--- !ruby/object:Gem::Specification
+name: torrenter
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- wismer
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-04-21 00:00:00.000000000 Z
+dependencies: []
+description: BitTorrent Client written in Ruby
+email:
+- matthewhl@gmail.com
+executables:
+- torrenter
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/torrenter
+- lib/torrenter.rb
+- lib/torrenter/message/message_types.rb
+- lib/torrenter/message/messager.rb
+- lib/torrenter/peer.rb
+- lib/torrenter/reactor.rb
+- lib/torrenter/torrent_reader.rb
+- lib/torrenter/udp.rb
+- lib/torrenter/version.rb
+homepage: http://wismer.github.io
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Load by typing the torrent file name after torrenter
+test_files: []