jruby-ldap-patched 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: '0080239062c69814c70892ff187d97b2a34126bd'
+  data.tar.gz: c35f493949efff7a1066b118770f7cc6561161bd
+SHA512:
+  metadata.gz: 24bfa5207760d5b22596fb256ce96528091c1c8ca86081369580f4b203054e46b75dcb94fa977b7da60050c2556bf87673f7bdad34cf6a5bf3ab4d79b9578709
+  data.tar.gz: 2716208db8625414b0719ef79609c8efd8845eab75872939c039ce5e0ffb9f1e2f94fe0d81a6d74755a88e656a2a94e331e523ffe4aa9feb2e1aa3fe025261bd

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in jruby-ldap.gemspec
+gemspec

data/History.txt

@@ -0,0 +1,7 @@
+== 0.0.2 (03/12/12)
+
+- 1.9 compatibility (thanks Arkadiy Kraportov)
+
+== 0.0.1 (10/09/07)
+
+- Initial release.

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Ola Bini <ola.bini@gmail.com>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,14 @@
+JRuby/LDAP
+-----------
+
+This is an interface compatible port of Ruby/LDAP - to allow binary LDAP usage through JRuby. This implementation is pure Ruby, but uses the Java Integration features of JRuby to access the JNDI libraries and through these implement the correct functionality.
+
+Many classes are missing right now, but the base functionality should be there.
+
+
+Usage
+-----
+require 'rubygems'
+require 'ldap'
+
+And then use it like all tutorials of Ruby/LDAP show you.

data/Rakefile

@@ -0,0 +1,14 @@
+require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+task :default => [:test, :build]
+
+desc "Run all tests"
+task :test => [:test_all]
+
+Rake::TestTask.new(:test_all) do |t|
+  t.test_files = FileList['test/**/test_*.rb']
+  t.libs << 'test'
+  t.libs.delete("lib") unless defined?(JRUBY_VERSION)
+end
+

data/jruby-ldap.gemspec

@@ -0,0 +1,20 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "jruby-ldap/version"
+
+Gem::Specification.new do |s|
+  s.name        = "jruby-ldap-patched"
+  s.version     = JRuby::LDAP::VERSION
+  s.authors     = ["Ola Bini", "Peter Souter"]
+  s.email       = ["ola.bini@gmail.com"]
+  s.homepage    = "https://github.com/petems/jruby-ldap-patched"
+  s.summary     = "Port of Ruby/LDAP to JRuby, with patch for Puppetserver"
+  s.description = "Port of Ruby/LDAP to JRuby, with patch for Puppetserver"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency 'rake', '< 11.0'
+end

data/lib/jruby-ldap.rb

@@ -0,0 +1,7 @@
+require "jruby-ldap/version"
+
+module JRuby
+  module LDAP
+    # Your code goes here...
+  end
+end

data/lib/jruby-ldap/version.rb

@@ -0,0 +1,5 @@
+module JRuby
+  module LDAP
+    VERSION = "0.0.3"
+  end
+end

data/lib/ldap.rb

@@ -0,0 +1,83 @@
+require 'java'
+
+module LDAP
+  def self.err2string(err)
+    case err||0
+    when -1 then "Can't contact LDAP server"
+    when 0 then "Success"
+    when 1 then "Operations error"
+    when 2 then "Protocol error"
+    when 3 then "Time limit exceeded"
+    when 4 then "Size limit exceeded"
+    when 5 then "Compare False"
+    when 6 then "Compare True"
+    when 7 then "Authentication method not supported"
+    when 8 then "Strong(er) authentication required"
+    when 9 then "Partial results and referral received"
+    when 10 then "Referral"
+    when 11 then "Administrative limit exceeded"
+    when 12 then "Critical extension is unavailable"
+    when 13 then "Confidentiality required"
+    when 14 then "SASL bind in progress"
+    when 15 then "Unknown error"
+    when 16 then "No such attribute"
+    when 17 then "Undefined attribute type"
+    when 18 then "Inappropriate matching"
+    when 19 then "Constraint violation"
+    when 20 then "Type or value exists"
+    when 21 then "Invalid syntax"
+    when 32 then "No such object"
+    when 33 then "Alias problem"
+    when 34 then "Invalid DN syntax"
+    when 35 then "Entry is a leaf"
+    when 36 then "Alias dereferencing problem"
+    when 47 then "Proxy Authorization Failure"
+    when 48 then "Inappropriate authentication"
+    when 49 then "Invalid credentials"
+    when 50 then "Insufficient access"
+    when 51 then "Server is busy"
+    when 52 then "Server is unavailable"
+    when 53 then "Server is unwilling to perform"
+    when 54 then "Loop detected"
+    when 64 then "Naming violation"
+    when 65 then "Object class violation"
+    when 66 then "Operation not allowed on non-leaf"
+    when 67 then "Operation not allowed on RDN"
+    when 68 then "Already exists"
+    when 69 then "Cannot modify object class"
+    when 70 then "Results too large"
+    when 71 then "Operation affects multiple DSAs"
+    when 80 then "Internal (implementation specific) error"
+    else "Unknown error"
+    end
+  end
+
+  def self.load_configuration(attrs={})
+    env = nil
+    env = javax.naming.directory.InitialDirContext.new.environment rescue nil
+    default = {'java.naming.factory.initial' => 'com.sun.jndi.ldap.LdapCtxFactory'}
+    if env
+      env2 = default.dup
+      env.each do |k,v|
+        env2[k.to_s] = v.to_s
+      end
+      env = env2
+    else
+      env = default.dup
+    end
+    env.merge! attrs
+    @environment = env
+  end
+  
+  def self.configuration(attrs = { })
+    @environment.merge attrs
+  end
+end
+
+require 'ldap/constants'
+require 'ldap/conn'
+require 'ldap/entry'
+require 'ldap/error'
+require 'ldap/mod'
+
+LDAP.load_configuration

data/lib/ldap/conn.rb

@@ -0,0 +1,285 @@
+module LDAP  
+  module ConnImplementation
+
+    if RUBY_PLATFORM =~ /^java.*/i
+      class LDAP::Entry
+        def to_hash
+           h = {}
+           get_attributes.each { |a| h[a.to_sym] = self[a] }
+           h[:dn] = [dn]
+           h
+        end
+      end
+    end
+
+    def controls(*args)
+      raise "NOT IMPLEMENTED"
+    end
+
+    def get_option(*args)
+      raise "NOT IMPLEMENTED"
+    end
+    
+    # Modify the RDN of the entry with DN, +dn+, giving it the new RDN,
+    # +new_rdn+. If +delete_old_rdn+ is *true*, the old RDN value will be deleted
+    # from the entry.
+    def modrdn(dn, new_rdn, delete_old_rdn)
+      begin 
+        if delete_old_rdn
+          @context.rename(dn, new_rdn)
+        else
+          obj = @context.lookup(dn)
+          @context.bind(new_rdn, obj)
+        end
+        @err = 0
+      rescue javax.naming.NameAlreadyBoundException => e
+        @err = 68
+      rescue javax.naming.InvalidNameException => e
+        @err = 34
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+      rescue javax.naming.directory.SchemaViolationException => e
+        @err = 65
+      rescue javax.naming.NamingException => e
+        @err = 21
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+      rescue javax.naming.NamingException => e
+        @err = -1
+      end
+      raise LDAP::ResultError.wrap(LDAP::err2string(@err), e) if @err != 0
+      self
+    end
+
+    def perror(*args)
+      raise "NOT IMPLEMENTED"
+    end
+
+    def referrals(*args)
+      raise "NOT IMPLEMENTED"
+    end
+    
+    def result2error(*args)
+      raise "NOT IMPLEMENTED"
+    end
+
+    def __jndi_context
+      @context
+    end
+    
+    def initialize(host='localhost', port=LDAP_PORT)
+      @host = host
+      @port = port
+    end
+    
+    def err
+      @err || 0
+    end
+    
+    def err2string(err)
+      LDAP.err2string(err)
+    end
+
+    def simple_bind(dn=nil, password=nil, &block)
+      bind(dn, password, LDAP_AUTH_SIMPLE, &block)
+    end
+
+    def bind(dn=nil, password=nil, method=LDAP_AUTH_SIMPLE)
+      raise LDAP::Error, "already bound" if bound?
+
+      url = @use_ssl ? "ldaps://#@host:#@port/" : "ldap://#@host:#@port/"
+      base_env = {javax.naming.Context::PROVIDER_URL => url}
+      base_env[javax.naming.Context::SECURITY_PRINCIPAL] = dn if dn
+      base_env[javax.naming.Context::SECURITY_CREDENTIALS] = password if password
+
+      @current_env = java.util.Hashtable.new(LDAP::configuration(base_env))
+
+      begin 
+        @context = javax.naming.directory.InitialDirContext.new(@current_env)
+        @err = 0
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NamingException => e
+        @err = -1
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      end
+      
+      if !block_given?
+        return self
+      end
+
+      begin 
+        yield self
+
+        return nil
+      ensure
+        unbind
+      end
+    end
+    
+    def set_option(opt, value)
+      @err = 0
+    end
+    
+    def add(dn, attrs)
+      raise LDAP::InvalidDataError, "The LDAP handler has already unbound." unless bound?
+
+      attrs = LDAP::hash2mods(LDAP::LDAP_MOD_ADD, attrs) if attrs.is_a?(Hash)
+
+      begin 
+        @context.create_subcontext(dn, LDAP::Mod.to_java_attributes(*attrs))
+        @err = 0
+      rescue javax.naming.NameNotFoundException => e
+        @err = 32
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.InvalidNameException => e
+        @err = 34
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.directory.SchemaViolationException => e
+        @err = 65
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NamingException => e
+        @err = 21
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      end
+      self
+    end
+
+    def modify(dn, attrs)
+      raise LDAP::InvalidDataError, "The LDAP handler has already unbound." unless bound?
+
+      attrs = LDAP::hash2mods(LDAP::LDAP_MOD_REPLACE, attrs) if attrs.is_a?(Hash)
+
+      begin 
+        @context.modify_attributes(dn, LDAP::Mod.to_java_modification_items(*attrs))
+        @err = 0
+      rescue javax.naming.NameNotFoundException => e
+        @err = 32
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.InvalidNameException => e
+        @err = 34
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.directory.SchemaViolationException => e
+        @err = 65
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NamingException => e
+        @err = 21
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      end
+
+      self
+    end
+    
+    def delete(dn)
+      raise LDAP::InvalidDataError, "The LDAP handler has already unbound." unless bound?
+
+      begin
+        @context.destroy_subcontext(dn)
+        @err = 0
+      rescue javax.naming.NameNotFoundException => e
+        @err = 32
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.InvalidNameException => e
+        @err = 34
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NamingException => e
+        @err = 21
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      end
+      self
+    end
+    
+    def search(base_dn, scope, filter, attrs=nil, attrsonly=nil, sec=0, usec=0, s_attr=nil, s_proc=nil)
+      raise LDAP::InvalidDataError, "The LDAP handler has already unbound." unless bound?
+
+      controls = javax.naming.directory.SearchControls.new
+      controls.search_scope = scope
+
+      if attrs && !attrs.empty?
+        controls.returning_attributes = attrs.to_java(:string)
+      end
+      if attrsonly
+        controls.returning_obj_flag = true
+      end
+
+      if sec != 0 || usec != 0
+        controls.time_limit = usec/1000 + sec*1000
+      end
+
+      begin 
+        @context.search(base_dn, filter, controls).each do |val|
+          yield LDAP::Entry.create_from_search_result(val)
+        end
+
+        @err = 0
+      rescue javax.naming.NameNotFoundException => e
+        @err = 32
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.InvalidNameException => e
+        @err = 34
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      rescue javax.naming.NoPermissionException => e
+        @err = 50
+        raise LDAP::ResultError.wrap(LDAP::err2string(@err), e)
+      end
+
+      self
+    end
+
+    def search2(base_dn, scope, filter, attrs=nil, attrsonly=nil, sec=0, usec=0, s_attr=nil, s_proc=nil)
+      arr = []
+      search(base_dn, scope, filter, attrs, attrsonly, sec, usec, s_attr, s_proc) do |val|
+        arr << LDAP::entry2hash(val)
+      end
+      arr
+    end
+    
+    def unbind
+      raise LDAP::InvalidDataError, "The LDAP handler has already unbound." unless bound?
+      @context.close
+      @err = 0
+      @context = nil
+    end
+    
+    def bound?
+      !@context.nil?
+    end
+  end   
+  
+
+  class Conn
+    class << self
+      alias open new
+    end
+
+    def initialize(host='localhost', port=LDAP_PORT)
+      super
+      @use_ssl = false
+    end
+    
+    include ConnImplementation
+  end
+
+  class SSLConn
+    class << self
+      alias open new
+    end
+
+    def initialize(host='localhost', port=LDAPS_PORT)
+      super
+      @use_ssl = true
+    end
+    
+    include ConnImplementation
+  end
+end