LDAPapi.xs

/* This file was modified by Howard Chu, hyc@symas.com, 2000-2003.
 * Most changes are #if OPENLDAP, some are not marked.
 */
#ifdef __cplusplus
extern "C" {
#endif

#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"

#ifdef __cplusplus
}
#endif

#include <lber.h>
#include <ldap.h>

#include <sasl/sasl.h>

/* Mozilla prototypes declare things as "const char *" while   */
/*      OpenLDAP uses "char *"                                 */

#ifdef MOZILLA_LDAP
 #define LDAP_CHAR const char
 #include <ldap_ssl.h>
#else

#ifndef OPENLDAP
 #include "ldap_compat.h"
#endif

 #define LDAP_CHAR char
#endif

#ifndef LDAP_RES_INTERMEDIATE
 #define LDAP_RES_INTERMEDIATE  0x79U /* 121 */
#endif

/* Function Prototypes for Internal Functions */

static char **av2modvals(AV *ldap_value_array_av, int ldap_isa_ber);
static LDAPMod *parse1mod(SV *ldap_value_ref,char *ldap_current_attribute,
    int ldap_add_func,int cont);
static LDAPMod **hash2mod(SV *ldap_change,int ldap_add_func, const char *func);

#ifdef OPENLDAP
   static int internal_rebind_proc(LDAP *ld,          LDAP_CONST char *url,
                                   ber_tag_t request, ber_int_t msgid,
                                   void *params);
#endif

/* The Name of the PERL function to return DN, PASSWD, AUTHTYPE on Rebind */
/* Set using 'set_rebind_proc()' */
SV *ldap_perl_rebindproc = NULL;


/* Use constant.h generated from constant.gen */
/* Courtesy of h.b.furuseth@usit.uio.no       */

#include "constant.h"


/* Strcasecmp - Some operating systems don't have this, including NT */

int StrCaseCmp(const char *s, const char *t)
{
   while (*s && *t && toupper(*s) == toupper(*t))
   {
      s++; t++;
   }
   return(toupper(*s) - toupper(*t));
}

/* av2modvals - Takes a single Array Reference (AV *) and returns */
/*    a null terminated list of char pointers.                    */

static
char **av2modvals(AV *ldap_value_array_av, int ldap_isa_ber)
{
   I32 ldap_arraylen;
   char **ldap_ch_modvalues = NULL;
   char *ldap_current_value_char = NULL;
   struct berval **ldap_bv_modvalues = NULL;
   struct berval *ldap_current_bval = NULL;
   SV **ldap_current_value_sv;
   int ldap_value_count = 0,ldap_pvlen,ldap_real_valuecount = 0;

   ldap_arraylen = av_len(ldap_value_array_av);
   if (ldap_arraylen < 0)
      return(NULL);

   if (ldap_isa_ber == 1)
   {
      New(1,ldap_bv_modvalues,2+ldap_arraylen,struct berval *);
   } else {
      New(1,ldap_ch_modvalues,2+ldap_arraylen,char *);
   }

   for (ldap_value_count = 0; ldap_value_count <=ldap_arraylen;
    ldap_value_count++)
   {
      ldap_current_value_sv = av_fetch(ldap_value_array_av,ldap_value_count,0);
      ldap_current_value_char = SvPV(*ldap_current_value_sv,PL_na);
      ldap_pvlen = SvCUR(*ldap_current_value_sv);
      if (strcmp(ldap_current_value_char,"") != 0)
      {
         if (ldap_isa_ber == 1)
         {
            New(1,ldap_current_bval,1,struct berval);
        ldap_current_bval->bv_len = ldap_pvlen;
        ldap_current_bval->bv_val = ldap_current_value_char;
        ldap_bv_modvalues[ldap_real_valuecount] = ldap_current_bval;
         } else {
            ldap_ch_modvalues[ldap_real_valuecount] = ldap_current_value_char;
         }
         ldap_real_valuecount++;
      }
   }
   if (ldap_isa_ber == 1)
   {
      ldap_bv_modvalues[ldap_real_valuecount] = NULL;
      return ((char **)ldap_bv_modvalues);
   } else {
      ldap_ch_modvalues[ldap_real_valuecount] = NULL;
      return (ldap_ch_modvalues);
   }
}


/* parse1mod - Take a single reference, figure out if it is a HASH, */
/*   ARRAY, or SCALAR, then extract the values and attributes and   */
/*   return a single LDAPMod pointer to this data.                  */

static
LDAPMod *parse1mod(SV *ldap_value_ref,char *ldap_current_attribute,
   int ldap_add_func,int cont)
{
   LDAPMod *ldap_current_mod;
   static HV *ldap_current_values_hv;
   HE *ldap_change_element;
   char *ldap_current_modop;
   SV *ldap_current_value_sv;
   I32 keylen;
   int ldap_isa_ber = 0;

   if (ldap_current_attribute == NULL)
      return(NULL);
   New(1,ldap_current_mod,1,LDAPMod);
   ldap_current_mod->mod_type = ldap_current_attribute;
   if (SvROK(ldap_value_ref))
   {
     if (SvTYPE(SvRV(ldap_value_ref)) == SVt_PVHV)
     {
      if (!cont)
      {
         ldap_current_values_hv = (HV *) SvRV(ldap_value_ref);
         hv_iterinit(ldap_current_values_hv);
      }
      if ((ldap_change_element = hv_iternext(ldap_current_values_hv)) == NULL)
     return(NULL);
      ldap_current_modop = hv_iterkey(ldap_change_element,&keylen);
      ldap_current_value_sv = hv_iterval(ldap_current_values_hv,
    ldap_change_element);
      if (ldap_add_func == 1)
      {
     ldap_current_mod->mod_op = 0;
      } else {
     if (strchr(ldap_current_modop,'a') != NULL)
     {
        ldap_current_mod->mod_op = LDAP_MOD_ADD;
     } else if (strchr(ldap_current_modop,'r') != NULL)
     {
        ldap_current_mod->mod_op = LDAP_MOD_REPLACE;
     } else if (strchr(ldap_current_modop,'d') != NULL) {
        ldap_current_mod->mod_op = LDAP_MOD_DELETE;
     } else {
        return(NULL);
     }
      }
      if (strchr(ldap_current_modop,'b') != NULL)
      {
     ldap_isa_ber = 1;
     ldap_current_mod->mod_op = ldap_current_mod->mod_op | LDAP_MOD_BVALUES;
      }
      if (SvTYPE(SvRV(ldap_current_value_sv)) == SVt_PVAV)
      {
     if (ldap_isa_ber == 1)
     {
        ldap_current_mod->mod_values =
          av2modvals((AV *)SvRV(ldap_current_value_sv),ldap_isa_ber);
     } else {
        ldap_current_mod->mod_values =
          av2modvals((AV *)SvRV(ldap_current_value_sv),ldap_isa_ber);
     }
      }
     } else if (SvTYPE(SvRV(ldap_value_ref)) == SVt_PVAV) {
      if (cont)
         return NULL;
      if (ldap_add_func == 1)
         ldap_current_mod->mod_op = 0;
      else
         ldap_current_mod->mod_op = LDAP_MOD_REPLACE;
      ldap_current_mod->mod_values = av2modvals((AV *)SvRV(ldap_value_ref),0);
      if (ldap_current_mod->mod_values == NULL)
      {
     ldap_current_mod->mod_op = LDAP_MOD_DELETE;
      }
     }
   } else {
      if (cont)
         return NULL;
      if (strcmp(SvPV(ldap_value_ref,PL_na),"") == 0)
      {
         if (ldap_add_func != 1)
         {
        ldap_current_mod->mod_op = LDAP_MOD_DELETE;
        ldap_current_mod->mod_values = NULL;
         } else {
            return(NULL);
         }
      } else {
         if (ldap_add_func == 1)
         {
            ldap_current_mod->mod_op = 0;
         } else {
        ldap_current_mod->mod_op = LDAP_MOD_REPLACE;
         }
         New(1,ldap_current_mod->mod_values,2,char *);
     ldap_current_mod->mod_values[0] = SvPV(ldap_value_ref,PL_na);
     ldap_current_mod->mod_values[1] = NULL;
      }
   }
   return(ldap_current_mod);
}


/* hash2mod - Cycle through all the keys in the hash and properly call */
/*    the appropriate functions to build a NULL terminated list of     */
/*    LDAPMod pointers.                                                */

static
LDAPMod ** hash2mod(SV *ldap_change_ref, int ldap_add_func, const char *func)
{
   LDAPMod **ldapmod = NULL;
   LDAPMod *ldap_current_mod;
   int ldap_attribute_count = 0;
   HE *ldap_change_element;
   char *ldap_current_attribute;
   SV *ldap_current_value_sv;
   I32 keylen;
   HV *ldap_change;

   if (!SvROK(ldap_change_ref) || SvTYPE(SvRV(ldap_change_ref)) != SVt_PVHV)
      croak("Net::LDAPapi::%s needs Hash reference as argument 3.",func);

   ldap_change = (HV *)SvRV(ldap_change_ref);

   hv_iterinit(ldap_change);
   while((ldap_change_element = hv_iternext(ldap_change)) != NULL)
   {
      ldap_current_attribute = hv_iterkey(ldap_change_element,&keylen);
      ldap_current_value_sv = hv_iterval(ldap_change,ldap_change_element);
      ldap_current_mod = parse1mod(ldap_current_value_sv,
    ldap_current_attribute,ldap_add_func,0);
      while (ldap_current_mod != NULL)
      {
         ldap_attribute_count++;
         (ldapmod
       ? Renew(ldapmod,1+ldap_attribute_count,LDAPMod *)
       : New(1,ldapmod,1+ldap_attribute_count,LDAPMod *));
         New(1,ldapmod[ldap_attribute_count -1],sizeof(LDAPMod),LDAPMod);
         Copy(ldap_current_mod,ldapmod[ldap_attribute_count-1],
       sizeof(LDAPMod),LDAPMod *);
         ldap_current_mod = parse1mod(ldap_current_value_sv,
           ldap_current_attribute,ldap_add_func,1);

      }
   }
   ldapmod[ldap_attribute_count] = NULL;
   return ldapmod;
}

/* internal_rebind_proc - Wrapper to call a PERL rebind process               */
/*   ldap_set_rebind_proc is slightly different between Mozilla and OpenLDAP  */

int
#ifdef OPENLDAP
internal_rebind_proc(LDAP *ld,          LDAP_CONST char *url,
                     ber_tag_t request, ber_int_t msgid,
                     void *params)
#endif
{
    return(LDAP_SUCCESS);
}

typedef struct bictx {
    char *authcid;
    char *passwd;
    char *realm;
    char *authzid;
} bictx;

static int
ldap_b2_interact(LDAP *ld, unsigned flags, void *def, void *inter)
{
    sasl_interact_t *in = inter;
    const char *p;
    bictx *ctx = def;
     for (;in->id != SASL_CB_LIST_END;in++)
    {
        p = NULL;
        switch(in->id)
        {
            case SASL_CB_GETREALM:
                p = ctx->realm;
                break;
            case SASL_CB_AUTHNAME:
                p = ctx->authcid;
                break;
            case SASL_CB_USER:
                p = ctx->authzid;
                break;
            case SASL_CB_PASS:
                p = ctx->passwd;
                break;
        }
        if (p)
        {
            in->len = strlen(p);
            in->result = p;
        }
    }
    return LDAP_SUCCESS;
}

static void
sv2timeval(SV *data, struct timeval *tv)
{
    if (SvPOK(data))
    { 
        /* set the NV flag if it's readable as a double */
        SvNV(data);
    }

    if (SvIOK(data) || SvNOK(data)) {
        tv->tv_sec = SvIV(data);
        tv->tv_usec = ((SvNV(data) - SvIV(data))*1000000);
    }
}

static SV *
timeval2sv(struct timeval *data)
{
   return newSVnv(data->tv_sec + ((double)data->tv_usec / 1000000));    
}

MODULE = Net::LDAPapi           PACKAGE = Net::LDAPapi

PROTOTYPES: ENABLE

double
constant(name,arg)
    char *          name
    int             arg


char *
constant_s(name)
    char *          name


int
ldap_initialize(ldp, url)
    LDAP *      ldp = NO_INIT
    LDAP_CHAR * url
    CODE:
    {
       RETVAL = ldap_initialize(&ldp, url);
    }
    OUTPUT:
    RETVAL
    ldp

int
ldap_create(ldp)
    LDAP ** ldp = NO_INIT
    CODE:
    {
        RETVAL = ldap_create(ldp);
    }
    OUTPUT:
    RETVAL
    ldp

int
ldap_bind_s(ldp, dn, passwd, authmethod)
    LDAP *      ldp
    LDAP_CHAR * dn
    LDAP_CHAR * passwd
    int         authmethod

int
ldap_set_option(ld,option,optdata)
    LDAP *          ld
    int             option
    SV *            optdata
    CODE:
    {
       void *optptr = NULL;

       struct timeval tv;

       int sv_i;

       switch(option) 
       {
#ifdef OPENLDAP
          case LDAP_OPT_TIMEOUT:
          case LDAP_OPT_NETWORK_TIMEOUT:
             sv2timeval(optdata, &tv);
             optptr = (void *)&tv;

             break;
#endif
          default:
             if (SvIOK(optdata)) 
             {
                sv_i = SvIV(optdata);
                optptr = (void *) &sv_i;
             }

             break;
       }

       RETVAL = ldap_set_option(ld,option,optptr);
    }
    OUTPUT:
    RETVAL

int
ldap_get_option(ld,option,optdata)
    LDAP *          ld
    int             option
    SV *            optdata
    CODE:
    {
       void *data = NULL;

       RETVAL = ldap_get_option(ld, option, &data);

       switch(option) 
       {
#ifdef OPENLDAP
          case LDAP_OPT_TIMEOUT:
          case LDAP_OPT_NETWORK_TIMEOUT:
             sv_setsv(SvRV(optdata), timeval2sv(data));
             break;
#endif
          default:
             sv_setiv(SvRV(optdata), (long)data);
             break;
       }

    }
    OUTPUT:
    RETVAL
    optdata

int
ldap_unbind_ext_s(ld,sctrls,cctrls)
    LDAP *          ld
    LDAPControl **  sctrls
    LDAPControl **  cctrls

int
ldap_search_s(ldp, base, scope, filter, attrs, attrsonly, res)
    LDAP *        ldp
    LDAP_CHAR *   base
    int           scope
    LDAP_CHAR *   filter
    LDAP_CHAR **  attrs
    int           attrsonly
    LDAPMessage * res = NO_INIT
    CODE:
    {
       RETVAL = ldap_search_s(ldp, base, scope, filter, attrs, attrsonly, &res);
    }
    OUTPUT:
    RETVAL
    res

#ifdef MOZILLA_LDAP

int
ldap_version(ver)
    LDAPVersion     *ver

#endif

int
ldap_abandon_ext(ld,msgid,sctrls,cctrls)
    LDAP *          ld
    int             msgid
    LDAPControl **  sctrls
    LDAPControl **  cctrls

int
ldap_add_ext(ld, dn, ldap_change_ref, sctrls, cctrls, msgidp)
    LDAP *         ld
    LDAP_CHAR *    dn
    SV *           ldap_change_ref
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    int            msgidp = NO_INIT
    CODE:
    {
        LDAPMod ** attrs = hash2mod(ldap_change_ref, 1, "ldap_add_ext");
        RETVAL = ldap_add_ext(ld, dn, attrs, sctrls, cctrls, &msgidp);
        Safefree(attrs);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_add_ext_s(ld,dn,ldap_change_ref,sctrls,cctrls)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAPMod **     ldap_change_ref = hash2mod($arg, 1, "ldap_add_ext_s");
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    CLEANUP:
       Safefree(ldap_change_ref);

int
ldap_sasl_bind(ld, dn, passwd, serverctrls, clientctrls, msgidp)
    LDAP *          ld
    LDAP_CHAR *     dn
    LDAP_CHAR *     passwd
    LDAPControl **  serverctrls
    LDAPControl **  clientctrls
    int             msgidp = NO_INIT
    CODE:
    {
        struct berval cred;

        if( passwd == NULL )
            cred.bv_val = "";
        else
            cred.bv_val = passwd;

        cred.bv_len = strlen(cred.bv_val);

        RETVAL = ldap_sasl_bind(ld, dn, LDAP_SASL_SIMPLE, &cred,
                                serverctrls, clientctrls, &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_modify_ext(ld, dn, ldap_change_ref, sctrls, cctrls, msgidp)
    LDAP *         ld
    LDAP_CHAR *    dn
    SV *           ldap_change_ref
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    int            msgidp = NO_INIT
    CODE:
    {
        LDAPMod ** mods  = hash2mod(ldap_change_ref, 0, "ldap_modify_ext");
        RETVAL = ldap_modify_ext(ld, dn, mods, sctrls, cctrls, &msgidp);
        Safefree(mods);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_modify_ext_s(ld,dn,ldap_change_ref,sctrl,cctrl)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAPMod **     ldap_change_ref = hash2mod($arg, 0, "$func_name");
    LDAPControl ** sctrl
    LDAPControl ** cctrl

int
ldap_rename(ld, dn, newrdn, newSuperior, deleteoldrdn, sctrls, cctrls, msgidp)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAP_CHAR *    newrdn
    LDAP_CHAR *    newSuperior
    int            deleteoldrdn
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    int            msgidp = NO_INIT
    CODE:
    {
        RETVAL = ldap_rename(ld, dn, newrdn, newSuperior,
                    deleteoldrdn, sctrls, cctrls, &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_rename_s(ld, dn, newrdn, newSuperior, deleteoldrdn, sctrls, cctrls)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAP_CHAR *    newrdn
    LDAP_CHAR *    newSuperior
    int            deleteoldrdn
    LDAPControl ** sctrls
    LDAPControl ** cctrls

int
ldap_compare_ext(ld,dn,attr,value,sctrls,cctrls,msgidp)
    LDAP *          ld
    LDAP_CHAR *     dn
    LDAP_CHAR *     attr
    LDAP_CHAR *     value
    LDAPControl **  sctrls
    LDAPControl **  cctrls
    int             msgidp = NO_INIT
    CODE:
    {
        struct berval bvalue;
        bvalue.bv_len = strlen(value);
        bvalue.bv_val = value;
        RETVAL = ldap_compare_ext(ld, dn, attr, &bvalue, sctrls, cctrls, &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_compare_ext_s(ld, dn, attr, value, sctrls, cctrls)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAP_CHAR *    attr
    LDAP_CHAR *    value
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    CODE:
    {
        struct berval bvalue;
        bvalue.bv_len = strlen(value);
        bvalue.bv_val = value;
        RETVAL = ldap_compare_ext_s(ld, dn, attr, &bvalue, sctrls, cctrls);
    }
    OUTPUT:
    RETVAL

int
ldap_delete_ext(ld,dn,sctrls,cctrls,msgidp)
    LDAP *         ld
    LDAP_CHAR *    dn
    LDAPControl ** sctrls
    LDAPControl ** cctrls
    int            msgidp = NO_INIT
    CODE:
    {
        RETVAL = ldap_delete_ext(ld, dn, sctrls, cctrls, &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_delete_ext_s(ld,dn,sctrls,cctrls)
    LDAP *          ld
    LDAP_CHAR *     dn
    LDAPControl **  sctrls
    LDAPControl **  cctrls

int
ldap_search_ext(ld, base, scope, filter, attrs, attrsonly, sctrls, cctrls, timeout, sizelimit, msgidp)
    LDAP *           ld
    LDAP_CHAR *      base
    int              scope
    LDAP_CHAR *      filter
    SV *             attrs
    int              attrsonly
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    SV *             timeout
    int              sizelimit
    int              msgidp = NO_INIT

    CODE:
    {
       char **attrs_char;
       SV **current;
       int arraylen,count;
       struct timeval tv_timeout;

       if (SvTYPE(SvRV(attrs)) != SVt_PVAV)
       {
          croak("Net::LDAPapi::ldap_search_ext needs ARRAY reference as argument 5.");
          XSRETURN(1);
       }

       if ((arraylen = av_len((AV *)SvRV(attrs))) < 0)
       {
          New(1,attrs_char,2,char *);
          attrs_char[0] = NULL;
       } else {
          New(1,attrs_char,arraylen+2,char *);
          for (count=0;count <= arraylen; count++)
          {
            current = av_fetch((AV *)SvRV(attrs),count,0);
            attrs_char[count] = SvPV(*current,PL_na);
          }
          attrs_char[arraylen+1] = NULL;
       }

       sv2timeval(timeout, &tv_timeout);

       RETVAL = ldap_search_ext(ld,        base,   scope,  filter,  attrs_char,
                                attrsonly, sctrls, cctrls, &tv_timeout, sizelimit,
                                &msgidp);
       Safefree(attrs_char);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_search_ext_s(ld, base, scope, filter, attrs, attrsonly, sctrls, cctrls, timeout, sizelimit, res)
    LDAP *           ld
    LDAP_CHAR *      base
    int              scope
    LDAP_CHAR *      filter
    SV *             attrs
    int              attrsonly
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    SV *             timeout
    int              sizelimit
    LDAPMessage *    res = NO_INIT
    CODE:
    {
       char **attrs_char;
       SV **current;
       int arraylen,count;
       struct timeval tv_timeout;

       if (SvTYPE(SvRV(attrs)) == SVt_PVAV)
       {
          if ((arraylen = av_len((AV *)SvRV(attrs))) < 0)
          {
             New(1, attrs_char, 2, char *);
             attrs_char[0] = NULL;
          } else {
             New(1, attrs_char, arraylen+2, char *);
             for (count=0;count <= arraylen; count++)
             {
                current = av_fetch((AV *)SvRV(attrs),count,0);
                attrs_char[count] = SvPV(*current,PL_na);
             }
             attrs_char[arraylen+1] = NULL;
          }
       } else {
          croak("Net::LDAPapi::ldap_search_ext_s needs ARRAY reference as argument 5.");
          XSRETURN(1);
       }

       sv2timeval(timeout, &tv_timeout);

       RETVAL = ldap_search_ext_s(ld,base,scope,filter,attrs_char,attrsonly,sctrls,cctrls,&tv_timeout,sizelimit,&res);

       Safefree(attrs_char);
    }
    OUTPUT:
    RETVAL
    res

int
ldap_extended_operation(ld, oid, bv_val, bv_len,  sctrls, cctrls, msgidp)
    LDAP *           ld
    LDAP_CHAR *      oid
    LDAP_CHAR *      bv_val
    int              bv_len
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    int              msgidp = NO_INIT

    CODE:
    {
       struct berval indata;

       if (bv_len == 0) {
          RETVAL = ldap_extended_operation(ld, oid, NULL,
                                           sctrls, cctrls,
                                           &msgidp);
       } else {
          indata.bv_val = bv_val;
          indata.bv_len = bv_len;

          RETVAL = ldap_extended_operation(ld, oid, &indata,
                                      sctrls, cctrls,
                                      &msgidp);
       }
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_extended_operation_s(ld, oid, bv_val, bv_len,  sctrls, cctrls, retoidp, retdatap)
    LDAP *           ld
    LDAP_CHAR *      oid
    LDAP_CHAR *      bv_val
    int              bv_len
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    char *        retoidp  = NO_INIT
    char *        retdatap = NO_INIT
    CODE:
    {
       struct berval indata, *retdata;

       if (bv_len == 0) {
          RETVAL = ldap_extended_operation_s(ld, oid, NULL,
                                             sctrls, cctrls,
                                             &retoidp, &retdata);
       } else {
          indata.bv_val = bv_val;
          indata.bv_len = bv_len;

          RETVAL = ldap_extended_operation_s(ld, oid, &indata,
                                             sctrls, cctrls,
                                             &retoidp, &retdata);
       }

       if (retdata != NULL)
          retdatap = ldap_strdup(retdata->bv_val);
      
       ber_memfree(retdata);
   }
   OUTPUT:
   RETVAL
   retoidp
   retdatap

int
ldap_whoami(ld, sctrls, cctrls, msgidp)
    LDAP *           ld
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    int              msgidp = NO_INIT

    CODE:
    {
       RETVAL = ldap_whoami(ld, sctrls, cctrls,
                            &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_whoami_s(ld, authzid, sctrls, cctrls)
    LDAP *           ld
    LDAPControl **   sctrls
    LDAPControl **   cctrls
    char *        authzid = NO_INIT
    CODE:
    {
       struct berval *retdata;

       RETVAL = ldap_whoami_s(ld, &retdata, sctrls, cctrls);

       if (retdata != NULL)
          authzid = ldap_strdup(retdata->bv_val);
      
       ber_memfree(retdata);
    }
    OUTPUT:
    RETVAL
    authzid

int
ldap_result(ld, msgid, all, timeout, result)
    LDAP *        ld
    int           msgid
    int           all
    SV *          timeout
    LDAPMessage * result = NO_INIT
    CODE:
    {
        struct timeval tv_timeout;

        sv2timeval(timeout, &tv_timeout);

        RETVAL = ldap_result(ld, msgid, all, &tv_timeout, &result);
    }
    OUTPUT:
    RETVAL
    result


int
ldap_msgfree(lm)
    LDAPMessage *   lm

void
ber_free(ber, freebuf)
    BerElement * ber
    int          freebuf

#if defined(MOZILLA_LDAP) || defined(OPENLDAP)

int
ldap_msgid(lm)
    LDAPMessage *   lm

int
ldap_msgtype(lm)
    LDAPMessage *   lm

#else

int
ldap_msgid(lm)
    LDAPMessage *   lm
    CODE:
    {
       RETVAL = lm->lm_msgid;
    }
    OUTPUT:
    RETVAL

int
ldap_msgtype(lm)
    LDAPMessage *   lm
    CODE:
    {
       RETVAL = lm->lm_msgtype;
    }
    OUTPUT:
    RETVAL

#endif

#if defined(MOZILLA_LDAP)

int
ldap_get_lderrno(ld,m,s)
    LDAP *          ld
    char *          m = NO_INIT
    char *          s = NO_INIT
    CODE:
    {
       RETVAL = ldap_get_lderrno(ld,&m,&s);
    }
    OUTPUT:
    RETVAL
    m
    s

int
ldap_set_lderrno(ld,e,m,s)
    LDAP *          ld
    int             e
    char *          m
    char *          s

#else

int
ldap_get_lderrno(ld,m,s)
    LDAP *          ld
    char *          m = NO_INIT
    char *          s = NO_INIT
    CODE:
    {
#ifdef OPENLDAP
       ldap_get_option(ld, LDAP_OPT_ERROR_NUMBER, &RETVAL);
       ldap_get_option(ld, LDAP_OPT_ERROR_STRING, &s);
       ldap_get_option(ld, LDAP_OPT_MATCHED_DN, &m);
#else
       RETVAL = ld->ld_errno;
       m = ld->ld_matched;
       s = ld->ld_error;
#endif
    }
    OUTPUT:
    RETVAL
    m
    s

int
ldap_set_lderrno(ld,e,m,s)
    LDAP *          ld
    int             e
    char *          m
    char *          s
    CODE:
    {
       RETVAL = 0;
#ifdef OPENLDAP
       ldap_set_option(ld, LDAP_OPT_ERROR_NUMBER, &e);
       ldap_set_option(ld, LDAP_OPT_ERROR_STRING, s);
       ldap_set_option(ld, LDAP_OPT_MATCHED_DN, m);
#else
       ld->ld_errno = e;
       ld->ld_matched = m;
       ld->ld_error = s;
#endif
    }
    OUTPUT:
    RETVAL

#endif

int
ldap_get_entry_controls(ld, entry, serverctrls_ref)
    LDAP        * ld
    LDAPMessage * entry
    SV *          serverctrls_ref
    CODE:
    {
        int i;

        if (SvTYPE(SvRV(serverctrls_ref)) != SVt_PVAV)
        {
           croak("Net::LDAPapi::ldap_get_entry_controls needs ARRAY reference as argument 3.");
            XSRETURN(-1);
        }

        AV *serverctrls_av = (AV *)SvRV(serverctrls_ref);

        LDAPControl **serverctrls = NULL;

        RETVAL = ldap_get_entry_controls( ld, entry, &serverctrls);

        // transfer returned controls to the perl code
        if( serverctrls != NULL ) {
            for( i = 0; serverctrls[i] != NULL; i++ )
                av_push(serverctrls_av, newSViv((IV)serverctrls[i]));
        }

        free(serverctrls);

        SvRV( serverctrls_ref ) = (SV *)serverctrls_av;
    }
    OUTPUT:
    RETVAL

int
ldap_parse_result(ld, msg, errorcodep, matcheddnp, errmsgp, referrals_ref, serverctrls_ref, freeit)
    LDAP *        ld
    LDAPMessage * msg
    int           errorcodep  = NO_INIT
    SV *          matcheddnp
    SV *          errmsgp
    SV *          referrals_ref
    SV *          serverctrls_ref
    int           freeit
    CODE:
    {
        int i;

        if (SvTYPE(SvRV(referrals_ref)) != SVt_PVAV)
        {
            croak("Net::LDAPapi::ldap_parse_result needs ARRAY reference as argument 6.");
            XSRETURN(-1);
        }

        if (SvTYPE(SvRV(serverctrls_ref)) != SVt_PVAV)
        {
            croak("Net::LDAPapi::ldap_parse_result needs ARRAY reference as argument 7.");
            XSRETURN(-1);
        }

        AV *serverctrls_av = (AV *)SvRV(serverctrls_ref);
        AV *referrals_av  = (AV *)SvRV(referrals_ref);
        char *matcheddn = NULL, *errmsg = NULL;
        LDAPControl **serverctrls = NULL;
        char **referrals = NULL;

        RETVAL =
            ldap_parse_result(ld,       msg,        &errorcodep,  &matcheddn,
                              &errmsg, &referrals, &serverctrls, freeit);

        // transfer returned referrals to the perl code
        if( referrals != NULL ) {
            for( i = 0; referrals[i] != NULL; i++ )
                av_push(referrals_av, newSViv((IV)referrals[i]));
        }

        // transfer returned controls to the perl code
        if( serverctrls != NULL ) {
            for( i = 0; serverctrls[i] != NULL; i++ )
                av_push(serverctrls_av, newSViv((IV)serverctrls[i]));
        }

        if (matcheddn) {
            sv_setpv(matcheddnp, matcheddn);
            free(matcheddn);
        }
        if (errmsg) {
            sv_setpv(errmsgp, errmsg);
            free(errmsg);
        }
        free(serverctrls);
        free(referrals);

        SvRV( referrals_ref ) = (SV *)referrals_av;
        SvRV( serverctrls_ref ) = (SV *)serverctrls_av;
    }
    OUTPUT:
    RETVAL
    errorcodep
    matcheddnp
    errmsgp

int
ldap_parse_extended_result(ld, msg, retoidp, retdatap, freeit)
    LDAP        * ld
    LDAPMessage * msg
    SV *          retoidp
    SV *          retdatap
    int           freeit
    CODE:
    {
       struct berval *retdata = NULL;
       char *retoid;
      
       RETVAL =
           ldap_parse_extended_result(ld, msg, &retoid,
                                      &retdata, freeit);

       sv_setpv(retoidp, retoid);
       if (retdata != NULL) {
          sv_setpvn(retdatap, retdata->bv_val, retdata->bv_len);
          ber_bvfree(retdata);
       }
    }
    OUTPUT:
    RETVAL
    retoidp
    retdatap
   
int
ldap_parse_intermediate(ld, msg, retoidp, retdatap, serverctrls_ref, freeit)
    LDAP        * ld
    LDAPMessage * msg
    SV *          retoidp
    SV *          retdatap
    SV *          serverctrls_ref
    int           freeit
    CODE:
    {
        int i;
        struct berval *retdata = NULL;
        char *retoid;

        if (SvTYPE(SvRV(serverctrls_ref)) != SVt_PVAV)
        {
            croak("Net::LDAPapi::ldap_parse_intermediate needs ARRAY reference as argument 5.");
            XSRETURN(-1);
        }

        AV *serverctrls_av = (AV *)SvRV(serverctrls_ref);

        LDAPControl **serverctrls = NULL;

        RETVAL =
            ldap_parse_intermediate(ld,       msg,          &retoid,
                                    &retdata, &serverctrls, freeit);

        sv_setpv(retoidp, retoid);
        if( retdata != NULL ) {
            sv_setpvn(retdatap, retdata->bv_val, retdata->bv_len);
            ber_bvfree(retdata);
        }

        // transfer returned controls to the perl code
        if( serverctrls != NULL ) {
            for( i = 0; serverctrls[i] != NULL; i++ )
                av_push(serverctrls_av, newSViv((IV)serverctrls[i]));
        }

        free(serverctrls);
        free(retoid);

        SvRV( serverctrls_ref ) = (SV *)serverctrls_av;
    }
    OUTPUT:
    RETVAL
    retoidp
    retdatap

int
ldap_parse_whoami(ld, msg, authzid)
    LDAP        * ld
    LDAPMessage * msg
    SV *          authzid
    CODE:
    {
        struct berval *retdata = NULL;
      
        RETVAL =
            ldap_parse_whoami(ld, msg, &retdata);

        if (retdata != NULL) {
            sv_setpvn(authzid, retdata->bv_val, retdata->bv_len);
            ber_bvfree(retdata);
        }
    }
    OUTPUT:
    RETVAL
    authzid

char *
ldap_control_oid(control)
    LDAPControl * control
    CODE:
    {
        RETVAL = control->ldctl_oid;
    }
    OUTPUT:
    RETVAL


SV *
ldap_control_berval(control)
    LDAPControl * control
    CODE:
    {
        RETVAL = newSVpv(control->ldctl_value.bv_val, control->ldctl_value.bv_len);
    }
    OUTPUT:
    RETVAL


int
ldap_control_critical(control)
    LDAPControl * control
    CODE:
    {
        RETVAL = control->ldctl_iscritical;
    }
    OUTPUT:
    RETVAL


char *
ldap_err2string(err)
    int err


int
ldap_count_references(ld, result)
    LDAP *ld
    LDAPMessage *result


int
ldap_count_entries(ld,result)
    LDAP *          ld
    LDAPMessage *   result


LDAPMessage *
ldap_first_entry(ld,result)
    LDAP *          ld
    LDAPMessage *   result


LDAPMessage *
ldap_next_entry(ld,preventry)
    LDAP *          ld
    LDAPMessage *   preventry

LDAPMessage *
ldap_first_message(ld, chain)
    LDAP        *ld
    LDAPMessage *chain

LDAPMessage *
ldap_next_message(ld, chain)
    LDAP        *ld
    LDAPMessage *chain

SV *
ldap_get_dn(ld,entry)
    LDAP *          ld
    LDAPMessage *   entry
    PREINIT:
       char * dn;
    CODE:
    {
       dn = ldap_get_dn(ld, entry);
       if (dn)
       {
          RETVAL = newSVpv(dn,0);
          ldap_memfree(dn);
       } else {
          RETVAL = &PL_sv_undef;
       }
    }
    OUTPUT:
    RETVAL

void
ldap_perror(ld,s)
	LDAP *          ld
	LDAP_CHAR *     s

char *
ldap_dn2ufn(dn)
    LDAP_CHAR *     dn

#if defined(OPENLDAP)
int
ldap_str2dn(str,dn,flags)
    LDAP_CHAR *    str
    LDAPDN *       dn
    unsigned       flags

int ldap_str2rdn(str,rdn,n_in,flags)
    LDAP_CHAR *    str
    LDAPRDN *      rdn
    char **        n_in
    unsigned       flags

#endif

void
ldap_explode_dn(dn,notypes)
    char *          dn
    int             notypes
    PPCODE:
    {
       char ** LDAPGETVAL;
       int i;

       if ((LDAPGETVAL = ldap_explode_dn(dn,notypes)) != NULL)
       {
           for (i = 0; LDAPGETVAL[i] != NULL; i++)
           {
          EXTEND(sp,1);
          PUSHs(sv_2mortal(newSVpv(LDAPGETVAL[i],strlen(LDAPGETVAL[i]))));
           }
          ldap_value_free(LDAPGETVAL);
       }
    }

void
ldap_explode_rdn(dn,notypes)
    char *          dn
    int     notypes
    PPCODE:
    {
       char ** LDAPGETVAL;
       int i;

       if ((LDAPGETVAL = ldap_explode_rdn(dn,notypes)) != NULL)
       {
           for (i = 0; LDAPGETVAL[i] != NULL; i++)
           {
          EXTEND(sp,1);
          PUSHs(sv_2mortal(newSVpv(LDAPGETVAL[i],strlen(LDAPGETVAL[i]))));
           }
          ldap_value_free(LDAPGETVAL);
       }
    }

SV *
ldap_first_attribute(ld,entry,ber)
    LDAP *          ld
    LDAPMessage *   entry
    BerElement *    ber = NO_INIT
    PREINIT:
       char * attr;
    CODE:
    {
       attr = ldap_first_attribute(ld, entry, &ber);
       if (attr)
       {
          RETVAL = newSVpv(attr,0);
          ldap_memfree(attr);
       } else {
          RETVAL = &PL_sv_undef;
       }
    }
    OUTPUT:
    RETVAL
    ber

SV *
ldap_next_attribute(ld,entry,ber)
    LDAP *          ld
    LDAPMessage *   entry
    BerElement *    ber
    PREINIT:
       char * attr;
    CODE:
    {
       attr = ldap_next_attribute(ld, entry, ber);
       if (attr)
       {
          RETVAL = newSVpv(attr,0);
          ldap_memfree(attr);
       } else {
          RETVAL = &PL_sv_undef;
       }
    }
    OUTPUT:
    RETVAL
    ber


void
ldap_get_values_len(ld,entry,target)
    LDAP *          ld
    LDAPMessage *   entry
    char *          target
    PPCODE:
    {
       struct berval ** LDAPGETVAL;
       int i;

       if ((LDAPGETVAL = ldap_get_values_len(ld,entry,target)) != NULL)
       {
           for (i = 0; LDAPGETVAL[i] != NULL; i++)
           {
          EXTEND(sp,1);
          PUSHs(sv_2mortal(newSVpv(LDAPGETVAL[i]->bv_val,LDAPGETVAL[i]->bv_len)));
           }
       }
    }

#ifdef MOZILLA_LDAP

int
ldapssl_client_init(certdbpath,certdbhandle)
    char *          certdbpath
    void *          certdbhandle

LDAP *
ldapssl_init(defhost,defport,defsecure)
    char *          defhost
    int             defport
    int             defsecure

int
ldapssl_install_routines(ld)
    LDAP *          ld

#endif

void
ldap_set_rebind_proc(ld,rebind_function,args)
    LDAP *          ld
    SV *            rebind_function
    void *          args
    CODE:
    {
       if (SvTYPE(SvRV(rebind_function)) != SVt_PVCV)
       {
          // rebind_function is not actually a function
          // and we set rebind function to NULL
#if defined(MOZILLA_LDAP) || defined(OPENLDAP)
          ldap_set_rebind_proc(ld,NULL,NULL);
#else
          ldap_set_rebind_proc(ld,NULL);
#endif
       } else {
          if (ldap_perl_rebindproc == (SV*)NULL)
             ldap_perl_rebindproc = newSVsv(rebind_function);
          else
             SvSetSV(ldap_perl_rebindproc, rebind_function);
#if defined(OPENLDAP)
          ldap_set_rebind_proc(ld, internal_rebind_proc, args);
#endif
       }
    }

HV *
ldap_get_all_entries(ld,result)
    LDAP *          ld
    LDAPMessage *   result
    CODE:
    {
       LDAPMessage *entry = NULL;
       char *dn = NULL, *attr = NULL;
       struct berval **vals = NULL;
       BerElement *ber = NULL;
       int count = 0;
       HV*   FullHash = newHV();

       for ( entry = ldap_first_entry(ld, result); entry != NULL;
        entry = ldap_next_entry(ld, entry) )
       {
          HV* ResultHash = newHV();
          SV* HashRef = newRV((SV*) ResultHash);

          if ((dn = ldap_get_dn(ld, entry)) == NULL)
              continue;

          for ( attr = ldap_first_attribute(ld, entry, &ber);
          attr != NULL;
          attr = ldap_next_attribute(ld, entry, ber) )
          {
              AV* AttributeValsArray = newAV();
              SV* ArrayRef = newRV((SV*) AttributeValsArray);
              if ((vals = ldap_get_values_len(ld, entry, attr)) != NULL)
              {
                  for (count=0; vals[count] != NULL; count++)
                  {
                      SV* SVval = newSVpvn(vals[count]->bv_val, vals[count]->bv_len);
                      av_push(AttributeValsArray, SVval);
                  }
              }
              hv_store(ResultHash, attr, strlen(attr), ArrayRef, 0);
              if (vals != NULL)
                  ldap_value_free_len(vals);
         }
         if (attr != NULL)
             ldap_memfree(attr);
         hv_store(FullHash, dn, strlen(dn), HashRef, 0);
         if (dn != NULL)
             ldap_memfree(dn);
#if defined(MOZILLA_LDAP) || defined(OPENLDAP)
         if (ber != NULL)
            ber_free(ber,0);
#endif
       }
       RETVAL = FullHash;
    }
    OUTPUT:
    RETVAL

int
ldap_is_ldap_url(url)
    LDAP_CHAR * url

SV *
ldap_url_parse(url)
    LDAP_CHAR *      url
    CODE:
    {
       LDAPURLDesc *realcomp;
       int count,ret;

       HV*   FullHash = newHV();
       RETVAL = newRV((SV*)FullHash);

       ret = ldap_url_parse(url,&realcomp);
       if (ret == 0)
       {
          static char *host_key = "host";
          static char *port_key = "port";
          static char *dn_key = "dn";
          static char *attr_key = "attr";
          static char *scope_key = "scope";
          static char *filter_key = "filter";
#ifdef MOZILLA_LDAP
          static char *options_key = "options";
          SV* options = newSViv(realcomp->lud_options);
#endif
#ifdef OPENLDAP
          static char *scheme_key = "scheme";
          static char *exts_key = "exts";
          AV* extsarray = newAV();
          SV* extsibref = newRV((SV*) extsarray);
          SV* scheme = newSVpv(realcomp->lud_scheme,0);
#endif
          SV* host = newSVpv(realcomp->lud_host,0);
          SV* port = newSViv(realcomp->lud_port);
          SV* dn; /* = newSVpv(realcomp->lud_dn,0); */
          SV* scope = newSViv(realcomp->lud_scope);
          SV* filter = newSVpv(realcomp->lud_filter,0);
          AV* attrarray = newAV();
          SV* attribref = newRV((SV*) attrarray);

          if (realcomp->lud_dn)
                 dn = newSVpv(realcomp->lud_dn,0);
          else
             dn = newSVpv("",0);

          if (realcomp->lud_attrs != NULL)
          {
             for (count=0; realcomp->lud_attrs[count] != NULL; count++)
             {
                SV* SVval = newSVpv(realcomp->lud_attrs[count],0);
                av_push(attrarray, SVval);
             }
          }
#ifdef OPENLDAP
          if (realcomp->lud_exts != NULL)
          {
             for (count=0; realcomp->lud_exts[count] != NULL; count++)
             {
                SV* SVval = newSVpv(realcomp->lud_exts[count],0);
                av_push(extsarray, SVval);
             }
          }
          hv_store(FullHash,exts_key,strlen(exts_key),extsibref,0);
          hv_store(FullHash,scheme_key,strlen(scheme_key),scheme,0);
#endif
          hv_store(FullHash,host_key,strlen(host_key),host,0);
          hv_store(FullHash,port_key,strlen(port_key),port,0);
          hv_store(FullHash,dn_key,strlen(dn_key),dn,0);
          hv_store(FullHash,attr_key,strlen(attr_key),attribref,0);
          hv_store(FullHash,scope_key,strlen(scope_key),scope,0);
          hv_store(FullHash,filter_key,strlen(filter_key),filter,0);
#ifdef MOZILLA_LDAP
          hv_store(FullHash,options_key,strlen(options_key),options,0);
#endif
          ldap_free_urldesc(realcomp);
       } else {
          RETVAL = &PL_sv_undef;
       }
    }
    OUTPUT:
    RETVAL

#ifndef OPENLDAP

int
ldap_url_search(ld,url,attrsonly)
    LDAP *      ld
    char *      url
    int     attrsonly

int
ldap_url_search_s(ld,url,attrsonly,result)
    LDAP *      ld
    char *      url
    int     attrsonly
    LDAPMessage *   result = NO_INIT
    CODE:
    {
       RETVAL = ldap_url_search_s(ld,url,attrsonly,&result);
    }
    OUTPUT:
    RETVAL
    result

int
ldap_url_search_st(ld,url,attrsonly,timeout,result)
    LDAP *      ld
    char *      url
    int     attrsonly
    SV * timeout
    LDAPMessage *   result = NO_INIT
    CODE:
    {
       struct timeval tv_timeout;

       sv2timeval(timeout, &tv_timeout);

       RETVAL = ldap_url_search_st(ld,url,attrsonly,&tv_timeout,&result);
    }
    OUTPUT:
    RETVAL
    result

#endif

int
ldap_sort_entries(ld,chain,attr)
    LDAP *      ld
    LDAPMessage *   chain
    char *      attr
    CODE:
    {
       RETVAL = ldap_sort_entries(ld,&chain,attr,StrCaseCmp);
    }
    OUTPUT:
    RETVAL
    chain

#ifdef MOZILLA_LDAP

int
ldap_multisort_entries(ld,chain,attrs)
    LDAP *      ld
    LDAPMessage *   chain
    SV *        attrs
    CODE:
    {
       char **attrs_char;
       SV ** current;
       int count,arraylen;
           if (SvTYPE(SvRV(attrs)) == SVt_PVAV)
           {
              if ((arraylen = av_len((AV *)SvRV(attrs))) < 0)
              {
                 New(1,attrs_char,2,char *);
                 attrs_char[0] = NULL;
              } else {
                 New(1,attrs_char,arraylen+2,char *);
                 for (count=0;count <= arraylen; count++)
                 {
                    current = av_fetch((AV *)SvRV(attrs),count,0);
                    attrs_char[count] = SvPV(*current,PL_na);
                 }
                 attrs_char[arraylen+1] = NULL;
              }
           } else {
              croak("Net::LDAPapi::ldap_multisort_entries needs ARRAY reference as argument 3.");
              XSRETURN(1);
           }
       RETVAL = ldap_multisort_entries(ld,&chain,attrs_char,StrCaseCmp);
    }
    OUTPUT:
    RETVAL
    chain

#endif

#ifdef OPENLDAP

int
ldap_start_tls(ld,serverctrls,clientctrls,msgidp)
    LDAP *         ld
    LDAPControl ** serverctrls
    LDAPControl ** clientctrls
    int            msgidp = NO_INIT
    CODE:
    {
        RETVAL = ldap_start_tls(ld, serverctrls, clientctrls, &msgidp);
    }
    OUTPUT:
    RETVAL
    msgidp

int
ldap_start_tls_s(ld,serverctrls,clientctrls)
    LDAP *         ld
    LDAPControl ** serverctrls
    LDAPControl ** clientctrls


int
ldap_sasl_interactive_bind_s(ld, who, passwd, serverctrls, clientctrls, mech, realm, authzid, props, flags)
    LDAP *         ld
    LDAP_CHAR *    who
    LDAP_CHAR *    passwd
    LDAPControl ** serverctrls
    LDAPControl ** clientctrls
    LDAP_CHAR *    mech
    LDAP_CHAR *    realm
    LDAP_CHAR *    authzid
    LDAP_CHAR *    props
    unsigned       flags
    CODE:
    {
        bictx ctx = {who, passwd, realm, authzid};
        if (props)
            ldap_set_option(ld, LDAP_OPT_X_SASL_SECPROPS, props);
        RETVAL = ldap_sasl_interactive_bind_s( ld, NULL, mech, serverctrls, clientctrls,
            flags, ldap_b2_interact, &ctx );
    }
    OUTPUT:
    RETVAL

int
ldap_sasl_bind_s(ld, dn, passwd, serverctrls, clientctrls, servercredp)
    LDAP *           ld
    LDAP_CHAR *      dn
    LDAP_CHAR *      passwd
    LDAPControl **   serverctrls
    LDAPControl **   clientctrls
    struct berval ** servercredp = NO_INIT
    CODE:
    {
        struct berval cred;

        if( passwd == NULL )
            cred.bv_val = "";
        else
            cred.bv_val = passwd;

        cred.bv_len = strlen(cred.bv_val);

	servercredp = 0;	/* mdw 20070918 */
        RETVAL = ldap_sasl_bind_s(ld, dn, LDAP_SASL_SIMPLE, &cred,
                                  serverctrls, clientctrls, servercredp);
    }
    OUTPUT:
    RETVAL
    servercredp

#endif

LDAPControl **
ldap_controls_array_init(total)
    int total
    CODE:
    {
        LDAPControl ** array;
        array = malloc(total * sizeof(LDAPControl *));
        RETVAL = array;
    }
    OUTPUT:
    RETVAL

void
ldap_controls_array_free(ctrls)
    LDAPControl ** ctrls
    CODE:
    {
        //int i;
        //for( i = 0; ctrls[i] != NULL; i++ )
        //    free((LDAPControl *)ctrls[i]);

        free(ctrls);
    }


void
ldap_control_set(array, ctrl, location)
    LDAPControl **array
    LDAPControl *ctrl
    int location
    CODE:
    {
        array[location] = ctrl;
    }

int
ldap_create_control(oid, bv_val, bv_len, iscritical, ctrlp)
    LDAP_CHAR *   oid
    LDAP_CHAR *   bv_val
    int           bv_len
    int           iscritical
    LDAPControl * ctrlp = NO_INIT
    CODE:
    {
        LDAPControl *ctrl = malloc(sizeof(LDAPControl));

        ctrl->ldctl_oid          = ber_strdup(oid);
        ber_mem2bv(bv_val, bv_len, 1, &ctrl->ldctl_value);
        ctrl->ldctl_iscritical   = iscritical;

        ctrlp = ctrl;

        RETVAL = 0;
    }
    OUTPUT:
    RETVAL
    ctrlp

void
ldap_control_free (ctrl)
    LDAPControl *ctrl

BerElement *
ber_alloc_t(options);
    int options