activeldap 1.0.1 → 1.0.2

data/lib/active_ldap/configuration.rb

@@ -23,7 +23,7 @@ module ActiveLdap
 
     DEFAULT_CONFIG = {}
     DEFAULT_CONFIG[:host] = '127.0.0.1'
-    DEFAULT_CONFIG[:port] = 389
+    DEFAULT_CONFIG[:port] = nil
     DEFAULT_CONFIG[:method] = :plain  # :ssl, :tls, :plain allowed
 
     DEFAULT_CONFIG[:bind_dn] = nil

data/lib/active_ldap/connection.rb

@@ -213,11 +213,14 @@ module ActiveLdap
       conn = @connection
       return conn if conn
 
-      if @dn or
-          (attribute_name_resolvable_without_connection? and
-           get_attribute_before_type_cast(dn_attribute)[1])
-        conn = self.class.active_connections[dn] || retrieve_connection
+      have_dn = !@dn.nil?
+      if !have_dn and attribute_name_resolvable_without_connection?
+        begin
+          have_dn = !get_attribute_before_type_cast(dn_attribute)[1].nil?
+        rescue DistinguishedNameInvalid
+        end
       end
+      conn = self.class.active_connections[dn] || retrieve_connection if have_dn
       conn || self.class.connection
     end
 

data/lib/active_ldap/get_text.rb

@@ -1,7 +1,15 @@
-begin
-  require "gettext/active_record"
+if Object.const_defined?(:GetText)
+  require 'active_record/version'
+  active_record_version = [ActiveRecord::VERSION::MAJOR,
+                           ActiveRecord::VERSION::MINOR,
+                           ActiveRecord::VERSION::TINY]
+  if (active_record_version <=> [2, 2, 0]) < 0
+    require "gettext/active_record"
+  end
   ActiveLdap.const_set("GetText", GetText)
-rescue LoadError
+end
+
+unless ActiveLdap.const_defined?(:GetText)
   require 'active_ldap/get_text_fallback'
 end
 

data/lib/active_ldap/ldif.rb

@@ -31,11 +31,19 @@ module ActiveLdap
       SIZE = 75
 
       module_function
+      def binary_value?(value)
+        if /\A#{Parser::SAFE_STRING}\z/u =~ value
+          false
+        else
+          true
+        end
+      end
+
       def encode(name, value)
         return "#{name}:\n" if value.blank?
         result = "#{name}:"
 
-        if value[-1, 1] == ' ' or /\A#{Parser::SAFE_STRING}\z/u !~ value
+        if value[-1, 1] == ' ' or binary_value?(value)
           result << ":"
           value = [value].pack("m").gsub(/\n/u, '')
         end
@@ -364,6 +372,9 @@ module ActiveLdap
           records << parse_record
           break if @scanner.eos?
           raise separator_is_missing if @scanner.scan_separator.nil?
+
+          break if @scanner.eos?
+          break if @scanner.scan_separators and @scanner.eos?
         end
         records
       end
@@ -475,6 +486,7 @@ module ActiveLdap
 
     class Scanner
       SEPARATOR = /(?:\r\n|\n)/u
+      SEPARATORS = /(?:(?:^#.*)?#{SEPARATOR})+/u
 
       def initialize(source)
         @source = source
@@ -506,13 +518,13 @@ module ActiveLdap
       end
 
       def scan_separators
-        return @scanner.scan(/#{SEPARATOR}+/u) if @sub_scanner.eos?
+        return @scanner.scan(SEPARATORS) if @sub_scanner.eos?
 
-        sub_result = scan(/#{SEPARATOR}+/u)
+        sub_result = scan(SEPARATORS)
         return nil if sub_result.nil?
         return sub_result unless @sub_scanner.eos?
 
-        result = @scanner.scan(/#{SEPARATOR}+/u)
+        result = @scanner.scan(SEPARATORS)
         return sub_result if result.nil?
 
         sub_result + result

data/lib/active_ldap/operations.rb

@@ -34,7 +34,11 @@ module ActiveLdap
 
         value = value.first if value.is_a?(Array) and value.first.size == 1
 
-        _attr, value, _prefix = split_search_value(value)
+        _attr = nil
+        _prefix = nil
+        if attr.nil? or attr == dn_attribute
+          _attr, value, _prefix = split_search_value(value)
+        end
         attr ||= _attr || ensure_search_attribute
         prefix ||= _prefix
         filter ||= [attr, value]
@@ -117,7 +121,9 @@ module ActiveLdap
       end
 
       def ensure_base(target)
-        [truncate_base(target),  base].join(',')
+        [truncate_base(target), base].reject do |component|
+          component.blank?
+        end.join(',')
       end
 
       def truncate_base(target)
@@ -383,10 +389,12 @@ module ActiveLdap
 
       module ModifyRecordLoadable
         def load(operator, options)
-          each do |operation|
-            operator.modify_entry(dn, operation.to_modify_entries,
-                                  {:controls => controls}.merge(options))
+          modify_entries = operations.inject([]) do |result, operation|
+            result + operation.to_modify_entries
           end
+          return if modify_entries.empty?
+          operator.modify_entry(dn, modify_entries,
+                                {:controls => controls}.merge(options))
         end
 
         module AddOperationModifiable

data/lib/active_ldap/schema.rb

@@ -189,7 +189,7 @@ module ActiveLdap
 
     def parse_attributes(str, attributes)
       str.scan(/([A-Z\-_]+)\s+
-                (?:\(\s*([\w\-]+(?:\s+\$\s+[\w\-]+)+)\s*\)|
+                (?:\(\s*(\w[\w\-;]*(?:\s+\$\s+\w[\w\-;]*)*)\s*\)|
                    \(\s*([^\)]*)\s*\)|
                    '([^\']*)'|
                    ((?!#{RESERVED_NAMES_RE})[a-zA-Z][a-zA-Z\d\-;]*)|
@@ -611,8 +611,12 @@ module ActiveLdap
         end
       end
 
+      UNWRITABLE_MUST_ATTRIBUTES = ["nTSecurityDescriptor"]
       def collect_attributes
-        must = attribute('MUST').collect {|name| @schema.attribute(name)}
+        must = attribute('MUST').reject do |name|
+          UNWRITABLE_MUST_ATTRIBUTES.include?(name)
+        end
+        must = must.collect {|name| @schema.attribute(name)}
         may = attribute('MAY').collect {|name| @schema.attribute(name)}
 
         all_must = must.dup

data/lib/active_ldap/schema/syntaxes.rb

@@ -187,9 +187,21 @@ module ActiveLdap
             fraction = match_data[-2]
             fraction = fraction.to_f if fraction
             time_zone = match_data[-1]
-            Time.send(:make_time,
-                      year, month, day, hour, minute, second, fraction,
-                      time_zone, Time.now)
+            begin
+              Time.send(:make_time,
+                        year, month, day, hour, minute, second, fraction,
+                        time_zone, Time.now)
+            rescue ArgumentError
+              raise if year >= 1700
+              out_of_range_messages = ["argument out of range",
+                                       "time out of range"]
+              raise unless out_of_range_messages.include?($!.message)
+              Time.at(0)
+            rescue RangeError
+              raise if year >= 1700
+              raise if $!.message != "bignum too big to convert into `long'"
+              Time.at(0)
+            end
           else
             value
           end

data/lib/active_ldap/user_password.rb

@@ -43,7 +43,7 @@ module ActiveLdap
     end
 
     def md5(password)
-      "{MD5}#{Base64.encode64(MD5.md5(password).digest).chomp}"
+      "{MD5}#{[MD5.md5(password).digest].pack('m').chomp}"
     end
 
     def smd5(password, salt=nil)
@@ -52,7 +52,7 @@ module ActiveLdap
       end
       salt ||= Salt.generate(4)
       md5_hash_with_salt = "#{MD5.md5(password + salt).digest}#{salt}"
-      "{SMD5}#{Base64.encode64(md5_hash_with_salt).chomp}"
+      "{SMD5}#{[md5_hash_with_salt].pack('m').chomp}"
     end
 
     def extract_salt_for_smd5(smd5ed_password)
@@ -60,7 +60,7 @@ module ActiveLdap
     end
 
     def sha(password)
-      "{SHA}#{Base64.encode64(SHA1.sha1(password).digest).chomp}"
+      "{SHA}#{[SHA1.sha1(password).digest].pack('m').chomp}"
     end
 
     def ssha(password, salt=nil)
@@ -69,7 +69,7 @@ module ActiveLdap
       end
       salt ||= Salt.generate(4)
       sha1_hash_with_salt = "#{SHA1.sha1(password + salt).digest}#{salt}"
-      "{SSHA}#{Base64.encode64(sha1_hash_with_salt).chomp}"
+      "{SSHA}#{[sha1_hash_with_salt].pack('m').chomp}"
     end
 
     def extract_salt_for_ssha(sshaed_password)

data/lib/active_ldap/validations.rb

@@ -34,6 +34,7 @@ module ActiveLdap
         end
 
         validate_on_create :validate_duplicated_dn_creation
+        validate :validate_dn
         validate :validate_excluded_classes
         validate :validate_required_ldap_values
         validate :validate_ldap_values
@@ -76,14 +77,24 @@ module ActiveLdap
 
     private
     def validate_duplicated_dn_creation
-      if id and exist?
-        if ActiveLdap.get_text_supported?
-          format = _("%{fn} is duplicated: %s")
-        else
-          format = _("is duplicated: %s")
-        end
-        errors.add("dn", format % dn)
+      _dn = nil
+      begin
+        _dn = dn
+      rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
+        return
       end
+      if _dn and exist?
+        format = _("is duplicated: %s")
+        errors.add("dn", format % _dn)
+      end
+    end
+
+    def validate_dn
+      dn
+    rescue DistinguishedNameInvalid
+      errors.add("dn", _("is invalid: %s") % $!.message)
+    rescue DistinguishedNameNotSetError
+      errors.add("dn", _("isn't set: %s") % $!.message)
     end
 
     def validate_excluded_classes
@@ -101,17 +112,9 @@ module ActiveLdap
       names = unexpected_classes.collect do |object_class|
         self.class.human_object_class_name(object_class)
       end
-      if ActiveLdap.get_text_supported?
-        format = n_("%{fn} has excluded value: %s",
-                    "%{fn} has excluded values: %s",
-                    names.size)
-      else
-        if names.size == 1
-          format = "has excluded value: %s"
-        else
-          format = "has excluded values: %s"
-        end
-      end
+      format = n_("has excluded value: %s",
+                  "has excluded values: %s",
+                  names.size)
       errors.add("objectClass", format % names.join(", "))
     end
 
@@ -129,6 +132,8 @@ module ActiveLdap
           real_name = to_real_attribute_name(required_attribute.name, true)
           raise UnknownAttribute.new(required_attribute) if real_name.nil?
 
+          next if required_attribute.read_only?
+
           value = @data[real_name] || []
           next unless self.class.blank_value?(value)
 
@@ -137,20 +142,12 @@ module ActiveLdap
             self.class.human_attribute_name(name)
           end
           args = [self.class.human_object_class_name(object_class)]
-          if ActiveLdap.get_text_supported?
-            if aliases.empty?
-              format = _("%{fn} is required attribute by objectClass '%s'")
-            else
-              format = _("%{fn} is required attribute by objectClass " \
-                         "'%s': aliases: %s")
-              args << aliases.join(', ')
-            end
+          if aliases.empty?
+            format = _("is required attribute by objectClass '%s'")
           else
-            format = "is required attribute by objectClass '%s'"
-            unless aliases.empty?
-              format << ": aliases: %s"
-              args << aliases.join(', ')
-            end
+            format = _("is required attribute by objectClass " \
+                       "'%s': aliases: %s")
+            args << aliases.join(', ')
           end
           errors.add(real_name, format % args)
         end
@@ -160,7 +157,7 @@ module ActiveLdap
     def validate_ldap_values
       entry_attribute.schemata.each do |name, attribute|
         value = self[name]
-        next if value.nil?
+        next if value.blank?
         validate_ldap_value(attribute, name, value)
       end
     end
@@ -171,19 +168,10 @@ module ActiveLdap
       params = [self.class.human_readable_format(value),
                 self.class.human_syntax_description(attribute.syntax),
                 failed_reason]
-      if ActiveLdap.get_text_supported?
-        if option
-          format =
-            _("%{fn} (%s) has invalid format: %s: required syntax: %s: %s")
-        else
-          format = _("%{fn} has invalid format: %s: required syntax: %s: %s")
-        end
+      if option
+        format = _("(%s) has invalid format: %s: required syntax: %s: %s")
       else
-        if option
-          format = _("(%s) has invalid format: %s: required syntax: %s: %s")
-        else
-          format = _("has invalid format: %s: required syntax: %s: %s")
-        end
+        format = _("has invalid format: %s: required syntax: %s: %s")
       end
       params.unshift(option) if option
       errors.add(name, format % params)

data/lib/active_ldap/xml.rb

@@ -0,0 +1,125 @@
+require 'erb'
+
+require 'active_ldap/ldif'
+
+module ActiveLdap
+  class Xml
+    class Serializer
+      PRINTABLE_STRING = /[\x20-\x7e\w\s]*/um
+
+      def initialize(dn, attributes, schema, options={})
+        @dn = dn
+        @attributes = attributes
+        @schema = schema
+        @options = options
+      end
+
+      def to_s
+        root = @options[:root]
+        result = "<#{root}>\n"
+        target_attributes.each do |key, values|
+          values = normalize_values(values).sort_by {|value, _| value}
+          if @schema.attribute(key).single_value?
+            result << "  #{serialize_attribute_value(key, *values[0])}\n"
+          else
+            result << serialize_attribute_values(key, values)
+          end
+        end
+        result << "</#{root}>\n"
+        result
+      end
+
+      private
+      def target_attributes
+        except_dn = false
+        attributes = @attributes.dup
+        (@options[:except] || []).each do |name|
+          if name == "dn"
+            except_dn = true
+          else
+            attributes.delete(name)
+          end
+        end
+        attributes = attributes.sort_by {|key, values| key}
+        attributes.unshift(["dn", [@dn]]) unless except_dn
+        attributes
+      end
+
+      def normalize_values(values)
+        targets = []
+        values.each do |value|
+          targets.concat(normalize_value(value))
+        end
+        targets
+      end
+
+      def normalize_value(value, options=[])
+        targets = []
+        if value.is_a?(Hash)
+          value.each do |real_option, real_value|
+            targets.concat(normalize_value(real_value, options + [real_option]))
+          end
+        elsif value.is_a?(Array)
+          value.each do |real_value|
+            targets.concat(normalize_value(real_value, options))
+          end
+        else
+          if /\A#{PRINTABLE_STRING}\z/u !~ value
+            value = [value].pack("m").gsub(/\n/u, '')
+            options += ["base64"]
+          end
+          xml_attributes = {}
+          options.each do |name, val|
+            xml_attributes[name] = val || "true"
+          end
+          targets << [value, xml_attributes]
+        end
+        targets
+      end
+
+      def serialize_attribute_values(name, values)
+        return "" if values.blank?
+
+        result = ""
+        if name == "dn" or @options[:type].to_s.downcase == "ldif"
+          values.collect do |value, xml_attributes|
+            xml = serialize_attribute_value(name, value, xml_attributes)
+            result << "  #{xml}\n"
+          end
+        else
+          plural_name = name.pluralize
+          result << "  <#{plural_name} type=\"array\">\n"
+          values.each do |value, xml_attributes|
+            xml = serialize_attribute_value(name, value, xml_attributes)
+            result << "    #{xml}\n"
+          end
+          result << "  </#{plural_name}>\n"
+        end
+        result
+      end
+
+      def serialize_attribute_value(name, value, xml_attributes)
+        if xml_attributes.blank?
+          xml_attributes = ""
+        else
+          xml_attributes = " " + xml_attributes.collect do |n, v|
+            "#{ERB::Util.h(n)}=\"#{ERB::Util.h(v)}\""
+          end.join(" ")
+        end
+        "<#{name}#{xml_attributes}>#{ERB::Util.h(value)}</#{name}>"
+      end
+    end
+
+    def initialize(dn, attributes, schema)
+      @dn = dn
+      @attributes = attributes
+      @schema = schema
+    end
+
+    def to_s(options={})
+      Serializer.new(@dn, @attributes, @schema, options).to_s
+    end
+  end
+
+  XML = Xml
+end