ruby-ldap3 0.10.0

data/mod.c

@@ -0,0 +1,359 @@
+/*
+ * mod.c
+ * $Id: mod.c,v 1.14 2005/03/07 22:57:34 ianmacd Exp $
+ */
+
+#include "ruby.h"
+#include "rbldap.h"
+
+VALUE rb_cLDAP_Mod;
+
+
+void
+rb_ldap_mod_free (RB_LDAPMOD_DATA * data)
+{
+  if (data->mod)
+    {
+      struct berval **bvals;
+      char **svals;
+      int i;
+
+      xfree(data->mod->mod_type);
+      if (data->mod->mod_op & LDAP_MOD_BVALUES)
+	{
+	  bvals = data->mod->mod_vals.modv_bvals;
+	  for (i = 0; bvals[i] != NULL; i++)
+	    {
+	      xfree (bvals[i]);
+	    }
+	  xfree (bvals);
+	}
+      else
+	{
+	  svals = data->mod->mod_vals.modv_strvals;
+	  for (i = 0; svals[i] != NULL; i++)
+	    {
+	      xfree (svals[i]);
+	    }
+	  xfree (svals);
+	}
+      xfree (data->mod);
+    }
+    xfree (data);
+}
+
+static LDAPMod *
+rb_ldap_new_mod (int mod_op, char *mod_type, char **modv_strvals)
+{
+  LDAPMod *mod;
+
+  if (mod_op & LDAP_MOD_BVALUES)
+    {
+      rb_bug ("rb_ldap_mod_new: illegal mod_op");
+    }
+
+  mod = ALLOC_N (LDAPMod, 1);
+  mod->mod_op = mod_op;
+  mod->mod_type = ALLOC_N(char,strlen(mod_type) + 1);
+  strcpy(mod->mod_type, mod_type);
+  mod->mod_vals.modv_strvals = modv_strvals;
+
+  return mod;
+}
+
+VALUE
+rb_ldap_mod_new (int mod_op, char *mod_type, char **modv_strvals)
+{
+  VALUE obj;
+  RB_LDAPMOD_DATA *moddata;
+
+  obj = Data_Make_Struct (rb_cLDAP_Mod, RB_LDAPMOD_DATA,
+			  0, rb_ldap_mod_free, moddata);
+  moddata->mod = rb_ldap_new_mod (mod_op, mod_type, modv_strvals);
+
+  return obj;
+}
+
+static LDAPMod *
+rb_ldap_new_mod2 (int mod_op, char *mod_type, struct berval **modv_bvals)
+{
+  LDAPMod *mod;
+
+  if (!(mod_op & LDAP_MOD_BVALUES))
+    {
+      rb_bug ("rb_ldap_mod_new: illegal mod_op");
+    }
+
+  mod = ALLOC_N (LDAPMod, 1);
+  mod->mod_op = mod_op;
+  mod->mod_type = ALLOC_N(char,strlen(mod_type) + 1);
+  strcpy(mod->mod_type, mod_type);
+  mod->mod_vals.modv_bvals = modv_bvals;
+
+  return mod;
+}
+
+VALUE
+rb_ldap_mod_new2 (int mod_op, char *mod_type, struct berval ** modv_bvals)
+{
+  VALUE obj;
+  RB_LDAPMOD_DATA *moddata;
+
+  obj = Data_Make_Struct (rb_cLDAP_Mod, RB_LDAPMOD_DATA,
+			  0, rb_ldap_mod_free, moddata);
+  moddata->mod = rb_ldap_new_mod2 (mod_op, mod_type, modv_bvals);
+
+  return obj;
+}
+
+static VALUE
+rb_ldap_mod_s_allocate (VALUE klass)
+{
+  RB_LDAPMOD_DATA *moddata;
+  VALUE obj;
+
+  obj =
+    Data_Make_Struct (klass, RB_LDAPMOD_DATA, 0, rb_ldap_mod_free, moddata);
+  moddata->mod = NULL;
+
+  return obj;
+}
+
+/*
+ * call-seq:
+ * Mod.new(mod_type, attr, vals)  => LDAP::Mod
+ *
+ * Create a new LDAP::Mod object of type +mod_type+. This is most commonly
+ * *LDAP_MOD_ADD*, *LDAP_MOD_REPLACE* or *LDAP_MOD_DELETE*, although some LDAP
+ * servers may offer extension types. 
+ *
+ * +attr+ should be the name of the attribute on which to operate, whilst
+ * +vals+ is an array of values pertaining to +attr+. If +vals+ contains
+ * binary data, +mod_type+ should be logically OR'ed (|) with
+ * *LDAP_MOD_BVALUES*.
+ *
+ * LDAP::Mod objects can be passed to methods in the LDAP::Conn class, such as
+ * Conn#add, Conn#add_ext, Conn#modify and Conn#modify_ext.
+ */
+static VALUE
+rb_ldap_mod_initialize (int argc, VALUE argv[], VALUE self)
+{
+  struct berval **bvals;
+  char **strvals;
+  int mod_op;
+  char *mod_type;
+  int i;
+  VALUE op, type, vals;
+  RB_LDAPMOD_DATA *moddata;
+
+  rb_scan_args (argc, argv, "3", &op, &type, &vals);
+  Data_Get_Struct (self, RB_LDAPMOD_DATA, moddata);
+  if (moddata->mod)
+    return Qnil;
+
+  mod_op = NUM2INT (op);
+  mod_type = RSTRING_PTR(type);
+  Check_Type (vals, T_ARRAY);
+
+  if (mod_op & LDAP_MOD_BVALUES)
+    {
+      bvals = ALLOC_N (struct berval *, RARRAY_LEN (vals) + 1);
+      for (i = 0; i < RARRAY_LEN (vals); i++)
+	{
+	  VALUE str;
+	  struct berval *bval;
+	  str = RARRAY_PTR (vals)[i];
+	  Check_Type (str, T_STRING);
+	  bval = ALLOC_N (struct berval, 1);
+	  bval->bv_len = RSTRING_LEN (str);
+	  RB_LDAP_SET_STR (bval->bv_val, str);
+	  bvals[i] = bval;
+	}
+      bvals[i] = NULL;
+      moddata->mod = rb_ldap_new_mod2 (mod_op, mod_type, bvals);
+    }
+  else
+    {
+      strvals = ALLOC_N (char *, RARRAY_LEN (vals) + 1);
+      for (i = 0; i < RARRAY_LEN (vals); i++)
+	{
+	  VALUE str;
+	  char *sval;
+	  str = RARRAY_PTR (vals)[i];
+	  RB_LDAP_SET_STR (sval, str);
+	  strvals[i] = sval;
+	}
+      strvals[i] = NULL;
+      moddata->mod = rb_ldap_new_mod (mod_op, mod_type, strvals);
+    }
+
+  return Qnil;
+}
+
+/*
+ * call-seq:
+ * mod.mod_op  => Fixnum
+ *
+ * Return the type of modification associated with the LDAP::Mod object.
+ * Standard types are *LDAP_MOD_ADD*, *LDAP_MOD_REPLACE* and
+ * *LDAP_MOD_DELETE*, although any of these may be logically OR'ed with
+ * *LDAP_MOD_BVALUES* to indicate that the values of the Mod object contain
+ * binary data.
+ */
+VALUE
+rb_ldap_mod_op (VALUE self)
+{
+  RB_LDAPMOD_DATA *moddata;
+
+  GET_LDAPMOD_DATA (self, moddata);
+  return INT2NUM (moddata->mod->mod_op);
+}
+
+/*
+ * call-seq:
+ * mod.mod_type  => String
+ *
+ * Return the name of the attribute associated with the LDAP::Mod object.
+ */
+VALUE
+rb_ldap_mod_type (VALUE self)
+{
+  RB_LDAPMOD_DATA *moddata;
+
+  GET_LDAPMOD_DATA (self, moddata);
+  return rb_tainted_str_new2 (moddata->mod->mod_type);
+}
+
+/*
+ * call-seq:
+ * mod.mod_vals  => Array of String
+ *
+ * Return the values associated with the Mod object.
+ */
+VALUE
+rb_ldap_mod_vals (VALUE self)
+{
+  RB_LDAPMOD_DATA *moddata;
+  struct berval **bvals;
+  char **svals;
+  int i;
+  VALUE val;
+
+  GET_LDAPMOD_DATA (self, moddata);
+
+  if (moddata->mod->mod_op & LDAP_MOD_BVALUES)
+    {
+      bvals = moddata->mod->mod_vals.modv_bvals;
+      val = rb_ary_new ();
+      for (i = 0; bvals[i] != NULL; i++)
+	{
+	  VALUE str;
+	  str = rb_tainted_str_new (bvals[i]->bv_val, bvals[i]->bv_len);
+	  rb_ary_push (val, str);
+	}
+    }
+  else
+    {
+      svals = moddata->mod->mod_vals.modv_strvals;
+      val = rb_ary_new ();
+      for (i = 0; svals[i] != NULL; i++)
+	{
+	  VALUE str;
+	  str = rb_tainted_str_new2 (svals[i]);
+	  rb_ary_push (val, str);
+	}
+    }
+
+  return val;
+}
+
+/* call-seq:
+ * mod.inspect  => String
+ *
+ * Produce a concise representation of the Mod object.
+ */
+VALUE
+rb_ldap_mod_inspect (VALUE self)
+{
+  VALUE str;
+  VALUE hash = rb_hash_new ();
+  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 ", 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
+  
+  switch (FIX2INT (rb_ldap_mod_op (self)) & ~LDAP_MOD_BVALUES)
+    {
+    case LDAP_MOD_ADD:
+      rb_str_cat2 (str, "LDAP_MOD_ADD");
+      break;
+    case LDAP_MOD_DELETE:
+      rb_str_cat2 (str, "LDAP_MOD_DELETE");
+      break;
+    case LDAP_MOD_REPLACE:
+      rb_str_cat2 (str, "LDAP_MOD_REPLACE");
+      break;
+#ifdef LDAP_MOD_INCREMENT
+    case LDAP_MOD_INCREMENT:
+      rb_str_cat2 (str, "LDAP_MOD_INCREMENT");
+      break;
+#endif
+#ifdef LDAP_MOD_OP
+    case LDAP_MOD_OP:
+      rb_str_cat2 (str, "LDAP_MOD_OP");
+      break;
+#endif
+    default:
+      /* We shouldn't end up here. */
+      rb_str_cat2 (str, "unknown");
+      break;
+    }
+  if (FIX2INT (rb_ldap_mod_op (self)) & LDAP_MOD_BVALUES)
+    rb_str_cat2 (str, "|LDAP_MOD_BVALUES");
+  rb_str_cat2 (str, "\n");
+
+  rb_hash_aset (hash, rb_ldap_mod_type (self), rb_ldap_mod_vals (self));
+  rb_str_concat (str, rb_inspect (hash));
+  rb_str_cat2 (str, ">");
+
+  return str;
+}
+
+/* Document-class: LDAP::Mod
+ *
+ * Create and manipulate LDAP::Mod objects, which can then be passed to methods
+ * in the LDAP::Conn class, such as Conn#add, Conn#add_ext, Conn#modify and
+ * Conn#modify_ext.
+ */
+void
+Init_ldap_mod ()
+{
+  rb_cLDAP_Mod = rb_define_class_under (rb_mLDAP, "Mod", rb_cObject);
+#if RUBY_VERSION_CODE < 170
+  rb_define_singleton_method (rb_cLDAP_Mod, "new", rb_ldap_class_new, -1);
+#endif
+#if RUBY_VERSION_CODE >= 173
+  rb_define_alloc_func (rb_cLDAP_Mod, rb_ldap_mod_s_allocate);
+#else
+  rb_define_singleton_method (rb_cLDAP_Mod, "allocate",
+                             rb_ldap_mod_s_allocate, 0);
+#endif
+  rb_ldap_mod_define_method ("initialize", rb_ldap_mod_initialize, -1);
+  rb_ldap_mod_define_method ("mod_op", rb_ldap_mod_op, 0);
+  rb_ldap_mod_define_method ("mod_type", rb_ldap_mod_type, 0);
+  rb_ldap_mod_define_method ("mod_vals", rb_ldap_mod_vals, 0);
+  rb_ldap_mod_define_method ("inspect", rb_ldap_mod_inspect, 0);
+
+  /*
+     rb_ldap_mod_define_method("mod_op=", rb_ldap_mod_set_op, 1);
+     rb_ldap_mod_define_method("mod_type=", rb_ldap_mod_set_type, 1);
+     rb_ldap_mod_define_method("mod_vals=", rb_ldap_mod_set_vals, 1);
+   */
+}

data/rbldap.h

@@ -0,0 +1,207 @@
+/*
+ * rbldap.h
+ * $Id: rbldap.h,v 1.17 2006/08/09 11:23:04 ianmacd Exp $
+ */
+
+#ifndef RB_LDAP_H
+#define RB_LDAP_H 1
+
+#ifdef USE_WLDAP32
+# ifdef HAVE_WINLBER_H
+#   include "winlber.h"
+# endif
+# include "winldap.h"
+#else
+# include <lber.h>
+# include <ldap.h>
+#endif
+
+#ifdef HAVE_LDAP_SSL_H
+#include <ldap_ssl.h>
+#endif
+
+#ifndef LDAP_OPT_SUCCESS
+# define LDAP_OPT_SUCCESS (0)
+# define LDAP_OPT_ERROR   (-1)
+#endif
+
+#define RB_LDAP_MAJOR_VERSION 0
+#define RB_LDAP_MINOR_VERSION 9
+#define RB_LDAP_PATCH_VERSION 20
+#define RB_LDAP_VERSION "0.10.0"
+
+#define LDAP_GET_OPT_MAX_BUFFER_SIZE    (1024)	/* >= sizeof(LDAPAPIInfo) */
+
+#define RB_LDAP_SET_STR(var,val) {\
+   Check_Type(val, T_STRING); \
+   var = ALLOC_N(char, RSTRING_LEN(val) + 1); \
+   memcpy(var, RSTRING_PTR(val), RSTRING_LEN(val) + 1); \
+}
+
+#if defined(HAVE_LDAP_SEARCH_EXT_S)
+# define HAVE_LDAPCONTROL
+#endif
+
+typedef struct rb_ldap_data
+{
+  LDAP *ldap;
+  int bind;
+  int err;
+} RB_LDAP_DATA;
+
+#define RLDAP_DATA_PTR(obj) ((RB_LDAP_DATA*)DATA_PTR(obj))
+
+typedef struct rb_ldapentry_data
+{
+  LDAP *ldap;
+  LDAPMessage *msg;
+#if RUBY_VERSION_CODE >= 190
+  VALUE dn;
+  VALUE attr;
+#endif
+} RB_LDAPENTRY_DATA;
+
+typedef struct rb_ldapmod_data
+{
+  LDAPMod *mod;
+} RB_LDAPMOD_DATA;
+
+struct timeval rb_time_interval(VALUE num);
+
+#ifndef HAVE_LDAP_MEMFREE
+# define ldap_memfree(ptr) free(ptr)
+#endif
+
+extern VALUE rb_mLDAP;
+
+extern VALUE rb_sLDAP_APIInfo;
+extern VALUE rb_cLDAP_Controls;
+
+extern VALUE rb_cLDAP_Conn;
+extern VALUE rb_cLDAP_SSLConn;
+extern VALUE rb_cLDAP_Entry;
+extern VALUE rb_cLDAP_Mod;
+extern VALUE rb_eLDAP_Error;
+extern VALUE rb_eLDAP_ResultError;
+extern VALUE rb_eLDAP_InvalidDataError;
+extern VALUE rb_eLDAP_InvalidEntryError;
+
+#ifdef LDAP_OPT_API_INFO
+VALUE rb_ldap_apiinfo_new (LDAPAPIInfo *);
+LDAPAPIInfo *rb_ldap_get_apiinfo (VALUE);
+#endif /* LDAP_OPT_API_INFO */
+
+#ifdef HAVE_LDAPCONTROL
+VALUE rb_ldap_control_new (LDAPControl *);
+LDAPControl *rb_ldap_get_control (VALUE);
+LDAPControl **rb_ldap_get_controls (VALUE);
+void rb_ldap_free_controls (LDAPControl ** ctrls);
+#endif
+
+VALUE rb_ldap_class_new (int, VALUE[], VALUE);
+VALUE rb_ldap_dummy_method (int, VALUE[], VALUE);
+VALUE rb_ldap_err2string (VALUE, VALUE);
+VALUE rb_ldap_dn2ufn (VALUE, VALUE);
+VALUE rb_ldap_hash2mods (VALUE, VALUE, VALUE);
+VALUE rb_ldap_entry2hash (VALUE, VALUE);
+
+VALUE rb_ldap_conn_new (VALUE, LDAP *);
+VALUE rb_ldap_conn_simple_bind_s (int, VALUE[], VALUE);
+VALUE rb_ldap_conn_bind_s (int, VALUE[], VALUE);
+VALUE rb_ldap_conn_start_tls_s (int, VALUE[], VALUE);
+VALUE rb_ldap_conn_unbind (VALUE);
+VALUE rb_ldap_conn_set_option (VALUE, VALUE, VALUE);
+VALUE rb_ldap_conn_get_option (VALUE, VALUE);
+VALUE rb_ldap_conn_perror (VALUE, VALUE);
+VALUE rb_ldap_conn_result2error (VALUE, VALUE);
+VALUE rb_ldap_conn_err2string (VALUE, VALUE);
+VALUE rb_ldap_conn_search_s (int, VALUE[], VALUE);
+VALUE rb_ldap_conn_search2_s (int, VALUE[], VALUE);
+VALUE rb_ldap_conn_add_s (VALUE, VALUE, VALUE);
+VALUE rb_ldap_conn_modify_s (VALUE, VALUE, VALUE);
+VALUE rb_ldap_conn_modrdn_s (VALUE, VALUE, VALUE, VALUE);
+VALUE rb_ldap_conn_delete_s (VALUE, VALUE);
+VALUE rb_ldap_conn_err (VALUE);
+VALUE rb_ldap_conn_set_sort (VALUE, VALUE, VALUE);
+VALUE rb_ldap_conn_get_sort (VALUE);
+
+VALUE rb_ldap_saslconn_bind (int, VALUE[], VALUE);
+
+VALUE rb_ldap_entry_new (LDAP *, LDAPMessage *);
+VALUE rb_ldap_entry_get_dn (VALUE self);
+VALUE rb_ldap_entry_get_values (VALUE, VALUE);
+VALUE rb_ldap_entry_get_attributes (VALUE);
+VALUE rb_ldap_entry_to_hash (VALUE);
+
+VALUE rb_ldap_mod_new (int, char *, char **);
+VALUE rb_ldap_mod_new2 (int, char *, struct berval **);
+VALUE rb_ldap_mod_op (VALUE);
+VALUE rb_ldap_mod_type (VALUE);
+VALUE rb_ldap_mod_vals (VALUE);
+
+#define Check_Kind(obj,klass) {\
+  if(!rb_obj_is_kind_of(obj,klass))\
+    rb_raise(rb_eTypeError,"type mismatch");\
+};
+
+#define Check_LDAP_Result(err) { \
+  if( (err) != LDAP_SUCCESS && (err) != LDAP_SIZELIMIT_EXCEEDED ){ \
+    rb_raise(rb_eLDAP_ResultError, "%s", ldap_err2string(err)); \
+  } \
+}
+
+#define Check_LDAP_OPT_Result(err) { \
+  if( (err) != LDAP_OPT_SUCCESS ){ \
+    rb_raise(rb_eLDAP_ResultError, "%s", ldap_err2string(err)); \
+  } \
+}
+
+#define GET_LDAP_DATA(obj,ptr) {\
+  Data_Get_Struct(obj, struct rb_ldap_data, ptr); \
+  if( ! ptr->ldap ){ \
+    rb_raise(rb_eLDAP_InvalidDataError, "The LDAP handler has already unbound.");\
+  } \
+}
+
+#define Check_LDAPENTRY(obj) {\
+  RB_LDAPENTRY_DATA *ptr; \
+  Data_Get_Struct(obj, struct rb_ldapentry_data, ptr); \
+  if( ! ptr->msg ){ \
+    VALUE value = rb_inspect(obj); \
+    rb_raise(rb_eLDAP_InvalidEntryError, "%s is not a valid entry", \
+	     StringValuePtr(value)); \
+  }; \
+}
+
+#if RUBY_VERSION_CODE < 190
+#define GET_LDAPENTRY_DATA(obj,ptr) { \
+  Data_Get_Struct(obj, struct rb_ldapentry_data, ptr); \
+  if( ! ptr->msg ){ \
+    VALUE value = rb_inspect(obj); \
+    rb_raise(rb_eLDAP_InvalidEntryError, "%s is not a valid entry", \
+	     StringValuePtr(value)); \
+  }; \
+}
+#else
+#define GET_LDAPENTRY_DATA(obj,ptr) { \
+  Data_Get_Struct(obj, struct rb_ldapentry_data, ptr); \
+}
+#endif
+
+#define GET_LDAPMOD_DATA(obj,ptr) {\
+  Data_Get_Struct(obj, struct rb_ldapmod_data, ptr); \
+  if( ! ptr->mod ) \
+    rb_raise(rb_eLDAP_InvalidDataError, "The Mod data is not ready for use."); \
+}
+
+#define rb_ldap_define_class(cname,parent) \
+        rb_define_class_under(rb_mLDAP,cname,parent)
+
+#define rb_ldap_conn_define_method(method,cfunc,argc) \
+        rb_define_method(rb_cLDAP_Conn,method,cfunc,argc)
+#define rb_ldap_entry_define_method(method,cfunc,argc) \
+        rb_define_method(rb_cLDAP_Entry,method,cfunc,argc)
+#define rb_ldap_mod_define_method(method,cfunc,argc) \
+        rb_define_method(rb_cLDAP_Mod,method,cfunc,argc)
+
+#endif