activesambaldap 0.0.1

data/lib/active_samba_ldap/base.rb

@@ -0,0 +1,126 @@
+module ActiveSambaLdap
+  class Error < StandardError
+  end
+
+  class RequiredVariableIsNotSet < Error
+    attr_reader :name
+    def initialize(name)
+      @name = name
+      super("required variable '#{name}' is not set")
+    end
+  end
+
+  class RequiredVariablesAreNotSet < RequiredVariableIsNotSet
+    attr_reader :names
+    def initialize(names)
+      @names = names
+      super("required variables '#{names.join(', ')}' are not set")
+    end
+  end
+
+  class UidNumberAlreadyExists < Error
+    attr_reader :number
+    def initialize(number)
+      @number = number
+      super("uid number '#{@number}' already exists")
+    end
+  end
+
+  class GroupDoesNotExist < Error
+    attr_reader :name
+    def initialize(name)
+      @name = name
+      super("group '#{@name}' doesn't exist")
+    end
+  end
+
+  class GidNumberAlreadyExists < Error
+    attr_reader :number
+    def initialize(number)
+      @number = number
+      super("gid number '#{@number}' already exists")
+    end
+  end
+
+  class GidNumberDoesNotExist < Error
+    attr_reader :number
+    def initialize(number)
+      @number = number
+      super("gid number '#{@number}' doesn't exist")
+    end
+  end
+
+  class GroupDoesNotHaveSambaSID < Error
+    attr_reader :number
+    def initialize(number)
+      @number = number
+      super("sambaSID attribute doesn't exist for gid number '#{@number}'")
+    end
+  end
+
+  class CanNotChangePrimaryGroup < Error
+    attr_reader :group, :members
+    def initialize(group, members)
+      @group = group
+      @members = members
+      message = "cannot change primary group from '#{group}' to other group "
+      message << "due to no other belonged groups: #{members.join(', ')}"
+      super(message)
+    end
+  end
+
+  class PrimaryGroupCanNotBeDestroyed < Error
+    attr_reader :group, :members
+    def initialize(group, members)
+      @group = group
+      @members = members
+      message = "cannot destroy group '#{group}' due to members who belong "
+      message << "to the group as primary group: #{members.join(', ')}"
+      super(message)
+    end
+  end
+
+  class InvalidConfigurationFormatError < Error
+    attr_reader :file, :location, :detail
+    def initialize(file, location, detail)
+      @file = file
+      @location = location
+      @detail = detail
+      super("found invalid configuration format at #{@file}:#{@location}" +
+            ": #{@detail}")
+    end
+  end
+
+  class InvalidConfigurationValueError < Error
+    attr_reader :name, :value, :detail
+    def initialize(name, value, detail)
+      @name = name
+      @value = value
+      @detail = detail
+      super("the value of #{@name} '#{@value.inspect}' is invalid: #{@detail}")
+    end
+  end
+
+  class Base < ActiveLdap::Base
+    include Reloadable::Subclasses
+
+    class << self
+      def restart_nscd
+        nscd_working = system("/etc/init.d/nscd status >/dev/null 2>&1")
+        system("/etc/init.d/nscd stop >/dev/null 2>&1") if nscd_working
+        yield if block_given?
+      ensure
+        system("/etc/init.d/nscd start >/dev/null 2>&1") if nscd_working
+      end
+
+      private
+      def extract_ldap_mapping_options(options)
+        extracted_options = {}
+        ActiveLdap::Base::VALID_LDAP_MAPPING_OPTIONS.each do |key|
+          extracted_options[key] = options[key] if options.has_key?(key)
+        end
+        extracted_options
+      end
+    end
+  end
+end

data/lib/active_samba_ldap/command.rb

@@ -0,0 +1,94 @@
+require 'optparse'
+require 'ostruct'
+
+module ActiveSambaLdap
+  module Command
+    module_function
+    def parse_options(argv=nil)
+      argv ||= ARGV.dup
+      options = OpenStruct.new
+      configuration_files = default_configuration_files
+      opts = OptionParser.new do |opts|
+        yield(opts, options)
+
+        opts.separator ""
+        opts.separator "Common options:"
+
+        opts.on_tail("--config=CONFIG",
+                     "Specify configuration file",
+                     "Default configuration files:",
+                     *configuration_files.collect {|x| "  #{x}"}) do |file|
+          configuration_files << file
+        end
+
+        opts.on_tail("-h", "--help", "Show this message") do
+          puts opts
+          exit
+        end
+
+        opts.on_tail("--version", "Show version") do
+          puts VERSION
+          exit
+        end
+      end
+
+      begin
+        opts.parse!(argv)
+      rescue OptionParser::ParseError
+        $stderr.puts($!)
+        $stderr.puts(opts)
+        exit 1
+      end
+
+      read_configuration_files(configuration_files)
+
+      [argv, opts, options]
+    end
+
+    def read_password(prompt, input=$stdin, output=$stdout)
+      output.print prompt
+      system "/bin/stty -echo" if input.tty?
+      input.gets.chomp
+    ensure
+      system "/bin/stty echo" if input.tty?
+      output.puts
+    end
+
+    def default_configuration_files
+      configuration_files = File.join(File.dirname(__FILE__),
+                                      "configuration_files")
+      if File.exists?(configuration_files)
+        files = File.readlines(configuration_files).collect do |line|
+          line.strip
+        end.reject do |line|
+          line.empty? or /^#/ =~ line
+        end
+      else
+        files = [
+          "/etc/activesambaldap/config.yaml",
+          "/etc/activesambaldap/bind.yaml",
+        ]
+      end
+      begin
+        configuration_files_for_user = [
+          File.expand_path(File.join("~", ".activesambaldap.conf")),
+          File.expand_path(File.join("~", ".activesambaldap.bind")),
+        ]
+        files.concat(configuration_files_for_user)
+      rescue ArgumentError
+      end
+      files
+    end
+
+    def read_configuration_files(files)
+      return if files.empty?
+      Base.configurations = files.inject({}) do |result, file|
+        if File.readable?(file)
+          result.merge(Configuration.read(file))
+        else
+          result
+        end
+      end
+    end
+  end
+end

data/lib/active_samba_ldap/computer.rb

@@ -0,0 +1,13 @@
+require 'active_samba_ldap/account'
+require 'active_samba_ldap/computer_account'
+
+module ActiveSambaLdap
+  class Computer < Base
+    include Reloadable::Subclasses
+
+    include Entry
+
+    include Account
+    include ComputerAccount
+  end
+end

data/lib/active_samba_ldap/computer_account.rb

@@ -0,0 +1,34 @@
+module ActiveSambaLdap
+  module ComputerAccount
+    NAME_RE = /\A#{Account::NAME_RE_SRC}\$\z/
+
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+      base.validates_format_of :uid, :with => NAME_RE
+    end
+
+    module ClassMethods
+      def valid_name?(name)
+        NAME_RE =~ name ? true : false
+      end
+
+      private
+      def default_prefix
+        configuration[:computers_suffix]
+      end
+    end
+
+    def remove_from_group(group)
+      group.computers.delete(self)
+    end
+
+    def default_gid_number
+      self.class.configuration[:default_computer_gid]
+    end
+
+    def created_group_name
+      super.sub(/\$$/, '')
+    end
+  end
+end

data/lib/active_samba_ldap/configuration.rb

@@ -0,0 +1,322 @@
+require 'socket'
+
+module ActiveSambaLdap
+  module Configuration
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    class << self
+      def read(file)
+        require 'yaml'
+        require 'erb'
+        erb = ERB.new(File.read(file))
+        erb.filename = file
+        result = nil
+        begin
+          begin
+            result = YAML.load(erb.result)
+            unless result
+              raise InvalidConfigurationFormatError.new(file, "0",
+                                                        "empty source")
+            end
+          rescue ArgumentError
+            if /syntax error on line (\d+), col (\d+): `(.*)'/ =~ $!.message
+              raise InvalidConfigurationFormatError.new(file, "#{$1}:#{$2}", $3)
+            else
+              raise
+            end
+          end
+        rescue InvalidConfigurationFormatError
+          raise
+        rescue Exception
+          file, location = $@.first.split(/:/, 2)
+          detail = "#{$!.class}: #{$!.message}"
+          raise InvalidConfigurationFormatError.new(file, location, detail)
+        end
+        result
+      end
+    end
+
+    module ClassMethods
+      class ValidHash < Hash
+        def [](name)
+          if Private.required_variables.include?(name) and !has_key?(name)
+            raise RequiredVariableIsNotSet.new(name)
+          end
+          super(name)
+        end
+      end
+
+      def merge_configuration(config)
+        config = config.symbolize_keys
+        config = (configurations["common"] || {}).symbolize_keys.merge(config)
+        ValidHash.new.merge(super(Private.new(config).merge))
+      end
+
+      def required_configuration_variables(*names)
+        config = configuration
+        if config.nil?
+          missing_variables = names
+        else
+          missing_variables = names.find_all do |name|
+            config[name.to_sym].nil?
+          end
+        end
+        unless missing_variables.empty?
+          raise RequiredVariablesAreNotSet.new(missing_variables)
+        end
+      end
+
+      class Private
+        VARIABLES = %w(base host port scope bind_dn
+                       password method allow_anonymous
+
+                       sid smb_conf samba_domain samba_netbios_name
+                       password_hash_type
+
+                       users_suffix groups_suffix computers_suffix
+                       idmap_suffix
+
+                       start_uid start_gid
+
+                       user_login_shell user_home_directory
+                       user_home_directory_mode
+                       user_gecos user_home_unc user_profile
+                       user_home_drive user_logon_script mail_domain
+
+                       skeleton_directory
+
+                       default_user_gid default_computer_gid
+                       default_max_password_age)
+
+        class << self
+          def required_variables
+            @required_variables ||= compute_required_variables
+          end
+
+          def compute_required_variables
+            not_required_variables = %w(base ldap_scope)
+            (VARIABLES - public_methods - not_required_variables).collect do |x|
+              x.to_sym
+            end
+          end
+        end
+
+        def initialize(target)
+          @target = target.symbolize_keys
+        end
+
+        def merge
+          result = @target.dup
+          VARIABLES.each do |variable|
+            key = variable.to_sym
+            result[key] ||= send(variable) if respond_to?(variable)
+
+            normalize_method = "normalize_#{variable}"
+            if respond_to?(normalize_method)
+              result[key] = __send__(normalize_method, result[key])
+            end
+
+            validate_method = "validate_#{variable}"
+            if respond_to?(validate_method)
+              __send__(validate_method, result[key])
+            end
+          end
+          result
+        end
+
+        def [](name)
+          @target[name.to_sym] || (respond_to?(name) ? send(name) : nil)
+        end
+
+        def sid
+          result = `net getlocalsid`
+          if $?.success?
+            result.chomp.gsub(/\G[^:]+:\s*/, '')
+          else
+            nil
+          end
+        end
+
+        def smb_conf
+          %w(/etc/samba/smb.conf /usr/local/etc/samba/smb.conf).each do |guess|
+            return guess if File.exist?(guess)
+          end
+          nil
+        end
+
+        def samba_domain
+          _smb_conf = self["smb_conf"]
+          if _smb_conf
+            File.open(_smb_conf) do |f|
+              f.read.grep(/^\s*[^#;]/).each do |line|
+                if /^\s*workgroup\s*=\s*(\S+)\s*$/i =~ line
+                  return $1.upcase
+                end
+              end
+            end
+          else
+            nil
+          end
+        end
+
+        def samba_netbios_name
+          netbios_name = nil
+          _smb_conf = self["smb_conf"]
+          if _smb_conf
+            File.open(_smb_conf) do |f|
+              f.read.grep(/^\s*[^#;]/).each do |line|
+                if /^\s*netbios\s*name\s*=\s*(.+)\s*$/i =~ line
+                  netbios_name = $1
+                  break
+                end
+              end
+            end
+          end
+          netbios_name ||= Socket.gethostname
+          netbios_name ? netbios_name.upcase : nil
+        end
+
+        def host
+          "localhost"
+        end
+
+        def port
+          389
+        end
+
+        def allow_anonymous
+          false
+        end
+
+        def method
+          :plain
+        end
+
+        def users_suffix
+          retrieve_value_from_smb_conf(/ldap\s+user\s+suffix/i) || "ou=Users"
+        end
+
+        def groups_suffix
+          retrieve_value_from_smb_conf(/ldap\s+group\s+suffix/i) || "ou=Groups"
+        end
+
+        def computers_suffix
+          retrieve_value_from_smb_conf(/ldap\s+machine\s+suffix/i) ||
+            "ou=Computers"
+        end
+
+        def idmap_suffix
+          retrieve_value_from_smb_conf(/ldap\s+idmap\s+suffix/i) || "ou=Idmap"
+        end
+
+        def start_uid
+          10000
+        end
+
+        def start_gid
+          10000
+        end
+
+        def default_user_gid
+          rid = ActiveSambaLdap::SambaGroup::DOMAIN_USERS_RID
+          ActiveSambaLdap::SambaGroup.rid2gid(rid)
+        end
+
+        def default_computer_gid
+          rid = ActiveSambaLdap::SambaGroup::DOMAIN_COMPUTERS_RID
+          ActiveSambaLdap::SambaGroup.rid2gid(rid)
+        end
+
+        def skeleton_directory
+          "/etc/skel"
+        end
+
+        def user_home_unc
+          netbios_name = self["samba_netbios_name"]
+          netbios_name ? "\\\\#{netbios_name}\\%U" : nil
+        end
+
+        def user_profile
+          netbios_name = self["samba_netbios_name"]
+          netbios_name ? "\\\\#{netbios_name}\\profiles\\%U" : nil
+        end
+
+        def user_home_directory
+          "/home/%U"
+        end
+
+        def user_home_directory_mode
+          0755
+        end
+
+        def normalize_user_home_directory_mode(mode)
+          if mode
+            Integer(mode)
+          else
+            nil
+          end
+        rescue ArgumentError
+          raise InvalidConfigurationValueError.new("user_home_directory",
+                                                   mode, $!.message)
+        end
+
+        def user_login_shell
+          "/bin/false"
+        end
+
+        def user_home_drive
+          "H:"
+        end
+
+        def user_logon_script
+          "logon.bat"
+        end
+
+        def user_gecos
+          nil
+        end
+
+        def bind_dn
+          nil
+        end
+
+        def password_hash_type
+          :ssha
+        end
+
+        def normalize_password_hash_type(type)
+          type.to_s.downcase.to_sym
+        end
+
+        AVAILABLE_HASH_TYPES = [:crypt, :md5, :smd5, :sha, :ssha]
+        def validate_password_hash_type(type)
+          unless AVAILABLE_HASH_TYPES.include?(type)
+            types = AVAILABLE_HASH_TYPES.collect {|x| x.inspect}.join(", ")
+            raise InvalidConfigurationValueError.new("password_hash_type",
+                                                     type,
+                                                     "must be in #{types}")
+          end
+        end
+
+        private
+        def retrieve_value_from_smb_conf(key)
+          smb_conf = self['smb_conf']
+          if smb_conf and File.readable?(smb_conf)
+            line = File.read(smb_conf).grep(key).reject do |l|
+              /^\s*[#;]/ =~ l
+            end.first
+            if line
+              line.split(/=/, 2)[1].strip
+            else
+              nil
+            end
+          else
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_samba_ldap/dc.rb

@@ -0,0 +1,17 @@
+module ActiveSambaLdap
+  class Dc < Base
+    include Reloadable::Subclasses
+
+    class << self
+      def ldap_mapping(options={})
+        default_options = {
+          :dn_attribute => "dc",
+          :prefix => "",
+          :classes => ["top", "dcObject", "organization"],
+        }
+        options = default_options.merge(options)
+        super(options)
+      end
+    end
+  end
+end

data/lib/active_samba_ldap/entry.rb

@@ -0,0 +1,80 @@
+module ActiveSambaLdap
+  module Entry
+    def self.included(base)
+      super
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def create(attributes=nil)
+        pool = nil
+        number_key = nil
+        ensure_ou((attributes || {})[dn_attribute.to_sym])
+        entry = super do |entry|
+          options = attributes || {}
+          options, pool, number_key = prepare_create_options(entry, options)
+          entry.fill_default_values(options)
+          yield entry if block_given?
+        end
+        if entry.errors.empty? and pool
+          pool[number_key] = Integer(entry[number_key]).succ
+          unless pool.save
+            pool.each do |key, value|
+              entry.add("pool: #{key}", value)
+            end
+          end
+        end
+        entry
+      end
+
+      private
+      def ensure_ou(dn)
+        return if dn.nil?
+        dn_value, ou = dn.split(/,/, 2)
+        return if ou.nil?
+        prefixes = [prefix]
+        ou.split(/\s*,\s*/).reverse_each do |entry|
+          name, value = entry.split(/\s*=\s*/, 2).collect {|x| x.strip}
+          raise ArgumentError, "#{ou} must be only ou" if name != "ou"
+          ou_class = Class.new(ActiveSambaLdap::Ou)
+          ou_class.ldap_mapping :prefix => prefixes.join(',')
+          prefixes.unshift(entry)
+          next if ou_class.exists?(value)
+          ou = ou_class.new(value)
+          ou.save!
+        end
+      end
+
+      def prepare_create_options_for_number(key, entry, options)
+        options = {key => entry[key]}.merge(options)
+        number, pool = ensure_number(key, options)
+        [options.merge(key => number), pool, key]
+      end
+
+      def ensure_number(key, options)
+        number = options[key]
+        pool = nil
+        unless number
+          pool = ensure_pool(options)
+          number = pool.send("find_available_#{key}", self)
+        end
+        [number, pool]
+      end
+
+      def ensure_pool(options)
+        pool = options[:pool]
+        unless pool
+          pool_class = options[:pool_class]
+          unless pool_class
+            pool_class = Class.new(UnixIdPool)
+            pool_class.ldap_mapping
+          end
+          samba_domain = options[:samba_domain]
+          samba_domain ||= pool_class.configuration[:samba_domain]
+          pool = options[:pool] = pool_class.find(samba_domain)
+        end
+        pool
+      end
+    end
+  end
+end