net-ldap 0.0.5 → 0.1.0

data/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::BER::BERParser
+  include Net::LDAP::Extensions::String
+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

data/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.join
+          [code].pack('C') + s.length.to_ber_length_encoding + s
+        end
+      end
+    end
+  end
+end # class Array

data/lib/net/ldap/core_ext/bignum.rb

@@ -0,0 +1,25 @@
+module Net
+  class LDAP
+    module Extensions
+      module Bignum
+
+        def to_ber
+          # NOTE: Array#pack's 'w' is a BER _compressed_ integer. We need uncompressed
+          # BER integers, so we're not using that.
+          # See also: http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-talk/228864
+          result = []
+
+          n = self
+          while n>0
+              b = n & 0xff
+              result << b
+              n = n >> 8
+          end
+
+          "\002" + ([result.size] + result.reverse).pack('C*')
+        end
+
+      end
+    end
+  end
+end

data/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

data/lib/net/ldap/core_ext/fixnum.rb

@@ -0,0 +1,64 @@
+module Net
+  class LDAP
+    module Extensions
+      module Fixnum
+        #
+        # to_ber
+        #
+        def to_ber
+          "\002" + to_ber_internal
+        end
+
+        #
+        # to_ber_enumerated
+        #
+        def to_ber_enumerated
+          "\012" + to_ber_internal
+        end
+
+        #
+        # to_ber_length_encoding
+        #
+        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.
+        MAX_SIZE = 0.size
+        def to_ber_internal
+          size = MAX_SIZE
+          while size>1
+              break if (self & (0xff << (size-1)*8)) > 0 
+              size -= 1
+          end
+
+          result = [size]
+
+          while size>0
+              # right shift size-1 bytes, mask with 0xff 
+              result << ((self >> ((size-1)*8)) & 0xff)
+
+              size -= 1
+          end
+
+          result.pack('C*')
+        end
+        private :to_ber_internal
+      end
+    end
+  end
+end

data/lib/net/ldap/core_ext/string.rb

@@ -0,0 +1,40 @@
+require 'stringio'
+
+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
+      end
+    end
+  end
+end

data/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

data/lib/net/ldap/dataset.rb

@@ -1,6 +1,3 @@
-# $Id$
-#
-#
 #----------------------------------------------------------------------------
 #
 # Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
@@ -22,87 +19,81 @@
 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #
 #---------------------------------------------------------------------------
-#
-#
-
-
-
 
 module Net
-class LDAP
-
-class Dataset < Hash
-
-  attr_reader :comments
-
-
-  def Dataset::read_ldif io
-    ds = Dataset.new
-
-    line = io.gets && chomp
-    dn = nil
-
-    while line
-      io.gets and chomp
-      if $_ =~ /^[\s]+/
-        line << " " << $'
-      else
-        nextline = $_
+  class LDAP
+    class Dataset < Hash
+      attr_reader :comments
 
-        if line =~ /^\#/
-          ds.comments << line
-        elsif line =~ /^dn:[\s]*/i
-          dn = $'
-          ds[dn] = Hash.new {|k,v| k[v] = []}
-        elsif line.length == 0
-          dn = nil
-        elsif line =~ /^([^:]+):([\:]?)[\s]*/
-          # $1 is the attribute name
-          # $2 is a colon iff the attr-value is base-64 encoded
-          # $' is the attr-value
-          # Avoid the Base64 class because not all Ruby versions have it.
-          attrvalue = ($2 == ":") ? $'.unpack('m').shift : $'
-          ds[dn][$1.downcase.intern] << attrvalue
+      class IOFilter
+        def initialize(io)
+          @io = io
+        end
+        def gets
+          s = @io.gets
+          s.chomp if s
         end
-
-        line = nextline
       end
-    end
-  
-    ds
-  end
-
-
-  def initialize
-    @comments = []
-  end
-
-
-  def to_ldif
-    ary = []
-    ary += (@comments || [])
 
-    keys.sort.each {|dn|
-      ary << "dn: #{dn}"
-
-      self[dn].keys.map {|sym| sym.to_s}.sort.each {|attr|
-        self[dn][attr.intern].each {|val|
-          ary << "#{attr}: #{val}"
-        }
-      }
+      def self.read_ldif io
+        ds = Dataset.new
+        io = IOFilter.new(io)
+
+        line = io.gets
+        dn = nil
+
+        while line
+          new_line = io.gets
+          if new_line =~ /^[\s]+/
+            line << " " << $'
+          else
+            nextline = new_line
+
+            if line =~ /^\#/
+              ds.comments << line
+            elsif line =~ /^dn:[\s]*/i
+              dn = $'
+              ds[dn] = Hash.new {|k,v| k[v] = []}
+            elsif line.length == 0
+              dn = nil
+            elsif line =~ /^([^:]+):([\:]?)[\s]*/
+              # $1 is the attribute name
+              # $2 is a colon iff the attr-value is base-64 encoded
+              # $' is the attr-value
+              # Avoid the Base64 class because not all Ruby versions have it.
+              attrvalue = ($2 == ":") ? $'.unpack('m').shift : $'
+              ds[dn][$1.downcase.intern] << attrvalue
+            end
+
+            line = nextline
+          end
+        end
 
-      ary << ""
-    }
+        ds
+      end
 
-    block_given? and ary.each {|line| yield line}
 
-    ary
-  end
+      def initialize
+        @comments = []
+      end
 
 
-end # Dataset
+      def to_ldif
+        ary = []
+        ary += (@comments || [])
+        keys.sort.each do |dn|
+          ary << "dn: #{dn}"
 
-end # LDAP
-end # Net
+          self[dn].keys.map {|sym| sym.to_s}.sort.each do |attr|
+            self[dn][attr.intern].each {|val| ary << "#{attr}: #{val}" }
+          end
 
+          ary << ""
+        end
+        block_given? and ary.each {|line| yield line}
+        ary
+      end
 
+    end 
+  end 
+end

data/lib/net/ldap/entry.rb

@@ -1,8 +1,5 @@
-# $Id$
-#
 # LDAP Entry (search-result) support classes
 #
-#
 #----------------------------------------------------------------------------
 #
 # Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
@@ -26,10 +23,6 @@
 #---------------------------------------------------------------------------
 #
 
-
-require 'base64'
-
-
 module Net
 class LDAP
 
@@ -265,5 +258,3 @@ class LDAP
 
 end # class LDAP
 end # module Net
-
-

data/lib/net/ldap/filter.rb

@@ -1,8 +1,3 @@
-# $Id$
-#
-#
-#----------------------------------------------------------------------------
-#
 # Copyright (C) 2006 by Francis Cianfrocca. All Rights Reserved.
 #
 # Gmail: garbagecat10
@@ -25,6 +20,7 @@
 #
 #
 
+require 'strscan'
 
 module Net
 class LDAP
@@ -408,7 +404,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
 
@@ -495,5 +490,3 @@ end # class Net::LDAP::FilterParser
 
 end # class Net::LDAP
 end # module Net
-
-