bittorrent 0.0.2

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MGFjNWY0YTZjYTM4OWUyOWY3MjlkZTZkNWJhNzhjMjdmYmEwNmRiOA==
+  data.tar.gz: !binary |-
+    ZDUzMGQ3NTA0ZmQ3YmQ3MmQwYTk0ZmVjN2E3Nzc0NGYxMTQ2NWRiMA==
+SHA512:
+  metadata.gz: !binary |-
+    N2ZkYzIyMmIxZDcyZTA4MTY3ZDc4MDdmMjkxNTY0ZGYwOGFkMzNiNjc2MmM2
+    ZDhiOWNiODVmNjk0NzVlZTViNTYwM2RiZjk5NmFhNWMyMzcwNjg5MzllODlk
+    MDg0Njk3NzlhNzFiMjk0YzU4OTJkNGQ2YjFlMzVmOTUxMmQ4YWM=
+  data.tar.gz: !binary |-
+    ODk0MTA2N2UwYWJjOGM3MDI5YWQ1ZjkzNWRjOWYyMWU2OWM2NzZjZjY4MzIw
+    YjBmNmI5MTlkOTM3MjI4NDFiY2I1ZWZlNzdjNTA3MmI0M2I0M2VjNzcxNDI2
+    MDRmZDIxM2I2YTliODEyNTE3ODQzNmFmOTE5NTRhZTExZjA0MjI=

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in bittorrent.gemspec
+gemspec

data/README.md

@@ -0,0 +1,11 @@
+# Bittorrent
+
+Bittorrent client written in Ruby.
+
+## Usage
+
+```
+bittorrent [TORRENT_FILE] [DOWNLOAD_FOLDER]
+```
+
+[follow me on twitter](http://twitter.com/therealcoelho)

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/bitfield.rb

@@ -0,0 +1,14 @@
+class Bitfield
+  
+  attr_accessor :bits
+  
+  def initialize(*bit_array)
+    @bits = bit_array.join.split('').map! { |char| char.to_i }
+    p @bits
+  end
+  
+  def have_piece(index)
+    @bits[index] = 1
+  end
+  
+end

data/bin/bittorrent

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'digest/sha1'
+require 'thread'
+require 'ipaddr'
+require 'socket'
+require 'timeout'
+require 'pp'
+
+require './ruby-bencode/lib/bencode.rb'
+require './client'
+require './piece'
+require './block'
+require './file_handler'
+require './meta_info'
+require './block_request_scheduler'
+require './block_request_process'
+require './byte_array'
+require './incoming_message_process'
+require './tracker'
+require './peer'
+require './bitfield'
+require './message'
+require './utils'
+
+include Utils
+
+if ARGV[0] == '-h'
+	puts 'Usage: bittorrent [TORRENT_FILE] [DOWNLOAD_FOLDER]'
+end
+
+torrent = ARGV[0]
+download_path = ARGV[1]
+
+client = Client.new(torrent, download_path)
+client.run!
+
+Utils::join_threads

data/bin/block.rb

@@ -0,0 +1,30 @@
+class Block
+  attr_accessor :start_byte, :end_byte, :data, :piece_index, :peer, :offset
+
+  def initialize(piece_index, offset, data, piece_length, peer)
+    @offset = offset
+    @peer = peer
+    @data = data
+    @piece_index = piece_index
+    @offset = offset
+    @start_byte = get_start_byte(piece_length)
+    @end_byte = get_end_byte
+  end
+
+  def inspect
+    "piece #{@piece_index}, offset #{@offset_in_piece}, data len #{@data.length}"
+  end
+
+  private
+
+    def get_start_byte(piece_length)
+      @piece_index * piece_length + @offset
+    end
+
+    def get_end_byte
+      @start_byte + @data.length - 1
+    end
+
+end
+
+  

data/bin/block_request_process.rb

@@ -0,0 +1,17 @@
+class BlockRequestProcess
+  def pipe(request)
+    connection = request[:connection]
+    connection.write(compose_request(request))
+  end
+
+  private
+
+  def compose_request(request)
+      msg_length = "\0\0\0\x0d"
+      id = "\6"
+      piece_index = [request[:index]].pack("N")
+      byte_offset = [request[:offset]].pack("N")
+      request_length = [request[:size]].pack("N")
+      msg_length + id + piece_index + byte_offset + request_length
+  end
+end

data/bin/block_request_scheduler.rb

@@ -0,0 +1,130 @@
+class BlockRequestScheduler
+
+  BLOCK_SIZE = 2**14
+  NUM_PENDING = 10
+  
+  attr_accessor :request_queue
+  
+  def initialize(peers, metainfo)
+    @peers = peers
+    @metainfo = metainfo
+    @all_block_requests = Queue.new
+    @request_queue = Queue.new
+    store_block_requests
+    init_requests
+  end
+  
+  def store_block_requests
+    store_all_but_last_piece
+    store_last_piece
+    store_last_block
+  end
+  
+  def init_requests
+    @peers.each do |peer|
+      NUM_PENDING.times { assign_request(peer, @all_block_requests.pop) }
+    end    
+  end
+  
+  def store_all_but_last_piece
+    0.upto(num_pieces - 2).each do |piece_num|
+      0.upto(num_blocks_in_piece - 1).each do |block_num|
+        store_request(piece_num, block_offset(block_num), BLOCK_SIZE)
+      end
+    end
+  end
+
+  def store_last_piece
+    0.upto(num_full_blocks_in_last_piece - 1) do |block_num|
+      store_request(num_pieces - 1, block_offset(block_num), BLOCK_SIZE)
+    end
+  end
+
+  def store_last_block
+    store_request(num_pieces - 1, last_block_offset, last_block_size)    
+  end
+
+  def store_request(index, offset, size)
+    @all_block_requests.push(create_block(index, offset, size))
+  end
+
+  def assign_request(peer, block)
+    peer.pending_requests << block
+    @request_queue.push(assign_peer(peer, block))
+  end
+  
+  def pipe(incoming_block)
+    request = get_next_request(incoming_block)
+    enqueue_request(incoming_block, request) if request
+  end
+
+  def get_next_request(block)
+    if @all_block_requests.empty?
+      oldest_pending_request(block)
+    else
+      @all_block_requests.pop
+    end
+  end
+  
+  def enqueue_request(incoming_block, request)
+    incoming_block.peer.pending_requests << request
+    @request_queue.push(assign_peer(incoming_block.peer, request))    
+  end
+  
+  def oldest_pending_request(block)
+    slowest_peer = @peers.sort_by{|peer| peer.pending_requests.length}.first
+    slowest_peer.pending_requests.last
+  end
+  
+  def assign_peer(peer, block)
+    { connection: peer.connection,
+      index:      block[:index],
+      offset:     block[:offset],
+      size:       block[:size] }
+  end
+  
+  def create_block(index, offset, size)
+    { index: index, offset: offset, size: size }
+  end
+
+  def num_pieces
+    (@metainfo.total_size.to_f/@metainfo.piece_length).ceil
+  end
+
+  def last_block_size
+    @metainfo.total_size.remainder(BLOCK_SIZE)
+  end
+
+  def num_full_blocks
+    @metainfo.total_size/BLOCK_SIZE
+  end
+
+  def last_piece_size
+    file_size - (@metainfo.piece_length * (@metainfo.number_of_pieces - 1))
+  end
+
+  def num_blocks_in_piece
+    (@metainfo.piece_length.to_f/BLOCK_SIZE).ceil
+  end
+
+  def num_full_blocks_in_last_piece
+    num_full_blocks.remainder(num_blocks_in_piece)
+  end
+
+  def total_num_blocks_in_last_piece
+    num_full_blocks_in_last_piece + 1
+  end
+
+  def last_block_offset
+    BLOCK_SIZE * num_full_blocks_in_last_piece
+  end
+
+  def last_block_offset
+    BLOCK_SIZE * num_full_blocks_in_last_piece
+  end
+
+  def block_offset(block_num)
+    BLOCK_SIZE * block_num
+  end
+  
+end

data/bin/byte_array.rb

@@ -0,0 +1,95 @@
+class ByteArray
+
+  def initialize(meta_info)
+    @length = meta_info.total_size
+    @bytes = Array.new([[0, @length - 1, false]])
+  end
+
+  def have_all(start, fin)
+    check_range(start,fin)
+    start_item, end_item = boundry_items(start, fin)
+    
+    start_index = @bytes.index(start_item)
+    end_index = @bytes.index(end_item)
+
+    result = Array.new(3,nil)
+    first, second, third = nil
+
+    if start_item[2] and end_item[2]
+      result[0] = [start_item[0], end_item[1], true]
+    elsif start_item[2]
+      result[0] = [start_item[0], fin, start_item[2]]
+      result[1] = [fin + 1, end_item[1], end_item[2]]
+    elsif end_item[2]
+      result[0] = [start_item[0], start - 1, start_item[2]]
+      result[1] = [start, end_item[1], true]
+    else
+      result[0] = [start_item[0], start - 1, start_item[2]]
+      result[1] = [start, fin, true]
+      result[2] = [fin + 1, end_item[1], end_item[2]]
+    end
+        
+    result.map! do |item|
+      unless item.nil?
+        item = nil if item[0] > item[1]
+      end
+      item
+    end
+    
+    @bytes[start_index..end_index] = result.compact    
+    consolidate!
+    @bytes
+  end
+  
+  def consolidate!
+    0.upto(@bytes.length - 2).each do |n|
+      if @bytes[n][2] == @bytes[n+1][2]
+        @bytes[n+1][0] = @bytes[n][0]
+        @bytes[n] = nil 
+      end
+    end
+    @bytes.compact!
+  end
+
+  def boundry_items(start, fin)
+    start_item, end_item = nil
+    @bytes.each_with_index do |element, index|
+      start_item = @bytes[index] if start.between?(element[0],element[1])
+      end_item = @bytes[index] if fin.between?(element[0],element[1])
+    end
+    [start_item, end_item]
+  end
+
+  def have_all?(start, fin)
+    check_range(start, fin)
+    @bytes.each do |i, j, bool|
+      if bool == false
+        if intersect?(start, fin, i, j)
+          return false
+        end
+      end
+    end
+    true
+  end
+
+  def intersect?(start, fin, i, j)
+    start.between?(i, j)     ||
+      fin.between?(i,j)      ||
+      i.between?(start, fin) ||
+      j.between?(start, fin)
+  end
+  
+  def complete?
+    @bytes == [[0, @length - 1, true]]
+  end
+
+  def check_range(start,fin)
+    if start < 0 or
+       fin < 0 or
+       start > @length - 1 or
+       fin > @length - 1 or
+       start > fin
+      raise "Byte Array: out of range"
+    end
+  end
+end

data/bin/client.rb

@@ -0,0 +1,104 @@
+class Client
+
+  # set queues and set processes in different methods
+  
+  def initialize(path_to_file, download_folder)
+    @metainfo = parse_metainfo(File.open(path_to_file), download_folder)
+    @tracker = Tracker.new(@metainfo.announce)
+    @id = rand_id # TODO: assign meaningful id
+    @peers = []
+    set_peers
+    @scheduler = BlockRequestScheduler.new(@peers, @metainfo)
+    @message_queue = Queue.new
+    @incoming_block_queue = Queue.new    
+  end
+
+  def parse_metainfo(torrent_file, download_folder)
+    metainfo = BEncode::Parser.new(torrent_file).parse!
+    MetaInfo.new(metainfo, download_folder)
+  end
+  
+  def rand_id
+    20.times.reduce("") { |a, _| a + rand(9).to_s }
+  end
+
+  def set_peers
+    peers = @tracker.make_request(tracker_request_params)["peers"].scan(/.{6}/)
+    get_unpacked_peers(peers).each do |ip_string, port|
+      set_peer(ip_string, port)
+    end
+  end  
+
+  def set_peer(ip_string, port)
+    begin
+      handshake = "\x13BitTorrent protocol\x00\x00\x00\x00\x00\x00\x00\x00#{@metainfo.info_hash}#{@id}"
+      Timeout::timeout(1) { @peers << Peer.new(ip_string, port, handshake, @metainfo.info_hash) }
+    rescue => exception
+      puts exception
+    end
+  end
+  
+  def tracker_request_params
+    { info_hash:    @metainfo.info_hash,
+      peer_id:      @id,
+      port:         '6881',
+      uploaded:     '0',
+      downloaded:   '0',
+      left:         '10000',
+      compact:      '1',
+      no_peer_id:   '0',
+      event:        'started' }
+  end
+
+  def get_unpacked_peers(peers)
+    peers.map {|p| p.unpack('a4n') }
+  end
+
+  def run!
+    Thread::abort_on_exception = true
+    @peers.each { |peer| peer.start!(@message_queue) }    
+    make_threads([scheduler, incoming_message, file_handler])
+  end
+  
+  def scheduler
+    lambda { pipe(@scheduler.request_queue, BlockRequestProcess.new) }
+  end
+
+  def incoming_message
+    lambda do
+      pipe(@message_queue,
+           IncomingMessageProcess.new(@metainfo.piece_length),
+           @incoming_block_queue)
+    end
+  end
+
+  def file_handler
+    lambda do
+      multi_pipe(@incoming_block_queue,
+                 FileHandler.new(@metainfo),
+                 @scheduler)
+    end
+  end
+  
+  def make_threads(processes)
+    processes.each do |process|
+      Thread.new { process.call }
+    end
+  end
+  
+  def multi_pipe(input, *processors)
+    while m = input.pop
+      processors.each { |p| p.pipe(m) }
+    end
+  end
+
+  def pipe(input, processor, output=nil)
+    while m = input.pop
+      if output
+         processor.pipe(m, output)
+      else
+        processor.pipe(m)
+      end
+    end
+  end
+end

data/bin/file_handler.rb

@@ -0,0 +1,105 @@
+require 'fileutils'
+
+class FileHandler
+  include FileUtils
+
+  def initialize(metainfo)
+    @metainfo = metainfo
+    @byte_array = ByteArray.new(@metainfo)
+    @temp_name = "temp/" + ('a'..'z').to_a.shuffle.take(10).join
+    @file = init_file
+    @download_path = download_path
+  end
+
+  def init_file
+    Dir.mkdir("temp") unless File.directory?("temp")
+    File.open(@temp_name, "w+")
+    File.open(@temp_name, "r+")
+  end
+
+  def pipe(block)
+    write_block(block)
+    record_block(block)
+
+    piece_start = @metainfo.pieces[block.piece_index].start_byte
+    piece_end = @metainfo.pieces[block.piece_index].end_byte
+
+    if @byte_array.have_all?(piece_start, piece_end)
+      verify_piece(block.piece_index)
+    end
+
+    finish if @byte_array.complete?
+  end
+
+  def write_block(block)
+    @file.seek(block.start_byte)
+    @file.write(block.data)
+  end
+
+  def record_block(block)
+    @byte_array.have_all(block.start_byte, block.end_byte)
+  end
+
+  def verify_piece(index)
+    piece = @metainfo.pieces[index]
+    if piece.hash == hash_from_file(piece)
+      puts "piece #{index} verified!"
+    else
+      puts "piece #{index} verification FAILED!"
+    end
+  end
+
+  def hash_from_file(piece)
+    Digest::SHA1.new.digest(read(piece.start_byte, piece.length))
+  end
+
+  def read(start, length)
+    @file.seek(start)
+    @file.read(length)
+  end
+
+  def finish
+    puts "finishing!"
+    @file.close
+    make_download_dir
+    if @metainfo.is_multi_file?
+      split_files
+      remove_temp_file
+    else
+      move_file
+    end
+    abort("File download successful!")
+  end
+
+  def split_files
+    File.open(@temp_name, "r") do |temp_file|
+      @metainfo.files.each do |file_info|
+        File.open(@download_path +  file_info[:name], "w") do |out_file|
+          out_file.write(temp_file.read(file_info[:length]))
+        end
+      end
+    end
+  end
+
+  def move_file
+    FileUtils.mv(@temp_name, @download_path + @metainfo.files[0][:name])
+  end
+  
+  def make_download_dir  
+    unless File.directory?(@download_path)
+      Dir.mkdir(@download_path)
+    end
+  end
+  
+  def remove_temp_file
+    File.delete(@temp_name)
+  end
+
+  def download_path
+    if @metainfo.download_folder[-1] == "/"
+      return @metainfo.download_folder
+    end
+    @metainfo.download_folder + "/"
+  end
+  
+end

data/bin/incoming_message_process.rb

@@ -0,0 +1,50 @@
+class IncomingMessageProcess
+  def initialize(piece_length)
+    @piece_length = piece_length
+  end
+
+  def pipe(message, output)
+    puts "Peer #{message.peer.id} has sent you a #{message.type} message"
+    case message.type
+    when :piece
+      piece_index, byte_offset, block_data = split_piece_payload(message.payload)
+      block = Block.new(piece_index,
+                        byte_offset,
+                        block_data,
+                        @piece_length,
+                        message.peer)
+      remove_from_pending(block)
+      output.push(block)
+    when :choking
+      message.peer.state[:is_choking] = true
+    when :unchoke
+      message.peer.state[:is_choking] = false
+    when :not_interested
+      message.peer.state[:is_interested] = false
+    when :interested
+      message.peer.state[:is_interested] = true
+    when :have
+      message.peer.bitfield.have_piece(message.payload.unpack("N")[0])
+      puts "have #{message.peer.bitfield}"
+    end
+  end
+
+  private
+
+  def remove_from_pending(block)
+    block.peer.pending_requests.delete_if do |req|
+      if req
+        req[:index] == block.piece_index and
+        req[:offset] == block.offset
+      end
+    end
+  end
+  
+  def split_piece_payload(payload)
+    piece_index = payload.slice!(0..3).unpack("N")[0]
+    byte_offset = payload.slice!(0..3).unpack("N")[0]
+    block_data = payload
+    [piece_index, byte_offset, block_data]
+  end
+
+end

data/bin/message.rb

@@ -0,0 +1,62 @@
+class Message
+  
+  MESSAGE_TYPES = { "-1" => :keep_alive,
+                     "0" => :choke,
+                     "1" => :unchoke,
+                     "2" => :interested,
+                     "3" => :not_interested,
+                     "4" => :have,
+                     "5" => :bitfield,
+                     "6" => :request,
+                     "7" => :piece,
+                     "8" => :cancel,
+                     "9" => :port }
+  
+  attr_accessor :peer, :length, :type, :payload
+  
+  def initialize(peer, length, id, payload)
+    @peer = peer
+    @length = length
+    @type = MESSAGE_TYPES[id.to_s]
+    @payload = payload
+  end
+  
+  def self.has_payload?(id)
+    # message ids associated with payload
+    /[456789]/.match(id)
+  end
+  
+  def print
+    "index: #{ self.payload[0..3].unpack("N")}, offset: #{self.payload[4..8].unpack("N") }"
+  end
+  
+  def self.parse_stream(peer, message_queue)
+    loop do
+      begin       
+        length = peer.connection.read(4).unpack("N")[0]
+        id = length.zero? ? "-1" : peer.connection.readbyte.to_s
+        payload = has_payload?(id) ? peer.connection.read(length - 1) : nil
+        message_queue << self.new(peer, length, id, payload)
+      rescue => exception
+        puts exception
+        break
+      end
+    end
+  end
+  
+  def self.send_interested(peer)
+    length = "\0\0\0\1"
+    id = "\2"
+    peer.connection.write(length + id) 
+  end
+  
+  def self.send_have(peers, index)
+    length = "\0\0\0\5"
+    id = "\4"
+    piece_index = [index].pack("N")
+    peers.each do |peer| 
+      peer.connection.write(length + id + piece_index)
+    end
+  
+  end
+end

data/bin/meta_info.rb

@@ -0,0 +1,100 @@
+class MetaInfo
+
+  attr_accessor :info_hash, :announce, :number_of_pieces,
+                :pieces, :files, :total_size, :piece_length,
+                :pieces_hash, :folder, :download_folder
+  
+  def initialize(meta_info, download_folder)
+    @info = meta_info["info"]
+    @download_folder = download_folder
+    @piece_length = @info["piece length"]
+    @info_hash = Digest::SHA1.new.digest(@info.bencode)
+    @pieces_hash = @info["pieces"]
+    @announce = meta_info["announce"]
+    @number_of_pieces = @info["pieces"].length/20
+    set_total_size
+    set_folder
+    set_files
+    set_pieces
+  end
+
+  def set_total_size
+    if is_multi_file?
+      set_multi_file_size
+    else
+      set_single_file_size
+    end
+  end
+
+  def set_multi_file_size
+    @total_size = @info["files"].inject(0) do |start_byte, file| 
+      start_byte + file["length"]
+    end
+  end
+  
+  def set_single_file_size
+    @total_size = @info["length"]
+  end
+
+  def set_folder
+    @folder = is_multi_file? ? @info["name"] : nil
+  end
+
+  def set_files
+    @files = []
+    if is_multi_file?
+      set_multi_files
+    else
+      add_file(@info["name"], @info["length"], 0, @info["length"] - 1)
+    end
+  end
+
+  def set_multi_files
+    @info["files"].inject(0) do |start_byte, file| 
+      name, length, start_byte, end_byte = get_add_file_args(start_byte, file)
+      add_file(name, length, start_byte, end_byte)      
+      start_byte + file["length"]
+    end
+  end
+
+  def get_add_file_args(start_byte, file)
+    name = file["path"][0]
+    length = file["length"]
+    start_byte = start_byte
+    end_byte = start_byte + file["length"] - 1
+    
+    return name, length, start_byte, end_byte
+  end
+  
+  def add_file(name, length, start, fin)
+    @files << { name: name, length: length, start_byte: start, end_byte: fin }
+  end
+ 
+  def set_pieces
+    @pieces = []
+    (0...@number_of_pieces).each do |index|
+      start_byte = index * @piece_length 
+      end_byte = get_end_byte(start_byte, index)
+      hash = get_correct_hash(index)
+      @pieces << Piece.new(index, start_byte, end_byte, hash)
+    end
+  end
+
+  def get_end_byte(start_byte, index)
+    return @total_size - 1 if last_piece?(index)
+    start_byte + @piece_length - 1
+  end
+    
+  def last_piece?(index)
+    index == @number_of_pieces - 1
+  end
+
+  def get_correct_hash(index)
+    @info["pieces"][20 * index...20 * (index+1)]
+  end
+    
+  def is_multi_file?
+    !@info["files"].nil?
+  end
+  
+end

data/bin/peer.rb

@@ -0,0 +1,67 @@
+class Peer
+  
+  attr_accessor :connection, :bitfield, :state, :id, :pending_requests
+
+  def initialize(ip_string, port, handshake, correct_info_hash)
+    @pending_requests = []
+    @connection = TCPSocket.new(IPAddr.new_ntoh(ip_string).to_s, port)
+    @state = { is_choking: true, is_choked: true, is_interested: false, is_interesting: false }
+    @correct_info_hash = correct_info_hash
+    greet(handshake)
+    set_bitfield
+  end
+  
+  def greet(handshake)
+    @connection.write(handshake)
+    set_initial_response
+    verify_initial_response
+    @id = @initial_response[:peer_id]
+  end
+  
+  def set_initial_response
+    pstrlen = @connection.getbyte
+    @initial_response = { 
+       pstrlen:   pstrlen,
+       pstr:      @connection.read(pstrlen),
+       reserved:  @connection.read(8),
+       info_hash: @connection.read(20),
+       peer_id:   @connection.read(20)
+    }
+  end
+  
+  def verify_initial_response
+    disconnect unless @initial_response[:info_hash] == @correct_info_hash
+  end
+  
+  def disconnect
+    @connection.close
+  end
+  
+  def set_bitfield
+    length = @connection.read(4).unpack("N")[0]
+    message_id = @connection.read(1).bytes[0]
+    if message_id == 5
+      @bitfield = Bitfield.new(@connection.read(length - 1).unpack("B8" * (length - 1)))
+    else
+      puts "no bitfield!"
+      @bitfield = nil
+    end
+  end
+
+  def start!(message_queue)
+    Thread.new { Message.parse_stream(self, message_queue) }
+    Thread.new { keep_alive }
+    Message.send_interested(self)
+  end
+
+  def keep_alive
+    loop do
+      begin
+        @connection.write("\0\0\0\0")
+      rescue
+        puts "keep alive broken"
+      end
+      sleep(60)
+    end
+  end 
+end

data/bin/piece.rb

@@ -0,0 +1,13 @@
+class Piece
+  
+  attr_accessor :index, :start_byte, :end_byte, :length, :hash
+  
+  def initialize(index, start_byte, end_byte, hash)
+    @index = index
+    @start_byte = start_byte
+    @end_byte = end_byte
+    @length = @end_byte - @start_byte + 1
+    @hash = hash
+  end
+  
+end

data/bin/tracker.rb

@@ -0,0 +1,15 @@
+require 'uri'
+
+class Tracker
+  
+  def initialize(uri_string)
+    @uri = URI(uri_string)
+  end
+  
+  def make_request(params)
+    request = @uri
+    request.query = URI.encode_www_form(params)
+    BEncode.load(Net::HTTP.get_response(request).body)
+  end
+
+end

data/bittorrent.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'bittorrent/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "bittorrent"
+  spec.version       = Bittorrent::VERSION
+  spec.authors       = ["Karl Coelho"]
+  spec.email         = ["karl.coelho1@gmail.com"]
+  spec.summary       = %q{Bittorrent Client written in Ruby.}
+  spec.description   = %q{Bittorrent Client written in Ruby.}
+  spec.homepage      = "http://github.com/karlcoelho/bittorrent"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+end

data/lib/bittorrent.rb

@@ -0,0 +1,5 @@
+require "bittorrent/version"
+
+module Bittorrent
+  # Your code goes here...
+end

data/lib/bittorrent/version.rb

@@ -0,0 +1,3 @@
+module Bittorrent
+  VERSION = "0.0.2"
+end

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification
+name: bittorrent
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Karl Coelho
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Bittorrent Client written in Ruby.
+email:
+- karl.coelho1@gmail.com
+executables:
+- bitfield.rb
+- bittorrent
+- block.rb
+- block_request_process.rb
+- block_request_scheduler.rb
+- byte_array.rb
+- client.rb
+- file_handler.rb
+- incoming_message_process.rb
+- message.rb
+- meta_info.rb
+- peer.rb
+- piece.rb
+- tracker.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/bitfield.rb
+- bin/bittorrent
+- bin/block.rb
+- bin/block_request_process.rb
+- bin/block_request_scheduler.rb
+- bin/byte_array.rb
+- bin/client.rb
+- bin/file_handler.rb
+- bin/incoming_message_process.rb
+- bin/message.rb
+- bin/meta_info.rb
+- bin/peer.rb
+- bin/piece.rb
+- bin/tracker.rb
+- bittorrent.gemspec
+- lib/bittorrent.rb
+- lib/bittorrent/version.rb
+homepage: http://github.com/karlcoelho/bittorrent
+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.0
+signing_key: 
+specification_version: 4
+summary: Bittorrent Client written in Ruby.
+test_files: []