Merge branch 'ldap-cleanup', remote branch 'halostatue/ldap-cleanup' into ldap-cleanup

Author: Rory O'Connell

lib/net/ldap.rb

@@ -629,7 +629,7 @@ def search(args = {})
     if @open_connection
       @result = @open_connection.search(args) { |entry|
         result_set << entry if result_set
-        yield(entry) if block_given?
+        yield entry if block_given?
       }
     else
       @result = 0
@@ -639,7 +639,7 @@ def search(args = {})
         if (@result = conn.bind(args[:auth] || @auth)) == 0
           @result = conn.search(args) { |entry|
             result_set << entry if result_set
-            yield(entry) if block_given?
+            yield entry if block_given?
           }
         end
       ensure
@@ -1041,7 +1041,7 @@ def search_root_dse
                 :attributes => [ :namingContexts, :supportedLdapVersion,
                   :altServer, :supportedControl, :supportedExtension,
                   :supportedFeatures, :supportedSASLMechanisms])
-    (rs and rs.first) or Entry.new
+    (rs and rs.first) or Net::LDAP::Entry.new
   end
 
   # Return the root Subschema record from the LDAP server as a
@@ -1072,16 +1072,16 @@ def search_subschema_entry
     rs = search(:ignore_server_caps => true, :base => "",
                 :scope => SearchScope_BaseObject,
                 :attributes => [:subschemaSubentry])
-    return Entry.new unless (rs and rs.first)
+    return Net::LDAP::Entry.new unless (rs and rs.first)
 
     subschema_name = rs.first.subschemasubentry
-    return Entry.new unless (subschema_name and subschema_name.first)
+    return Net::LDAP::Entry.new unless (subschema_name and subschema_name.first)
 
     rs = search(:ignore_server_caps => true, :base => subschema_name.first,
                 :scope => SearchScope_BaseObject,
                 :filter => "objectclass=subschema",
                 :attributes => [:objectclasses, :attributetypes])
-    (rs and rs.first) or Entry.new
+    (rs and rs.first) or Net::LDAP::Entry.new
   end
 
   #--
@@ -1405,7 +1405,7 @@ def search(args = {})
         case pdu.app_tag
         when 4 # search-data
           n_results += 1
-          yield(pdu.search_entry) if block_given?
+          yield pdu.search_entry if block_given?
         when 19 # search-referral
           if return_referrals
             if block_given?

lib/net/ldap/dataset.rb

@@ -20,80 +20,155 @@
 #
 #---------------------------------------------------------------------------
 
-module Net
-  class LDAP
-    class Dataset < Hash
-      attr_reader :comments
-
-      class IOFilter
-        def initialize(io)
-          @io = io
-        end
-        def gets
-          s = @io.gets
-          s.chomp if s
-        end
+##
+# An LDAP Dataset. Used primarily as an intermediate format for converting
+# to and from LDIF strings and Net::LDAP::Entry objects.
+class Net::LDAP::Dataset < Hash
+  ##
+  # Dataset object comments.
+  attr_reader :comments
+
+  class << self
+    class ChompedIO #:nodoc:
+      def initialize(io)
+        @io = io
       end
+      def gets
+        s = @io.gets
+        s.chomp if s
+      end
+    end
 
-      def self.read_ldif io
-        ds = Dataset.new
-        io = IOFilter.new(io)
+    ##
+    # Reads an object that returns data line-wise (using #gets) and parses
+    # LDIF data into a Dataset object.
+    def read_ldif(io) #:yields: entry-type, value Used mostly for debugging.
+      ds = Net::LDAP::Dataset.new
+      io = ChompedIO.new(io)
 
-        line = io.gets
-        dn = nil
+      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
+      while line
+        new_line = io.gets
+
+        if new_line =~ /^[\s]+/
+          line << " " << $'
+        else
+          nextline = new_line
+
+          if line =~ /^#/
+            ds.comments << line
+            yield :comment, line if block_given?
+          elsif line =~ /^dn:[\s]*/i
+            dn = $'
+            ds[dn] = Hash.new { |k,v| k[v] = [] }
+            yield :dn, dn if block_given?
+          elsif line.empty?
+            dn = nil
+            yield :end, nil if block_given?
+          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.to_sym] << attrvalue
+            yield :attr, [$1.downcase.to_sym, attrvalue] if block_given?
           end
-        end
 
-        ds
+          line = nextline
+        end
       end
 
+      ds
+    end
 
-      def initialize
-        @comments = []
+    ##
+    # Creates a Dataset object from an Entry object. Used mostly to assist
+    # with the conversion of
+    def from_entry(entry)
+      dataset = Net::LDAP::Dataset.new
+      hash = { }
+      entry.each_attribute do |attribute, value|
+        next if attribute == :dn
+        hash[attribute] = value
       end
+      dataset[entry.dn] = hash
+      dataset
+    end
+  end
 
+  def initialize(*args, &block) #:nodoc:
+    super
+    @comments = []
+  end
 
-      def to_ldif
-        ary = []
-        ary += (@comments || [])
-        keys.sort.each do |dn|
-          ary << "dn: #{dn}"
+  ##
+  # Outputs an LDAP Dataset as an array of strings representing LDIF
+  # entries.
+  def to_ldif
+    ary = []
+    ary += @comments unless @comments.empty?
+    keys.sort.each do |dn|
+      ary << "dn: #{dn}"
 
-          self[dn].keys.map {|sym| sym.to_s}.sort.each do |attr|
-            self[dn][attr.intern].each {|val| ary << "#{attr}: #{val}" }
+      attributes = self[dn].keys.map { |attr| attr.to_s }.sort
+      attributes.each do |attr|
+        self[dn][attr.to_sym].each do |value|
+          if attr == "userpassword" or value_is_binary?(value)
+            value = [value].pack("m").chomp.gsub(/\n/m, "\n ")
+            ary << "#{attr}:: #{value}"
+          else
+            ary << "#{attr}: #{value}"
           end
-
-          ary << ""
         end
-        block_given? and ary.each {|line| yield line}
-        ary
       end
 
-    end 
-  end 
+      ary << ""
+    end
+    block_given? and ary.each { |line| yield line}
+
+    ary
+  end
+
+  ##
+  # Outputs an LDAP Dataset as an LDIF string.
+  def to_ldif_string
+    to_ldif.join("\n")
+  end
+
+  ##
+  # Convert the parsed LDIF objects to Net::LDAP::Entry objects.
+  def to_entries
+    ary = []
+    keys.each do |dn|
+      entry = Net::LDAP::Entry.new(dn)
+      self[dn].each do |attr, value|
+        entry[attr] = value
+      end
+      ary << entry
+    end
+    ary
+  end
+
+  # This is an internal convenience method to determine if a value requires
+  # base64-encoding before conversion to LDIF output. The standard approach
+  # in most LDAP tools is to check whether the value is a password, or if
+  # the first or last bytes are non-printable. Microsoft Active Directory,
+  # on the other hand, sometimes sends values that are binary in the middle.
+  #
+  # In the worst cases, this could be a nasty performance killer, which is
+  # why we handle the simplest cases first. Ideally, we would also test the
+  # first/last byte, but it's a bit harder to do this in a way that's
+  # compatible with both 1.8.6 and 1.8.7.
+  def value_is_binary?(value)
+    value = value.to_s
+    return true if value[0] == ?: or value[0] == ?<
+    value.each_byte { |byte| return true if (byte < 32) || (byte > 126) }
+    false
+  end
+  private :value_is_binary?
 end
+
+require 'net/ldap/entry' unless defined? Net::LDAP::Entry