fargo 0.1.0

data/lib/fargo/client.rb

@@ -0,0 +1,161 @@
+require 'active_support/callbacks'
+require 'active_support/configurable'
+require 'active_support/core_ext/object/try'
+
+module Fargo
+  class Client
+
+    include ActiveSupport::Callbacks
+    include ActiveSupport::Configurable
+
+    define_callbacks :setup
+
+    include Fargo::Publisher
+    include Fargo::Supports::Chat
+    include Fargo::Supports::Uploads
+    include Fargo::Supports::NickList
+    include Fargo::Supports::Searches
+    include Fargo::Supports::Downloads
+    include Fargo::Supports::Persistence
+    include Fargo::Supports::Timeout
+    include Fargo::Supports::FileList
+
+    # Options
+    #   :hub_port
+    #   :hub_address
+    #   :search_port
+    #   :active_port
+    #   :nick
+    #   :password
+    #   :email
+    #   :speed
+    #   :passive
+    #   :download_slots
+    #   :download_dir
+    #   :slots
+    configure do |config|
+      config.download_dir = '/tmp/fargo/downloads'
+      config.version      = '0.75'
+      # default the address to the address of this machine
+      config.address      = IPSocket.getaddress(Socket.gethostname)
+      config.passive      = true
+      config.nick         = 'fargo'
+    end
+
+    attr_reader :hub, :searcher, :active_server
+
+    def initialize
+      @connection_timeout_threads = {}
+    end
+
+    # Don't do this in initialization so we have time to set all the options
+    def setup
+      @hub = Fargo::Connection::Hub.new self
+      @hub.config.port    = config.hub_port if config.hub_port
+      @hub.config.address = config.hub_address if config.hub_address
+
+      unless config.passive
+        # TODO: get this working again
+        # Always create a search connection for this.
+        # searcher_options = new_options.merge :port => search_port,
+        #                                      :connection => Fargo::Connection::Search
+        # @searcher    = Fargo::Server.new searcher_options
+        #
+        # # For now, being active means that you can only download things. Always make a
+        # # connection which downloads things.
+        # active_options     = new_options.merge :port => active_port,
+        #                                        :connection => Fargo::Connection::Download
+        # @active_server = Fargo::Server.new active_options
+      end
+
+      run_callbacks :setup
+    end
+
+    def get_info nick
+      hub.write "$GetINFO #{nick} #{config.nick}"
+    end
+
+    def get_ip *nicks
+      hub.write "$UserIP #{nicks.flatten.join '$$'}"
+    end
+
+    def connect_with nick
+      @connection_timeout_threads[nick] = Thread.start do
+        sleep 10
+        connection_timeout! nick
+      end
+
+      if config.passive
+        hub.write "$RevConnectToMe #{self.config.nick} #{nick}"
+      else
+        hub.write "$ConnectToMe #{nick} #{config.address}:#{config.active_port}"
+      end
+    end
+
+    def connected_with! nick
+      return unless @connection_timeout_threads.has_key?(nick)
+      @connection_timeout_threads.delete(nick).exit
+    end
+
+    def connect
+      setup if hub.nil?
+
+      # connect all our associated servers
+      hub.connect
+
+      unless config.passive
+        searcher.connect
+        active_server.connect
+      end
+
+      true
+    end
+
+    def connected?
+      hub.try :connected?
+    end
+
+    def disconnect
+      return if hub.nil?
+
+      Fargo.logger.info "Disconnecting from hub."
+      hub.disconnect
+      unless config.passive
+        searcher.disconnect
+        active_server.disconnect
+      end
+    end
+
+    def search_hub query
+      raise ConnectionError.new('Not connected Yet!') if hub.nil?
+
+      if config.passive
+        location = "Hub:#{config.nick}"
+      else
+        location = "#{config.address}:#{config.search_port}"
+      end
+
+      hub.write "$Search #{location} #{query.to_s}"
+    end
+
+    # see hub/parser#@@search for what's passed in
+    # searches this client's files based on those options and returns an array
+    # of SearchResult(s)
+    def search_files options
+      # TODO: implement me
+      []
+    end
+
+    def description
+      "<++ V:#{config.version},M:#{config.passive ? 'P' : 'A'},H:1/0/0,S:#{open_slots},Dt:1.2.0/W>"
+    end
+
+    private
+
+    def connection_timeout! nick
+      @connection_timeout_threads.delete(nick)
+      publish :connection_timeout, :nick => nick
+    end
+
+  end
+end

data/lib/fargo/connection/base.rb

@@ -0,0 +1,133 @@
+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?
+      end
+
+      def listen
+        return unless @threads.nil? || @threads.size == 0
+        
+        run_callbacks :listen do
+          @threads = []
+
+          # Start a thread to read the socket
+          @threads << Thread.start { loop { read_data } }
+
+          # Start a thread to send information from the queue
+          @threads << Thread.start { loop { write_data @outgoing.pop } }
+
+          @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
+
+        if @threads
+          @threads.each &:exit
+          @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
+        if @socket.closed?
+          Fargo.logger.debug 'When reading data, socket was already closed!'
+          disconnect
+        else
+          begin
+            data = @socket.gets '|'
+            raise ConnectionError.new("Received nil data!") if data.nil?
+          rescue => e
+            Fargo.logger.warn "#{self}: Error reading data, disconnecting: #{e}"
+            disconnect
+          end
+
+          Fargo.logger.debug "#{self} Received: #{data.inspect}" 
+          receive data.chomp('|')
+        end
+      end
+
+      def write_data data
+        if @socket.closed?
+          Fargo.logger.debug "When writing data, socket was already closed!"
+          disconnect
+        else
+          begin
+            Fargo.logger.debug "#{self} Sending: #{data.inspect}" 
+            @socket << data
+          rescue
+            @client.publish :write_error
+            disconnect
+          end
+        end
+      end
+    
+    end
+  end
+end

data/lib/fargo/connection/download.rb

@@ -0,0 +1,302 @@
+require 'zlib'
+
+module Fargo
+  module Connection
+    class Download < Base
+      
+      include Fargo::Utils
+      include Fargo::Parser
+      
+      set_callback :listen, :before, :pre_listen
+      set_callback :listen, :after do |connection|
+        send_lock if connection.config.first
+      end
+      
+      attr_accessor :download
+
+      def pre_listen
+        Fargo.logger.debug "Initiating connection on: #{config.address}:#{config.port}"
+        
+        config.quit_on_disconnect = false
+        @lock, @pk = generate_lock
+        @handshake_step = 0
+        
+        @buffer_size = (2 << 12).freeze
+      end
+
+      def send_lock
+        write "$MyNick #{@client.config.nick}|$Lock #{@lock} Pk=#{@pk}"
+      end
+
+      def read_data
+        # only download if we're at the correct time
+        return super if @handshake_step != 6 
+
+        @exit_time = 20 # reset our timeout time
+        
+        data = @socket.readpartial @buffer_size
+        
+        if @zlib
+          @zs = Zlib::Inflate.new if @zs.nil?
+          data = @zs.inflate data
+        end
+        
+        @file << data
+        @recvd += data.length
+
+        if @recvd == @length
+          download_finished!
+        elsif @recvd > @length
+          error "#{self} #{@recvd} > #{@length}!!!"
+          download_finished!
+        else
+          publish :download_progress, :percent    => @recvd.to_f / @length, 
+                                      :file       => download_path, 
+                                      :nick       => @other_nick, 
+                                      :download   => @download,
+                                      :size       => @length, 
+                                      :compressed => @zlib
+        end
+      rescue IOError => e
+        error "#{self}: IOError, disconnecting #{e}"
+      end
+
+      def receive data
+        message = parse_message data
+
+        case message[:type]
+          when :mynick
+            if @handshake_step == 0
+              @handshake_step  = 1 
+              @other_nick      = message[:nick]
+
+              @client.connected_with! @other_nick
+              @client.lock_connection_with! @other_nick, self
+              @download = @client.lock_next_download! @other_nick, self
+
+              if @download.try(:file).nil?
+                error "Nothing to download from:#{@other_nick}!"
+              end
+            else
+              error 'Premature disconnect when mynick received'
+            end
+
+          when :lock
+            if @handshake_step == 1
+              @remote_lock = message[:lock]
+              @handshake_step = 2
+              send_lock unless config.first
+              out = ''
+              out << '$Supports TTHF ADCGet ZLIG|'
+              out << "$Direction Download #{@my_num = rand(10000)}|"
+              out << "$Key #{generate_key @remote_lock}|"
+              write out
+            else
+              error 'Premature disconnect when lock received'
+            end
+            
+          when :supports
+            if @handshake_step == 2
+              @client_extensions = message[:extensions]
+              @handshake_step    = 3
+            else
+              error 'Premature disconnect when supports received'
+            end
+            
+          when :direction
+            if @handshake_step == 3 && message[:direction] == 'upload'
+              @client_num     = message[:number]
+              @handshake_step = 4
+            else
+              error 'Premature disconnect when direction received'
+            end
+            
+          when :key
+            if @handshake_step == 4 && generate_key(@lock) == message[:key]
+
+              FileUtils.mkdir_p File.dirname(download_path), :mode => 0755
+
+              begin_download!
+
+            else
+              error 'Premature disconnect when key received'
+            end
+
+          when :file_length, :adcsnd
+            if @handshake_step == 5
+              @recvd          = 0
+              @handshake_step = 6
+
+              @zlib   = message[:zlib]
+              @length = message[:size]
+
+              write "$Send" unless @client_extensions.include? 'ADCGet'
+
+              publish :download_started, :file     => download_path, 
+                                         :download => @download, 
+                                         :nick     => @other_nick   
+            else
+              error "Premature disconnect when #{message[:type]} received"
+            end
+
+          when :noslots
+            if @download
+              Fargo.logger.debug "#{self}: No Slots for #{self[:download]}"
+              
+              download_failed! 'No Slots'
+            end
+
+          when :error
+            error "#{self}: Error! #{message[:message]}"
+          
+          # This wasn't handled by us, proxy it on up to the client  
+          else
+            @client.publish message[:type], message
+
+        end
+      end
+      
+      def begin_download!
+        @file = File.new download_path, File::CREAT | File::WRONLY
+
+        @file.seek @download.offset
+        @file.sync      = true
+        @socket.sync    = true
+        @handshake_step = 5
+
+        if @download.file_list?
+          if @client_extensions.include? 'XmlBZList'
+            @download.file = 'files.xml.bz2'
+          elsif @client_extensions.include? 'BZList'
+            @download.file = 'MyList.bz2'
+          else
+            @download.file = 'MyList.DcLst' # TODO: support this?
+          end
+        end
+
+        if @client_extensions.include? 'ADCGet'
+          download_query = @download.file
+          if @download.tth && @client_extensions.include?('TTHF')
+            download_query = @download.tth.gsub ':', '/'
+          end
+
+          zlig = ''
+          if @client_extensions.include? 'ZLIG'
+            zlig = 'ZL1'
+            Fargo.logger.debug "Enabling zlib compression on: #{@download.file}"
+          end
+
+          write "$ADCGET file #{download_query} #{@download.offset} #{@download.size} #{zlig}"
+        else
+          write "$Get #{@download.file}$#{@download.offset + 1}"
+        end
+
+        # This is the thread for the timeout of a connection. The @exit_time
+        # variable is reset to 20 after every bit of information is received.
+        @exit_time = 20
+        @exit_thread = Thread.start { 
+          while @exit_time > 0
+            sleep 1
+            @exit_time -= 1
+            Fargo.logger.debug "#{self} time out in #{@exit_time} seconds"
+          end
+
+          download_failed! 'Download timeout!' 
+        }
+        
+        Fargo.logger.debug "#{self}: Beginning download of #{@download}"
+      end
+      
+      def download_failed! msg, opts = {}
+        Fargo.logger.debug "#{self}: #{msg} #{@download}"
+        
+        # cache because publishing must be at end of method and we're about to
+        # clear these
+        path, download = download_path, @download
+
+        reset_download
+
+        publish :download_failed, opts.merge(:nick => @other_nick, 
+                                             :download   => download, 
+                                             :file       => path, 
+                                             :last_error => msg)
+
+        @exit_thread = nil
+      end
+      
+      def download_finished!
+        Fargo.logger.debug "#{self}: Finished download of #{@download}"
+        
+        # cache because publishing must be at end of method and we're about to
+        # clear these
+        path, download = download_path, @download
+        
+        reset_download
+        
+        publish :download_finished, :file => path, :download => download, 
+                                    :nick => @other_nick
+      end
+      
+      def disconnect
+        Fargo.logger.debug "#{self} Disconnecting from: #{@other_nick}"
+        
+        super
+
+        if @download
+          download_failed! @last_error, :recvd => @recvd, :length => @length
+        end
+        
+        reset_download
+      end
+     
+      private
+      def reset_download
+        @file.close unless @file.nil? || @file.closed?
+        if @file_path && File.exists?(@file_path) && File.size(@file_path) == 0
+          File.delete(@file_path) 
+        end
+
+        if @socket
+          @socket.sync = false
+          @socket.flush
+        end
+
+        # If this was called from exit thread, don't kill it
+        if @exit_thread != Thread.current 
+          @exit_thread.exit if @exit_thread && @exit_thread.alive?
+          @exit_thread = nil
+        end
+        
+        # clear out these variables
+        @zs = @file_path = @zlib = @download = @length = @recvd = nil        
+
+        # Go back to the get step
+        @handshake_step = 5
+      end
+  
+      def download_path
+        return nil if @download.try(:file).nil?
+
+        @file_path ||= begin
+          prefix   = @client.config.download_dir
+          filename = File.basename @download.file.gsub("\\", '/')
+          path     = File.join(prefix, @other_nick, filename)
+
+          i = 0
+          while File.exists?(path)
+            i += 1
+            path = File.join(prefix, @other_nick, "#{i}-#{filename}")
+          end
+
+          path
+        end
+      end
+
+      def error message
+        Fargo.logger.warn @last_error = message
+        disconnect
+      end
+
+    end
+  end
+end

data/lib/fargo/connection/hub.rb

@@ -0,0 +1,120 @@
+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