fargo 0.1.1 → 0.2.0

data/lib/fargo/supports/timeout.rb

@@ -1,17 +1,20 @@
 module Fargo
   module Supports
     module Timeout
-      
+
       def timeout_response timeout, succeed_subscription
         thread = Thread.current
-        subscribed_block = lambda do |*args|
+
+        subscribed_block = lambda do |args|
           thread.wakeup if succeed_subscription.call(*args)
         end
 
-        subscribe &subscribed_block
-        yield
+        id = channel.subscribe subscribed_block
+
+        yield if block_given?
         sleep timeout
-        unsubscribe &subscribed_block
+
+        channel.unsubscribe id
       end
 
     end

data/lib/fargo/supports/uploads.rb

@@ -2,15 +2,15 @@ module Fargo
   module Supports
     module Uploads
       # TODO: write this module...
-      
+
       def open_slots
         0
       end
-      
+
       def share_size
-        5368709121 # 5 GB + 1 byte    
+        5368709121 # 5 GB + 1 byte
       end
-      
+
     end
   end
-end
+end

data/lib/fargo/utils.rb

@@ -1,12 +1,13 @@
 module Fargo
   module Utils
-    
+
     # Lord knows why they're doing this...
     def generate_key lock
       lock_bytes = lock.bytes.to_a
       bytes = []
       bytes << (lock_bytes[0] ^ lock_bytes[-1] ^ lock_bytes[-2] ^ 5)
-      (1..lock.length-1).each{ |i| 
+
+      (1..lock.length-1).each{ |i|
         bytes << (lock_bytes[i] ^ lock_bytes[i - 1])
       }
 
@@ -14,7 +15,7 @@ module Fargo
       bytes.each{ |b| key << encode_char(((b << 4) | (b >> 4)) & 0xff) }
       key
     end
-  
+
     # Generates a lock between 80 and 134 random characters, and a pk of 16
     # random characters. At least in theory, other clients were doing exactly
     # this, so I just mirrored them.
@@ -22,7 +23,7 @@ module Fargo
       lock = 'EXTENDEDPROTOCOL'
       [lock + ('ABC' * 6), 'ABCD' * 4]
     end
-  
+
     # Watch out for those special ones...
     def encode_char c
       if [0, 5, 36, 96, 124, 126].include? c

data/lib/fargo/version.rb

@@ -1,3 +1,3 @@
 module Fargo
-  VERSION = '0.1.1'
+  VERSION = '0.2.0'
 end

data/lib/fargo.rb

@@ -1,26 +1,26 @@
-require 'socket'
 require 'fileutils'
+require 'eventmachine'
 require 'active_support/dependencies/autoload'
 require 'active_support/core_ext/module/attribute_accessors'
 require 'active_support/buffered_logger'
 require 'active_support/concern'
+require 'active_support/configurable'
 
 module Fargo
   extend ActiveSupport::Autoload
 
   class ConnectionException < RuntimeError; end
-  
+
   mattr_accessor:logger
   self.logger = ActiveSupport::BufferedLogger.new STDOUT
 
-  autoload :Utils  
-  autoload :Publisher
+  autoload :Utils
   autoload :Parser
-  autoload :Server
   autoload :Client
   autoload :Search
   autoload :SearchResult
   autoload :VERSION
+  autoload :TTH
 
   module Supports
     extend ActiveSupport::Autoload
@@ -35,14 +35,12 @@ module Fargo
     autoload :FileList
   end
 
-  module Connection
+  module Protocol
     extend ActiveSupport::Autoload
 
-    autoload :Base
+    autoload :DC
     autoload :Download
     autoload :Hub
-    autoload :Search
-    autoload :Upload
   end
 
-end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: fargo
 version: !ruby/object:Gem::Version 
-  hash: 25
+  hash: 23
   prerelease: false
   segments: 
   - 0
-  - 1
-  - 1
-  version: 0.1.1
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Alex Crichton
@@ -15,11 +15,25 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-22 00:00:00 -04:00
+date: 2010-09-27 00:00:00 -04:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
   version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id001
+  type: :runtime
+  name: eventmachine
+  prerelease: false
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -30,12 +44,12 @@ dependencies:
         - 0
         - 0
         version: 3.0.0
-  requirement: *id001
+  requirement: *id002
   type: :runtime
   name: activesupport
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -44,12 +58,12 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  requirement: *id002
+  requirement: *id003
   type: :runtime
   name: libxml-ruby
   prerelease: false
 - !ruby/object:Gem::Dependency 
-  version_requirements: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ">="
@@ -58,7 +72,7 @@ dependencies:
         segments: 
         - 0
         version: "0"
-  requirement: *id003
+  requirement: *id004
   type: :runtime
   name: bzip2-ruby
   prerelease: false
@@ -66,23 +80,30 @@ description: Direct Connect (DC) Client implemented in pure Ruby
 email: alex@alexcrichton.com
 executables: []
 
-extensions: []
-
+extensions: 
+- ext/fargo/extconf.rb
 extra_rdoc_files: []
 
 files: 
+- ext/fargo/base32.c
+- ext/fargo/base32.h
+- ext/fargo/extconf.rb
+- ext/fargo/fargo_tth.c
+- ext/fargo/sboxes.c
+- ext/fargo/tiger.c
+- ext/fargo/tiger.h
+- ext/fargo/tigertree.c
+- ext/fargo/tigertree.h
+- ext/fargo/tth.c
+- ext/fargo/tth.h
 - lib/fargo.rb
 - lib/fargo/client.rb
-- lib/fargo/connection/base.rb
-- lib/fargo/connection/download.rb
-- lib/fargo/connection/hub.rb
-- lib/fargo/connection/search.rb
-- lib/fargo/connection/upload.rb
 - lib/fargo/parser.rb
-- lib/fargo/publisher.rb
+- lib/fargo/protocol/dc.rb
+- lib/fargo/protocol/download.rb
+- lib/fargo/protocol/hub.rb
 - lib/fargo/search.rb
 - lib/fargo/search_result.rb
-- lib/fargo/server.rb
 - lib/fargo/supports/chat.rb
 - lib/fargo/supports/downloads.rb
 - lib/fargo/supports/file_list.rb
@@ -102,6 +123,7 @@ rdoc_options:
 - --charset=UTF-8
 require_paths: 
 - lib
+- ext
 required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
   requirements: 

data/lib/fargo/connection/base.rb

@@ -1,126 +0,0 @@
-require 'active_support/configurable'
-require 'active_support/callbacks'
-
-module Fargo
-  class ConnectionError < RuntimeError; end
-
-  module Connection
-    class Base
-
-      include ActiveSupport::Configurable
-      include ActiveSupport::Callbacks
-      include Fargo::Publisher
-
-      attr_accessor :socket
-      define_callbacks :listen
-
-      def initialize client
-        @outgoing = Queue.new
-        @client   = client
-        config.quit_on_disconnect = true
-      end
-
-      def connect
-        Fargo.logger.info(
-          "#{self}: Opening connection with #{config.address}, #{config.port}"
-        )
-
-        open_socket
-        listen
-
-        connection_type = self.class.name.split('::').last.downcase
-        @client.publish :"#{connection_type}_connection_opened"
-      end
-
-      def receive
-        raise 'Implement me!'
-      end
-
-      def open_socket
-        @socket ||= TCPSocket.open config.address, config.port
-      rescue Errno::ECONNREFUSED
-        raise Fargo::ConnectionError.new "Couldn't open a connection to #{config.address}:#{config.port}"
-      end
-
-      def connected?
-        !@socket.nil? && !@socket.closed?
-      end
-
-      def listen
-        return unless @threads.nil? || @threads.size == 0
-
-        run_callbacks :listen do
-          @threads = []
-          @looping = true
-
-          # Start a thread to read the socket
-          @threads << Thread.start { read_data while @looping }
-
-          # Start a thread to send information from the queue
-          @threads << Thread.start { write_data @outgoing.pop while @looping }
-
-          @threads.each { |t| t.abort_on_exception = true }
-        end
-      end
-
-      def disconnect
-        Fargo.logger.debug "#{self}: Disconnecting connection"
-
-        write "$Quit #{@client.config.nick}" if config.quit_on_disconnect
-
-        @looping = false
-
-        if @threads
-          @threads.each{ |t| t.exit unless t == Thread.current }
-          @threads.clear
-        end
-
-        if @socket
-          begin
-            @socket.close
-          rescue => e
-            Fargo.logger.error "Error closing socket: #{e}"
-          end
-        end
-
-        @socket = nil
-        @outgoing.clear
-
-        connection_type = self.class.name.split('::').last.downcase
-        @client.publish :"#{connection_type}_disconnected"
-      end
-
-      def write string
-        string << '|' unless string.end_with?('|')
-        @outgoing << string # append this to the queue of things to be written
-        true
-      end
-
-      private
-
-      def read_data
-        data = @socket.gets '|'
-        raise ConnectionError.new('Received nil data!') if data.nil?
-
-        Fargo.logger.debug "#{self} Received: #{data.inspect}"
-        receive data.chomp('|')
-      rescue => e
-        unless @socket.closed?
-          Fargo.logger.warn "#{self}: Error reading data, going away: #{e}"
-          disconnect
-        end
-      end
-
-      def write_data data
-        Fargo.logger.debug "#{self} Sending: #{data.inspect}"
-        @socket << data
-      rescue => e
-        unless @socket.closed?
-          Fargo.logger.warn "#{self}: Error writing data, going away: #{e}"
-          disconnect
-        end
-      end
-
-    end
-  end
-end

data/lib/fargo/connection/hub.rb

@@ -1,120 +0,0 @@
-module Fargo
-  module Connection
-    class Hub < Base
-
-      include Fargo::Utils
-      include Fargo::Parser
-      
-      attr_reader :hubname
-      
-      configure do |config|
-        config.address = '127.0.0.1'
-        config.port    = 7314
-      end
-
-      # See <http://www.teamfair.info/DC-Protocol.htm> for specifics on 
-      # the DC protocol
-      def receive data
-        message = parse_message data
-
-        case message[:type]
-          when :lock 
-            @validated = false
-            write "$Key #{generate_key message[:lock]}"
-          when :hubname
-            @hubname = message[:name]
-            write "$ValidateNick #{@client.config.nick}" unless @validated
-          when :getpass
-            write "$MyPass #{@client.password}"
-          when :badpass, :hubfull
-            Fargo.logger.warn "Disconnecting because of: #{message.inspect}"
-            disconnect
-          when :hello
-            if message[:who] == @client.config.nick
-              Fargo.logger.info "Connected to DC Hub #{@hubname} (#{config.address}:#{config.port})"
-              @validated = true
-
-              write '$Version 1,0091'
-              write '$GetNickList'
-              write "$MyINFO $ALL #{@client.config.nick} " +
-                "#{@client.description}$ $#{@client.config.speed || 'DSL'}" + 
-                "#{@status || 1.chr}$#{@client.config.email}" +
-                "$#{@client.share_size}$"
-            end
-            
-          when :connect_to_me
-            if !@client.nicks.include?(message[:nick])
-              Fargo.logger.info "Invalid connect_to_me request from: #{message[:nick]}"
-              return
-            end
-
-            @client_connections ||= []
-            
-            connection = Fargo::Connection::Download.new @client
-            connection.config.address = message[:address]
-            connection.config.port    = message[:port]
-            # we're going to initiate the download
-            connection.config.first   = true
-
-            # proxy all messages from them back to the client and delete the
-            # connection if necessary
-            connection.subscribe { |*args|
-              @client.publish *args
-              @client_connections.delete connection unless connection.connected?
-            }
-            
-            # establish the connection. This will also listen for data to be
-            # read/written
-            connection.connect
-            
-            # keep track of who we're downloading from
-            @client_connections << connection
-            
-          when :search
-            # Make sure we received a valid search request
-            if message[:searcher].nil? || !@client.nicks.include?(message[:searcher])
-              Fargo.logger.info "Invalid search request: #{message.inspect}"
-              return
-            end
-            
-            # Let the client handle the results
-            @results = @client.search_files message
-            
-            # Send all the results to the peer. Take care of active/passive
-            # connections
-            @results.each { |r| 
-              if message[:address]
-                r.active_send @client.config.nick, message[:ip], message[:port]
-              else
-                write "$SR #{@client.config.nick} #{r}" 
-              end
-            }
-
-          when :revconnect
-            # TODO: Don't send RevConnectToMe when we're passive and 
-            # receiving is passive
-            if @client.config.passive
-              write "$RevConnectToMe #{@client.config.nick} #{message[:who]}"
-            else
-              write "$ConnectToMe #{@client.config.nick} #{@client.config.address}:#{@client.config.extport}"
-            end
-            
-          # proxy this message on up the stack if we don't handle it
-          else
-            @client.publish message[:type], message
-            
-        end
-      end
-      
-      def disconnect
-        if @client_connections
-          @client_connections.each &:disconnect
-          @client_connections.clear
-        end
-
-        super
-      end
-
-    end # Hub
-  end # Connection
-end # Fargo

data/lib/fargo/connection/search.rb

@@ -1,19 +0,0 @@
-module Fargo
-  module Connection
-    class Search < Base
-
-      # maybe do something special here at some point?
-      # this is currently just receiving the search result packets over UDP
-      # and fowarding them to the client who will handle them. This doesn't
-      # explicitly disconnect because I'm not sure if multiple results
-      # are sent. This connection will close itself because there will
-      # be a read error I think...
-      def receive data
-        message = parse_message data
-        
-        @client.publish message[:type], message
-      end
-  
-    end
-  end
-end

data/lib/fargo/connection/upload.rb

@@ -1,85 +0,0 @@
-# TODO: actually get this class to work in some fashion
-module Fargo
-  module Connection
-    class Upload < Base
-      
-      include Fargo::Utils
-      include Fargo::Parser
-  
-      def post_listen
-        @lock, @pk = generate_lock
-        write "$MyNick #{self[:nick]}|$Lock #{@lock} Pk=#{@pk}"
-        @handshake_step = 0
-      end
-  
-      def supports
-        "$Supports BZList TTHL TTHF" # ???
-      end
-      
-      def receive data
-        message = parse_message data
-        publish message[:type], message
-        case message[:type]
-          when :mynick
-            if @handshake_step == 0
-              @remote_nick = message[:nick]
-              @handshake_step = 1
-            else
-              disconnect
-            end
-          when :lock
-            if @handshake_step == 1
-              @remote_lock = message[:lock]
-              @handshake_step = 2
-            else
-              disconnect
-            end
-          when :supports
-            if @handshake_step == 2
-              @remote_extensions = message[:extensions]
-              @handshake_step = 3
-            else
-              disconnect
-            end
-          when :direction
-            if @handshake_step == 3 && message[:direction] == 'download'
-              @handshake_step = 4
-              @client_num = message[:number]
-            else
-              disconnect
-            end
-          when :key
-            if @handshake_step == 4 && generate_key(@lock) == message[:key]
-              write supports
-              write "$Direction Download #{@my_num = rand 10000}"
-              write "$Key #{generate_key @remote_lock}"
-              @handshake_step = 5
-            else
-              disconnect
-            end
-          when :get
-            if @handshake_step == 5
-              @filepath = message[:path]
-              @offset = message[:offset]
-              write "$FileLength #{file_length}"
-              @handshake_step = 5
-            else
-              disconnect
-            end
-          when :send
-            write_chunk if @handshake_step == 5
-        
-          else
-            # Fargo.logger.warn "Ignoring `#{data}'\n"
-        end
-      end
-  
-      def write_chunk
-      end
-  
-      def file_length
-      end
-  
-    end
-  end
-end

data/lib/fargo/publisher.rb

@@ -1,42 +0,0 @@
-module Fargo
-  module Publisher
-
-    attr_reader :subscribers
-
-    def subscribe &subscriber
-      raise RuntimeError.new('Need a subscription block!') if subscriber.nil?
-
-      Fargo.logger.debug "#{self}: subscribing #{subscriber}"
-      (@subscribers ||= []) << subscriber
-    end
-
-    def subscribed_to?
-      @subscribers && @subscribers.size > 0
-    end
-
-    def unsubscribe &subscriber
-      raise RuntimeError.new('Need a subscription block!') if subscriber.nil?
-
-      Fargo.logger.debug "#{self}: unsubscribing #{subscriber}"
-      (@subscribers ||= []).delete subscriber
-    end
-
-    def publish message_type, hash = {}
-      @subscribers ||= []
-
-      to_remove = []
-
-      @subscribers.each do |subscriber|
-        begin
-          subscriber.call message_type, hash
-        rescue => e
-          Fargo.logger.warn "#{self}: error publishing to: #{subscriber}! #{e}"
-          to_remove << subscriber
-        end
-      end
-
-      @subscribers -= to_remove
-    end
-
-  end
-end