rubtella 0.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+.DS_Store
+log

data/README

@@ -0,0 +1,5 @@
+This is (will be) ruby client for gnutella network.
+
+I'm doing it as my university project. 
+
+I haven't found any working ruby library for gnutella yet so I hope this one will be first :)

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/config/config.rb

@@ -0,0 +1,19 @@
+module Rubtella
+  module Config
+
+    # generating guid
+    def self.generate_guid
+      guid = Array.new
+      16.times { guid << rand(255)}
+      
+      guid
+    end
+
+    IP_ADDRESS = "195.150.93.207"
+    PORT = 54321
+    GUID  = generate_guid
+
+    
+    
+  end
+end

data/lib/errors.rb

@@ -0,0 +1,4 @@
+module Rubtella
+  class UnknownPayload < StandardError;end
+  class RubtellaError < StandardError;end
+end

data/lib/http_data.rb

@@ -0,0 +1,53 @@
+module Rubtella
+  module HTTPData
+    class Builder
+      attr_accessor :status, :headers, :data
+
+      def initialize status = "", headers = nil, data = ""
+        @status = String.new status
+        @headers = headers
+        @data = String.new data
+      end
+
+      def build
+        @http_data = Array.new
+        @http_data << @status
+        @http_data << "\r\n"
+        @headers.each {|k,v|  @http_data << "#{k}: #{v}\r\n"}
+        @http_data << "\r\n"
+        @http_data << @data
+        @http_data.to_s
+      end
+    end
+
+    class Parser
+
+
+      attr_accessor :status, :headers, :data, :http_data, :peers
+
+      def initialize http_data
+        @http_data = http_data
+        parse
+      end
+
+      def parse
+        @headers = Hash.new
+        @peers = Array.new
+
+        headers, @data = @http_data.split("\r\n\r\n")
+        headers = headers.split("\r\n")
+        @status = headers.shift
+        headers.each {|h| k,v = h.split(": "); @headers[k] = v}
+        if up = @headers["X-Try-Ultrapeers"]
+          up.split(",").each {|u| ip,port = u.split(":"); @peers << Peer.new(ip,port)}
+
+        end
+        
+      end
+
+      def ok?
+        @status =~ /200 OK/
+      end
+    end
+  end
+end

data/lib/logger.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+require 'ruby-growl'
+require 'logger'
+
+class RubtellaLogger
+
+  def initialize
+    @rubylogger = init_logger
+    @growl = init_growl
+  end
+  
+  def init_logger
+    log = Logger.new('log/rubtella.log')
+    log.level = Logger::INFO
+    log.formatter = proc{|s,t,p,m|"%5s [%s] (%s) %s :: %s\n" % [s, t.strftime("%Y-%m-%d %H:%M:%S"), $$, p, m]}
+    return log
+  end
+
+  def init_growl
+    g = Growl.new "localhost", "rubtela",
+                  ["rubtella log"]
+    return g
+  end
+
+  def info(message)
+    begin
+      @rubylogger.info message
+      @growl.notify "rubtella log", "Rubtella", message
+    rescue
+      puts 'logger error'
+    end
+  end
+
+end
+
+@@logger = RubtellaLogger.new

data/lib/peer.rb

@@ -0,0 +1,11 @@
+module Rubtella
+  class Peer
+    attr_accessor :ip, :port
+
+    def initialize(ip, port)
+      @ip = ip
+      @port = port.to_i
+    end
+
+  end
+end

data/lib/rubtella.rb

@@ -0,0 +1,154 @@
+#!/usr/bin/ruby  
+# ruby gnutella client
+
+require 'socket'  
+require 'timeout'
+require 'lib/logger'
+require 'rubygems'
+require 'ruby-debug'
+
+
+
+module Rubtella
+  
+  GNUTELLA_REQUEST = "GNUTELLA CONNECT/0.6"
+  GNUTELLA_RESPONSE_OK = "GNUTELLA/0.6 200 OK"
+  
+   
+
+  class Listener
+
+    include Socket::Constants
+
+    #listen for connection
+    def listen
+      server = TCPServer.new("0.0.0.0", PORT)  
+      
+        
+      while (session = server.accept) 
+
+        
+         Thread.start do  
+
+           begin
+             parse_request session
+           rescue => e
+             session.puts "Rubtella Server Error: " + e.to_s
+             puts "Rubtella Server Error: " + e.to_s
+           ensure
+             session.close
+           end
+
+         end
+      end   #end loop 
+
+    end
+
+    def parse_request request
+      req = request.recv 1000
+
+      puts req
+      request.send Sender.pong, 0
+      puts 'response send!'
+      req = request.recv 1000
+      puts 'received content:'
+
+      puts req
+      puts 'received!'
+    end
+
+  end
+
+  class Sender
+
+
+    attr_accessor :peer, :connected
+    
+    def initialize peer
+      @peer = peer
+      @standard_headers = {"User-Agent" => "Rubtella",
+                           "X-Ultrapeer" => "False",
+                           "X-Query-Routing" => "0.1"}
+    end
+
+    def connect
+      begin
+        puts "connecting to: #{@peer.ip}:#{@peer.port}"
+        stream = TCPSocket.new @peer.ip, @peer.port
+        timeout(5) do 
+          stream.send handshake_req, 0
+        end
+        @response = stream.recv 1000
+      
+        resp = HTTPData::Parser.new @response 
+        stream.send handshake_resp, 0
+
+        if resp.ok?
+          #connection established
+          puts 'connection established'
+          @connected = @peer
+          puts "Connected with #{@connected.ip} #{@connected.port}"
+          @@logger.info "Connected with #{@connected.ip} #{@connected.port}"
+          
+          manage_connection stream
+        else
+          puts 'failed to connect'
+          @peer = resp.peers.shift
+          connect
+        end
+      rescue Timeout::Error
+        @peer = resp.peers.shift
+        connect
+      rescue => e
+        @@logger.info e.to_s
+      end
+    end
+
+    def handshake_req
+     req = HTTPData::Builder.new GNUTELLA_REQUEST, @standard_headers
+     req.build
+    end
+
+    def handshake_resp
+      resp = HTTPData::Builder.new GNUTELLA_RESPONSE_OK, @standard_headers
+      resp.build
+    end
+    
+    def manage_connection stream
+      loop do
+        puts 'we\'re listening..'
+        resp = stream.recv 1000
+        if parse(resp) == "ping"
+          pong = TCPData::Builder::Pong.new
+          stream.send pong.build , 0 
+          puts 'pong send..'
+          stream.close
+          puts 'connection closed'
+          break
+        end
+      end 
+
+      
+
+    end
+    
+    def parse message
+      parsed = TCPData::Parser.new message
+      puts parsed.message
+      
+      parsed.message
+
+    end
+
+    def send_query(text)
+      stream = TCPSocket.new @connected.ip, @connected.port
+      query = TCPData::Builder::Query.new(:criteria => text)
+      @@logger.info "sending query - #{text}"
+      stream.send query.build, 0
+      puts 'we\'re listening..'
+      resp = stream.recv 1000
+      parse(resp)
+    end
+  end
+
+end

data/lib/tcp_data.rb

@@ -0,0 +1,155 @@
+require 'config/config'
+
+module Rubtella
+  module TCPData
+    class Base
+      include Rubtella::Config
+      attr_accessor :guid, :payload_type, :ttl, :hops, :payload_lenght, :binary_data, :messages, :messages_codes, :rest
+
+      @messages ={"\000" => "ping",
+                  "\001" => "pong",
+                  "\100" => "push",
+                  "\200" => "query",
+                  "\201" => "query_hit"}
+
+      @messages.default = "Unknown Payload Type"
+
+      @messages_codes = {"ping" => 0,
+                         "pong" => 1,
+                         "push" => 64,
+                         "query" => 128,
+                         "query_hit" =>129}
+
+      @messages_codes.default = "Unknown Payload Type"
+    end 
+
+    class Builder < Base
+      def init_messages_codes
+        @messages_codes = {"ping" => 0,
+                           "pong" => 1,
+                           "push" => 64,
+                           "query" => 128,
+                           "query_hit" =>129}
+
+        @messages_codes.default = "Unknown Payload Type"
+      end
+  
+                            
+      def initialize       
+        #initailze all stuff
+          init_messages_codes
+          
+          @guid = GUID
+          @ttl = 5
+          @hops = 0
+          @payload_length = 0
+      end
+
+      def build
+        @data = Array.new
+        @guid = GUID
+        
+        build_message
+
+        @data = [@guid, @payload_type, @ttl, @hops, @payload_length, @payload]
+
+        @binary_data = @data.flatten.pack("C*")
+        @binary_data
+      end
+
+      def build_message
+        # this method needs to be implemented by a child class
+        @payload = []
+      end
+      
+
+      class Ping < Builder
+        def initialize args = nil
+          super()
+
+          @payload_type = @messages_codes["ping"]
+        end
+      end
+
+      class Pong < Builder
+
+        attr_accessor :ip_address , :port
+
+        def initialize args = nil
+          super()
+
+          @payload_type = @messages_codes["pong"]
+          @port = build_port PORT
+          @ip_address = build_ip IP_ADDRESS
+          @files_amount = [0,0,0]
+          @files_size = [0,0,0]
+
+        end
+
+        def build_message
+          @payload = [@port, @ip_address, @files_amount, @files_size]
+        end
+
+        def build_port(port)
+          [port%256, port/256]# .pack("C*")
+        end
+
+        def build_ip(ip_address)
+          ip_address.split(".").collect {|b| b.to_i} # .pack("C*")
+        end
+      end
+
+      class Query < Builder
+
+          def initialize args = nil
+
+            super()
+
+            @payload_type = @messages_codes["query"]
+            @speed = 0
+            @criteria = args.is_a?(Hash) ? args[:criteria] : ""
+
+          end
+
+          def build_message
+            @payload = [@speed, @criteria.unpack("C*")]
+          end
+
+      end
+
+    end
+    class Parser < Base
+
+      def initialize data 
+        @binary_data = data
+        parse 
+      end
+
+      def parse
+        @guid = @binary_data[0..15]
+        @payload_type = @binary_data[16..16]
+        @ttl = @binary_data[17..17]
+        @hops =  @binary_data[18..18]
+        @payload_lenght = @binary_data[19..22]
+        @payload = @binary_data[23..-1]
+      end
+
+      def message
+        case @payload_type
+        when "\000"
+          "ping"
+        when "\001"
+          "pong"
+        when "\100"
+          "push"
+        when "\200"
+          "query"
+        when "\201"
+          "query"
+        else
+          raise "Unknown Payload Type"
+        end
+      end
+    end
+  end
+end

data/rubtella.rb

@@ -0,0 +1,6 @@
+require 'config/config'
+require 'lib/errors'
+require 'lib/peer'
+require 'lib/tcp_data'
+require 'lib/http_data'
+require 'lib/rubtella'

data/rubtellad.rb

@@ -0,0 +1,24 @@
+require 'rubtella'
+
+$0 = 'rubtella-base'
+
+@p = fork do
+  $0 = 'rubtella'
+  Thread.new do
+    server = Rubtella::Listener.new
+    server.listen
+  end
+  
+  Thread.new do
+    gnutella = Rubtella::Sender.new Rubtella::Peer.new("70.188.16.73",38093) 
+    gnutella.connect
+    gnutella.send_query("doors")
+  end
+  
+  while true
+    sleep 100
+  end
+end 
+
+Process.detach(@p)
+

metadata

@@ -0,0 +1,66 @@
+--- !ruby/object:Gem::Specification 
+name: rubtella
+version: !ruby/object:Gem::Version 
+  version: 0.0.0
+platform: ruby
+authors: 
+- Mateusz Zawisza
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-01-10 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: Library for Gnuttale in Ruby
+email: mateusz.zawisza@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- .gitignore
+- README
+- VERSION
+- config/config.rb
+- lib/errors.rb
+- lib/http_data.rb
+- lib/logger.rb
+- lib/peer.rb
+- lib/rubtella.rb
+- lib/tcp_data.rb
+- rubtella.rb
+- rubtellad.rb
+has_rdoc: true
+homepage: http://github.com/mateuszzawisza/rubtella/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Library for Gnuttale in Ruby
+test_files: []
+