net-ldap 0.0.5 → 0.1.0

data/lib/net/ldap/pdu.rb

@@ -1,4 +1,3 @@
-# $Id$
 #
 # LDAP PDU support classes
 #
@@ -24,12 +23,12 @@
 #
 #---------------------------------------------------------------------------
 
-module Net
+require 'ostruct'
 
+module Net
 	class LdapPduError < StandardError; end
 
 	class LdapPdu
-
 		BindRequest = 0
 		BindResult = 1
 		UnbindRequest = 2

data/lib/net/ldap/psw.rb

@@ -1,6 +1,3 @@
-# $Id$
-#
-#
 #----------------------------------------------------------------------------
 #
 # Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
@@ -22,43 +19,39 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 #---------------------------------------------------------------------------
-#
-#
 
+require 'digest/sha1'
+require 'digest/md5'
 
 module Net
-class LDAP
-
-
-class Password
-  class << self
-
-  # Generate a password-hash suitable for inclusion in an LDAP attribute.
-  # Pass a hash type (currently supported: :md5 and :sha) and a plaintext
-  # password. This function will return a hashed representation.
-  # STUB: This is here to fulfill the requirements of an RFC, which one?
-  # TODO, gotta do salted-sha and (maybe) salted-md5.
-  # Should we provide sha1 as a synonym for sha1? I vote no because then
-  # should you also provide ssha1 for symmetry?
-  def generate( type, str )
-    case type
-    when :md5
-      require 'md5'
-      "{MD5}#{ [MD5.new( str.to_s ).digest].pack("m").chomp }"
-    when :sha
-      require 'sha1'
-      "{SHA}#{ [SHA1.new( str.to_s ).digest].pack("m").chomp }"
-    # when ssha
-    else
-      raise Net::LDAP::LdapError.new( "unsupported password-hash type (#{type})" )
+  class LDAP
+    class Password
+      class << self
+        # Generate a password-hash suitable for inclusion in an LDAP
+        # attribute. Pass a hash type (currently supported: :md5 and :sha)
+        # and a plaintext password. This function will return a hashed
+        # representation.
+        #
+        # STUB: This is here to fulfill the requirements of an RFC, which
+        # one?
+        #
+        # TODO, gotta do salted-sha and (maybe) salted-md5.
+        # Should we provide sha1 as a synonym for sha1? I vote no because
+        # then should you also provide ssha1 for symmetry?
+        def generate(type, str)
+          digest, digest_name = case type
+                                when :md5
+                                  [Digest::MD5.new, 'MD5']
+                                when :sha
+                                  [Digest::SHA1.new, 'SHA']
+                                else
+                                  raise Net::LDAP::LdapError.new("unsupported password-hash type (#{type})")
+                                end
+
+          digest << str.to_s
+          return "{#{digest_name}}#{[digest.digest].pack('m').chomp }"
+        end
+      end
     end
-  end
-
-  end
+  end 
 end
-
-
-end # class LDAP
-end # module Net
-
-

data/lib/net/ldif.rb

@@ -27,13 +27,8 @@
 # THIS FILE IS A STUB.
 
 module Net
-
   class LDIF
-
-
-  end # class LDIF
-
-
-end # module Net
+  end
+end
 
 

data/lib/net/snmp.rb

@@ -26,14 +26,12 @@
 #
 #
 
-require 'net/ber'
-
-
 module Net
 
     class SNMP
+      VERSION = '0.1.0'
 
-	AsnSyntax = BER.compile_syntax({
+	AsnSyntax = Net::BER.compile_syntax({
 	    :application => {
 		:primitive => {
 		    1 => :integer,	# Counter32, (RFC2578 sec 2)

data/spec/integration/ssl_ber_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+require 'socket'
+require 'openssl'
+
+require 'net/ldap'
+
+describe "BER serialisation (SSL)" do
+  # Transmits str to #to and reads it back from #from. 
+  #
+  def transmit(str)
+    to.write(str)
+    to.close
+    
+    from.read
+  end
+    
+  attr_reader :to, :from
+  before(:each) do
+    @from, @to = IO.pipe
+    
+    flexmock(OpenSSL::SSL::SSLSocket).
+      new_instances.should_receive(:connect => nil)
+              
+    @to   = Net::LDAP::Connection.wrap_with_ssl(to)
+    @from = Net::LDAP::Connection.wrap_with_ssl(from)
+  end
+  
+  it "should transmit strings" do
+    transmit('foo').should == 'foo'
+  end 
+  it "should correctly transmit numbers" do
+    to.write 1234.to_ber
+    from.read_ber.should == 1234
+  end 
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,3 @@
+Spec::Runner.configure do |config|
+  config.mock_with :flexmock
+end

data/spec/unit/ber/ber_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+
+require 'net/ber'
+require 'net/ldap'
+
+describe "Ber encoding of various types" do
+  def properly_encode_and_decode
+    simple_matcher('properly encode and decode') do |given|
+      given.to_ber.read_ber.should == given
+    end
+  end
+  
+  context "array" do
+    it "should properly encode []" do
+      [].should properly_encode_and_decode
+    end 
+  end
+end

data/test/common.rb

@@ -1,7 +1,3 @@
 # Add 'lib' to load path.
-$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
-
-require 'rubygems'
 require 'test/unit'
-
 require 'net/ldap'

data/test/test_ber.rb

@@ -1,100 +1,78 @@
-# $Id: testber.rb 230 2006-12-19 18:27:57Z blackhedd $
-
+# encoding: ASCII-8BIT
 require 'common'
 
 class TestBer < Test::Unit::TestCase
 
-	def test_encode_boolean
-		assert_equal( "\x01\x01\x01", true.to_ber ) # should actually be: 01 01 ff
-		assert_equal( "\x01\x01\x00", false.to_ber )
-	end
-
-	#def test_encode_nil
-	#	assert_equal( "\x05\x00", nil.to_ber )
-	#end
-
-	def test_encode_integer
-
-		# Fixnum
-		#
-		#assert_equal( "\x02\x02\x96\x46", -27_066.to_ber )
-		#assert_equal( "\x02\x02\xFF\x7F", -129.to_ber )
-		#assert_equal( "\x02\x01\x80", -128.to_ber )
-		#assert_equal( "\x02\x01\xFF", -1.to_ber )
-
-		assert_equal( "\x02\x01\x00", 0.to_ber )
-		assert_equal( "\x02\x01\x01", 1.to_ber )
-		assert_equal( "\x02\x01\x7F", 127.to_ber )
-		assert_equal( "\x02\x02\x00\x80", 128.to_ber )
-		assert_equal( "\x02\x02\x00\xFF", 255.to_ber )
-
-		assert_equal( "\x02\x02\x01\x00", 256.to_ber )
-		assert_equal( "\x02\x03\x00\xFF\xFF", 65535.to_ber )
-
-		assert_equal( "\x02\x03\x01\x00\x00", 65536.to_ber )
-		assert_equal( "\x02\x04\x00\xFF\xFF\xFF", 16_777_215.to_ber )
-
-		assert_equal( "\x02\x04\x01\x00\x00\x00", 0x01000000.to_ber )
-		assert_equal( "\x02\x04\x3F\xFF\xFF\xFF", 0x3FFFFFFF.to_ber )
-
-		# Bignum
-		#
-		assert_equal( "\x02\x04\x4F\xFF\xFF\xFF", 0x4FFFFFFF.to_ber )
-		#assert_equal( "\x02\x05\x00\xFF\xFF\xFF\xFF", 0xFFFFFFFF.to_ber )
-	end
-
-	# TOD Add some much bigger numbers
-	# 5000000000 is a Bignum, which hits different code.
-	def test_ber_integers
-		assert_equal( "\002\001\005", 5.to_ber )
-		assert_equal( "\002\002\001\364", 500.to_ber )
-		assert_equal( "\002\003\0\303P", 50000.to_ber )
-		assert_equal( "\002\005\001*\005\362\000", 5000000000.to_ber )
-	end
-
-	def test_ber_bignums
-		# Some of these values are Fixnums and some are Bignums. Different BER code.
-		[
-			5,
-			50,
-			500,
-			5000,
-			50000,
-			500000,
-			5000000,
-			50000000,
-			500000000,
-			1000000000,
-			2000000000,
-			3000000000,
-			4000000000,
-			5000000000
-		].each {|val|
-			assert_equal( val, val.to_ber.read_ber )
-		}
-	end
-
-	def test_ber_parsing
-		assert_equal( 6, "\002\001\006".read_ber( Net::LDAP::AsnSyntax ))
-		assert_equal( "testing", "\004\007testing".read_ber( Net::LDAP::AsnSyntax ))
-	end
-
-	def test_ber_parser_on_ldap_bind_request
-		require 'stringio'
-
-		s = StringIO.new(
-			"0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus" )
-
-		assert_equal(
-			[1, [3, "Administrator", "ad_is_bogus"]],
-			s.read_ber( Net::LDAP::AsnSyntax ))
-	end
-
-	def test_oid
-		oid = Net::BER::BerIdentifiedOid.new( [1,3,6,1,2,1,1,1,0] )
-		assert_equal( "\006\b+\006\001\002\001\001\001\000", oid.to_ber )
-
-		oid = Net::BER::BerIdentifiedOid.new( "1.3.6.1.2.1.1.1.0" )
-		assert_equal( "\006\b+\006\001\002\001\001\001\000", oid.to_ber )
-	end
+  def test_encode_boolean
+    assert_equal( "\x01\x01\x01", true.to_ber ) # should actually be: 01 01 ff
+    assert_equal( "\x01\x01\x00", false.to_ber )
+  end
+
+  #def test_encode_nil
+  # assert_equal( "\x05\x00", nil.to_ber )
+  #end
+
+  def test_encode_integer
+
+    # Fixnum
+    #
+    #assert_equal( "\x02\x02\x96\x46", -27_066.to_ber )
+    #assert_equal( "\x02\x02\xFF\x7F", -129.to_ber )
+    #assert_equal( "\x02\x01\x80", -128.to_ber )
+    #assert_equal( "\x02\x01\xFF", -1.to_ber )
+
+    assert_equal( "\x02\x01\x00", 0.to_ber )
+    assert_equal( "\x02\x01\x01", 1.to_ber )
+    assert_equal( "\x02\x01\x7F", 127.to_ber )
+    assert_equal( "\x02\x01\x80", 128.to_ber )
+    assert_equal( "\x02\x01\xFF", 255.to_ber )
+
+    assert_equal( "\x02\x02\x01\x00", 256.to_ber )
+    assert_equal( "\x02\x02\xFF\xFF", 65535.to_ber )
+
+    assert_equal( "\x02\x03\x01\x00\x00", 65536.to_ber )
+    assert_equal( "\x02\x03\xFF\xFF\xFF", 16_777_215.to_ber )
+
+    assert_equal( "\x02\x04\x01\x00\x00\x00", 0x01000000.to_ber )
+    assert_equal( "\x02\x04\x3F\xFF\xFF\xFF", 0x3FFFFFFF.to_ber )
+
+    # Bignum
+    #
+    assert_equal( "\x02\x04\x4F\xFF\xFF\xFF", 0x4FFFFFFF.to_ber )
+    #assert_equal( "\x02\x05\x00\xFF\xFF\xFF\xFF", 0xFFFFFFFF.to_ber )
+  end
+
+  # TOD Add some much bigger numbers
+  # 5000000000 is a Bignum, which hits different code.
+  def test_ber_integers
+    assert_equal( "\002\001\005", 5.to_ber )
+    assert_equal( "\002\002\001\364", 500.to_ber )
+    assert_equal( "\x02\x02\xC3P", 50000.to_ber )
+    assert_equal( "\002\005\001*\005\362\000", 5000000000.to_ber )
+  end
+
+  def test_ber_bignums
+    # Some of these values are Fixnums and some are Bignums. Different BER code.
+    100.times do |p|
+      n = 2 << p
+      assert_equal(n, n.to_ber.read_ber, "2**#{p} could not be read back")
+        
+      n = 5 * 10**p
+      assert_equal(n, n.to_ber.read_ber)
+    end
+  end
+
+  def test_ber_parsing
+    assert_equal( 6, "\002\001\006".read_ber( Net::LDAP::AsnSyntax ))
+    assert_equal( "testing", "\004\007testing".read_ber( Net::LDAP::AsnSyntax ))
+  end
+
+  def test_ber_parser_on_ldap_bind_request
+    s = StringIO.new(
+      "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus" )
+
+    assert_equal(
+      [1, [3, "Administrator", "ad_is_bogus"]],
+      s.read_ber( Net::LDAP::AsnSyntax ))
+  end
 end

data/test/test_filter.rb

@@ -74,7 +74,7 @@ class TestFilter < Test::Unit::TestCase
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
 			Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
 		].each {|ber|
-			f = Net::LDAP::Filter.parse_ber( ber.to_ber.read_ber( Net::LDAP::AsnSyntax) )
+		f = Net::LDAP::Filter.parse_ber( ber.to_ber.read_ber( Net::LDAP::AsnSyntax) )
 			assert( f == ber )
 			assert_equal( f.to_ber, ber.to_ber )
 		}

data/test/test_ldif.rb

@@ -11,7 +11,7 @@ class TestLdif < Test::Unit::TestCase
   TestLdifFilename = "#{File.dirname(__FILE__)}/testdata.ldif"
 
   def test_empty_ldif
-    ds = Net::LDAP::Dataset::read_ldif( StringIO.new )
+    ds = Net::LDAP::Dataset.read_ldif( StringIO.new )
     assert_equal( true, ds.empty? )
   end
 

data/test/test_snmp.rb

@@ -18,111 +18,94 @@ class TestSnmp < Test::Unit::TestCase
   end
 
   def test_invalid_packet
-      data = "xxxx"
-      assert_raise( Net::BER::BerError ) {
-	ary = data.read_ber(Net::SNMP::AsnSyntax)
-      }
+    data = "xxxx"
+    assert_raise( Net::BER::BerError ) {
+ary = data.read_ber(Net::SNMP::AsnSyntax)
+    }
 
   end
 
-  # The method String#read_ber! added by Net::BER consumes a well-formed BER object
-  # from the head of a string. If it doesn't find a complete, well-formed BER object,
-  # it returns nil and leaves the string unchanged. If it finds an object, it returns
-  # the object and removes it from the head of the string. This is good for handling
-  # partially-received data streams, such as from network connections.
-  def test_consume_string
-      data = "xxx"
-      assert_equal( nil, data.read_ber! )
-      assert_equal( "xxx", data )
-
-      data = SnmpGetRequest + "!!!"
-      ary = data.read_ber!( Net::SNMP::AsnSyntax )
-      assert_equal( "!!!", data )
-      assert ary.is_a?(Array)
-      assert ary.is_a?(Net::BER::BerIdentifiedArray)
-  end
-
   def test_weird_packet
-      assert_raise( Net::SnmpPdu::Error ) {
-	Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
-      }
+    assert_raise( Net::SnmpPdu::Error ) {
+Net::SnmpPdu.parse("aaaaaaaaaaaaaa")
+    }
   end
 
   def test_get_request
-      data = SnmpGetRequest.dup
-      pkt = data.read_ber(Net::SNMP::AsnSyntax)
-      assert pkt.is_a?(Net::BER::BerIdentifiedArray)
-      assert_equal( 48, pkt.ber_identifier) # Constructed [0], signifies GetRequest
+    data = SnmpGetRequest.dup
+    pkt = data.read_ber(Net::SNMP::AsnSyntax)
+    assert pkt.is_a?(Net::BER::BerIdentifiedArray)
+    assert_equal( 48, pkt.ber_identifier) # Constructed [0], signifies GetRequest
 
-      pdu = Net::SnmpPdu.parse(pkt)
-      assert_equal(:get_request, pdu.pdu_type )
-      assert_equal(16170, pdu.request_id ) # whatever was in the test data. 16170 is not magic.
-      assert_equal( [[[1,3,6,1,2,1,1,1,0],nil]], pdu.variables )
+    pdu = Net::SnmpPdu.parse(pkt)
+    assert_equal(:get_request, pdu.pdu_type )
+    assert_equal(16170, pdu.request_id ) # whatever was in the test data. 16170 is not magic.
+    assert_equal( [[[1,3,6,1,2,1,1,1,0],nil]], pdu.variables )
 
-      assert_equal( pdu.to_ber_string, SnmpGetRequest )
+    assert_equal( pdu.to_ber_string, SnmpGetRequest )
   end
 
   def test_empty_pdu
-      pdu = Net::SnmpPdu.new
-      assert_raise( Net::SnmpPdu::Error ) {
-	pdu.to_ber_string
-      }
+    pdu = Net::SnmpPdu.new
+    assert_raise( Net::SnmpPdu::Error ) {
+pdu.to_ber_string
+    }
   end
 
   def test_malformations
-      pdu = Net::SnmpPdu.new
-	pdu.version = 0
-	pdu.version = 2
-      assert_raise( Net::SnmpPdu::Error ) {
-	pdu.version = 100
-      }
-
-      pdu.pdu_type = :get_request
-      pdu.pdu_type = :get_next_request
-      pdu.pdu_type = :get_response
-      pdu.pdu_type = :set_request
-      pdu.pdu_type = :trap
-      assert_raise( Net::SnmpPdu::Error ) {
-	pdu.pdu_type = :something_else
-      }
+    pdu = Net::SnmpPdu.new
+    pdu.version = 0
+    pdu.version = 2
+    assert_raise( Net::SnmpPdu::Error ) {
+      pdu.version = 100
+    }
+
+    pdu.pdu_type = :get_request
+    pdu.pdu_type = :get_next_request
+    pdu.pdu_type = :get_response
+    pdu.pdu_type = :set_request
+    pdu.pdu_type = :trap
+    assert_raise( Net::SnmpPdu::Error ) {
+      pdu.pdu_type = :something_else
+    }
   end
 
   def test_make_response
-      pdu = Net::SnmpPdu.new
-      pdu.version = 0
-      pdu.community = "public"
-      pdu.pdu_type = :get_response
-      pdu.request_id = 9999
-      pdu.error_status = 0
-      pdu.error_index = 0
-      pdu.add_variable_binding [1,3,6,1,2,1,1,1,0], "test"
-
-      assert_equal( SnmpGetResponse,  pdu.to_ber_string )
+    pdu = Net::SnmpPdu.new
+    pdu.version = 0
+    pdu.community = "public"
+    pdu.pdu_type = :get_response
+    pdu.request_id = 9999
+    pdu.error_status = 0
+    pdu.error_index = 0
+    pdu.add_variable_binding [1,3,6,1,2,1,1,1,0], "test"
+
+    assert_equal( SnmpGetResponse,  pdu.to_ber_string )
   end
 
   def test_make_bad_response
-      pdu = Net::SnmpPdu.new
-      assert_raise(Net::SnmpPdu::Error) {pdu.to_ber_string}
-      pdu.pdu_type = :get_response
-      pdu.request_id = 999
-      pdu.to_ber_string
-      # Not specifying variables doesn't create an error. (Maybe it should?)
+    pdu = Net::SnmpPdu.new
+    assert_raise(Net::SnmpPdu::Error) {pdu.to_ber_string}
+    pdu.pdu_type = :get_response
+    pdu.request_id = 999
+    pdu.to_ber_string
+    # Not specifying variables doesn't create an error. (Maybe it should?)
   end
 
   def test_snmp_integers
-      c32 = Net::SNMP::Counter32.new(100)
-      assert_equal( "A\001d", c32.to_ber )
-      g32 = Net::SNMP::Gauge32.new(100)
-      assert_equal( "B\001d", g32.to_ber )
-      t32 = Net::SNMP::TimeTicks32.new(100)
-      assert_equal( "C\001d", t32.to_ber )
+    c32 = Net::SNMP::Counter32.new(100)
+    assert_equal( "A\001d", c32.to_ber )
+    g32 = Net::SNMP::Gauge32.new(100)
+    assert_equal( "B\001d", g32.to_ber )
+    t32 = Net::SNMP::TimeTicks32.new(100)
+    assert_equal( "C\001d", t32.to_ber )
   end
 
   def test_community
-      data = SnmpGetRequestXXX.dup
-      ary = data.read_ber(Net::SNMP::AsnSyntax)
-      pdu = Net::SnmpPdu.parse( ary )
-      assert_equal( "xxxxxx", pdu.community )
+    data = SnmpGetRequestXXX.dup
+    ary = data.read_ber(Net::SNMP::AsnSyntax)
+    pdu = Net::SnmpPdu.parse( ary )
+    assert_equal( "xxxxxx", pdu.community )
   end
 
 end