fargo 0.1.0

data/lib/fargo/connection/search.rb

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

@@ -0,0 +1,85 @@
+# 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/parser.rb

@@ -0,0 +1,121 @@
+module Fargo
+  module Parser
+  
+    #
+    # See <http://www.teamfair.info/DC-Protocol.htm> for more information
+    #
+    @@commandmatch    = /\$(.*)$/
+    @@messagematch    = /^<(.*?)> (.*)$/
+  
+    # TODO: Supports, UserIP, ops command
+    # Client - hub commands
+    @@validatedenied  = /^ValidateDenide/
+    @@getpass         = /^GetPass$/
+    @@badpass         = /^BadPass$/
+    @@lock            = /^Lock (.*) Pk=.*?$/
+    @@userip          = /^UserIP (.*)$/
+    @@hubname         = /^HubName (.*)$/
+    @@hubfull         = /^HubIsFull$/
+    @@hubtopic        = /^HubTopic (.*)$/
+    @@hello           = /^Hello (.*)$/
+    @@myinfo          = /^MyINFO \$ALL (.*?) (.*?)\$ \$(.*?).\$(.*?)\$(.*?)\$/
+    @@myinfo2         = /^MyINFO \$ALL (.*?) (.*?)\$$/
+    @@to              = /^To: (.*?) From: (.*?) \$<.*?> (.*)$/
+    @@hubto           = /^To: (.*?) From: Hub \$(.*)$/
+    @@ctm             = /^ConnectToMe (.*?) (.*?):(.*?)$/
+    @@nicklist        = /^NickList (.*?)$/
+    @@psr             = /^SR (.*?) (.*?)\005(.*?) (.*?)\/(.*?)\005(.*?) \((.*?):(.*?)\)$/
+    @@psearch         = /^Search Hub:(.*) (.)\?(.)\?(.*)\?(.)\?(.*)$/
+    @@search          = /^Search (.*):(.*) (.)\?(.)\?(.*)\?(.)\?(.*)$/
+    @@oplist          = /^OpList (.*?)$/
+    @@botlist         = /^BotList (.*?)$/
+    @@quit            = /^Quit (.*)$/
+    @@sr              = /^SR (.*?) (.*?)\005(.*?) (.*?)\/(.*?)\005(.*?) (.*?):(.*?)$/
+    @@rctm            = /^RevConnectToMe (.*?) (.*?)$/
+  
+    # Client to client commands
+    @@mynick        = /^MyNick (.*)$/
+    @@key           = /^Key (.*)$/
+    @@direction     = /^Direction (Download|Upload) (\d+)$/
+    @@get           = /^Get (.*)\$(\d+)$/
+    @@send          = /^Send$/
+    @@filelength    = /^FileLength (.*?)$/
+    @@getlistlen    = /^GetListLen$/
+    @@maxedout      = /^MaxedOut$/
+    @@supports      = /^Supports (.*)$/
+    @@error         = /^Error (.*)$/
+    @@ugetblock     = /^UGetBlock (.*?) (.*?) (.*)$/
+    @@adcsnd        = /^ADCSND (.*?) (.*?) (.*?) (.*?)$/
+    @@adcsnd_zl1    = /^ADCSND (.*?) (.*?) (.*?) (.*?) ZL1$/
+  
+    def parse_message text
+      case text
+        when @@commandmatch then parse_command_message $1
+        when @@messagematch then {:type => :chat, :from => $1, :text => $2}
+        when ''             then {:type => :garbage}
+        else                     {:type => :mystery, :text => text}
+      end
+    end
+
+    def parse_command_message text
+      case text
+        when @@validatedenied then {:type => :denide}
+        when @@getpass        then {:type => :getpass}
+        when @@badpass        then {:type => :badpass}
+        when @@lock           then {:type => :lock, :lock => $1}
+        when @@hubname        then {:type => :hubname, :name => $1}
+        when @@hubname        then {:type => :hubfull}
+        when @@hubtopic       then {:type => :hubtopic, :topic => $1}
+        when @@hello          then {:type => :hello, :who  => $1}
+        when @@myinfo         then {:type => :myinfo, :nick => $1, :interest => $2, :speed => $3,
+                                    :email => $4, :sharesize => $5.to_i}
+        when @@myinfo2        then {:type => :myinfo, :nick=> $1, :interest => $2, :sharesize=> 0}
+        when @@to             then {:type => :privmsg, :to => $1, :from => $2, :text => $3}
+        when @@hubto          then {:type => :privmsg, :to => $1, :from => "Hub", :text => $2}
+        when @@ctm            then {:type => :connect_to_me, :nick => $1, :address => $2, 
+                                    :port => $3.to_i}
+        when @@nicklist       then {:type => :nick_list, :nicks => $1.split(/\$\$/)}
+        when @@psr            then {:type => :search_result, :nick => $1, :file => $2, 
+                                    :size => $3.to_i, :open_slots => $4.to_i, :slots => $5.to_i, 
+                                    :hub => $6, :address => $7, 
+                                    :port => $8.to_i}
+        when @@psearch        then {:type => :search, :searcher => $1, :restrict_size => $2,
+                                    :min_size => $3.to_i, :size => $4.to_i, :filetype => $5, 
+                                    :pattern => $6}
+        when @@search         then {:type => :search, :address => $1, :port => $2.to_i, 
+                                    :restrict_size => $3,
+                                    :min_size => $4.to_i, :size => $5.to_i, :filetype => $6, 
+                                    :pattern => $7}
+        when @@oplist         then {:type => :op_list, :nicks => $1.split(/\$\$/)}
+        when @@oplist         then {:type => :bot_list, :nicks => $1.split(/\$\$/)}
+        when @@quit           then {:type => :quit, :who => $1}
+        when @@sr             then {:type => :search_result, :nick => $2, :file => $3, 
+                                    :size => $4.to_i, :open_slots => $5.to_i, :slots => $6.to_i, 
+                                    :hubname => $7}
+        when @@rctm           then {:type => :revconnect, :who => $1}
+        
+        when @@mynick         then {:type => :mynick, :nick => $1}
+        when @@key            then {:type => :key, :key => $1}
+        when @@direction      then {:type => :direction, :direction => $1.downcase, :number => $3.to_i}
+        when @@get            then {:type => :get, :path => $1, :offset => $2.to_i - 1}
+        when @@send           then {:type => :send}
+        when @@filelength     then {:type => :file_length, :size => $1.to_i}
+        when @@getlistlen     then {:type => :getlistlen}
+        when @@maxedout       then {:type => :noslots}
+        when @@supports       then {:type => :supports, :extensions => $1.split(' ')}
+        when @@error          then {:type => :error, :message => $1}
+        when @@adcsnd_zl1      then {:type => :adcsnd, :kind => $1, :tth => $2, :offset => $3.to_i, 
+                                    :size => $4.to_i, :zlib => true}
+        when @@adcsnd         then {:type => :adcsnd, :kind => $1, :tth => $2, :offset => $3.to_i, 
+                                                              :size => $4.to_i}
+        when @@ugetblock      then {:type => :ugetblock, :start => $1.to_i, :finish => $2.to_i,
+                                    :path => $3}
+        when @@userip         then 
+          h = {:type => :userip, :users => {}}
+          $1.split("$$").map{ |s| h[:users][s.split(' ')[0]] = s.split(' ')[1]}
+          h
+        else                       {:type => :mystery, :text => text}
+      end
+    end
+  end
+end

data/lib/fargo/publisher.rb

@@ -0,0 +1,26 @@
+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.each { |subscriber| subscriber.call message_type, hash } if @subscribers
+    end
+  end
+end

data/lib/fargo/search.rb

@@ -0,0 +1,61 @@
+module Fargo
+  class Search
+    
+    ANY        = 1
+    AUDIO      = 2
+    COMPRESSED = 3
+    DOCUMENT   = 4
+    EXECUTABLE = 5
+    VIDEO      = 7
+    FOLDER     = 8
+  
+    attr_accessor :size_restricted, :is_minimum_size, :size, :filetype, :pattern
+  
+    def initialize opts = {}
+      self.size_restricted = opts[:size_restricted]
+      self.is_minimum_size = opts[:is_minimum_size]
+      self.size = opts[:size]
+      self.filetype = opts[:filetype] || ANY
+      if opts[:pattern]
+        self.pattern = opts[:pattern]
+      elsif opts[:query]
+        self.query = opts[:query]
+      end
+    end
+  
+    def query= query
+      @pattern = query.split(' ').join('$')
+    end
+    
+    def queries
+      pattern.split("$")
+    end
+
+    def query
+      pattern.gsub('$', ' ')
+    end
+    
+    def matches_result? map
+      file = map[:file].downcase
+      matches_query = queries.inject(true) { |last, word| last && file.index(word.downcase) }
+      if size_restricted == 'T'
+        if is_minimum_size 
+          matches_query && map[:size] > size
+        else
+          matches_query && map[:size] < size
+        end
+      else
+        matches_query
+      end
+    end
+
+    def to_s
+      if size_restricted
+        "#{size_restricted ? 'T' : 'F' }?#{!size_restricted || is_minimum_size ? 'T' : 'F'}?#{size || 0}?#{filetype}?#{pattern}"      
+      else
+        "F?T?#{size || 0}?#{filetype}?#{pattern}"
+      end
+    end
+  
+  end
+end

data/lib/fargo/search_result.rb

@@ -0,0 +1,31 @@
+module Fargo
+  class SearchResult
+
+    # Needs :file, :filesize, :client, :target (if passive)
+    def initialize file, filesize, client, target = nil
+      @file, @filesize, @client, @target = file, filesize, client, target
+    end
+
+    def to_s
+      file = @file.gusb '/', "\\"
+      if File.directory? @file
+        s = file
+      else
+        s = "#{file}\005#{@filesize}"
+      end
+
+      s << sprintf(" %d/%d\005%s (%s:%d)", @client.open_slots,
+                                           @client.slots,
+                                           @client.hub.hubname,
+                                           @client.hub.config.ip,
+                                           @client.hub.config.port)
+      s << "\005#{@target}" if @client.config.passive
+    end
+
+    def active_send nick, ip, port
+      socket = UDPSocket.new
+      socket.send "$SR #{nick} #{to_s}", 0, ip, port
+      socket.close
+    end
+  end
+end

data/lib/fargo/server.rb

@@ -0,0 +1,52 @@
+module Fargo
+  class Server
+    
+    include Fargo::Publisher
+  
+    def initialize options = {}
+      @options = options
+      @options[:address] = '0.0.0.0'
+      @peers = []
+    end
+    
+    def connected?
+      !@server.nil?
+    end
+
+    def connect
+      return if connected?
+      
+      Fargo.logger.info "#{self}: Starting server on #{@options[:address]}:#{@options[:port]}"
+
+      @server = TCPServer.new @options[:address], @options[:port]
+    
+      @active_thread = Thread.start { loop {
+        
+        connection = @options[:connection].new @options.merge(:first => false)
+        
+        connection_type = self.class.name.split("::").last.downcase
+        disconnect_symbol = :"#{connection_type}_disconnected"
+        
+        connection.subscribe{ |type, hash|
+          @peers.delete connection if type == disconnect_symbol
+        }
+        
+        connection.socket = @server.accept
+        connection.listen
+        @peers << connection
+      } }
+    end
+  
+    def disconnect
+      Fargo.logger.info "#{self}: disconnecting..."
+      @active_thread.exit if @active_thread
+      
+      @server.close if @server rescue nil
+      @server = nil
+      
+      @peers.each{ |p| p.disconnect } 
+      @peers.clear
+    end
+  
+  end
+end

data/lib/fargo/supports/chat.rb

@@ -0,0 +1,35 @@
+module Fargo
+  module Supports
+    module Chat
+      extend ActiveSupport::Concern
+      
+      included do
+        set_callback :setup, :after, :subscribe_to_chats
+      end
+
+      def messages
+        @public_chats
+      end
+
+      def messages_with nick
+        @chats[nick] if @chats
+      end
+
+      def subscribe_to_chats
+        @public_chats = []
+        @chats = Hash.new{ |h, k| h[k] = [] }
+
+        subscribe do |type, map|
+          if type == :chat
+            @public_chats << map
+          elsif type == :privmsg
+            @chats[map[:from]] << map
+          elsif type == :hub_disconnected
+            @chats.clear
+            @public_chats.clear
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fargo/supports/downloads.rb

@@ -0,0 +1,261 @@
+module Fargo
+  module Supports
+    module Downloads
+      extend ActiveSupport::Concern
+
+      class Download < Struct.new(:nick, :file, :tth, :size, :offset)
+        attr_accessor :percent, :status
+
+        def file_list?
+          file == 'files.xml.bz2'
+        end
+      end
+      
+      attr_reader :current_downloads, :finished_downloads, :queued_downloads,
+                  :failed_downloads, :open_download_slots, :trying, :timed_out,
+                  :download_slots
+      
+      included do
+        set_callback :setup, :after, :initialize_queues
+      end
+      
+      def clear_failed_downloads
+        failed_downloads.clear
+      end
+      
+      def clear_finished_downloads
+        finished_downloads.clear
+      end
+
+      def download nick, file, tth=nil, size=-1, offset=0
+        raise ConnectionException.new 'Not connected yet!' unless hub
+        raise 'File cannot be nil!' if file.nil?
+
+        unless nicks.include? nick
+          raise ConnectionException.new "User #{nick} does not exist!" 
+        end
+
+        download         = Download.new nick, file, tth, size, offset
+        download.percent = 0
+        download.status  = 'idle'
+
+        # Append it to the queue of things to download. This will be processed
+        # elsewhere
+        @to_download << download
+        true
+      end
+
+      def retry_download nick, file
+        dl = (@failed_downloads[nick] ||= []).detect{ |h| h.file == file }
+
+        if dl.nil?
+          Fargo.logger.warn "#{file} isn't a failed download for: #{nick}!"
+          return
+        end
+        
+        @failed_downloads[nick].delete dl
+        download dl.nick, dl.file, dl.tth, dl.size
+      end
+
+      def remove_download nick, file
+        # We need to synchronize this access, so append these arguments to a 
+        # queue to be processed later
+        @to_remove << [nick, file]
+        true
+      end
+
+      def lock_next_download! user, connection
+        @downloading_lock.synchronize {
+          return get_next_download_with_lock! user, connection
+        }
+      end
+
+      # If a connection timed out, retry all queued downloads for that user
+      def try_again nick
+        return false unless @timed_out.include? nick
+
+        @timed_out.delete nick
+        downloads = @failed_downloads[nick].dup
+        @failed_downloads[nick].clear
+        downloads.each{ |d| download nick, d.file, d.tth, d.size }
+
+        true
+      end
+
+      private
+
+      # Finds the next queued up download and begins downloading it.
+      def start_download
+        return false if open_download_slots == 0 || @current_downloads.size + @trying.size > download_slots
+
+        arr = nil
+
+        @downloading_lock.synchronize {
+          # Find the first nick and download list
+          arr = @queued_downloads.to_a.detect{ |nick, downloads|
+            downloads.size > 0 && 
+              !@current_downloads.has_key?(nick) && 
+              !@trying.include?(nick) && 
+              !@timed_out.include?(nick) && 
+              has_slot?(nick)
+          }
+
+          return false if arr.nil? || arr.size == 0
+          dl_nick    = arr[0]
+          connection = connection_for dl_nick
+
+          # If we already have an open connection to this user, tell that
+          # connection to download the file. Otherwise, request a connection
+          # which will handle downloading when the connection is complete.
+          if connection
+            Fargo.logger.debug "Requesting previous connection downloads: #{arr[1].first}"
+            download = get_next_download_with_lock! dl_nick, connection
+            connection.download = download
+            connection.begin_download!
+          else
+            Fargo.logger.debug "Requesting connection with: #{dl_nick} for downloading"
+            @trying << dl_nick
+            connect_with dl_nick
+          end
+        }
+
+        arr
+      end
+
+      # This method should only be called when synchronized by the mutex
+      def get_next_download_with_lock! user, connection
+        raise 'No open slots!'                    if @open_download_slots <= 0
+        raise "Already downloading from #{user}!" if @current_downloads[user]
+
+        if @queued_downloads[user].nil? || @queued_downloads[user].size == 0
+          return nil
+        end
+
+        download                 = @queued_downloads[user].shift 
+        @current_downloads[user] = download
+        @trying.delete user
+
+        Fargo.logger.debug "#{self}: Locking download: #{download}"
+
+        block = Proc.new{ |type, map|
+          Fargo.logger.debug "#{connection}: received: #{type.inspect} - #{map.inspect}"
+
+          if type == :download_progress
+            download.percent = map[:percent]
+          elsif type == :download_started
+            download.status = 'downloading'
+          elsif type == :download_finished
+            connection.unsubscribe &block
+            download.percent = 1
+            download.status = 'finished'
+            download_finished! user, false
+          elsif type == :download_failed || type == :download_disconnected
+            connection.unsubscribe &block
+            download.status = 'failed'
+            download_finished! user, true
+          end
+        }
+
+        connection.subscribe &block
+
+        download
+      end
+      
+      def download_finished! user, failed
+        download = nil
+        @downloading_lock.synchronize{ 
+          download = @current_downloads.delete user
+          @open_download_slots += 1
+        }
+
+        if failed
+          (@failed_downloads[user] ||= []) << download
+        else
+          (@finished_downloads[user] ||= []) << download
+        end
+
+        start_download # Start another download if possible
+      end
+      
+      def connection_failed_with! nick
+        @trying.delete nick
+        @timed_out << nick
+
+        @downloading_lock.synchronize {
+          @queued_downloads[nick].each{ |d| d.status = 'timeout' }
+          @failed_downloads[nick] ||= []
+          @failed_downloads[nick] = @failed_downloads[nick] | @queued_downloads[nick]
+          @queued_downloads[nick].clear
+        }
+
+        start_download # This one failed, try the next one
+      end
+
+      def initialize_queues
+        @download_slots ||= 4
+
+        FileUtils.mkdir_p config.download_dir, :mode => 0755
+
+        @downloading_lock = Mutex.new
+
+        # Don't use Hash.new{} because this can't be dumped by Marshal
+        @queued_downloads   = {}
+        @current_downloads  = {}
+        @failed_downloads   = {}
+        @finished_downloads = {}
+        @trying             = []
+        @timed_out          = []
+
+        @open_download_slots = download_slots
+
+        subscribe { |type, hash|
+          if type == :connection_timeout
+            connection_failed_with! hash[:nick] if @trying.include?(hash[:nick])
+          elsif type == :hub_disconnected
+            exit_download_queue_threads
+          elsif type == :hub_connection_opened
+            start_download_queue_threads
+          end
+        }
+      end
+
+      def exit_download_queue_threads
+        @download_starter_thread.exit
+        @download_removal_thread.exit
+      end
+
+      # Both of these need access to the synchronization lock, so we use 
+      # separate threads to do these processes.
+      def start_download_queue_threads
+        @to_download = Queue.new
+        @download_starter_thread = Thread.start {
+          loop {
+            download = @to_download.pop
+
+            if @timed_out.include? download.nick
+              download.status = 'timeout'
+              (@failed_downloads[download.nick] ||= []) << download
+            else
+              (@queued_downloads[download.nick] ||= []) << download
+              start_download
+            end
+          }
+        }
+
+        @to_remove = Queue.new
+        @download_removal_thread = Thread.start {
+          loop {
+            user, file = @to_remove.pop
+
+            @downloading_lock.synchronize {
+              @queued_downloads[user] ||= []
+              download = @queued_downloads[user].detect{ |h| h.file == file }
+              @queued_downloads[user].delete download unless download.nil?
+            }
+          }
+        }
+      end
+
+    end # Downloads  
+  end # Supports
+end # Fargo