Cleaned up the layout quite a bit to make Gemifying and including into Rails 3 less painful. Some steps to 1.9 compatibility

lib/net/ldap/core_ext/all.rb

@@ -0,0 +1,43 @@
+require 'net/ldap/core_ext/array'
+require 'net/ldap/core_ext/string'
+require 'net/ldap/core_ext/bignum'
+require 'net/ldap/core_ext/fixnum'
+require 'net/ldap/core_ext/false_class'
+require 'net/ldap/core_ext/true_class'
+
+class Array
+  include Net::LDAP::Extensions::Array
+end
+
+class String
+  include Net::LDAP::Extensions::String
+  include Net::BER::BERParser
+end
+
+class Bignum
+  include Net::LDAP::Extensions::Bignum
+end
+
+class Fixnum
+  include Net::LDAP::Extensions::Fixnum
+end
+
+class FalseClass
+  include Net::LDAP::Extensions::FalseClass
+end
+
+class TrueClass
+  include Net::LDAP::Extensions::TrueClass
+end
+
+class IO
+  include Net::BER::BERParser
+end
+
+class StringIO
+  include Net::BER::BERParser
+end
+
+class OpenSSL::SSL::SSLSocket
+  include Net::BER::BERParser
+end

lib/net/ldap/core_ext/array.rb

@@ -0,0 +1,42 @@
+module Net
+  class LDAP
+    module Extensions
+      module Array
+        #
+        # to_ber_appsequence
+        # An application-specific sequence usually gets assigned
+        # a tag that is meaningful to the particular protocol being used.
+        # This is different from the universal sequence, which usually
+        # gets a tag value of 16.
+        # Now here's an interesting thing: We're adding the X.690
+        # "application constructed" code at the top of the tag byte (0x60),
+        # but some clients, notably ldapsearch, send "context-specific
+        # constructed" (0xA0). The latter would appear to violate RFC-1777,
+        # but what do I know? We may need to change this.
+        #
+
+        def to_ber                 id = 0; to_ber_seq_internal( 0x30 + id ); end
+        def to_ber_set             id = 0; to_ber_seq_internal( 0x31 + id ); end
+        def to_ber_sequence        id = 0; to_ber_seq_internal( 0x30 + id ); end
+        def to_ber_appsequence     id = 0; to_ber_seq_internal( 0x60 + id ); end
+        def to_ber_contextspecific id = 0; to_ber_seq_internal( 0xA0 + id ); end
+
+        def to_ber_oid
+          ary = self.dup
+          first = ary.shift
+          raise Net::BER::BerError.new( "invalid OID" ) unless [0,1,2].include?(first)
+          first = first * 40 + ary.shift
+          ary.unshift first
+          oid = ary.pack("w*")
+          [6, oid.length].pack("CC") + oid
+        end
+
+        private
+        def to_ber_seq_internal code
+          s = self.to_s
+          [code].pack('C') + s.length.to_ber_length_encoding + s
+        end
+      end
+    end
+  end
+end # class Array

lib/net/ldap/core_ext/bignum.rb

@@ -0,0 +1,38 @@
+module Net
+  class LDAP
+    module Extensions
+      module Bignum
+
+        def to_ber
+          #i = [self].pack('w')
+          #i.length > 126 and raise Net::BER::BerError.new( "range error in bignum" )
+          #[2, i.length].pack("CC") + i
+
+          # Ruby represents Bignums as two's-complement numbers so we may actually be
+          # good as far as representing negatives goes.
+          # I'm sure this implementation can be improved performance-wise if necessary.
+          # Ruby's Bignum#size returns the number of bytes in the internal representation
+          # of the number, but it can and will include leading zero bytes on at least
+          # some implementations. Evidently Ruby stores these as sets of quadbytes.
+          # It's not illegal in BER to encode all of the leading zeroes but let's strip
+          # them out anyway.
+          #
+          sz = self.size
+          out = "\000" * sz
+          (sz*8).times {|bit|
+      	if self[bit] == 1
+      	    out[bit/8] += (1 << (bit % 8))
+      	end
+          }
+
+          while out.length > 1 and out[-1] == 0
+      	out.slice!(-1,1)
+          end
+
+          [2, out.length].pack("CC") + out.reverse
+        end
+
+      end
+    end
+  end
+end

lib/net/ldap/core_ext/false_class.rb

@@ -0,0 +1,11 @@
+module Net
+  class LDAP
+    module Extensions
+      module FalseClass
+        def to_ber
+          "\001\001\000"
+        end
+      end
+    end
+  end
+end

lib/net/ldap/core_ext/fixnum.rb

@@ -0,0 +1,52 @@
+module Net
+  class LDAP
+    module Extensions
+      module Fixnum
+        def to_ber
+          "\002" + to_ber_internal
+        end
+
+        def to_ber_enumerated
+          "\012" + to_ber_internal
+        end
+
+        def to_ber_length_encoding
+          if self <= 127
+            [self].pack('C')
+          else
+            i = [self].pack('N').sub(/^[\0]+/,"")
+            [0x80 + i.length].pack('C') + i
+          end
+        end
+
+        # Generate a BER-encoding for an application-defined INTEGER.
+        # Example: SNMP's Counter, Gauge, and TimeTick types.
+        #
+        def to_ber_application tag
+            [0x40 + tag].pack("C") + to_ber_internal
+        end
+
+        #--
+        # Called internally to BER-encode the length and content bytes of a Fixnum.
+        # The caller will prepend the tag byte.
+        def to_ber_internal
+          # PLEASE optimize this code path. It's awfully ugly and probably slow.
+          # It also doesn't understand negative numbers yet.
+          raise Net::BER::BerError.new( "range error in fixnum" ) unless self >= 0
+          z = [self].pack("N")
+          zlen = if self < 0x80
+      	1
+          elsif self < 0x8000
+      	2
+          elsif self < 0x800000
+      	3
+          else
+      	4
+          end
+          [zlen].pack("C") + z[0-zlen,zlen]
+        end
+        private :to_ber_internal
+      end
+    end
+  end
+end

lib/net/ldap/core_ext/string.rb

@@ -0,0 +1,48 @@
+module Net
+  class LDAP
+    module Extensions
+      module String
+        #
+        # to_ber
+        # A universal octet-string is tag number 4,
+        # but others are possible depending on the context, so we
+        # let the caller give us one.
+        # The preferred way to do this in user code is via to_ber_application_sring
+        # and to_ber_contextspecific.
+        #
+        def to_ber code = 4
+          [code].pack('C') + length.to_ber_length_encoding + self
+        end
+
+        #
+        # to_ber_application_string
+        #
+        def to_ber_application_string code
+          to_ber( 0x40 + code )
+        end
+
+        #
+        # to_ber_contextspecific
+        #
+        def to_ber_contextspecific code
+          to_ber( 0x80 + code )
+        end
+        
+        def read_ber syntax=nil
+      	  StringIO.new(self).read_ber(syntax)
+        end
+          
+        def read_ber! syntax=nil
+      	  obj,n_consumed = read_ber_from_string(self, syntax)
+      	  if n_consumed
+      	    self.slice!(0...n_consumed)
+      	    obj
+      	  else
+      	    nil
+      	  end
+        end
+        
+      end
+    end
+  end
+end

lib/net/ldap/core_ext/true_class.rb

@@ -0,0 +1,11 @@
+module Net
+  class LDAP
+    module Extensions
+      module TrueClass
+        def to_ber
+          "\001\001\001"
+        end
+      end
+    end
+  end
+end

lib/net/ldap/entry.rb

@@ -26,10 +26,6 @@
 #---------------------------------------------------------------------------
 #
 
-
-require 'base64'
-
-
 module Net
 class LDAP
 

lib/net/ldap/filter.rb

@@ -408,7 +408,6 @@ class FilterParser #:nodoc:
   attr_reader :filter
 
   def initialize str
-    require 'strscan'
     @filter = parse( StringScanner.new( str )) or raise Net::LDAP::LdapError.new( "invalid filter syntax" )
   end
 

lib/net/ldap/psw.rb

@@ -43,10 +43,8 @@ class Password
   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