ruby-ldap 0.9.9

data/lib/ldap/schema.rb

@@ -0,0 +1,129 @@
+# Manipulation of LDAP schema data.
+#
+#--
+# $Id: schema.rb,v 1.9 2006/02/08 23:15:17 ianmacd Exp $
+#++
+
+# The LDAP module encapsulates the various LDAP-related classes in their own
+# namespace.
+#
+module LDAP
+
+  # Retrieve and process information pertaining to LDAP schemas.
+  #
+  class Schema < Hash
+
+    def initialize(entry)
+      if( entry )
+	entry.each{|key,vals|
+	  self[key] = vals
+	}
+      end
+    end
+
+    # Return the list of values related to the schema component given in
+    # +key+. See LDAP::Conn#schema for common values of +key+.
+    #
+    def names(key)
+      self[key].collect{|val| val =~ /NAME\s+'([\w\d_\-]+)'/; $1}
+    end
+
+    # Return the list of attributes in object class +oc+ that are of category
+    # +at+. +at+ may be the string *MUST*, *MAY* or *SUP*.
+    #
+    def attr(oc,at)
+      self['objectClasses'].each{|s|
+	if( s =~ /NAME\s+'#{oc}'/ )
+	  case s
+	  when /#{at}\s+\(([\w\d_\-\s\$]+)\)/i then return $1.split("$").collect{|attr| attr.strip}
+	  when /#{at}\s+([\w\d_\-]+)/i then return $1.split("$").collect{|attr| attr.strip}
+	  end
+	end
+      }
+      return nil
+    end
+
+    # Return the list of attributes that an entry with object class +oc+
+    # _must_ possess.
+    #
+    def must(oc)
+      attr(oc, "MUST")
+    end
+
+    # Return the list of attributes that an entry with object class +oc+
+    # _may_ possess.
+    #
+    def may(oc)
+      attr(oc, "MAY")
+    end
+
+    # Return the superior object class of object class +oc+.
+    #
+    def sup(oc)
+      attr(oc, "SUP")
+    end
+  end
+
+  class Conn
+
+    # Fetch the schema data for the connection.
+    #
+    # If +base+ is given, it gives the base DN for the search. +attrs+, if
+    # given, is an array of attributes that should be returned from the
+    # server. The default list is *objectClasses*, *attributeTypes*,
+    # *matchingRules*, *matchingRuleUse*, *dITStructureRules*,
+    # *dITContentRules*, *nameForms* and *ldapSyntaxes*.
+    #
+    # +sec+ and +usec+ can be used to specify a time-out for the search in
+    # seconds and microseconds, respectively.
+    # 
+    def schema(base = nil, attrs = nil, sec = 0, usec = 0)
+      attrs ||= [
+	'objectClasses',
+	'attributeTypes',
+	'matchingRules',
+	'matchingRuleUse',
+	'dITStructureRules',
+	'dITContentRules',
+	'nameForms',
+	'ldapSyntaxes',
+      ]
+      base ||= root_dse(['subschemaSubentry'], sec, usec)[0]['subschemaSubentry'][0]
+      base ||= 'cn=schema'
+      ent = search2(base, LDAP_SCOPE_BASE, '(objectClass=subschema)',
+		    attrs, false, sec, usec)
+      return Schema.new(ent[0])
+    end
+
+    # Fetch the root DSE (DSA-specific Entry) for the connection. DSA stands
+    # for Directory System Agent and simply refers to the LDAP server you are
+    # using.
+    #
+    # +attrs+, if given, is an array of attributes that should be returned
+    # from the server. The default list is *subschemaSubentry*,
+    # *namingContexts*, *monitorContext*, *altServer*, *supportedControl*,
+    # *supportedExtension*, *supportedFeatures*, *supportedSASLMechanisms*
+    # and *supportedLDAPVersion*.
+    #
+    # +sec+ and +usec+ can be used to specify a time-out for the search in
+    # seconds and microseconds, respectively.
+    #
+    def root_dse(attrs = nil, sec = 0, usec = 0)
+      attrs ||= [
+	'subschemaSubentry',
+	'namingContexts',
+	'monitorContext',
+	'altServer',
+	'supportedControl',
+	'supportedExtension',
+	'supportedFeatures',
+	'supportedSASLMechanisms',
+	'supportedLDAPVersion',
+      ]
+
+      entries = search2('', LDAP_SCOPE_BASE, '(objectClass=*)',
+			attrs, false, sec, usec)
+      return entries
+    end
+  end
+end

data/misc.c

@@ -0,0 +1,512 @@
+/* -*- C -*-
+ * $Id: misc.c,v 1.11 2006/07/03 22:54:52 ianmacd Exp $
+ */
+
+#include "ruby.h"
+#include "rbldap.h"
+
+VALUE rb_sLDAP_APIInfo;
+VALUE rb_cLDAP_Control;
+
+#ifdef LDAP_OPT_API_INFO
+VALUE
+rb_ldap_apiinfo_new (LDAPAPIInfo * info)
+{
+  VALUE info_version, api_version, protocol_version;
+  VALUE extensions, vendor_name, vendor_version;
+  int i;
+
+  info_version = INT2NUM (info->ldapai_info_version);
+  api_version = INT2NUM (info->ldapai_api_version);
+  protocol_version = INT2NUM (info->ldapai_protocol_version);
+  vendor_version = INT2NUM (info->ldapai_vendor_version);
+  vendor_name = rb_tainted_str_new2 (info->ldapai_vendor_name);
+  extensions = rb_ary_new ();
+
+  for (i = 0; info->ldapai_extensions[i]; i++)
+    {
+      rb_ary_push (extensions,
+		   rb_tainted_str_new2 (info->ldapai_extensions[i]));
+    }
+
+  return rb_struct_new (rb_sLDAP_APIInfo,
+			info_version, api_version, protocol_version,
+			extensions, vendor_name, vendor_version, 0);
+}
+
+LDAPAPIInfo *
+rb_ldap_get_apiinfo (VALUE data)
+{
+  LDAPAPIInfo *info;
+  VALUE r_extensions;
+  int len, i;
+  char **c_extensions;
+
+  if (data == Qnil)
+    return NULL;
+
+  info = ALLOC_N (LDAPAPIInfo, 1);
+  info->ldapai_info_version =
+    FIX2INT (rb_struct_getmember (data, rb_intern ("info_version")));
+  info->ldapai_api_version =
+    FIX2INT (rb_struct_getmember (data, rb_intern ("api_version")));
+  info->ldapai_protocol_version =
+    FIX2INT (rb_struct_getmember (data, rb_intern ("protocol_version")));
+  r_extensions = rb_struct_getmember (data, rb_intern ("extensions"));
+  len = RARRAY_LEN (r_extensions);
+  c_extensions = ALLOCA_N (char *, len);
+  for (i = 0; i <= len - 1; i++)
+    {
+      VALUE str = RARRAY_PTR (r_extensions)[i];
+      RB_LDAP_SET_STR (c_extensions[i], str);
+    }
+  info->ldapai_extensions = c_extensions;
+  RB_LDAP_SET_STR (info->ldapai_vendor_name,
+		   rb_struct_getmember (data, rb_intern ("vendor_name")));
+  info->ldapai_vendor_version =
+    FIX2INT (rb_struct_getmember (data, rb_intern ("vendor_version")));
+
+  return info;
+}
+#endif /* LDAP_OPT_API_INFO */
+
+#ifdef HAVE_LDAPCONTROL
+static void
+rb_ldap_control_free (LDAPControl * ctl)
+{
+  if (ctl)
+    {
+      if (ctl->ldctl_value.bv_val)
+	xfree (ctl->ldctl_value.bv_val);
+      if (ctl->ldctl_oid)
+	xfree (ctl->ldctl_oid);
+      xfree (ctl);
+    }
+}
+
+VALUE
+rb_ldap_control_new (LDAPControl * ctl)
+{
+  if (!ctl)
+    return Qnil;
+  else
+    return Data_Wrap_Struct (rb_cLDAP_Control, 0, rb_ldap_control_free, ctl);
+}
+
+/* Identical to rb_ldap_control_new, but does not define a routine with which
+   to free memory. This should be called only by rb_ldap_parse_result().
+ */
+VALUE
+rb_ldap_control_new2 (LDAPControl * ctl)
+{
+  if (!ctl)
+    return Qnil;
+  else
+    return Data_Wrap_Struct (rb_cLDAP_Control, 0, 0, ctl);
+}
+
+/* This is called by #initialize_copy and is using for duping/cloning. */
+VALUE
+rb_ldap_control_copy (VALUE copy, VALUE orig)
+{
+  LDAPControl *orig_ctl, *copy_ctl;
+
+  Data_Get_Struct (orig, LDAPControl, orig_ctl);
+  Data_Get_Struct (copy, LDAPControl, copy_ctl);
+  memcpy (copy_ctl, orig_ctl, (size_t) sizeof (LDAPControl));
+
+  return copy;
+}
+
+static VALUE
+rb_ldap_control_s_allocate (VALUE klass)
+{
+  LDAPControl *ctl;
+
+  ctl = ALLOC_N (LDAPControl, 1);
+  ctl->ldctl_value.bv_val = NULL;
+  ctl->ldctl_value.bv_len = 0;
+  ctl->ldctl_oid = NULL;
+  ctl->ldctl_iscritical = 0;
+  return Data_Wrap_Struct (klass, 0, rb_ldap_control_free, ctl);
+}
+
+#if RUBY_VERSION_CODE < 170
+static VALUE
+rb_ldap_control_s_new (int argc, VALUE argv[], VALUE klass)
+{
+  VALUE obj;
+
+  obj = rb_ldap_control_s_allocate (klass);
+  rb_obj_call_init (obj, argc, argv);
+
+  return obj;
+}
+#endif
+
+static VALUE
+rb_ldap_control_set_value (VALUE self, VALUE val)
+{
+  LDAPControl *ctl;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+
+  if (ctl->ldctl_value.bv_val)
+    free (ctl->ldctl_value.bv_val);
+
+  if (val == Qnil)
+    {
+      ctl->ldctl_value.bv_val = NULL;
+      ctl->ldctl_value.bv_len = 0;
+    }
+  else
+    {
+      RB_LDAP_SET_STR (ctl->ldctl_value.bv_val, val);
+      ctl->ldctl_value.bv_len = RSTRING_LEN (val);
+    }
+
+  return val;
+}
+
+static VALUE
+rb_ldap_control_get_value (VALUE self)
+{
+  LDAPControl *ctl;
+  VALUE val;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+
+  if (ctl->ldctl_value.bv_len == 0 || ctl->ldctl_value.bv_val == NULL)
+    {
+      val = Qnil;
+    }
+  else
+    {
+      val =
+	rb_tainted_str_new (ctl->ldctl_value.bv_val, ctl->ldctl_value.bv_len);
+    }
+
+  return val;
+}
+
+/*
+ * Document-method: value
+ *
+ * call-seq:
+ * ctrl.value  => String or nil
+ *
+ * Return the value of the control.
+ */
+
+/* 
+ * Document-method: value=
+ *
+ * call-seq:
+ * ctrl.value=(val)  => val
+ *
+ * Set the value of the control.
+ */
+static VALUE
+rb_ldap_control_value (int argc, VALUE argv[], VALUE self)
+{
+  VALUE val;
+
+  if (rb_scan_args (argc, argv, "01", &val) == 1)
+    val = rb_ldap_control_set_value (self, val);
+  else
+    val = rb_ldap_control_get_value (self);
+  return val;
+}
+
+static VALUE
+rb_ldap_control_set_oid (VALUE self, VALUE val)
+{
+  LDAPControl *ctl;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+
+  if (ctl->ldctl_oid)
+    free (ctl->ldctl_oid);
+
+  if (val == Qnil)
+    {
+      ctl->ldctl_oid = NULL;
+    }
+  else
+    {
+      RB_LDAP_SET_STR (ctl->ldctl_oid, val);
+    }
+
+  return val;
+}
+
+static VALUE
+rb_ldap_control_get_oid (VALUE self)
+{
+  LDAPControl *ctl;
+  VALUE val;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+
+  if (ctl->ldctl_oid == NULL)
+    {
+      val = Qnil;
+    }
+  else
+    {
+      val = rb_tainted_str_new2 (ctl->ldctl_oid);
+    }
+
+  return val;
+}
+
+/*
+ * Document-method: oid
+ *
+ * call-seq:
+ * ctrl.oid  => String or nil
+ *
+ * Return the OID of the control.
+ */
+
+/* 
+ * Document-method: oid=
+ *
+ * call-seq:
+ * ctrl.oid=(oid)  => oid
+ *
+ * Set the OID of the control.
+ */
+static VALUE
+rb_ldap_control_oid (int argc, VALUE argv[], VALUE self)
+{
+  VALUE val;
+  LDAPControl *ctl;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+  if (rb_scan_args (argc, argv, "01", &val) == 1)
+    {
+      val = rb_ldap_control_set_oid (self, val);
+    }
+  else
+    {
+      val = rb_ldap_control_get_oid (self);
+    }
+  return val;
+}
+
+static VALUE
+rb_ldap_control_set_critical (VALUE self, VALUE val)
+{
+  LDAPControl *ctl;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+  ctl->ldctl_iscritical = (val == Qtrue) ? 1 : 0;
+  return val;
+}
+
+static VALUE
+rb_ldap_control_get_critical (VALUE self)
+{
+  LDAPControl *ctl;
+  VALUE val;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+  val = ctl->ldctl_iscritical ? Qtrue : Qfalse;
+
+  return val;
+}
+
+/*
+ * Document-method: critical
+ *
+ * call-seq:
+ * ctrl.critical    => true or false
+ * ctrl.critical?   => true or false
+ * ctrl.iscritical  => true or false
+ *
+ * Return the criticality of the control.
+ */
+
+/*
+ * Document-method: critical=
+ *
+ * call-seq:
+ * ctrl.critical=(val)    => val
+ * ctrl.iscritical=(val)  => val
+ *
+ * Set the criticality of the control. +val+ should be *true* or *false*.
+ */
+static VALUE
+rb_ldap_control_critical (int argc, VALUE argv[], VALUE self)
+{
+  VALUE val;
+  LDAPControl *ctl;
+
+  Data_Get_Struct (self, LDAPControl, ctl);
+  if (rb_scan_args (argc, argv, "01", &val) == 1)
+    {
+      val = rb_ldap_control_set_critical (self, val);
+    }
+  else
+    {
+      val = rb_ldap_control_get_critical (self);
+    }
+  return val;
+}
+
+/*
+ * Document-method: new
+ *
+ * call-seq:
+ * LDAP::Control.new(oid, value, criticality)  => LDAP::Control
+ *
+ * Create a new LDAP::Control. +oid+ is the OID of the control, +value+ is the
+ * value to be assigned to the control, and +criticality+ is the criticality
+ * of the control, which should be *true* or *false*.
+ */
+static VALUE
+rb_ldap_control_initialize (int argc, VALUE argv[], VALUE self)
+{
+  VALUE oid, value, critical;
+
+  switch (rb_scan_args (argc, argv, "03", &oid, &value, &critical))
+    {
+    case 3:
+      rb_ldap_control_set_critical (self, critical);
+    case 2:
+      rb_ldap_control_set_value (self, value);
+    case 1:
+      rb_ldap_control_set_oid (self, oid);
+    default:
+      break;
+    }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ * ctrl.inspect  => String
+ *
+ * Produce a concise representation of the control.
+ */
+static VALUE
+rb_ldap_control_inspect (VALUE self)
+{
+  VALUE str;
+
+  str = rb_tainted_str_new2 ("#<");
+  rb_str_cat2 (str, rb_class2name (CLASS_OF (self)));
+  rb_str_cat2 (str, " oid=");
+  rb_str_concat (str, rb_inspect (rb_ldap_control_get_oid (self)));
+  rb_str_cat2 (str, " value=");
+  rb_str_concat (str, rb_inspect (rb_ldap_control_get_value (self)));
+  rb_str_cat2 (str, " iscritical=");
+  rb_str_concat (str, rb_inspect (rb_ldap_control_get_critical (self)));
+  rb_str_cat2 (str, ">");
+
+  return str;
+}
+
+VALUE
+rb_ldap_controls_new (LDAPControl ** ctrls)
+{
+  int i;
+  VALUE ary;
+
+  if (!ctrls)
+    return Qnil;
+
+  ary = rb_ary_new ();
+  for (i = 0; ctrls[i]; i++)
+    rb_ary_push (ary, rb_ldap_control_new (ctrls[i]));
+
+  return ary;
+}
+
+LDAPControl *
+rb_ldap_get_control (VALUE obj)
+{
+  LDAPControl *ctl;
+
+  if (obj == Qnil)
+    {
+      return NULL;
+    }
+  else
+    {
+      Data_Get_Struct (obj, LDAPControl, ctl);
+      return ctl;
+    }
+}
+
+LDAPControl **
+rb_ldap_get_controls (VALUE data)
+{
+  LDAPControl **ctls;
+  int len, i;
+
+  if (data == Qnil)
+    return NULL;
+
+  Check_Type (data, T_ARRAY);
+  len = RARRAY_LEN (data);
+  ctls = ALLOC_N (LDAPControl *, len + 1);
+  for (i = 0; i < len; i++)
+    {
+      ctls[i] = rb_ldap_get_control (rb_ary_entry (data, i));
+    }
+  ctls[len] = NULL;
+
+  return ctls;
+}
+#endif
+
+/* Document-class: LDAP::Control
+ *
+ * Create, manipulate and inspect LDAP controls.
+ */
+void
+Init_ldap_misc ()
+{
+  rb_sLDAP_APIInfo = rb_struct_define ("APIInfo", "info_version",	/* ldapai_xxxx */
+				       "api_version",
+				       "protocol_version",
+				       "extensions",
+				       "vendor_name", "vendor_version", NULL);
+  rb_define_const (rb_mLDAP, "APIInfo", rb_sLDAP_APIInfo);
+
+#ifdef HAVE_LDAPCONTROL
+  rb_cLDAP_Control = rb_define_class_under (rb_mLDAP, "Control", rb_cObject);
+#if RUBY_VERSION_CODE < 170
+  rb_define_singleton_method (rb_cLDAP_Control, "new",
+                             rb_ldap_control_s_new, -1);
+#endif
+#if RUBY_VERSION_CODE >= 173
+  rb_define_alloc_func (rb_cLDAP_Control, rb_ldap_control_s_allocate);
+#else
+  rb_define_singleton_method (rb_cLDAP_Control, "allocate",
+                             rb_ldap_control_s_allocate, 0);
+#endif
+  rb_define_method (rb_cLDAP_Control, "initialize",
+		    rb_ldap_control_initialize, -1);
+  rb_define_method (rb_cLDAP_Control, "initialize_copy", rb_ldap_control_copy,
+		    1);
+  rb_define_method (rb_cLDAP_Control, "inspect", rb_ldap_control_inspect, 0);
+  rb_define_method (rb_cLDAP_Control, "oid", rb_ldap_control_oid, -1);
+  rb_define_method (rb_cLDAP_Control, "oid=", rb_ldap_control_oid, -1);
+  rb_define_method (rb_cLDAP_Control, "value", rb_ldap_control_value, -1);
+  rb_define_method (rb_cLDAP_Control, "value=", rb_ldap_control_value, -1);
+  rb_define_method (rb_cLDAP_Control, "critical?", rb_ldap_control_critical,
+		    -1);
+  rb_define_method (rb_cLDAP_Control, "critical", rb_ldap_control_critical,
+		    -1);
+  rb_define_method (rb_cLDAP_Control, "critical=", rb_ldap_control_critical,
+		    -1);
+  rb_define_method (rb_cLDAP_Control, "iscritical", rb_ldap_control_critical,
+		    -1);
+  rb_define_method (rb_cLDAP_Control, "iscritical=", rb_ldap_control_critical,
+		    -1);
+#endif
+}