ruby-ldap3 0.10.0

data/entry.c

@@ -0,0 +1,342 @@
+/*
+ * entry.c
+ * $Id: entry.c,v 1.13 2005/03/15 10:15:32 ianmacd Exp $
+ */
+
+#include "ruby.h"
+#include "rbldap.h"
+
+VALUE rb_cLDAP_Entry;
+
+#if RUBY_VERSION_CODE >= 190
+static void
+rb_ldap_entry_mark(RB_LDAPENTRY_DATA *edata)
+{
+  rb_gc_mark(edata->dn);
+  rb_gc_mark(edata->attr);
+  /* 
+   * edata->ldap and edata->msg are managed in a block given by each search
+   * operation. ldap_msgfree should be called after ldap_search.
+   * they are just for C language interfaces, don't touch these members
+   * in ruby method implementation.
+   */
+}
+
+/*
+ * load libldap's value data structure into ruby array of string
+ */
+static VALUE
+rb_ldap_entry_load_val(LDAP *ldap, LDAPMessage *msg, char *c_attr)
+{
+  struct berval **bv;
+  VALUE vals;
+  int nvals;
+  int i;
+
+  bv = ldap_get_values_len(ldap, msg, c_attr);
+  if (bv == NULL)
+    return Qnil;
+
+  nvals = ldap_count_values_len(bv);
+  vals = rb_ary_new2(nvals);
+  for (i = 0; i < nvals; i++) {
+    rb_ary_push(vals, rb_tainted_str_new(bv[i]->bv_val, bv[i]->bv_len));
+  }
+  ldap_value_free_len(bv);
+
+  return vals;
+}
+
+/*
+ * load libldap's attributes data structure into ruby hash
+ */
+static VALUE
+rb_ldap_entry_load_attr(LDAP *ldap, LDAPMessage *msg)
+{
+  VALUE hash = rb_hash_new();
+  BerElement *ber = NULL;
+  char *c_attr;
+
+  for (c_attr = ldap_first_attribute(ldap, msg, &ber);
+    c_attr != NULL;
+    c_attr = ldap_next_attribute(ldap, msg, ber)) {
+    VALUE attr = rb_tainted_str_new2(c_attr);
+    VALUE vals = rb_ldap_entry_load_val(ldap, msg, c_attr);
+
+    rb_hash_aset(hash, attr, vals);
+    ldap_memfree(c_attr);
+  }
+
+#if !defined(USE_OPENLDAP1)
+  ber_free(ber, 0);
+#endif
+
+  return hash;
+}
+#endif
+
+void
+rb_ldap_entry_free (RB_LDAPENTRY_DATA * edata)
+{
+  xfree(edata);
+  /* edata->msg is valid in a block given by each search operation */
+  /* ldap_msgfree should be called after ldap_search */
+}
+
+VALUE
+rb_ldap_entry_new (LDAP * ldap, LDAPMessage * msg)
+{
+  VALUE val;
+  RB_LDAPENTRY_DATA *edata;
+#if RUBY_VERSION_CODE >= 190
+  char *c_dn;
+#endif
+
+#if RUBY_VERSION_CODE >= 190
+  val = Data_Make_Struct (rb_cLDAP_Entry, RB_LDAPENTRY_DATA,
+			  rb_ldap_entry_mark, rb_ldap_entry_free, edata);
+#else
+  val = Data_Make_Struct (rb_cLDAP_Entry, RB_LDAPENTRY_DATA,
+			  0, rb_ldap_entry_free, edata);
+#endif
+  edata->ldap = ldap;
+  edata->msg = msg;
+
+#if RUBY_VERSION_CODE >= 190
+  /* get dn */
+  c_dn = ldap_get_dn(ldap, msg);
+  if (c_dn) {
+    edata->dn = rb_tainted_str_new2(c_dn);
+    ldap_memfree(c_dn);
+  }
+  else {
+    edata->dn = Qnil;
+  }
+
+  /* get attributes */
+  edata->attr = rb_ldap_entry_load_attr(ldap, msg);
+#endif
+  return val;
+}
+
+/*
+ * call-seq:
+ * entry.get_dn  => String
+ * entry.dn      => String
+ */
+VALUE
+rb_ldap_entry_get_dn (VALUE self)
+{
+  RB_LDAPENTRY_DATA *edata;
+#if RUBY_VERSION_CODE < 190
+  char *cdn;
+  VALUE dn;
+#endif
+
+  GET_LDAPENTRY_DATA (self, edata);
+
+#if RUBY_VERSION_CODE < 190
+  cdn = ldap_get_dn (edata->ldap, edata->msg);
+  if (cdn)
+    {
+      dn = rb_tainted_str_new2 (cdn);
+      ldap_memfree (cdn);
+    }
+  else
+    {
+      dn = Qnil;
+    }
+
+  return dn;
+#else
+  return edata->dn;
+#endif
+}
+
+/*
+ * call-seq:
+ * entry.get_values(attr)  => Array of String
+ * entry.vals(attr)        => Array of String
+ * entry[attr]             => Array of String
+ *
+ * Return an array of all the values belonging to the attribute, +attr+, of
+ * the entry.
+ */
+VALUE
+rb_ldap_entry_get_values (VALUE self, VALUE attr)
+{
+  RB_LDAPENTRY_DATA *edata;
+#if RUBY_VERSION_CODE < 190
+  char *c_attr;
+  struct berval **c_vals;
+  int i;
+  int count;
+  VALUE vals;
+#endif
+
+  GET_LDAPENTRY_DATA (self, edata);
+#if RUBY_VERSION_CODE < 190
+  c_attr = StringValueCStr (attr);
+
+  c_vals = ldap_get_values_len (edata->ldap, edata->msg, c_attr);
+  if (c_vals)
+    {
+      vals = rb_ary_new ();
+      count = ldap_count_values_len (c_vals);
+      for (i = 0; i < count; i++)
+	{
+	  VALUE str;
+	  str = rb_tainted_str_new (c_vals[i]->bv_val, c_vals[i]->bv_len);
+	  rb_ary_push (vals, str);
+	}
+      ldap_value_free_len (c_vals);
+    }
+  else
+    {
+      vals = Qnil;
+    }
+
+  return vals;
+#else
+  return rb_hash_aref(edata->attr, attr);
+#endif
+}
+
+/*
+ * call-seq:
+ * entry.get_attributes  => Array of String
+ * entry.attrs           => Array of String
+ *
+ * Return an array of all the attributes belonging to the entry.
+ */
+VALUE
+rb_ldap_entry_get_attributes (VALUE self)
+{
+  RB_LDAPENTRY_DATA *edata;
+#if RUBY_VERSION_CODE < 190
+  VALUE vals;
+  char *attr;
+  BerElement *ber = NULL;
+#else
+  VALUE attrs;
+#endif
+
+  GET_LDAPENTRY_DATA (self, edata);
+
+#if RUBY_VERSION_CODE < 190
+  vals = rb_ary_new ();
+  for (attr = ldap_first_attribute (edata->ldap, edata->msg, &ber);
+       attr != NULL;
+       attr = ldap_next_attribute (edata->ldap, edata->msg, ber))
+    {
+      rb_ary_push (vals, rb_tainted_str_new2 (attr));
+      ldap_memfree(attr);
+    }
+
+    #if !defined(USE_OPENLDAP1)
+    if( ber != NULL ){
+      ber_free(ber, 0);
+    }
+    #endif
+
+  return vals;
+#else
+  attrs = rb_funcall(edata->attr, rb_intern("keys"), 0);
+  if (TYPE(attrs) != T_ARRAY) {
+    return Qnil;
+  }
+
+  return attrs;
+#endif
+}
+
+/*
+ * call-seq:
+ * entry.to_hash  => Hash
+ *
+ * Convert the entry to a hash.
+ */
+VALUE
+rb_ldap_entry_to_hash (VALUE self)
+{
+#if RUBY_VERSION_CODE < 190
+  VALUE attrs = rb_ldap_entry_get_attributes (self);
+  VALUE hash = rb_hash_new ();
+  VALUE attr, vals;
+  int i;
+#else
+  RB_LDAPENTRY_DATA *edata;
+  VALUE hash, dn_ary;
+#endif
+
+#if RUBY_VERSION_CODE < 190
+  Check_Type (attrs, T_ARRAY);
+  rb_hash_aset (hash, rb_tainted_str_new2 ("dn"),
+		rb_ary_new3 (1, rb_ldap_entry_get_dn (self)));
+  for (i = 0; i < RARRAY_LEN (attrs); i++)
+    {
+      attr = rb_ary_entry (attrs, i);
+      vals = rb_ldap_entry_get_values (self, attr);
+      rb_hash_aset (hash, attr, vals);
+    }
+#else
+  GET_LDAPENTRY_DATA (self, edata);
+  hash = rb_hash_dup(edata->attr);
+  dn_ary = rb_ary_new3(1, edata->dn);
+  rb_hash_aset(hash, rb_tainted_str_new2("dn"), dn_ary);
+#endif
+
+  return hash;
+}
+
+/*
+ * call-seq:
+ * entry.inspect  => String
+ *
+ * Produce a concise representation of the entry.
+ */
+VALUE
+rb_ldap_entry_inspect (VALUE self)
+{
+  VALUE str;
+  const char *c;
+
+  c = rb_obj_classname (self);
+  str = rb_str_new (0, strlen (c) + 10 + 16 + 1);	/* 10:tags 16:addr 1:nul */
+  sprintf (RSTRING_PTR (str), "#<%s:0x%lx\n", c, self);
+
+#if RUBY_VERSION_CODE < 190
+  RSTRING(str)->len = strlen (RSTRING_PTR (str));
+#else
+  rb_str_set_len(str, strlen (RSTRING_PTR (str)));
+#endif
+
+  rb_str_concat (str, rb_inspect (rb_ldap_entry_to_hash (self)));
+  rb_str_cat2 (str, ">");
+
+  return str;
+}
+
+/* Document-class: LDAP::Entry
+ *
+ * These methods can be used to probe the entries returned by LDAP searches.
+ */
+void
+Init_ldap_entry ()
+{
+  rb_cLDAP_Entry = rb_define_class_under (rb_mLDAP, "Entry", rb_cObject);
+  rb_define_const (rb_mLDAP, "Message", rb_cLDAP_Entry);	/* for compatibility */
+  rb_undef_method (CLASS_OF (rb_cLDAP_Entry), "new");
+  rb_undef_alloc_func (rb_cLDAP_Entry);
+  rb_ldap_entry_define_method ("get_dn", rb_ldap_entry_get_dn, 0);
+  rb_ldap_entry_define_method ("get_values", rb_ldap_entry_get_values, 1);
+  rb_ldap_entry_define_method ("get_attributes",
+			       rb_ldap_entry_get_attributes, 0);
+  rb_alias (rb_cLDAP_Entry, rb_intern ("dn"), rb_intern ("get_dn"));
+  rb_alias (rb_cLDAP_Entry, rb_intern ("vals"), rb_intern ("get_values"));
+  rb_alias (rb_cLDAP_Entry, rb_intern ("[]"), rb_intern ("get_values"));
+  rb_alias (rb_cLDAP_Entry, rb_intern ("attrs"),
+	    rb_intern ("get_attributes"));
+  rb_ldap_entry_define_method ("to_hash", rb_ldap_entry_to_hash, 0);
+  rb_ldap_entry_define_method ("inspect", rb_ldap_entry_inspect, 0);
+}

data/extconf.rb

@@ -0,0 +1,310 @@
+#!/usr/bin/env ruby
+#
+# extconf.rb for ldap extension
+# $Id: extconf.rb,v 1.7 2006/04/18 23:49:56 ianmacd Exp $
+#
+
+require 'mkmf'
+
+$INTERACTIVE = false
+
+if( ARGV.include?("--help") )
+  print <<EOF
+  --with-ldap-dir     specify the LDAP directory.
+  --with-ldap-include specify the directory containing ldap.h and lber.h.
+  --with-ldap-lib     specify the directory containing the LDAP libraries.
+  --with-netscape     build with Netscape SDK.
+  --with-mozilla      build with Mozilla SDK (Enables certificate authentication).
+  --with-openldap1    build with OpenLDAP 1.x.
+  --with-openldap2    build with OpenLDAP 2.x.
+  --with-wldap32      Active Directory Client API.
+
+The following are library configuration options:
+  --with-libcrypto=crypto,   --without-libcrypto
+  --with-libssl=ssl,         --without-libssl
+  --with-libnsl=nsl,         --without-libnsl
+  --with-libldap=ldap,       --without-libldap
+  --with-liblber=lber,       --without-liblber
+  --with-libldap_r=ldap_r,   --without-libldap_r
+  --with-libpthread=pthread, --without-libpthread
+  --with-libresolv=resolv,   --without-libresolv
+
+  --help             show this help.
+EOF
+exit(0)
+end
+
+def find_files(dir = nil)
+  if( dir )
+    search_dirs = [dir]
+  else
+    search_dirs =
+      ["/usr/local", "/usr", "/opt"] +
+      Dir.glob("/usr/local/./*ldap*").collect{|d| d.gsub(/\/\.\//, "/")} +
+      Dir.glob("/usr/./*ldap*").collect{|d| d.gsub(/\/\.\//, "/") +
+        Dir.glob("/usr/lib{64,}/mozldap/*ldap*") + ["/usr/include/mozldap"]
+    }
+  end
+  for d in search_dirs
+    h = File.join(d,"include","ldap.h")
+    l = File.join(d,"lib","libldap*")
+    if( File.exist?(h) )
+      l = Dir.glob(l)[0]
+      if( l )
+        if( $INTERACTIVE )
+          print("--with-ldap-dir=#{d} [y/n]")
+          ans = $stdin.gets
+          ans.chop!
+          if( ans == "y" )
+            result = [d, File.basename(l).split(".")[0][3..-1], File.basename(h)]
+            return result
+            break
+          end
+        else
+          print("--with-ldap-dir=#{d}\n")
+          result = [d, File.basename(l).split(".")[0][3..-1], File.basename(h)]
+          return result
+          break
+        end
+      end
+    end
+  end
+end
+
+def ldap_with_config(arg, default = nil)
+  cfg1  = with_config(arg, nil)
+  cfg2  = arg_config("--without-" + arg, nil)
+  if( cfg1 )
+    return cfg1
+  else
+    if( cfg2 )
+      return nil
+    else
+      return default
+    end
+  end
+end
+
+$use_netscape  = ldap_with_config("netscape")
+if ldap_with_config("mozilla")
+  $use_netscape  = '6'
+end
+$use_openldap1 = ldap_with_config("openldap1")
+$use_openldap2 = ldap_with_config("openldap2")
+$use_wldap32   = ldap_with_config("wldap32")
+
+dir_config('ldap')
+$ldap_dir    = ldap_with_config("ldap-dir") || ldap_with_config("ldap")
+
+$ldap_dir, $libldap, $ldap_h = find_files($ldap_dir)
+
+if( !($use_netscape || $use_openldap1 || $use_openldap2 || $use_wldap32) )
+  case $libldap
+  when /^ldapssl[0-9]+$/
+    print("--with-netscape\n")
+    $use_netscape = "4"
+  when /^ssldap50+$/, /^ldap50+$/
+    print("--with-netscape=5")
+    $use_netscape = "5"
+  when /^ssldap60+$/, /^ldap60+$/
+    print("--with-netscape=6")
+    $use_netscape = "6"
+  else
+    if RUBY_PLATFORM =~ /-(:?mingw32|mswin32)/
+      print("--with-wldap32\n")
+      $use_wldap32 = true
+    else
+      print("--with-openldap2\n")
+      $use_openldap2 = true
+    end
+  end
+end
+if( $use_netscape == true )
+  $use_netscape = "5"
+end
+
+if( $use_netscape )
+  case $use_netscape
+  when /^4/
+    $defs << "-DUSE_NETSCAPE_SDK"
+    #$libnsl     = ldap_with_config("libnsl", "nsl")
+    #$libpthread = ldap_with_config("libpthread", "pthread")
+    $libresolv  = ldap_with_config("libresolv", "resolv")
+    $libldap    = ldap_with_config("libldap", $libldap)
+    $libns      = ldap_with_config("libns", "nspr3,plc3,plds3").split(",")
+  when /^5/
+    $defs << "-DUSE_NETSCAPE_SDK"
+    #$libnsl     = ldap_with_config("libnsl", "nsl")
+    #$libpthread = ldap_with_config("libpthread", "pthread")
+    $libresolv  = ldap_with_config("libresolv", "resolv")
+    $libldap    = ldap_with_config("libldap", $libldap)
+    $libns      = ldap_with_config("libns", "nspr4,plc4,plds4").split(",")
+    $liblber    = ldap_with_config("liblber", "lber50")
+    $libssl     = ldap_with_config("libssl", "ssl3")
+  when /^6/
+    %x{pkg-config --exists 'mozldap >= 6.0 nspr >= 4.0'}
+
+    if $? == 0
+      puts 'Mozzilla LDAP libs will be used.'
+      $mozlibs = %x{pkg-config mozldap nspr --libs}.chomp
+      $mozincs = %x{pkg-config mozldap nspr --cflags}.chomp
+    else
+      puts 'pkg-config reported that no right mozilla LDAP libs were found'
+      puts 'we need mozldap >= 6.0 and nspr >= 4.0'
+      exit 1
+    end
+
+    $defs << "-DUSE_NETSCAPE_SDK -DUSE_SSL_CLIENTAUTH"
+    #$libnsl     = ldap_with_config("libnsl", "nsl")
+    #$libpthread = ldap_with_config("libpthread", "pthread")
+    $libresolv  = ldap_with_config("libresolv", "resolv")
+    $libldap    = ldap_with_config("libldap", "ldap60")
+    $libns      = ldap_with_config("libns", "nspr4,plc4,plds4").split(",")
+    $liblber    = ldap_with_config("liblber", "lber60")
+    $libssl     = ldap_with_config("libssl", "ssl3")
+  end
+end
+
+if( $use_openldap1 )
+  $defs << "-DUSE_OPENLDAP1"
+  $defs << "-DUSE_OPENLDAP"
+  $libresolv  = ldap_with_config("libresolv", "resolv")
+  $libldap   = ldap_with_config("libldap", "ldap")
+  $liblber   = ldap_with_config("liblber", "lber")
+end
+
+if( $use_openldap2 )
+  $defs << "-DUSE_OPENLDAP2"
+  $defs << "-DUSE_OPENLDAP"
+  # OpenLDAP 2.3 finally deprecates a bunch of non-_ext functions. We need
+  # this to enable them.
+  $defs << "-DLDAP_DEPRECATED"
+  $libresolv  = ldap_with_config("libresolv", "resolv")
+  $libcrypto  = ldap_with_config("libcrypto", "crypto")
+  $libssl     = ldap_with_config("libssl", "ssl")
+  $libpthread = ldap_with_config("libpthread", "pthread")
+  $libnsl     = ldap_with_config("libnsl", "nsl")
+  $liblber    = ldap_with_config("liblber", "lber")
+  $libldap_r  = ldap_with_config("libldap_r", "ldap_r")
+  $libldap    = ldap_with_config("libldap", "ldap")
+end
+
+if( $use_wldap32 )
+  srcdir = File.dirname($0)
+  if( !File.exist?("win") )
+    Dir.mkdir("win")
+  end
+  `lib /def:#{srcdir}/win/wldap32.def /out:#{srcdir}/win/wldap32.lib`
+  $defs << "-DUSE_WLDAP32"
+  dir_config("wldap32", "#{srcdir}/win", "./win")
+  $libldap = ldap_with_config("libldap", "wldap32")
+end
+
+if( $libpthread )
+  $defs << "-D_REENTRANT"
+end
+
+if( $use_wldap32 )
+  have_header("winldap.h")
+  have_header("winlber.h")
+  have_header("sys/time.h")
+elsif $use_netscape =~ /^6/
+  # mozilla
+  pkg_config('mozldap')
+  pkg_config('nspr')
+else
+  ldap_h = have_header("ldap.h")
+  lber_h = have_header("lber.h")
+  ldap_ssl_h = have_header("ldap_ssl.h")
+  if( !(ldap_h && lber_h) )
+    print("can't find ldap.h and lber.h\n")
+    print("use the option '--with-ldap-dir'!\n")
+    exit(0)
+  end
+
+  have_header("openssl/ssl.h")    || have_header("ssl.h")
+  have_header("openssl/crypto.h") || have_header("crypto.h")
+end
+
+$LIBS << ' -pthread'
+for l in [$libcrypto, $libssl, $libnsl, $libpthread, $libresolv,
+          $libns, $liblber, $libldap_r, $libldap].flatten
+  if( l )
+    have_library(l)
+  end
+end
+
+have_func("ldap_init", 'ldap.h')
+have_func("ldap_set_option")
+have_func("ldap_get_option")
+have_func("ldap_start_tls_s") if $use_openldap2
+have_func("ldap_memfree")
+have_func("ldap_perror") if !arg_config("--disable-ldap-perror")
+have_func("ldap_sort_entries")
+#have_func("ldap_sort_values")
+have_func("ldapssl_init")  # NS SDK
+have_func("ldap_sslinit")  # WLDAP32
+have_func("ldap_sasl_bind_s")
+have_func("ldap_rename_s")
+have_func("ldap_compare_s")
+have_func("ldap_add_ext_s")
+have_func("ldap_compare_ext_s")
+have_func("ldap_delete_ext_s")
+have_func("ldap_modify_ext_s")
+have_func("ldap_search_ext_s")
+have_func("ldap_unbind_ext_s")
+have_func("ldap_sasl_interactive_bind_s")
+
+$defs << "-DRUBY_VERSION_CODE=#{RUBY_VERSION.gsub(/\D/, '')}"
+
+create_makefile("ldap")
+
+
+$slapd = ldap_with_config("slapd") || File.join($ldap_dir,"libexec","slapd")
+$schema_dir = ldap_with_config("schema-dir")
+if( !$schema_dir )
+  $schema_dir = File.join($ldap_dir,"etc","openldap","schema")
+  if( !File.exist?($schema_dir) )
+    $schema_dir = File.join($ldap_dir,"etc","openldap")
+  end
+end
+
+$run_test = "/bin/sh $(srcdir)/test/test.sh #{CONFIG['RUBY_INSTALL_NAME']}"
+if( $use_openldap1 )
+  $run_test += " openldap1"
+else( $use_openldap2 )
+  if( $libssl && $libcrypto )
+    $run_test = "/bin/sh $(srcdir)/test/test.sh #{CONFIG['RUBY_INSTALL_NAME']} newcert; " + $run_test
+    $run_test += " openldap2-ssl"
+  else
+    $run_test += " openldap2"
+  end
+end
+$run_test += " #{$slapd} #{$schema_dir}"
+
+
+File.open("Makefile","a") do |f|
+  f.print <<EOF
+
+test::
+\t#{$run_test}
+
+testclean: test-clean
+
+test-clean::
+\t(cd $(srcdir); /bin/sh test/test.sh clean)
+
+reconfig::
+\t$(RUBY_INSTALL_NAME) $(srcdir)/extconf.rb #{ARGV.join(" ")}
+
+doc:
+#\t$(RUBY_INSTALL_NAME) -rrdoc/ri/ri_paths -e 'puts RI::Paths::PATH[0]'
+\trdoc --ri-site *.c lib/ldap
+
+unit:
+\t(cd test; $(RUBY_INSTALL_NAME) tc_ldif.rb)
+
+.PHONY: doc
+EOF
+
+end