karmasphere-client 0.6.4

data/README

@@ -0,0 +1,41 @@
+= Karmasphere Ruby Client Library
+
+produced by Meng Weng Wong 200606
+
+== Usage
+
+After installation, run
+
+  rubykarmaclient --ip4=127.0.0.2
+
+You should get back a response from the Karmasphere system
+showing the reputation of that IP address.
+
+== Installation
+
+The Karmasphere Client has been packaged as a rubygem.  As
+it is still in active development, and as the rest of the
+Karmasphere system is still in alpha, this gem has not yet
+been uploaded to RubyForge (20060701).
+
+== User Documentation
+
+To learn about the Karmasphere system, see http://www.karmasphere.com/userguide/
+
+== Developer Documentation
+
+If you are an MTA or Anti-Spam Vendor, see http://www.karmasphere.com/devzone/
+
+== Bugs
+
+See http://rt.karmasphere.com/
+
+== History
+
+[20060701] Packaged for rake/rubygems by Meng Weng Wong <mengwong@karmasphere.com>.
+[200606] Originally written by Dave Brown <dagbrown>.
+
+== License
+
+This client software is distributed under the same terms as Ruby.
+

data/bin/rubykarmaclient

@@ -0,0 +1,135 @@
+#!/usr/bin/ruby
+
+# mengwong@pobox.com 20060629
+# Karmasphere client for Ruby
+
+# usage:
+#  rubykarmaclient --host=slave.karmasphere.com --ip4=127.0.0.2
+
+# ----------------------------------------------------------
+#			 libraries
+# ----------------------------------------------------------
+
+require "socket"
+require "rubygems" # if run from trunk/lib, with ../bin/rubykarmaclient, the dev libs will load instead of the system libs
+require "rubytorrent/bencoding"
+require "karmasphere/client"
+require "karmasphere/query"
+require "karmasphere/response"
+
+# ----------------------------------------------------------
+#		     options processing
+# ----------------------------------------------------------
+
+require "getoptlong"
+opts = GetoptLong.new(
+        [ "--host"              , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--port"              , GetoptLong::REQUIRED_ARGUMENT ],
+		[ "--composite"         , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--combiner"          , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--ip4"               , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--ip6"               , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--domain"            , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--url"               , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--email"             , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--flags"             , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--username"          , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--password"          , GetoptLong::REQUIRED_ARGUMENT ],
+        [ "--tcp"               , GetoptLong::NO_ARGUMENT ],
+        [ "--help"              , GetoptLong::NO_ARGUMENT ],
+        [ "--single"            , GetoptLong::NO_ARGUMENT ],
+        [ "--debug", "-d"       , GetoptLong::NO_ARGUMENT ]
+	);
+
+myopts = {};
+opts.each { |opt, arg| myopts[opt] = arg }
+
+# ----------------------------------------------------------
+# symbolic constants
+# ----------------------------------------------------------
+
+FL_WANTFACTS = 1
+DEFAULT_IP = "127.0.0.2"
+DEFAULT_COMPOSITE = "karmasphere.email-sender"
+
+if myopts.has_key? '--help' then
+   print "usage: rubykarmaclient
+                 [     --username=xxx --password=yyy          ]
+                 [     --ip4=127.0.0.2                        ]
+                 [     --domain=example.com                   ]
+                 [     --url=http://www.example.com/phishing/ ]
+                 [     --tcp                                  ]
+                 [     --composite=karmasphere.email-sender   ]
+"
+		exit;
+end
+
+
+# ----------------------------------------------------------
+#		      data preparation
+# ----------------------------------------------------------
+
+identities = []
+[ "--ip4", "--ip6", "--domain", "--url", "--email" ].each do |identifier|
+	identities << myopts[identifier] if myopts[identifier];
+end
+
+identities << DEFAULT_IP if identities.length == 0;
+
+print "identifiers = #{identities}\n" if myopts['--debug'];
+
+# ----------------------------------------------------------
+#			    main
+# ----------------------------------------------------------
+
+# 
+# set up client
+# 
+
+clientargs = { }
+
+if myopts.has_key? '--tcp' then clientargs[:type] = :CONNECTION_TCP else clientargs[:type] = :CONNECTION_UDP end
+
+if myopts.has_key? '--host' then clientargs[:host] = myopts['--host'] end
+
+if myopts.has_key? '--username' then clientargs[:principal]   = myopts['--username'] end
+if myopts.has_key? '--password' then clientargs[:credentials] = myopts['--password'] end
+
+client=Karmasphere::Client.new(clientargs)
+
+# 
+# set up query
+# 
+
+query_id = myopts['--id'] || "000";
+
+queryargs = { :Id => query_id,
+  :Identities => identities }
+
+if myopts.has_key? '--flags' then
+  queryargs[:Flags] = myopts['--flags']
+else
+  queryargs[:Flags] = FL_WANTFACTS
+end
+
+if myopts.has_key? '--composite' then
+  queryargs[:Composites] = myopts['--composite'].split(',')
+else
+  queryargs[:Composites] = [ DEFAULT_COMPOSITE ]
+end
+
+print "query args: " , queryargs.inspect, "\n" if myopts['--debug'];
+query = Karmasphere::Query.new( queryargs )
+print query.inspect, "\n" if myopts['--debug'];
+
+# 
+# display response
+# 
+
+response = client.ask(query)
+
+if myopts['--debug']
+  puts response.instance_variable_get('@hash').inspect
+end
+
+puts response

data/lib/karmasphere.rb

@@ -0,0 +1,5 @@
+require "karmasphere/debug"
+require "karmasphere/constants"
+require "karmasphere/client"
+require "karmasphere/query"
+require "karmasphere/response"

data/lib/karmasphere/client.rb

@@ -0,0 +1,116 @@
+#------------------------------------------------------------------------
+# The (mostly-complete) Karmasphere Client
+#------------------------------------------------------------------------
+require "socket"
+require "rubytorrent/bencoding"
+require "stringio"
+require "fcntl"
+require "karmasphere/debug"
+
+module Karmasphere
+  CONNECTION_UDP = :CONNECTION_UDP
+  CONNECTION_TCP = :CONNECTION_TCP
+
+    class CredentialsError < Exception
+    end
+
+    class Client
+        private 
+        def send_query(query)
+            if @auth 
+                querystr=query.to_hash.merge(@auth).to_bencoding
+            else
+                querystr=query.to_hash.to_bencoding
+            end
+
+            if TCPSocket === @socket then
+                @socket.send [querystr.length].pack("N"),0
+            end
+
+          Karmasphere.dprint("sending query string #{querystr}\n");
+            @socket.send querystr,0
+          Karmasphere.dprint("sent.\n");
+        end
+
+        def find_response(query)
+            # (hack, not guaranteed to work) handle out-of-order responses
+            loop do
+                if @response_pool.has_key? query.id then
+                    return @response_pool.delete(query.id)
+                else
+                    response=Response.new( decode(receive_response), query )
+                    @response_pool[response.id] = response;
+                end
+            end
+        end
+
+        def receive_response
+            if TCPSocket === @socket then
+                length_s = @socket.recvfrom(4)[0]
+                length_n = length_s.unpack("N")[0]
+                Karmasphere.dprint("client decoding TCP response of #{length_n} bytes\n");
+                @socket.recvfrom(length_n)[0]
+            else
+              Karmasphere.dprint("client awaiting response from #@socket\n");
+              reply, from = @socket.recvfrom(8192)
+              Karmasphere.dprint("client response received from #@socket\n");
+              reply
+            end
+        end
+
+        def decode(querystr)
+            RubyTorrent::BStream.new(
+                StringIO.new( querystr )
+            ).to_a[0]
+        end
+
+        def make_query(query)
+            send_query query
+            find_response query
+        end
+
+        public
+        def initialize(*args)
+            host="query.karmasphere.com"
+            port=8666
+            type=CONNECTION_UDP
+            if Hash === args[0] then
+                opts = args[0]
+                host = opts[:host] if opts.has_key? :host 
+                port = opts[:port] if opts.has_key? :port
+                type = opts[:type] if opts.has_key? :type and
+                                      opts[:type] == CONNECTION_TCP ||
+                                      opts[:type] == CONNECTION_UDP
+                @auth = nil
+                if opts.has_key? :principal then
+                    unless opts.has_key? :credentials
+                        raise CredentialsError, "principal missing credentials"
+                    end
+                end
+                if opts.has_key? :credentials then
+                    unless opts.has_key? :principal
+                        raise CredentialsError, "credentials missing principal"
+                    end
+                    @auth = { "a" => [ opts[:principal], opts[:credentials] ] }
+                end
+            end
+
+            if type == CONNECTION_UDP
+                @socket = UDPSocket.new
+              Karmasphere.dprint "UDP client: attempting to connect to #{host}:#{port}\n"
+                @socket.connect host, port
+                @socket.fcntl(Fcntl::F_SETFD,1) if defined? Fcntl::F_SETFD
+              Karmasphere.dprint "UDP client: created socket #@socket\n"
+            else
+              Karmasphere.dprint "TCP client: attempting to connect to #{host}:#{port}\n"
+                @socket = TCPSocket.new host, port
+            end
+
+            @response_pool={}
+        end
+
+        def ask(query)
+            make_query(query)
+        end
+    end
+end

data/lib/karmasphere/constants.rb

@@ -0,0 +1,18 @@
+#------------------------------------------------------------------------
+# Constants used in the Karmasphere Query class
+#------------------------------------------------------------------------
+
+module Karmasphere
+    IDT_IP4_ADDRESS          = 0
+    IDT_IP6_ADDRESS          = 1
+    IDT_DOMAIN_NAME          = 2
+    IDT_EMAIL_ADDRESS        = 3
+    IDT_URL                  = 4
+    IDT_OPAQUE               = 5
+    AUTHENTIC                = "a"
+    SMTP_CLIENT_IP           = "smtp.client-ip"
+    SMTP_ENV_HELO            = "smtp.env.helo"
+    SMTP_ENV_MAIL_FROM       = "smtp.env.mail-from"
+    SMTP_ENV_RCPT_TO         = "smtp.env.rcpt-to"
+    SMTP_HEADER_FROM_ADDRESS = "smtp.header.from.address"
+end

data/lib/karmasphere/debug.rb

@@ -0,0 +1,22 @@
+
+module Karmasphere
+
+  # if you want debugging turned on,
+  # set any one of these environment variables:
+  # * KARMADEBUG
+  # * RUBYDEBUG
+  # or change the following line to read .find(lambda { true })
+  
+  KARMADEBUG = %w{KARMADEBUG RUBYDEBUG}.find(nil) do |debugenv|
+    ENV[debugenv] and ENV[debugenv].size and ENV[debugenv] != "0"
+  end
+
+  # use +dprint+ instead of print.  it will print to STDERR,
+  # but only when debugging is turned on.
+
+  def dprint(*args)
+    STDERR.print("KarmaDebug: ", "%0.6f: " % Time.now, *args) if KARMADEBUG
+  end
+
+  module_function :dprint  
+end

data/lib/karmasphere/query.rb

@@ -0,0 +1,92 @@
+#------------------------------------------------------------------------
+# Karmasphere Query class (translation of the Perl code)
+#------------------------------------------------------------------------
+
+require "karmasphere/constants"
+
+module Karmasphere
+    class Query
+        @@ID=0
+        Realflag = { 
+            :Id => "_",
+            :Identities => "i",
+            :Composites => "s",
+            :Combiners => "c",
+            :Flags => "fl"
+        }
+
+        private
+        def guess_identity_type(addr)
+            case addr
+                when /^[0-9\.]{7,15}$/:        IDT_IP4_ADDRESS
+                when /^[0-9a-f:\/]{2,64}$/i:   IDT_IP6_ADDRESS
+                when /^https?:\/\//:           IDT_URL
+                when /@/:                      IDT_EMAIL_ADDRESS
+                when /\./:                     IDT_DOMAIN_NAME
+                else                           IDT_OPAQUE
+            end
+        end
+
+        public
+
+        def initialize(*args)
+            self.id = "q#{@@ID += 1}"
+
+            if args.length > 0
+                opts = args[0] if Hash === args[0]
+
+                [:Id, :Identities, :Composites, :Composite, :Feeds,
+                    :Combiners, :Combiner, :Flags].each do |option|
+
+                    if opts.has_key? option
+                        send("#{option.to_s.downcase}=", opts[option])
+                    end
+                end
+            end
+        end
+
+        attr_accessor :id, :composites, :feeds, :combiners
+
+        attr_writer :flags
+        def flags
+          @flags.to_i
+        end
+
+        def composite=(newcomposite)
+            self.composites=newcomposite
+        end
+
+        def feed=(newfeed)
+            @feeds=[newfeed]
+        end
+
+        def identities=(stuff)
+            if String === stuff then
+                return self.identities=[stuff]
+            end
+
+            @identities = if Array === stuff then
+                              stuff.map do |item|
+                                  if Array === item then
+                                      item
+                                  else
+                                      [item, guess_identity_type(item)]
+                                  end
+                              end
+                          end
+        end
+        attr_reader :identities
+        alias identity= identities=
+
+        def to_hash
+            retval={}
+            [:Id, :Identities, :Composites, 
+                :Feeds, :Combiners, :Flags].each do |k|
+                if instance_variables.member? "@#{k.to_s.downcase}"
+                    retval[Realflag[k]]=send "#{k.to_s.downcase}"
+                end
+            end
+            retval
+        end
+    end
+end

data/lib/karmasphere/response.rb

@@ -0,0 +1,116 @@
+#------------------------------------------------------------------------
+# Desired Output Format
+#------------------------------------------------------------------------
+
+# the Java, Perl and C clients all produce the same output format.
+#
+#   20060907-15:53:55 mengwong@newyears-air:~/src/karmasphere/trunk/lib% karmaclient --ip4=127.0.0.2 --host=bowie.tx.karmasphere.com
+#   Response id 'q0': 12ms, 1 combinations, 8 facts
+#   Combiner 'karmasphere.emailchecker': verdict 1000 (isipp.iadb-vouched-ip: if-pass(0) => return good(1.0))
+#   Feed 'sorbs.dul' opinion -1000 (Dynamic IP Addresses See: http://www.sorbs.net/lookup.shtml?$)
+#   Feed 'spamhaus.xbl-cbl' opinion -1000 (http://www.spamhaus.org/query/bl?ip=$)
+#   Feed 'cymru.bogons' opinion -1000 (Invalid source IP address (cymru))
+#   Feed 'dsbl.list' opinion -1000 (http://dsbl.org/listing?$)
+#   Feed 'dsbl.multihop' opinion -1000 (http://dsbl.org/listing?$)
+#   Feed 'spamcop.bl' opinion 2147483647 (null data)
+#   Feed 'isipp.iadb-vouched-ip' opinion 1000 (Vouched by ISIPP/IADB)
+#   Feed 'spamhaus.sbl' opinion -1000 (http://www.spamhaus.org/query/bl?ip=$)
+#   20060907-15:54:01 mengwong@newyears-air:~/src/karmasphere/trunk/lib%
+
+#------------------------------------------------------------------------
+# Response class for the Karmasphere client
+#------------------------------------------------------------------------
+
+module Karmasphere
+    class Response
+        private
+        def combination_get(key, combiner=nil)
+            if combinations then
+                if !combiner and combinations.has_key?("default") then
+                    combination('default')
+                elsif !combiner then
+                    combinations.values.find do |combo|
+                        if combo.has_key? key then combo[key] end
+                    end
+                else
+                    my_combination=combination(combiner)
+                    if my_combination then
+                        return my_combination[key]
+                    end
+                end
+            end
+        end
+
+        public
+
+        def initialize(hash, query=nil)
+            @hash=hash
+	    @query=query
+        end
+
+        def id; @hash["_"] end
+
+        def time; @hash["time"] if @hash.has_key? "time" end
+
+        def facts
+            if @hash.has_key? "facts" then 
+                @hash["facts"]
+            elsif @hash.has_key? "f" then 
+                @hash["f"] 
+            else
+                []
+            end
+        end
+
+        def combinations
+            if @hash.has_key? "c" then 
+                @hash["c"] 
+            elsif @hash.has_key? "combiners" then 
+                @hash["combiners"] 
+            end
+        end
+
+        def combination(combiner)
+            combinations[combiner]
+        end
+
+        def combiner_names
+            if combinations then
+                combinations.keys
+            else
+                []
+            end
+        end
+
+        def verdict(name=nil); combination_get "v",name; end
+        alias value verdict
+        def data(name=nil); combination_get "d", name; end
+
+        def error; @hash["error"] if @hash.has_key? "error"; end
+        def message; @hash["message"] if @hash.has_key? "message"; end
+
+        def to_s;
+            "Response_id '#{id}': " +
+                if time then "#{time}ms, "  else "" end + 
+                "#{combiner_names.length} combinations, " +
+                "#{facts.length} facts\n" +
+                if error then 
+                    "Error: #{message}\n" 
+                else
+                    combiner_names.map do |name|
+                        "Combiner '#{name}': verdict #{value(name)} " +
+                        "(#{data(name) || '(undef)'})\n"
+                    end.join("") +
+                    facts.map do |fact|
+                            "Feed '#{fact['f']}' opinion #{fact['v']} (" +
+                            if fact.has_key? "d" then
+                                fact["d"]
+                            else
+                                "null data"
+                            end + ")" +
+                if fact.has_key? "i" then " (identity=#{fact['i']})" else "" end + "\n"
+                    end.join("")
+                end
+        end
+    end
+end

data/lib/rubytorrent/bencoding.rb

@@ -0,0 +1,182 @@
+## bencoding.rb -- parse and generate bencoded values.
+## Copyright 2004 William Morgan.
+##
+## This file is part of RubyTorrent. RubyTorrent is free software;
+## you can redistribute it and/or modify it under the terms of version
+## 2 of the GNU General Public License as published by the Free
+## Software Foundation.
+##
+## RubyTorrent is distributed in the hope that it will be useful, but
+## WITHOUT ANY WARRANTY; without even the implied warranty of
+## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+## General Public License (in the file COPYING) for more details.
+
+require 'uri'
+require 'digest/sha1'
+ 
+module RubyTorrent
+
+## we mess in the users' namespaces in this file. there's no good way
+## around it. i don't think it's too egregious though.
+
+class BEncodingError < StandardError; end
+
+class BStream
+  include Enumerable
+
+  @@classes = []
+
+  def initialize(s)
+    @s = s
+  end
+
+  def self.register_bencoded_class(c)
+    @@classes.push c
+  end
+
+  def each
+    happy = true
+    begin
+      happy = false
+      c = @s.getc
+      @@classes.each do |klass|
+        if klass.bencoded? c
+          o = klass.parse_bencoding(c, @s)
+          happy = true
+          yield o
+          break
+        end
+      end unless c.nil?
+      unless happy
+        @s.ungetc c unless c.nil?
+      end
+    end while happy
+    self
+  end
+end
+
+end
+
+class String
+  def to_bencoding
+    self.length.to_s + ":" + self.to_s
+  end
+
+  def self.bencoded?(c)
+    (?0 .. ?9).include? c
+  end
+
+  def self.parse_bencoding(c, s)
+    lens = c.chr
+    while ((x = s.getc) != ?:)
+      unless (?0 .. ?9).include? x
+        s.ungetc x
+        raise RubyTorrent::BEncodingError, "invalid bencoded string length #{lens} + #{x}" 
+      end
+      lens += x.chr
+    end
+    raise RubyTorrent::BEncodingError, %{invalid length #{lens} in bencoded string} unless lens.length <= 20
+    len = lens.to_i
+    raise RubyTorrent::BEncodingError, %{invalid length #{lens} in bencoded string} unless len >= 0
+    (len > 0 ? s.read(len) : "")
+  end
+
+  RubyTorrent::BStream.register_bencoded_class self
+end
+
+class Integer
+  def to_bencoding
+    "i" + self.to_s + "e"
+  end
+
+  def self.bencoded?(c)
+    c == ?i
+  end
+
+  def self.parse_bencoding(c, s)
+    ints = ""
+    while ((x = s.getc.chr) != 'e')
+      raise RubyTorrent::BEncodingError, "invalid bencoded integer #{x.inspect}" unless x =~ /\d|-/
+      ints += x
+    end
+    raise RubyTorrent::BEncodingError, "invalid integer #{ints} (too long)" unless ints.length <= 20
+    int = ints.to_i
+    raise RubyTorrent::BEncodingError, %{can't parse bencoded integer "#{ints}"} if (int == 0) && (ints !~ /^0$/) #'
+    int
+  end
+
+  RubyTorrent::BStream.register_bencoded_class self
+end
+
+class Time
+  def to_bencoding
+    self.to_i.to_bencoding
+  end
+end
+
+module URI
+  def to_bencoding
+    self.to_s.to_bencoding
+  end
+end
+
+# Symbol#to_bencoding added by dagbrown 2006/6/3 for karmaclient
+
+class Symbol
+    def to_bencoding
+        to_s.bencoding
+    end
+end
+
+class Array
+  def to_bencoding
+    "l" + self.map { |e| e.to_bencoding }.join + "e"
+  end
+
+  def self.bencoded?(c)
+    c == ?l
+  end
+
+  def self.parse_bencoding(c, s)
+    ret = RubyTorrent::BStream.new(s).map { |x| x }
+    raise RubyTorrent::BEncodingError, "missing list terminator" unless s.getc == ?e
+    ret
+  end
+
+  RubyTorrent::BStream.register_bencoded_class self
+end
+
+class Hash
+  def to_bencoding
+    "d" + keys.sort.map do |k|
+      v = self[k]
+      if v.nil?
+        nil
+      else
+        [k.to_bencoding, v.to_bencoding].join
+      end
+    end.compact.join + "e"
+  end
+
+  def self.bencoded?(c)
+    c == ?d
+  end
+
+  def self.parse_bencoding(c, s)
+    ret = {}
+    key = nil
+    RubyTorrent::BStream.new(s).each do |x|
+      if key == nil
+        key = x
+      else
+        ret[key] = x
+        key = nil
+      end
+    end
+
+    raise RubyTorrent::BEncodingError, "no dictionary terminator" unless s.getc == ?e
+    ret
+  end
+
+  RubyTorrent::BStream.register_bencoded_class self
+end

data/test/test_all.rb

@@ -0,0 +1,8 @@
+#!/usr/bin/ruby -w
+
+$: << File.join(File.dirname(__FILE__), "..","lib")
+
+require "test/unit"
+require "test/test_client"
+require "test/test_query"
+require "test/test_response"

data/test/test_client.rb

@@ -0,0 +1,264 @@
+#------------------------------------------------------------------------
+# Tests for the client
+#------------------------------------------------------------------------
+
+require "test/unit"
+require "rubytorrent/bencoding"
+require "socket"
+require "karmasphere/client"
+require "karmasphere/query"
+require "karmasphere/response"
+require "karmasphere/debug"
+
+# For test purposes, we create a mini-server which bencodes
+# and transmits this response no matter what input is given.
+# In this test suite -- we're testing the client -- we
+# decode the response from the mini-server and match it
+# against this expected value.
+
+$stub_response = { 
+    "_" => 12345,
+    "facts" => [ 
+        { 
+            "f" => 4000,
+            "v" => -1,
+            "d" => "Invalid Source IP Address (cymru)"
+        }
+    ],
+    "combiners" => {
+        "karmasphere.emailchecker" => {
+            "v" => -1000,
+            "d" => "<f4000: if-fail(0) => return bad(1.0)>"
+        }
+    }
+}
+
+# We have four test cases in total, exploring each combination of:
+# * Turnaround vs Stub
+# * TCP vs UDP
+
+$port = 8666
+
+class TC_Client_Turnaround_TCP < Test::Unit::TestCase
+  @@port = $port+1
+
+  def setup
+    @thr=Thread.new do
+      Karmasphere.dprint("TC_Client_Turnaround_TCP: constructing listen server on port #@@port\n");
+      @server = TCPServer.new(nil, @@port)
+
+      # mengwong 20060701: i believe TCPServers are
+      # automatically created with reuseaddr = true,
+      # but you may use the following code to check.
+      Karmasphere.dprint("created server with #{@server.getsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR).inspect}\n");
+
+      while(session = @server.accept)
+        Thread.new do
+          Karmasphere.dprint("accepted new session #{session.inspect}\n");
+          len_str = session.recv(4)
+          len=len_str.unpack("N")[0]
+          info=session.recv(len)
+          Karmasphere.dprint("received #{len} bytes of info: #{info}\n");
+          session.send len_str+info, 0
+          Karmasphere.dprint("echoing back #{len} bytes of info: #{info}\n");
+          session.close
+        end
+      end
+    end
+  end
+
+  def teardown
+    @server.close
+    @server = nil
+    @thr.kill
+    GC.start
+  end
+
+  def test_startup
+    Karmasphere.dprint("test_client: test_startup: beginning\n");
+
+    # we need to wait for the listener thread established in
+    # setup to be ready.  we do a poor man's thread
+    # synchronization by simply testing the @server.  if we
+    # were doing this right, we'd use a MonitorMixin as
+    # documented on page 138 of the pickax book.
+    while not @server do
+      Karmasphere.dprint("test_startup: server not ready.  passing.\n");
+      Thread.pass
+    end
+
+    Karmasphere.dprint("test_client: test_startup: proceeding.\n");
+
+    assert client=Karmasphere::Client.new(:host => "localhost", 
+                                          :port => @@port,
+                                          :type => Karmasphere::CONNECTION_TCP)
+    query = Karmasphere::Query.new({ "_" => 12345 })
+    response = client.ask(query)
+    Karmasphere.dprint("test_client: got back response " , response.instance_variable_get("@hash"));
+    assert_equal query.to_hash, response.instance_variable_get("@hash")
+  end
+end
+
+class TC_Client_Turnaround_UDP < Test::Unit::TestCase
+  @@port = $port + 2
+  def setup
+    Karmasphere.dprint("TC_Client_Turnaround_UDP: constructing listen server on port #@@port\n");
+    @thr=Thread.new do
+
+      @server = UDPSocket.new
+      @server.bind(nil, @@port)
+
+      info=@server.recvfrom(8192)
+      Karmasphere.dprint("TC_Client_Turnaround_UDP: received ", info, "\n");
+        
+      @server.flush
+      client_h=info[1][2]
+      client_p=info[1][1]
+      query=info[0]
+      @server.send query, 0, client_h, client_p
+      @server.flush
+      Karmasphere.dprint("TC_Client_Turnaround_UDP: sent stuff back to #{client_h}:#{client_p}\n");
+      
+    end
+  end
+
+  def teardown
+    Karmasphere.dprint("TC_Client_Turnaround_UDP: tearing down server.\n");
+    @server.close
+    @server = nil
+    @thr.kill
+    GC.start
+  end
+
+  def test_startup
+    while not @server do
+      Karmasphere.dprint("test_startup: server not ready.  passing.\n");
+      Thread.pass
+    end
+    assert client=Karmasphere::Client.new(:host => "localhost",
+                                          :port => @@port
+                                          )
+    query = Karmasphere::Query.new({ "_" => 12345 })
+    response = client.ask(query)
+    assert_equal query.to_hash, response.instance_variable_get("@hash")
+
+  end
+
+  def test_credentials
+    while not @server do
+      Karmasphere.dprint("test_startup: server not ready.  passing.\n");
+      Thread.pass
+    end
+    assert_raises Karmasphere::CredentialsError do
+      Karmasphere::Client.new(:host => "localhost",
+                              :port => @@port,
+                              :principal => "foo")
+    end
+    assert_raises Karmasphere::CredentialsError do
+      Karmasphere::Client.new(:host => "localhost",
+                              :port => @@port,
+                              :credentials => "bar")
+    end
+
+    assert client=Karmasphere::Client.new(:host => "localhost",
+                                          :port => @@port,
+                                          :principal => "foo",
+                                          :credentials => "bar"
+                                          )
+    query = Karmasphere::Query.new({ "_" => 12345 })
+    response = client.ask(query)
+    assert_equal query.to_hash.merge({"a" => [ "foo", "bar" ]}),
+    response.instance_variable_get("@hash")
+  end
+end
+
+class TC_Client_Stub_UDP < Test::Unit::TestCase
+  @@port = $port + 3
+  def setup
+    @thr=Thread.new do
+      Karmasphere.dprint("TC_Client_Stub_UDP: constructing listen server on port #@@port\n");
+
+      @server = UDPSocket.new
+      @server.bind("localhost", @@port)
+      Karmasphere.dprint("TC_Client_Stub_UDP: created server #@port\n");
+      @server_ready = true
+      
+      info=@server.recvfrom(8192)
+      @server.flush
+      client_h=info[1][2]
+      client_p=info[1][1]
+      Karmasphere.dprint("TC_Client_Stub_UDP: server received packet from #{client_h}:#{client_p}\n");
+      query=info[0]
+      @server.send $stub_response.to_bencoding, 0, client_h, client_p
+      Karmasphere.dprint("TC_Client_Stub_UDP: miniserver sent stuff back to #{client_h}:#{client_p}\n");
+      Karmasphere.dprint("TC_Client_Stub_UDP: close_write()d.\n");
+    end
+  end
+
+  def teardown
+    @thr.kill
+    @server.close
+    @server = nil
+    GC.start
+  end
+
+  def test_startup
+    while not @server_ready do
+      Karmasphere.dprint("Stub_UDP test_startup: server not ready.  passing.\n");
+      Thread.pass
+    end
+    Karmasphere.dprint("test_startup: proceeding.\n");
+    assert client=Karmasphere::Client.new(:host => "localhost",
+                                          :port => @@port
+                                          )
+    query = Karmasphere::Query.new(:Id => 12345)
+    Karmasphere.dprint("test_startup: client asking query...\n");
+    response = client.ask(query)
+    Karmasphere.dprint("test_startup: ... client received response #{response}\n");
+    assert_equal $stub_response, response.instance_variable_get('@hash')
+  end
+end
+
+class TC_Client_Stub_TCP < Test::Unit::TestCase
+  @@port = $port + 4
+    def setup
+    Karmasphere.dprint("TC_Client_Stub_TCP: constructing listen server on port #@@port\n");
+        @thr = Thread.new do
+
+            @server = TCPServer.new(nil, @@port)
+            while(session = @server.accept)
+                Thread.new do
+                    while not session.closed?
+                        len_str = session.recv(4)
+                        len=len_str.unpack("N")[0]
+                        info=session.recv(len)
+                        response_str=$stub_response.to_bencoding
+                        response_len_str = [ response_str.length ].pack "N"
+                        session.send response_len_str+response_str, 0
+                    end
+                end
+            end
+        end
+    end
+
+    def teardown
+        @server.close
+        @server = nil
+        @thr.kill
+        GC.start
+    end
+
+    def test_startup
+        while not @server do
+          Karmasphere.dprint("test_startup: server not ready.  passing.\n");
+          Thread.pass
+        end
+        assert client=Karmasphere::Client.new(:host => "localhost", 
+                                              :port => @@port,
+                                              :type => Karmasphere::CONNECTION_TCP)
+        query = Karmasphere::Query.new(:Id => 12345)
+        response = client.ask(query)
+        assert_equal $stub_response, response.instance_variable_get('@hash')
+    end
+end
+

data/test/test_query.rb

@@ -0,0 +1,120 @@
+require "test/unit"
+require "karmasphere/query"
+
+class TC_Basic_Query < Test::Unit::TestCase
+    def test_automatic_query_id
+        client=Karmasphere::Query.new
+        assert_kind_of Karmasphere::Query, client
+
+        client2=Karmasphere::Query.new
+        assert_kind_of Karmasphere::Query, client2
+
+        assert_equal client.id, "q1"
+        assert_equal client.to_hash, { "_" => "q1" }
+
+        assert_equal client2.id, "q2"
+        assert_equal client2.to_hash, { "_" => "q2" }
+    end
+
+    def test_query_identities_munging
+        client=Karmasphere::Query.new(:Id => "q2")
+        assert_kind_of Karmasphere::Query, client
+
+        client.identities=[ ["127.0.0.1", 0 ] ]
+        assert_equal( [ ["127.0.0.1", 0 ] ], client.identities)
+        assert_equal( { "_" => "q2", "i" => [ ["127.0.0.1", 0 ] ] },
+            client.to_hash)
+
+        client.identities = [ "127.0.0.1" ]
+        assert_equal( [ ["127.0.0.1", 0 ] ], client.identities)
+        assert_equal({ "_" => "q2", "i" => [ ["127.0.0.1", 0 ] ] }, 
+            client.to_hash)
+
+        client.identities = "127.0.0.1"
+        assert_equal( [ ["127.0.0.1", 0 ] ], client.identities)
+        assert_equal({ "_" => "q2", "i" => [ ["127.0.0.1", 0 ] ] }, 
+            client.to_hash)
+
+        client.identity = "127.0.0.1"
+        assert_equal( [ ["127.0.0.1", 0 ] ], client.identities)
+        assert_equal({ "_" => "q2", "i" => [ ["127.0.0.1", 0 ] ] }, 
+            client.to_hash)
+    end
+
+    def test_query_identities_guessing
+        client=Karmasphere::Query.new(:Id => "q3")
+        assert_kind_of Karmasphere::Query, client
+
+        client.identities = "127.0.0.1"
+        assert_equal( [ ["127.0.0.1", 0 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["127.0.0.1", 0 ] ] }, 
+            client.to_hash)
+
+        client.identities = "::1/128"
+        assert_equal( [ ["::1/128", 1 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["::1/128", 1 ] ] }, 
+            client.to_hash)
+
+        client.identities = "example.com"
+        assert_equal( [ ["example.com", 2 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["example.com", 2 ] ] }, 
+            client.to_hash)
+
+        client.identities = "example@example.com"
+        assert_equal( [ ["example@example.com", 3 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["example@example.com", 3 ] ] }, 
+            client.to_hash)
+
+        client.identities = "http://www.example.com/"
+        assert_equal( [ ["http://www.example.com/", 4 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["http://www.example.com/", 4 ] ] }, 
+            client.to_hash)
+
+        client.identities = "chunky bacon"
+        assert_equal( [ ["chunky bacon", 5 ] ], client.identities )
+        assert_equal({ "_" => "q3", "i" => [ ["chunky bacon", 5 ] ] }, 
+            client.to_hash)
+    end
+
+    def test_query_identities_on_construction
+        client=Karmasphere::Query.new(:Id => 'q4',
+                                      :Identities => "example.com")
+        assert_kind_of Karmasphere::Query, client
+
+        assert_equal( [ ["example.com", 2 ] ], client.identities,
+                    "Automatically-detected identity at construction time")
+        assert_equal({ "_" => "q4", "i" => [ ["example.com", 2 ] ] }, 
+            client.to_hash, "Simple identity at construction time")
+
+        client = Karmasphere::Query.new( :Id => 'q5',
+                                         :Identities => [ [ "127.0.0.1", 
+                                             Karmasphere::IDT_IP4_ADDRESS,
+                                             Karmasphere::AUTHENTIC ] ] )
+        assert_equal( [ [ "127.0.0.1", 0, "a" ] ], client.identities )
+        assert_equal({ "_" => "q5", "i" => [ ["127.0.0.1", 0, "a" ] ] }, 
+            client.to_hash, "Complicated identity at construction time")
+    end
+
+    def test_query_example_query
+        client = Karmasphere::Query.new( :Id => 12345, 
+            :Identities => [ [ "127.0.0.1", Karmasphere::IDT_IP4_ADDRESS,
+                                            Karmasphere::SMTP_CLIENT_IP ],
+                             [ "antony@karmasphere.com", 
+                                 Karmasphere::IDT_EMAIL_ADDRESS,
+                                 Karmasphere::SMTP_ENV_MAIL_FROM ],
+                             [ "karmasphere.com",
+                                 Karmasphere::IDT_DOMAIN_NAME,
+                                 Karmasphere::SMTP_ENV_HELO ] ],
+            :Composites => "karmasphere.emailchecker",
+            :Flags => 1 )
+
+        assert_kind_of Karmasphere::Query, client
+
+        assert_equal( { "_" => 12345, 
+                        "i" => [ [ "127.0.0.1", 0, "smtp.client-ip" ],
+                        [ "antony@karmasphere.com", 3, "smtp.env.mail-from" ],
+                        [ "karmasphere.com", 2, "smtp.env.helo" ] ],
+                        "s" => "karmasphere.emailchecker", "fl" => 1 },
+                     client.to_hash, "Test query from the protocol spec")
+    end
+end

data/test/test_response.rb

@@ -0,0 +1,65 @@
+require "test/unit"
+require "karmasphere/response"
+
+$response_hash = { 
+    "_" => 12345,
+    "facts" => [ 
+        { 
+            "f" => 4000,
+            "v" => -1,
+            "d" => "Invalid Source IP Address (cymru)"
+        }
+    ],
+    "combiners" => {
+        "karmasphere.emailchecker" => {
+            "v" => -1000,
+            "d" => "<f4000: if-fail(0) => return bad(1.0)>"
+        }
+    }
+}
+
+class TC_BasicResponse < Test::Unit::TestCase
+    def test_basicresponse
+        response=nil
+        assert_nothing_raised {
+            response=Karmasphere::Response.new({"_" => 12345})
+        }
+        assert_kind_of Karmasphere::Response, response
+        assert_equal 12345, response.id
+        assert_nil response.time
+        assert_nil response.combinations
+        assert_equal [], response.facts
+        assert_equal [], response.combiner_names
+        assert_nil response.error
+        assert_nil response.message
+    end
+
+    def test_errorresponse
+        response=nil
+        assert_nothing_raised {
+            response=Karmasphere::Response.new({"_" => "q314159", 
+                                           "error" => 1,
+                                           "message" => "an error occurred"})
+        }
+        assert_kind_of Karmasphere::Response, response
+        assert_equal "q314159", response.id
+        # I don't think I need go through all those assert_nils again
+        assert_equal 1, response.error
+        assert_equal "an error occurred", response.message
+        assert_equal "Response_id 'q314159': 0 combinations, 0 facts\nError: an error occurred\n", response.to_s
+    end
+
+    def test_success
+        response=nil
+        assert_nothing_raised { 
+            response=Karmasphere::Response.new $response_hash
+        }
+        assert_kind_of Karmasphere::Response, response
+        assert_equal ["karmasphere.emailchecker"], response.combiner_names
+        assert_equal([{ 
+                "f" => 4000,
+                "v" => -1,
+                "d" => "Invalid Source IP Address (cymru)"
+            }], response.facts)
+    end
+end

metadata

@@ -0,0 +1,57 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.0
+specification_version: 1
+name: karmasphere-client
+version: !ruby/object:Gem::Version 
+  version: 0.6.4
+date: 2007-04-30 00:00:00 -07:00
+summary: Karmasphere Client
+require_paths: 
+  - lib
+email: devsupport@karmasphere.com
+homepage: http://www.karmasphere.com.com/devzone/
+rubyforge_project: 
+description: 
+autorequire: karmasphere
+default_executable: 
+bindir: bin
+has_rdoc: false
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+    - 
+      - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+  - Meng Weng Wong
+files: 
+  - bin/rubykarmaclient
+  - test/test_all.rb
+  - test/test_client.rb
+  - test/test_query.rb
+  - test/test_response.rb
+  - lib/karmasphere
+  - lib/karmasphere.rb
+  - lib/rubytorrent
+  - lib/karmasphere/client.rb
+  - lib/karmasphere/constants.rb
+  - lib/karmasphere/debug.rb
+  - lib/karmasphere/query.rb
+  - lib/karmasphere/response.rb
+  - lib/rubytorrent/bencoding.rb
+  - README
+test_files: 
+  - test/test_all.rb
+rdoc_options: []
+extra_rdoc_files: 
+  - README
+executables: 
+  - rubykarmaclient
+extensions: []
+requirements: []
+dependencies: []