activeldap3 1.2.3

data/lib/active_ldap/timeout_stub.rb

@@ -0,0 +1,17 @@
+require 'timeout'
+
+module Timeout
+  # STUB
+  def Timeout.alarm(sec, exception=Timeout::Error, &block)
+    timeout(sec, exception, &block)
+  end
+end # Timeout
+
+if __FILE__ == $0
+  require 'time'
+  Timeout.alarm(2) do 
+    loop do 
+      p Time.now
+    end
+  end
+end

data/lib/active_ldap/user_password.rb

@@ -0,0 +1,92 @@
+require 'English'
+require 'digest/md5'
+require 'digest/sha1'
+
+module ActiveLdap
+  module UserPassword
+    module_function
+    def valid?(password, hashed_password)
+      unless /^\{([A-Z][A-Z\d]+)\}/ =~ hashed_password
+        raise ArgumentError, _("Invalid hashed password: %s") % hashed_password
+      end
+      type = $1
+      hashed_password_without_type = $POSTMATCH
+      normalized_type = type.downcase
+      unless respond_to?(normalized_type)
+        raise ArgumentError, _("Unknown Hash type: %s") % type
+      end
+      salt_extractor = "extract_salt_for_#{normalized_type}"
+      if respond_to?(salt_extractor)
+        salt = send(salt_extractor, hashed_password_without_type)
+        if salt.nil?
+          raise ArgumentError,
+            _("Can't extract salt from hashed password: %s") % hashed_password
+        end
+        generated_password = send(normalized_type, password, salt)
+      else
+        generated_password = send(normalized_type, password)
+      end
+      hashed_password == generated_password
+    end
+
+    def crypt(password, salt=nil)
+      salt ||= "$1$#{Salt.generate(8)}"
+      "{CRYPT}#{password.crypt(salt)}"
+    end
+
+    def extract_salt_for_crypt(crypted_password)
+      if /^\$1\$/ =~ crypted_password
+        $MATCH + $POSTMATCH[0, 8].sub(/\$.*/, '') + "$"
+      else
+        crypted_password[0, 2]
+      end
+    end
+
+    def md5(password)
+      "{MD5}#{[Digest::MD5.digest(password)].pack('m').chomp}"
+    end
+
+    def smd5(password, salt=nil)
+      if salt and salt.size != 4
+        raise ArgumentError, _("salt size must be == 4: %s") % salt.inspect
+      end
+      salt ||= Salt.generate(4)
+      md5_hash_with_salt = "#{Digest::MD5.digest(password + salt)}#{salt}"
+      "{SMD5}#{[md5_hash_with_salt].pack('m').chomp}"
+    end
+
+    def extract_salt_for_smd5(smd5ed_password)
+      Base64.decode64(smd5ed_password)[-4, 4]
+    end
+
+    def sha(password)
+      "{SHA}#{[Digest::SHA1.digest(password)].pack('m').chomp}"
+    end
+
+    def ssha(password, salt=nil)
+      if salt and salt.size != 4
+        raise ArgumentError, _("salt size must be == 4: %s") % salt.inspect
+      end
+      salt ||= Salt.generate(4)
+      sha1_hash_with_salt = "#{Digest::SHA1.digest(password + salt)}#{salt}"
+      "{SSHA}#{[sha1_hash_with_salt].pack('m').chomp}"
+    end
+
+    def extract_salt_for_ssha(sshaed_password)
+      extract_salt_for_smd5(sshaed_password)
+    end
+
+    module Salt
+      CHARS = ['.', '/'] + ['0'..'9', 'A'..'Z', 'a'..'z'].collect do |x|
+        x.to_a
+      end.flatten
+
+      module_function
+      def generate(length)
+        salt = ""
+        length.times {salt << CHARS[rand(CHARS.length)]}
+        salt
+      end
+    end
+  end
+end

data/lib/active_ldap/validations.rb

@@ -0,0 +1,229 @@
+module ActiveLdap
+  module Validations
+    def self.append_features(base)
+      super
+
+      base.class_eval do
+        alias_method :new_record?, :new_entry?
+        class << self
+          alias_method :human_attribute_name_active_ldap,
+                       :human_attribute_name
+        end
+        include ActiveRecord::Validations
+        class << self
+          alias_method :human_attribute_name_active_record,
+                       :human_attribute_name
+          alias_method :human_attribute_name,
+                       :human_attribute_name_active_ldap
+          unless method_defined?(:human_attribute_name_with_gettext)
+            def human_attribute_name_with_gettext(attribute_key_name)
+              s_("#{self}|#{attribute_key_name.humanize}")
+            end
+          end
+        end
+
+        class_local_attr_accessor true, :validation_skip_attributes
+        remove_method :validation_skip_attributes
+        self.validation_skip_attributes = []
+
+        validate :validate_duplicated_dn_creation, :on => :create
+        validate :validate_duplicated_dn_rename, :on => :update
+        validate :validate_dn
+        validate :validate_excluded_classes
+        validate :validate_required_ldap_values
+        validate :validate_ldap_values
+
+        class << self
+          if method_defined?(:evaluate_condition)
+            def evaluate_condition_with_active_ldap_support(condition, entry)
+              evaluate_condition_without_active_ldap_support(condition, entry)
+            rescue ActiveRecord::ActiveRecordError
+              raise Error, $!.message
+            end
+            alias_method_chain :evaluate_condition, :active_ldap_support
+          end
+        end
+
+        def save_with_active_ldap_support!
+          save_without_active_ldap_support!
+        rescue ActiveRecord::RecordInvalid
+          raise EntryInvalid, $!.message
+        end
+        alias_method_chain :save!, :active_ldap_support
+
+        private
+        def run_validations_with_active_ldap_support(validation_method)
+          run_validations_without_active_ldap_support(validation_method)
+        rescue ActiveRecord::ActiveRecordError
+          raise Error, $!.message
+        end
+        if private_method_defined?(:run_validations)
+          alias_method_chain :run_validations, :active_ldap_support
+        else
+          alias_method(:run_callbacks_with_active_ldap_support,
+                       :run_validations_with_active_ldap_support)
+          alias_method_chain :run_callbacks, :active_ldap_support
+          alias_method(:run_validations_without_active_ldap_support,
+                       :run_callbacks_without_active_ldap_support)
+        end
+      end
+    end
+
+    def validation_skip_attributes
+      @validation_skip_attributes ||= []
+    end
+
+    def validation_skip_attributes=(attributes)
+      @validation_skip_attributes = attributes
+    end
+
+    private
+    def format_validation_message(format, parameters)
+      format % parameters
+    end
+
+    def validate_duplicated_dn_creation
+      _dn = nil
+      begin
+        _dn = dn
+      rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
+        return
+      end
+      if _dn and exist?
+        format = _("is duplicated: %s")
+        message = format_validation_message(format, _dn)
+        errors.add("distinguishedName", message)
+      end
+    end
+
+    def validate_duplicated_dn_rename
+      _dn_attribute = dn_attribute_with_fallback
+      original_dn_value = @ldap_data[_dn_attribute]
+      current_dn_value = @data[_dn_attribute]
+      return if original_dn_value == current_dn_value
+      return if original_dn_value == [current_dn_value]
+
+      _dn = nil
+      begin
+        _dn = dn
+      rescue DistinguishedNameInvalid, DistinguishedNameNotSetError
+        return
+      end
+      if _dn and exist?
+        format = _("is duplicated: %s")
+        message = format_validation_message(format, _dn)
+        errors.add("distinguishedName", message)
+      end
+    end
+
+    def validate_dn
+      dn
+    rescue DistinguishedNameInvalid
+      format = _("is invalid: %s")
+      message = format_validation_message(format, $!.message)
+      errors.add("distinguishedName", message)
+    rescue DistinguishedNameNotSetError
+      format = _("isn't set: %s")
+      message = format_validation_message(format, $!.message)
+      errors.add("distinguishedName", message)
+    end
+
+    def validate_excluded_classes
+      excluded_classes = self.class.excluded_classes
+      return if excluded_classes.empty?
+
+      _schema = schema
+      _classes = classes.collect do |name|
+        _schema.object_class(name)
+      end
+      unexpected_classes = excluded_classes.inject([]) do |classes, name|
+        excluded_class = _schema.object_class(name)
+        if _classes.include?(excluded_class)
+          classes << excluded_class
+        end
+        classes
+      end
+      return if unexpected_classes.empty?
+
+      names = unexpected_classes.collect do |object_class|
+        self.class.human_object_class_name(object_class)
+      end
+      format = n_("has excluded value: %s",
+                  "has excluded values: %s",
+                  names.size)
+      message = format_validation_message(format, names.join(", "))
+      errors.add("objectClass", message)
+    end
+
+    # validate_required_ldap_values
+    #
+    # Basic validation:
+    # - Verify that every 'MUST' specified in the schema has a value defined
+    def validate_required_ldap_values
+      _schema = nil
+      @validation_skip_attributes ||= []
+      _validation_skip_attributes =
+        @validation_skip_attributes +
+        (self.class.validation_skip_attributes || [])
+      # Make sure all MUST attributes have a value
+      entry_attribute.object_classes.each do |object_class|
+        object_class.must.each do |required_attribute|
+          # Normalize to ensure we catch schema problems
+          # needed?
+          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?
+          next if _validation_skip_attributes.include?(real_name)
+
+          value = @data[real_name] || []
+          next unless self.class.blank_value?(value)
+
+          _schema ||= schema
+          aliases = required_attribute.aliases.collect do |name|
+            self.class.human_attribute_name(name)
+          end
+          args = [self.class.human_object_class_name(object_class)]
+          if aliases.empty?
+            format = _("is required attribute by objectClass '%s'")
+          else
+            format = _("is required attribute by objectClass " \
+                       "'%s': aliases: %s")
+            args << aliases.join(', ')
+          end
+          message = format_validation_message(format, args)
+          errors.add(real_name, message)
+        end
+      end
+    end
+
+    def validate_ldap_values
+      entry_attribute.schemata.each do |name, attribute|
+        value = self[name]
+        next if self.class.blank_value?(value)
+        validate_ldap_value(attribute, name, value)
+      end
+    end
+
+    def validate_ldap_value(attribute, name, value)
+      failed_reason, option = attribute.validate(value)
+      return if failed_reason.nil?
+      if attribute.binary?
+        inspected_value = _("<binary-value>")
+      else
+        inspected_value = self.class.human_readable_format(value)
+      end
+      params = [inspected_value,
+                self.class.human_syntax_description(attribute.syntax),
+                failed_reason]
+      if option
+        format = _("(%s) has invalid format: %s: required syntax: %s: %s")
+      else
+        format = _("has invalid format: %s: required syntax: %s: %s")
+      end
+      params.unshift(option) if option
+      message = format_validation_message(format, params)
+      errors.add(name, message)
+    end
+  end
+end

data/lib/active_ldap/xml.rb

@@ -0,0 +1,122 @@
+require 'erb'
+require 'builder'
+
+require 'active_ldap/ldif'
+
+module ActiveLdap
+  class Xml
+    class Serializer
+      PRINTABLE_STRING = /[\x20-\x7e\w\s]*/
+
+      def initialize(dn, attributes, schema, options={})
+        @dn = dn
+        @attributes = attributes
+        @schema = schema
+        @options = options
+      end
+
+      def to_s
+        root = @options[:root]
+        indent = @options[:indent] || 2
+        xml = @options[:builder] || Builder::XmlMarkup.new(:indent => indent)
+        xml.tag!(root) do
+          target_attributes.each do |key, values|
+            values = normalize_values(values).sort_by {|value, _| value}
+            if @schema.attribute(key).single_value?
+              serialize_attribute_value(xml, key, *values[0])
+            else
+              serialize_attribute_values(xml, key, values)
+            end
+          end
+        end
+      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 = []
+        case value
+        when Hash
+          value.each do |real_option, real_value|
+            targets.concat(normalize_value(real_value, options + [real_option]))
+          end
+        when Array
+          value.each do |real_value|
+            targets.concat(normalize_value(real_value, options))
+          end
+        when DN
+          targets.concat(normalize_value(value.to_s, options))
+        when nil
+          # ignore
+        else
+          if /\A#{PRINTABLE_STRING}\z/ !~ 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(xml, name, values)
+        return if values.blank?
+
+        if name == "dn" or @options[:type].to_s.downcase == "ldif"
+          values.each do |value, xml_attributes|
+            serialize_attribute_value(xml, name, value, xml_attributes)
+          end
+        else
+          plural_name = name.pluralize
+          attributes = @options[:skip_types] ? {} : {"type" => "array"}
+          xml.tag!(plural_name, attributes) do
+            values.each do |value, xml_attributes|
+              serialize_attribute_value(xml, name, value, xml_attributes)
+            end
+          end
+        end
+      end
+
+      def serialize_attribute_value(xml, name, value, xml_attributes)
+        xml.tag!(name, value, xml_attributes)
+      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