/* * This file was generated automatically by ExtUtils::ParseXS version 2.18 from the * contents of API.xs. Do not edit this file, edit API.xs instead. * * ANY CHANGES MADE HERE WILL BE LOST! * */ /****************************************************************************** * $Id: API.xs,v 1.18 2000/10/05 19:47:27 leif%netscape.com Exp $ * * The contents of this file are subject to the Mozilla Public License * Version 1.1 (the "License"); you may not use this file except in * compliance with the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the * License for the specific language governing rights and limitations * under the License. * * The Original Code is PerLDAP. The Initial Developer of the Original * Code is Netscape Communications Corp. and Clayton Donley. Portions * created by Netscape are Copyright (C) Netscape Communications * Corp., portions created by Clayton Donley are Copyright (C) Clayton * Donley. All Rights Reserved. * * Contributor(s): * * DESCRIPTION * This is the XSUB interface for the API. * *****************************************************************************/ #ifdef __cplusplus extern "C" { #endif /* Perl Include Files */ #include "EXTERN.h" #include "perl.h" #include "XSUB.h" #ifdef __cplusplus } #endif /* LDAP C SDK Include Files */ #include #include /* SSL is only available in Binary */ #ifdef USE_SSL # include #endif /* AUTOLOAD methods for LDAP constants */ #include "constant.h" /* Prototypes */ static int perldap_init(); static void * perldap_malloc(size_t size); static void * perldap_calloc(size_t number, size_t size); static void * perldap_realloc(void *ptr, size_t size); static void perldap_free(void *ptr); static char ** avref2charptrptr(SV *avref); static struct berval ** avref2berptrptr(SV *avref); static SV* charptrptr2avref(char **cppval); static SV* berptrptr2avref(struct berval **bval); static LDAPMod *parse1mod(SV *ldap_value_ref,char *ldap_current_attribute, int ldap_add_func,int cont); static int calc_mod_size(HV *ldap_change); static LDAPMod **hash2mod(SV *ldap_change_ref,int ldap_add_func,const char *func); static int StrCaseCmp(const char *s, const char *t); static char * StrDup(const char *source); static int LDAP_CALL internal_rebind_proc(LDAP *ld,char **dnp,char **pwp, int *authmethodp,int freeit,void *arg); static int LDAP_CALL ldap_default_rebind_proc(LDAP *ld, char **dn, char **pswd, int *auth, int freeit, void *arg); /* Global Definitions and Variables */ SV *ldap_perl_rebindproc = NULL; static char *ldap_default_rebind_dn = NULL; static char *ldap_default_rebind_pwd = NULL; static int ldap_default_rebind_auth = LDAP_AUTH_SIMPLE; /* Return a Perl List from a char ** in PPCODE */ #define RET_CPP(cppvar) \ int cppindex; \ if (cppvar) { \ for (cppindex = 0; cppvar[cppindex] != NULL; cppindex++) \ { \ EXTEND(sp,1); \ PUSHs(sv_2mortal(newSVpv(cppvar[cppindex],strlen(cppvar[cppindex])))); \ } \ ldap_value_free(cppvar); } /* Return a Perl List from a berval ** in PPCODE */ #define RET_BVPP(bvppvar) \ int bvppindex; \ if (bvppvar) { \ for (bvppindex = 0; bvppvar[bvppindex] != NULL; bvppindex++) \ { \ EXTEND(sp,1); \ PUSHs(sv_2mortal(newSVpv(bvppvar[bvppindex]->bv_val,bvppvar[bvppindex]->bv_len))); \ } \ ldap_value_free_len(bvppvar); } /* * Function Definition */ static int perldap_init() { struct ldap_memalloc_fns memalloc_fns; memalloc_fns.ldapmem_malloc = perldap_malloc; memalloc_fns.ldapmem_calloc = perldap_calloc; memalloc_fns.ldapmem_realloc = perldap_realloc; memalloc_fns.ldapmem_free = perldap_free; return (ldap_set_option(NULL, LDAP_OPT_MEMALLOC_FN_PTRS, &memalloc_fns)); } static void * perldap_malloc(size_t size) { void *new_ptr; New(1, new_ptr, size, char); return (new_ptr); } static void * perldap_calloc(size_t number, size_t size) { void *new_ptr; Newz(1, new_ptr, (number*size), char); return (new_ptr); } static void * perldap_realloc(void *ptr, size_t size) { Renew(ptr, size, char); return (ptr); } static void perldap_free(void *ptr) { Safefree(ptr); } /* Return a char ** when passed a reference to an AV */ static char ** avref2charptrptr(SV *avref) { I32 avref_arraylen; int ix_av; SV **current_val; char **tmp_cpp; if ((! SvROK(avref)) || (SvTYPE(SvRV(avref)) != SVt_PVAV) || ((avref_arraylen = av_len((AV *)SvRV(avref))) < 0)) { return NULL; } Newz(1,tmp_cpp,avref_arraylen+2,char *); for (ix_av = 0;ix_av <= avref_arraylen;ix_av++) { current_val = av_fetch((AV *)SvRV(avref),ix_av,0); tmp_cpp[ix_av] = StrDup(SvPV(*current_val,na)); } tmp_cpp[ix_av] = NULL; return (tmp_cpp); } /* Return a struct berval ** when passed a reference to an AV */ static struct berval ** avref2berptrptr(SV *avref) { I32 avref_arraylen; int ix_av,val_len; SV **current_val; char *tmp_char,*tmp2; struct berval **tmp_ber; if ((! SvROK(avref)) || (SvTYPE(SvRV(avref)) != SVt_PVAV) || ((avref_arraylen = av_len((AV *)SvRV(avref))) < 0)) { return NULL; } Newz(1,tmp_ber,avref_arraylen+2,struct berval *); for (ix_av = 0;ix_av <= avref_arraylen;ix_av++) { New(1,tmp_ber[ix_av],1,struct berval); current_val = av_fetch((AV *)SvRV(avref),ix_av,0); tmp_char = SvPV(*current_val,na); val_len = SvCUR(*current_val); Newz(1,tmp2,val_len+1,char); Copy(tmp_char,tmp2,val_len,char); tmp_ber[ix_av]->bv_val = tmp2; tmp_ber[ix_av]->bv_len = val_len; } tmp_ber[ix_av] = NULL; return(tmp_ber); } /* Return an AV reference when given a char ** */ static SV* charptrptr2avref(char **cppval) { AV* tmp_av = newAV(); SV* tmp_ref = newRV((SV*)tmp_av); int ix; if (cppval != NULL) { for (ix = 0; cppval[ix] != NULL; ix++) { SV* SVval = newSVpv(cppval[ix],0); av_push(tmp_av,SVval); } ldap_value_free(cppval); } return(tmp_ref); } /* Return an AV Reference when given a struct berval ** */ static SV* berptrptr2avref(struct berval **bval) { AV* tmp_av = newAV(); SV* tmp_ref = newRV((SV*)tmp_av); int ix; if (bval != NULL) { for(ix = 0; bval[ix] != NULL; ix++) { SV *SVval = newSVpv(bval[ix]->bv_val,bval[ix]->bv_len); av_push(tmp_av,SVval); } ldap_value_free_len(bval); } return(tmp_ref); } /* 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); Newz(1,ldap_current_mod,1,LDAPMod); ldap_current_mod->mod_type = StrDup(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_bvalues = avref2berptrptr(ldap_current_value_sv); } else { ldap_current_mod->mod_values = avref2charptrptr(ldap_current_value_sv); } } } 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 = avref2charptrptr(ldap_value_ref); 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,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] = StrDup(SvPV(ldap_value_ref,na)); ldap_current_mod->mod_values[1] = NULL; } } return(ldap_current_mod); } /* calc_mod_size */ /* Calculates the number of LDAPMod's buried inside the ldap_change passed */ /* in. This is used by hash2mod to calculate the size to allocate in Newz */ static int calc_mod_size(HV *ldap_change) { int mod_size = 0; HE *ldap_change_element; SV *ldap_change_element_value_ref; HV *ldap_change_element_value; hv_iterinit(ldap_change); while((ldap_change_element = hv_iternext(ldap_change)) != NULL) { ldap_change_element_value_ref = hv_iterval(ldap_change,ldap_change_element); /* Hashes can take up multiple mod slots. */ if ( (SvROK(ldap_change_element_value_ref)) && (SvTYPE(SvRV(ldap_change_element_value_ref)) == SVt_PVHV) ) { ldap_change_element_value = (HV *)SvRV(ldap_change_element_value_ref); hv_iterinit(ldap_change_element_value); while ( hv_iternext(ldap_change_element_value) != NULL ) { mod_size++; } } /* scalars and array references only take up one mod slot */ else { mod_size++; } } return(mod_size); } /* 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("Mozilla::LDAP::API::%s needs Hash reference as argument 3.",func); ldap_change = (HV *)SvRV(ldap_change_ref); Newz(1,ldapmod,1+calc_mod_size(ldap_change),LDAPMod *); 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[ldap_attribute_count-1] = (LDAPMod *)ldap_current_mod; ldap_current_mod = parse1mod(ldap_current_value_sv, ldap_current_attribute,ldap_add_func,1); } } ldapmod[ldap_attribute_count] = NULL; return ldapmod; } /* StrCaseCmp - Replacement for strcasecmp, since it doesn't exist on many systems, including NT... */ static int StrCaseCmp(const char *s, const char *t) { while (*s && *t && toupper(*s) == toupper(*t)) { s++; t++; } return(toupper(*s) - toupper(*t)); } /* * StrDup * * Duplicates a string, but uses the Perl memory allocation * routines (so it can be free by the internal routines */ static char * StrDup(const char *source) { char *dest; STRLEN length; if ( source == NULL ) return(NULL); length = strlen(source); Newz(1,dest,length+1,char); Copy(source,dest,length+1,char); return(dest); } /* internal_rebind_proc - Wrapper to call a PERL rebind process */ static int LDAP_CALL internal_rebind_proc(LDAP *ld, char **dnp, char **pwp, int *authmethodp, int freeit, void *arg) { if (freeit == 0) { int count = 0; dSP; ENTER ; SAVETMPS ; count = perl_call_sv(ldap_perl_rebindproc,G_ARRAY|G_NOARGS); SPAGAIN; if (count != 3) croak("ldap_perl_rebindproc: Expected DN, PASSWORD, and AUTHTYPE returned.\n"); *authmethodp = POPi; *pwp = StrDup(POPp); *dnp = StrDup(POPp); FREETMPS ; LEAVE ; } else { if (dnp && *dnp) { Safefree(*dnp); } if (pwp && *pwp) { Safefree(*pwp); } } return(LDAP_SUCCESS); } /* NT and internal_rebind_proc hate each other, so they need this... */ static int LDAP_CALL ldap_default_rebind_proc(LDAP *ld, char **dn, char **pwd, int *auth, int freeit, void *arg) { if (!ldap_default_rebind_dn || !ldap_default_rebind_pwd) { *dn = NULL; *pwd = NULL; *auth = 0; return LDAP_OPERATIONS_ERROR; } *dn = ldap_default_rebind_dn; *pwd = ldap_default_rebind_pwd; *auth = ldap_default_rebind_auth; return LDAP_SUCCESS; } #ifndef PERL_UNUSED_VAR # define PERL_UNUSED_VAR(var) if (0) var = var #endif XS(XS_Mozilla__LDAP__API_constant); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_constant) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::constant", "name, arg"); PERL_UNUSED_VAR(cv); /* -W */ { char * name = (char *)SvPV_nolen(ST(0)); int arg = (int)SvIV(ST(1)); double RETVAL; dXSTARG; RETVAL = constant(name, arg); XSprePUSH; PUSHn((double)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_abandon); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_abandon) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_abandon", "ld, msgid"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int msgid = (int)SvIV(ST(1)); int RETVAL; dXSTARG; RETVAL = ldap_abandon(ld, msgid); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAA 1 XS(XS_Mozilla__LDAP__API_ldap_abandon_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_abandon_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_abandon_ext", "ld, msgid, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int msgid = (int)SvIV(ST(1)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(2))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); int RETVAL; dXSTARG; RETVAL = ldap_abandon_ext(ld, msgid, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_add); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_add) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_add", "ld, dn, attrs"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** attrs = hash2mod(ST(2),1,"ldap_add"); int RETVAL; dXSTARG; RETVAL = ldap_add(ld, dn, attrs); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_mods_free(attrs, 1); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAB 1 XS(XS_Mozilla__LDAP__API_ldap_add_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_add_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_add_ext", "ld, dn, attrs, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** attrs = hash2mod(ST(2),1,"ldap_add_ext"); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); int msgidp; int RETVAL; dXSTARG; RETVAL = ldap_add_ext(ld, dn, attrs, serverctrls, clientctrls, &msgidp); sv_setiv(ST(5), (IV)msgidp); SvSETMAGIC(ST(5)); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_mods_free(attrs, 1); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_add_ext_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_add_ext_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_add_ext_s", "ld, dn, attrs, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** attrs = hash2mod(ST(2),1,"ldap_add_ext_s"); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); int RETVAL; dXSTARG; RETVAL = ldap_add_ext_s(ld, dn, attrs, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_mods_free(attrs, 1); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_add_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_add_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_add_s", "ld, dn, attrs"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** attrs = hash2mod(ST(2),1,"ldap_add_s"); int RETVAL; dXSTARG; RETVAL = ldap_add_s(ld, dn, attrs); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_mods_free(attrs, 1); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_ber_free); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_ber_free) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_ber_free", "ber, freebuf"); PERL_UNUSED_VAR(cv); /* -W */ { BerElement * ber = INT2PTR(BerElement *,SvIV(ST(0))); int freebuf = (int)SvIV(ST(1)); { if (ber) { ldap_ber_free(ber, freebuf); } } } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_bind); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_bind) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_bind", "ld, dn, passwd, authmethod"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * passwd = (const char *)SvPV_nolen(ST(2)); int authmethod = (int)SvIV(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_bind(ld, dn, passwd, authmethod); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_bind_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_bind_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_bind_s", "ld, dn, passwd, authmethod"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * passwd = (const char *)SvPV_nolen(ST(2)); int authmethod = (int)SvIV(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_bind_s(ld, dn, passwd, authmethod); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_compare); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_compare) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_compare", "ld, dn, attr, value"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * attr = (const char *)SvPV_nolen(ST(2)); const char * value = (const char *)SvPV_nolen(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_compare(ld, dn, attr, value); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAC 1 XS(XS_Mozilla__LDAP__API_ldap_compare_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_compare_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_compare_ext", "ld, dn, attr, bvalue, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * attr = (const char *)SvPV_nolen(ST(2)); struct berval bvalue; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); int msgidp; int RETVAL; dXSTARG; bvalue.bv_val = (char *)SvPV(ST(3),na); bvalue.bv_len = na; RETVAL = ldap_compare_ext(ld, dn, attr, &bvalue, serverctrls, clientctrls, &msgidp); sv_setiv(ST(6), (IV)msgidp); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_compare_ext_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_compare_ext_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_compare_ext_s", "ld, dn, attr, bvalue, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * attr = (const char *)SvPV_nolen(ST(2)); struct berval bvalue; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); int RETVAL; dXSTARG; bvalue.bv_val = (char *)SvPV(ST(3),na); bvalue.bv_len = na; RETVAL = ldap_compare_ext_s(ld, dn, attr, &bvalue, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_compare_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_compare_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_compare_s", "ld, dn, attr, value"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * attr = (const char *)SvPV_nolen(ST(2)); const char * value = (const char *)SvPV_nolen(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_compare_s(ld, dn, attr, value); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAD 1 XS(XS_Mozilla__LDAP__API_ldap_control_free); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_control_free) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_control_free", "ctrl"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPControl * ctrl = INT2PTR(LDAPControl *,SvIV(ST(0))); ldap_control_free(ctrl); } XSRETURN_EMPTY; } #endif #ifdef CONTROLS_COUNT_WORKS #define XSubPPtmpAAAE 1 XS(XS_Mozilla__LDAP__API_ldap_controls_count); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_controls_count) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_controls_count", "ctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPControl ** ctrls = INT2PTR(LDAPControl **,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_controls_count(ctrls); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif #ifdef LDAPV3 #define XSubPPtmpAAAF 1 XS(XS_Mozilla__LDAP__API_ldap_controls_free); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_controls_free) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_controls_free", "ctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPControl ** ctrls = INT2PTR(LDAPControl **,SvIV(ST(0))); ldap_controls_free(ctrls); } XSRETURN_EMPTY; } #endif XS(XS_Mozilla__LDAP__API_ldap_count_entries); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_count_entries) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_count_entries", "ld, result"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * result = INT2PTR(LDAPMessage *,SvIV(ST(1))); int RETVAL; dXSTARG; RETVAL = ldap_count_entries(ld, result); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAG 1 XS(XS_Mozilla__LDAP__API_ldap_count_messages); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_count_messages) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_count_messages", "ld, result"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * result = INT2PTR(LDAPMessage *,SvIV(ST(1))); int RETVAL; dXSTARG; RETVAL = ldap_count_messages(ld, result); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_count_references); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_count_references) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_count_references", "ld, result"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * result = INT2PTR(LDAPMessage *,SvIV(ST(1))); int RETVAL; dXSTARG; RETVAL = ldap_count_references(ld, result); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_create_filter); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_create_filter) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 8) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_create_filter", "buf, buflen, pattern, prefix, suffix, attr, value, valwords"); PERL_UNUSED_VAR(cv); /* -W */ { char * buf = (char *)SvPV_nolen(ST(0)); unsigned long buflen = (unsigned long)SvUV(ST(1)); char * pattern = (char *)SvPV_nolen(ST(2)); char * prefix = (char *)SvPV_nolen(ST(3)); char * suffix = (char *)SvPV_nolen(ST(4)); char * attr = (char *)SvPV_nolen(ST(5)); char * value = (char *)SvPV_nolen(ST(6)); char ** valwords = (char **)avref2charptrptr(ST(7)); int RETVAL; dXSTARG; RETVAL = ldap_create_filter(buf, buflen, pattern, prefix, suffix, attr, value, valwords); XSprePUSH; PUSHi((IV)RETVAL); if (valwords) ldap_value_free(valwords); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAH 1 XS(XS_Mozilla__LDAP__API_ldap_create_persistentsearch_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_create_persistentsearch_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_create_persistentsearch_control", "ld, changetypes, changesonly, return_echg_ctrls, ctrl_iscritical, ctrlp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int changetypes = (int)SvIV(ST(1)); int changesonly = (int)SvIV(ST(2)); int return_echg_ctrls = (int)SvIV(ST(3)); char ctrl_iscritical = (char)*SvPV_nolen(ST(4)); LDAPControl ** ctrlp; int RETVAL; dXSTARG; RETVAL = ldap_create_persistentsearch_control(ld, changetypes, changesonly, return_echg_ctrls, ctrl_iscritical, ctrlp); sv_setiv(ST(5), PTR2IV(ctrlp)); SvSETMAGIC(ST(5)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_create_sort_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_create_sort_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_create_sort_control", "ld, sortKeyList, ctrl_iscritical, ctrlp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPsortkey ** sortKeyList = INT2PTR(LDAPsortkey **,SvIV(ST(1))); char ctrl_iscritical = (char)*SvPV_nolen(ST(2)); LDAPControl ** ctrlp; int RETVAL; dXSTARG; RETVAL = ldap_create_sort_control(ld, sortKeyList, ctrl_iscritical, ctrlp); sv_setiv(ST(3), PTR2IV(ctrlp)); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_create_sort_keylist); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_create_sort_keylist) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_create_sort_keylist", "sortKeyList, string_rep"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPsortkey ** sortKeyList; char * string_rep = (char *)SvPV_nolen(ST(1)); int RETVAL; dXSTARG; RETVAL = ldap_create_sort_keylist(&sortKeyList, string_rep); sv_setiv(ST(0), PTR2IV(sortKeyList)); SvSETMAGIC(ST(0)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_create_virtuallist_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_create_virtuallist_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_create_virtuallist_control", "ld, ldvlistp, ctrlp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPVirtualList * ldvlistp = INT2PTR(LDAPVirtualList *,SvIV(ST(1))); LDAPControl ** ctrlp; int RETVAL; dXSTARG; RETVAL = ldap_create_virtuallist_control(ld, ldvlistp, ctrlp); sv_setiv(ST(2), PTR2IV(ctrlp)); SvSETMAGIC(ST(2)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_delete); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_delete) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_delete", "ld, dn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); int RETVAL; dXSTARG; RETVAL = ldap_delete(ld, dn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAI 1 XS(XS_Mozilla__LDAP__API_ldap_delete_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_delete_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_delete_ext", "ld, dn, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(2))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); int msgidp; int RETVAL; dXSTARG; RETVAL = ldap_delete_ext(ld, dn, serverctrls, clientctrls, &msgidp); sv_setiv(ST(4), (IV)msgidp); SvSETMAGIC(ST(4)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_delete_ext_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_delete_ext_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_delete_ext_s", "ld, dn, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(2))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); int RETVAL; dXSTARG; RETVAL = ldap_delete_ext_s(ld, dn, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_delete_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_delete_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_delete_s", "ld, dn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); int RETVAL; dXSTARG; RETVAL = ldap_delete_s(ld, dn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_dn2ufn); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_dn2ufn) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_dn2ufn", "dn"); PERL_UNUSED_VAR(cv); /* -W */ { const char * dn = (const char *)SvPV_nolen(ST(0)); char * RETVAL; dXSTARG; RETVAL = ldap_dn2ufn(dn); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_err2string); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_err2string) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_err2string", "err"); PERL_UNUSED_VAR(cv); /* -W */ { int err = (int)SvIV(ST(0)); char * RETVAL; dXSTARG; RETVAL = ldap_err2string(err); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_explode_dn); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_explode_dn) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_explode_dn", "dn, notypes"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { const char * dn = (const char *)SvPV_nolen(ST(0)); const int notypes = (const int)SvIV(ST(1)); { char **MOZLDAP_VAL = ldap_explode_dn(dn,notypes); RET_CPP(MOZLDAP_VAL); } PUTBACK; return; } } XS(XS_Mozilla__LDAP__API_ldap_explode_rdn); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_explode_rdn) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_explode_rdn", "dn, notypes"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { const char * dn = (const char *)SvPV_nolen(ST(0)); int notypes = (int)SvIV(ST(1)); { char **MOZLDAP_VAL = ldap_explode_rdn(dn,notypes); RET_CPP(MOZLDAP_VAL); } PUTBACK; return; } } #ifdef LDAPV3 #define XSubPPtmpAAAJ 1 XS(XS_Mozilla__LDAP__API_ldap_extended_operation); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_extended_operation) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_extended_operation", "ld, requestoid, requestdata, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * requestoid = (const char *)SvPV_nolen(ST(1)); struct berval requestdata; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); int msgidp; int RETVAL; dXSTARG; requestdata.bv_val = (char *)SvPV(ST(2),na); requestdata.bv_len = na; RETVAL = ldap_extended_operation(ld, requestoid, &requestdata, serverctrls, clientctrls, &msgidp); sv_setiv(ST(5), (IV)msgidp); SvSETMAGIC(ST(5)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_extended_operation_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_extended_operation_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_extended_operation_s", "ld, requestoid, requestdata, serverctrls, clientctrls, retoidp, retdatap"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * requestoid = (const char *)SvPV_nolen(ST(1)); struct berval requestdata; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); char * retoidp; struct berval ** retdatap; int RETVAL; dXSTARG; requestdata.bv_val = (char *)SvPV(ST(2),na); requestdata.bv_len = na; RETVAL = ldap_extended_operation_s(ld, requestoid, &requestdata, serverctrls, clientctrls, &retoidp, retdatap); sv_setpv((SV*)ST(5), retoidp); SvSETMAGIC(ST(5)); ST(6) = berptrptr2avref((struct berval **)retdatap); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); if (retdatap) ldap_value_free_len(retdatap); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_first_attribute); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_first_attribute) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_first_attribute", "ld, entry, ber"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); BerElement * ber; char * RETVAL; dXSTARG; RETVAL = ldap_first_attribute(ld, entry, &ber); sv_setiv(ST(2), PTR2IV(ber)); SvSETMAGIC(ST(2)); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; ldap_memfree(RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_first_entry); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_first_entry) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_first_entry", "ld, chain"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * chain = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_first_entry(ld, chain); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAK 1 XS(XS_Mozilla__LDAP__API_ldap_first_message); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_first_message) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_first_message", "ld, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_first_message(ld, res); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_first_reference); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_first_reference) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_first_reference", "ld, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_first_reference(ld, res); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_free_friendlymap); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_free_friendlymap) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_free_friendlymap", "map"); PERL_UNUSED_VAR(cv); /* -W */ { FriendlyMap * map = INT2PTR(FriendlyMap *,SvIV(ST(0))); ldap_free_friendlymap(map); } XSRETURN_EMPTY; } #ifdef LDAPV3 #define XSubPPtmpAAAL 1 XS(XS_Mozilla__LDAP__API_ldap_free_sort_keylist); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_free_sort_keylist) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_free_sort_keylist", "sortKeyList"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPsortkey ** sortKeyList = INT2PTR(LDAPsortkey **,SvIV(ST(0))); ldap_free_sort_keylist(sortKeyList); } XSRETURN_EMPTY; } #endif XS(XS_Mozilla__LDAP__API_ldap_free_urldesc); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_free_urldesc) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_free_urldesc", "ludp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPURLDesc * ludp = INT2PTR(LDAPURLDesc *,SvIV(ST(0))); ldap_free_urldesc(ludp); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_friendly_name); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_friendly_name) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_friendly_name", "filename, name, map"); PERL_UNUSED_VAR(cv); /* -W */ { char * filename = (char *)SvPV_nolen(ST(0)); char * name = (char *)SvPV_nolen(ST(1)); FriendlyMap * map = INT2PTR(FriendlyMap *,SvIV(ST(2))); char * RETVAL; dXSTARG; RETVAL = ldap_friendly_name(filename, name, map); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_get_dn); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_dn) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_dn", "ld, entry"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); char * RETVAL; dXSTARG; RETVAL = ldap_get_dn(ld, entry); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; ldap_memfree(RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAM 1 XS(XS_Mozilla__LDAP__API_ldap_get_entry_controls); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_entry_controls) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_entry_controls", "ld, entry, serverctrlsp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPControl ** serverctrlsp; int RETVAL; dXSTARG; RETVAL = ldap_get_entry_controls(ld, entry, &serverctrlsp); sv_setiv(ST(2), PTR2IV(serverctrlsp)); SvSETMAGIC(ST(2)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_getfilter_free); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_getfilter_free) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_getfilter_free", "lfdp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPFiltDesc * lfdp = INT2PTR(LDAPFiltDesc *,SvIV(ST(0))); ldap_getfilter_free(lfdp); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_getfirstfilter); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_getfirstfilter) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_getfirstfilter", "lfdp, tagpat, value"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPFiltDesc * lfdp = INT2PTR(LDAPFiltDesc *,SvIV(ST(0))); char * tagpat = (char *)SvPV_nolen(ST(1)); char * value = (char *)SvPV_nolen(ST(2)); LDAPFiltInfo * RETVAL; dXSTARG; RETVAL = ldap_getfirstfilter(lfdp, tagpat, value); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAN 1 XS(XS_Mozilla__LDAP__API_ldap_get_lang_values); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_lang_values) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_lang_values", "ld, entry, target, type"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); const char * target = (const char *)SvPV_nolen(ST(2)); char * type = (char *)SvPV_nolen(ST(3)); { char ** MOZLDAP_VAL = ldap_get_lang_values(ld,entry,target,&type); RET_CPP(MOZLDAP_VAL); } PUTBACK; return; } } XS(XS_Mozilla__LDAP__API_ldap_get_lang_values_len); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_lang_values_len) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_lang_values_len", "ld, entry, target, type"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); const char * target = (const char *)SvPV_nolen(ST(2)); char * type = (char *)SvPV_nolen(ST(3)); { struct berval ** MOZLDAP_VAL = ldap_get_lang_values_len(ld,entry,target,&type); RET_BVPP(MOZLDAP_VAL); } PUTBACK; return; } } #endif XS(XS_Mozilla__LDAP__API_ldap_get_lderrno); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_lderrno) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items < 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_lderrno", "ld, ..."); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int RETVAL; dXSTARG; { char *match = (char *)NULL, *msg = (char *)NULL; SV *tmp, *m = (SV *)NULL, *s = (SV *)NULL; if (items > 1) { m = ST(1); if (items > 2) s = ST(2); } RETVAL = ldap_get_lderrno(ld, (m && SvROK(m)) ? &match : (char **)NULL, (s && SvROK(s)) ? &msg : (char **)NULL); if (match) { tmp = SvRV(m); if (SvTYPE(tmp) <= SVt_PV) sv_setpv(tmp, match); } if (msg) { tmp = SvRV(s); if (SvTYPE(tmp) <= SVt_PV) sv_setpv(tmp, msg); } } XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_getnextfilter); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_getnextfilter) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_getnextfilter", "lfdp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPFiltDesc * lfdp = INT2PTR(LDAPFiltDesc *,SvIV(ST(0))); LDAPFiltInfo * RETVAL; dXSTARG; RETVAL = ldap_getnextfilter(lfdp); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_get_option); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_option) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_option", "ld, option, optdata"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int option = (int)SvIV(ST(1)); int optdata; int RETVAL; dXSTARG; RETVAL = ldap_get_option(ld, option, &optdata); sv_setiv(ST(2), (IV)optdata); SvSETMAGIC(ST(2)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_get_values); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_values) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_values", "ld, entry, target"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); const char * target = (const char *)SvPV_nolen(ST(2)); { char **MOZLDAP_VAL = ldap_get_values(ld,entry,target); RET_CPP(MOZLDAP_VAL); } PUTBACK; return; } } XS(XS_Mozilla__LDAP__API_ldap_get_values_len); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_get_values_len) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_get_values_len", "ld, entry, target"); PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(ax); /* -Wall */ SP -= items; { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); const char * target = (const char *)SvPV_nolen(ST(2)); { struct berval **MOZLDAP_VAL = ldap_get_values_len(ld,entry,target); RET_BVPP(MOZLDAP_VAL); } PUTBACK; return; } } XS(XS_Mozilla__LDAP__API_ldap_init); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_init) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_init", "host, port"); PERL_UNUSED_VAR(cv); /* -W */ { const char * host = (const char *)SvPV_nolen(ST(0)); int port = (int)SvIV(ST(1)); LDAP * RETVAL; dXSTARG; RETVAL = ldap_init(host, port); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_init_getfilter); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_init_getfilter) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_init_getfilter", "fname"); PERL_UNUSED_VAR(cv); /* -W */ { char * fname = (char *)SvPV_nolen(ST(0)); LDAPFiltDesc * RETVAL; dXSTARG; RETVAL = ldap_init_getfilter(fname); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_init_getfilter_buf); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_init_getfilter_buf) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_init_getfilter_buf", "buf, buflen"); PERL_UNUSED_VAR(cv); /* -W */ { char * buf = (char *)SvPV_nolen(ST(0)); long buflen = (long)SvIV(ST(1)); LDAPFiltDesc * RETVAL; dXSTARG; RETVAL = ldap_init_getfilter_buf(buf, buflen); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_is_ldap_url); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_is_ldap_url) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_is_ldap_url", "url"); PERL_UNUSED_VAR(cv); /* -W */ { char * url = (char *)SvPV_nolen(ST(0)); int RETVAL; dXSTARG; RETVAL = ldap_is_ldap_url(url); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAO 1 XS(XS_Mozilla__LDAP__API_ldap_memcache_destroy); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_destroy) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_destroy", "cache"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMemCache * cache = INT2PTR(LDAPMemCache *,SvIV(ST(0))); ldap_memcache_destroy(cache); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_memcache_flush); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_flush) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_flush", "cache, dn, scope"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMemCache * cache = INT2PTR(LDAPMemCache *,SvIV(ST(0))); char * dn = (char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); ldap_memcache_flush(cache, dn, scope); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_memcache_get); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_get) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_get", "ld, cachep"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMemCache ** cachep; int RETVAL; dXSTARG; RETVAL = ldap_memcache_get(ld, cachep); sv_setiv(ST(1), PTR2IV(cachep)); SvSETMAGIC(ST(1)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_memcache_init); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_init) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_init", "ttl, size, baseDNs, cachep"); PERL_UNUSED_VAR(cv); /* -W */ { unsigned long ttl = (unsigned long)SvUV(ST(0)); unsigned long size = (unsigned long)SvUV(ST(1)); char ** baseDNs = (char **)avref2charptrptr(ST(2)); LDAPMemCache ** cachep; int RETVAL; dXSTARG; RETVAL = ldap_memcache_init(ttl,size,baseDNs,NULL,cachep); sv_setiv(ST(3), PTR2IV(cachep)); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); if (baseDNs) ldap_value_free(baseDNs); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_memcache_set); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_set) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_set", "ld, cache"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMemCache * cache = INT2PTR(LDAPMemCache *,SvIV(ST(1))); int RETVAL; dXSTARG; RETVAL = ldap_memcache_set(ld, cache); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_memcache_update); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memcache_update) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memcache_update", "cache"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMemCache * cache = INT2PTR(LDAPMemCache *,SvIV(ST(0))); ldap_memcache_update(cache); } XSRETURN_EMPTY; } #endif XS(XS_Mozilla__LDAP__API_ldap_memfree); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_memfree) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_memfree", "p"); PERL_UNUSED_VAR(cv); /* -W */ { void * p = INT2PTR(void *,SvIV(ST(0))); ldap_memfree(p); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_modify); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modify) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modify", "ld, dn, mods"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** mods = hash2mod(ST(2),0,"ldap_modify"); int RETVAL; dXSTARG; RETVAL = ldap_modify(ld, dn, mods); XSprePUSH; PUSHi((IV)RETVAL); if (mods) ldap_mods_free(mods, 1); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAP 1 XS(XS_Mozilla__LDAP__API_ldap_modify_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modify_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modify_ext", "ld, dn, mods, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** mods = hash2mod(ST(2),0,"ldap_modify_ext"); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); int msgidp = (int)SvIV(ST(5)); int RETVAL; dXSTARG; RETVAL = ldap_modify_ext(ld, dn, mods, serverctrls, clientctrls, &msgidp); sv_setiv(ST(5), (IV)msgidp); SvSETMAGIC(ST(5)); XSprePUSH; PUSHi((IV)RETVAL); if (mods) ldap_mods_free(mods, 1); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_modify_ext_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modify_ext_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modify_ext_s", "ld, dn, mods, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** mods = hash2mod(ST(2),0,"ldap_modify_ext_s"); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(3))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); int RETVAL; dXSTARG; RETVAL = ldap_modify_ext_s(ld, dn, mods, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); if (mods) ldap_mods_free(mods, 1); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_modify_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modify_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modify_s", "ld, dn, mods"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); LDAPMod ** mods = hash2mod(ST(2), 0, "ldap_modify_s"); int RETVAL; dXSTARG; RETVAL = ldap_modify_s(ld, dn, mods); XSprePUSH; PUSHi((IV)RETVAL); if (mods) ldap_mods_free(mods, 1); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_modrdn); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modrdn) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modrdn", "ld, dn, newrdn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_modrdn(ld, dn, newrdn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_modrdn_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modrdn_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modrdn_s", "ld, dn, newrdn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_modrdn_s(ld, dn, newrdn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_modrdn2); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modrdn2) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modrdn2", "ld, dn, newrdn, deleteoldrdn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); int deleteoldrdn = (int)SvIV(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_modrdn2(ld, dn, newrdn, deleteoldrdn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_modrdn2_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_modrdn2_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_modrdn2_s", "ld, dn, newrdn, deleteoldrdn"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); int deleteoldrdn = (int)SvIV(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_modrdn2_s(ld, dn, newrdn, deleteoldrdn); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_mods_free); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_mods_free) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_mods_free", "mods, freemods"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMod ** mods = INT2PTR(LDAPMod **,SvIV(ST(0))); int freemods = (int)SvIV(ST(1)); ldap_mods_free(mods, freemods); } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_msgfree); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_msgfree) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_msgfree", "lm"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMessage * lm = INT2PTR(LDAPMessage *,SvIV(ST(0))); int RETVAL; dXSTARG; { if (lm) { RETVAL = ldap_msgfree(lm); } } XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_msgid); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_msgid) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_msgid", "lm"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMessage * lm = INT2PTR(LDAPMessage *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_msgid(lm); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_msgtype); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_msgtype) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_msgtype", "lm"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPMessage * lm = INT2PTR(LDAPMessage *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_msgtype(lm); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_multisort_entries); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_multisort_entries) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_multisort_entries", "ld, chain, attr"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * chain = INT2PTR(LDAPMessage *,SvIV(ST(1))); char ** attr = (char **)avref2charptrptr(ST(2)); int RETVAL; dXSTARG; { RETVAL = ldap_multisort_entries(ld,&chain,attr,StrCaseCmp); } sv_setiv(ST(1), PTR2IV(chain)); SvSETMAGIC(ST(1)); XSprePUSH; PUSHi((IV)RETVAL); if (attr) ldap_value_free(attr); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_next_attribute); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_next_attribute) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_next_attribute", "ld, entry, ber"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); BerElement * ber = INT2PTR(BerElement *,SvIV(ST(2))); char * RETVAL; dXSTARG; RETVAL = ldap_next_attribute(ld, entry, ber); sv_setiv(ST(2), PTR2IV(ber)); SvSETMAGIC(ST(2)); sv_setpv(TARG, RETVAL); XSprePUSH; PUSHTARG; ldap_memfree(RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_next_entry); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_next_entry) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_next_entry", "ld, entry"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * entry = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_next_entry(ld, entry); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAQ 1 XS(XS_Mozilla__LDAP__API_ldap_next_message); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_next_message) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_next_message", "ld, msg"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * msg = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_next_message(ld, msg); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_next_reference); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_next_reference) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_next_reference", "ld, ref"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * ref = INT2PTR(LDAPMessage *,SvIV(ST(1))); LDAPMessage * RETVAL; dXSTARG; RETVAL = ldap_next_reference(ld, ref); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_entrychange_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_entrychange_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_entrychange_control", "ld, ctrls, chgtypep, prevdnp, chgnumpresentp, chgnump"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPControl ** ctrls = INT2PTR(LDAPControl **,SvIV(ST(1))); int chgtypep; char * prevdnp; int chgnumpresentp; long chgnump; int RETVAL; dXSTARG; RETVAL = ldap_parse_entrychange_control(ld, ctrls, &chgtypep, &prevdnp, &chgnumpresentp, &chgnump); sv_setiv(ST(2), (IV)chgtypep); SvSETMAGIC(ST(2)); sv_setpv((SV*)ST(3), prevdnp); SvSETMAGIC(ST(3)); sv_setiv(ST(4), (IV)chgnumpresentp); SvSETMAGIC(ST(4)); sv_setiv(ST(5), (IV)chgnump); SvSETMAGIC(ST(5)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_extended_result); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_extended_result) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_extended_result", "ld, res, retoidp, retdatap, freeit"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(1))); char * retoidp; struct berval ** retdatap; int freeit = (int)SvIV(ST(4)); int RETVAL; dXSTARG; RETVAL = ldap_parse_extended_result(ld, res, &retoidp, retdatap, freeit); sv_setpv((SV*)ST(2), retoidp); SvSETMAGIC(ST(2)); ST(3) = berptrptr2avref((struct berval **)retdatap); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_reference); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_reference) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_reference", "ld, ref, referalsp, serverctrlsp, freeit"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * ref = INT2PTR(LDAPMessage *,SvIV(ST(1))); char ** referalsp; LDAPControl ** serverctrlsp; int freeit = (int)SvIV(ST(4)); int RETVAL; dXSTARG; RETVAL = ldap_parse_reference(ld, ref, &referalsp, &serverctrlsp, freeit); ST(2) = charptrptr2avref(referalsp); SvSETMAGIC(ST(2)); sv_setiv(ST(3), PTR2IV(serverctrlsp)); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_result); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_result) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 8) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_result", "ld, res, errcodep, matcheddnp, errmsgp, referralsp, serverctrlsp, freeit"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(1))); int errcodep; char * matcheddnp; char * errmsgp; char ** referralsp; LDAPControl ** serverctrlsp; int freeit = (int)SvIV(ST(7)); int RETVAL; dXSTARG; RETVAL = ldap_parse_result(ld, res, &errcodep, &matcheddnp, &errmsgp, &referralsp, &serverctrlsp, freeit); sv_setiv(ST(2), (IV)errcodep); SvSETMAGIC(ST(2)); sv_setpv((SV*)ST(3), matcheddnp); SvSETMAGIC(ST(3)); sv_setpv((SV*)ST(4), errmsgp); SvSETMAGIC(ST(4)); ST(5) = charptrptr2avref(referralsp); SvSETMAGIC(ST(5)); sv_setiv(ST(6), PTR2IV(serverctrlsp)); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_sasl_bind_result); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_sasl_bind_result) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_sasl_bind_result", "ld, res, servercredp, freeit"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(1))); struct berval ** servercredp; int freeit = (int)SvIV(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_parse_sasl_bind_result(ld, res, servercredp, freeit); ST(2) = berptrptr2avref((struct berval **)servercredp); SvSETMAGIC(ST(2)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_sort_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_sort_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_sort_control", "ld, ctrls, result, attribute"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPControl ** ctrls = INT2PTR(LDAPControl **,SvIV(ST(1))); unsigned long result; char * attribute; int RETVAL; dXSTARG; RETVAL = ldap_parse_sort_control(ld, ctrls, &result, &attribute); sv_setuv(ST(2), (UV)result); SvSETMAGIC(ST(2)); sv_setpv((SV*)ST(3), attribute); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_parse_virtuallist_control); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_parse_virtuallist_control) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_parse_virtuallist_control", "ld, ctrls, target_posp, list_sizep, errcodep"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPControl ** ctrls = INT2PTR(LDAPControl **,SvIV(ST(1))); unsigned long target_posp; unsigned long list_sizep; int errcodep; int RETVAL; dXSTARG; RETVAL = ldap_parse_virtuallist_control(ld, ctrls, &target_posp, &list_sizep, &errcodep); sv_setuv(ST(2), (UV)target_posp); SvSETMAGIC(ST(2)); sv_setuv(ST(3), (UV)list_sizep); SvSETMAGIC(ST(3)); sv_setiv(ST(4), (IV)errcodep); SvSETMAGIC(ST(4)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_perror); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_perror) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_perror", "ld, s"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * s = (const char *)SvPV_nolen(ST(1)); ldap_perror(ld, s); } XSRETURN_EMPTY; } #ifdef LDAPV3 #define XSubPPtmpAAAR 1 XS(XS_Mozilla__LDAP__API_ldap_rename); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_rename) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 8) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_rename", "ld, dn, newrdn, newparent, deleteoldrdn, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); const char * newparent = (const char *)SvPV_nolen(ST(3)); int deleteoldrdn = (int)SvIV(ST(4)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(6))); int msgidp; int RETVAL; dXSTARG; RETVAL = ldap_rename(ld, dn, newrdn, newparent, deleteoldrdn, serverctrls, clientctrls, &msgidp); sv_setiv(ST(7), (IV)msgidp); SvSETMAGIC(ST(7)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_rename_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_rename_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_rename_s", "ld, dn, newrdn, newparent, deleteoldrdn, serverctrls, clientctrls"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * newrdn = (const char *)SvPV_nolen(ST(2)); const char * newparent = (const char *)SvPV_nolen(ST(3)); int deleteoldrdn = (int)SvIV(ST(4)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(6))); int RETVAL; dXSTARG; RETVAL = ldap_rename_s(ld, dn, newrdn, newparent, deleteoldrdn, serverctrls, clientctrls); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_result); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_result) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_result", "ld, msgid, all, timeout, result"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int msgid = (int)SvIV(ST(1)); int all = (int)SvIV(ST(2)); struct timeval timeout; LDAPMessage * result; int RETVAL; dXSTARG; timeout.tv_sec = atof((char *)SvPV(ST(3),na)); timeout.tv_usec = 0; RETVAL = ldap_result(ld, msgid, all, &timeout, &result); sv_setiv(ST(4), PTR2IV(result)); SvSETMAGIC(ST(4)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_result2error); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_result2error) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_result2error", "ld, r, freeit"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * r = INT2PTR(LDAPMessage *,SvIV(ST(1))); int freeit = (int)SvIV(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_result2error(ld, r, freeit); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAS 1 XS(XS_Mozilla__LDAP__API_ldap_sasl_bind); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_sasl_bind) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_sasl_bind", "ld, dn, mechanism, cred, serverctrls, clientctrls, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * mechanism = (const char *)SvPV_nolen(ST(2)); struct berval cred; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); int msgidp; int RETVAL; dXSTARG; cred.bv_val = (char *)SvPV(ST(3),na); cred.bv_len = na; RETVAL = ldap_sasl_bind(ld, dn, mechanism, &cred, serverctrls, clientctrls, &msgidp); sv_setiv(ST(6), (IV)msgidp); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_sasl_bind_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_sasl_bind_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_sasl_bind_s", "ld, dn, mechanism, cred, serverctrls, clientctrls, servercredp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * dn = (const char *)SvPV_nolen(ST(1)); const char * mechanism = (const char *)SvPV_nolen(ST(2)); struct berval cred; LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(4))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(5))); struct berval ** servercredp; int RETVAL; dXSTARG; cred.bv_val = (char *)SvPV(ST(3),na); cred.bv_len = na; RETVAL = ldap_sasl_bind_s(ld, dn, mechanism, &cred, serverctrls, clientctrls, servercredp); ST(6) = berptrptr2avref((struct berval **)servercredp); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_search); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_search) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 6) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_search", "ld, base, scope, filter, attrs, attrsonly"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * base = (const char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); const char * filter = (const char *)SvPV_nolen(ST(3)); char ** attrs = (char **)avref2charptrptr(ST(4)); int attrsonly = (int)SvIV(ST(5)); int RETVAL; dXSTARG; RETVAL = ldap_search(ld, base, scope, filter, attrs, attrsonly); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_value_free(attrs); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAT 1 XS(XS_Mozilla__LDAP__API_ldap_search_ext); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_search_ext) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 11) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_search_ext", "ld, base, scope, filter, attrs, attrsonly, serverctrls, clientctrls, timeoutp, sizelimit, msgidp"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * base = (const char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); const char * filter = (const char *)SvPV_nolen(ST(3)); char ** attrs = (char **)avref2charptrptr(ST(4)); int attrsonly = (int)SvIV(ST(5)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(6))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(7))); struct timeval timeoutp; int sizelimit = (int)SvIV(ST(9)); int msgidp; int RETVAL; dXSTARG; timeoutp.tv_sec = atof((char *)SvPV(ST(8),na)); timeoutp.tv_usec = 0; RETVAL = ldap_search_ext(ld, base, scope, filter, attrs, attrsonly, serverctrls, clientctrls, &timeoutp, sizelimit, &msgidp); sv_setiv(ST(10), (IV)msgidp); SvSETMAGIC(ST(10)); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_value_free(attrs); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_search_ext_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_search_ext_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 11) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_search_ext_s", "ld, base, scope, filter, attrs, attrsonly, serverctrls, clientctrls, timeoutp, sizelimit, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * base = (const char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); const char * filter = (const char *)SvPV_nolen(ST(3)); char ** attrs = (char **)avref2charptrptr(ST(4)); int attrsonly = (int)SvIV(ST(5)); LDAPControl ** serverctrls = INT2PTR(LDAPControl **,SvIV(ST(6))); LDAPControl ** clientctrls = INT2PTR(LDAPControl **,SvIV(ST(7))); struct timeval timeoutp; int sizelimit = (int)SvIV(ST(9)); LDAPMessage * res; int RETVAL; dXSTARG; timeoutp.tv_sec = atof((char *)SvPV(ST(8),na)); timeoutp.tv_usec = 0; RETVAL = ldap_search_ext_s(ld, base, scope, filter, attrs, attrsonly, serverctrls, clientctrls, &timeoutp, sizelimit, &res); sv_setiv(ST(10), PTR2IV(res)); SvSETMAGIC(ST(10)); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_value_free(attrs); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldap_search_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_search_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 7) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_search_s", "ld, base, scope, filter, attrs, attrsonly, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * base = (const char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); const char * filter = (const char *)SvPV_nolen(ST(3)); char ** attrs = (char **)avref2charptrptr(ST(4)); int attrsonly = (int)SvIV(ST(5)); LDAPMessage * res; int RETVAL; dXSTARG; RETVAL = ldap_search_s(ld, base, scope, filter, attrs, attrsonly, &res); sv_setiv(ST(6), PTR2IV(res)); SvSETMAGIC(ST(6)); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_value_free(attrs); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_search_st); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_search_st) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 8) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_search_st", "ld, base, scope, filter, attrs, attrsonly, timeout, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * base = (const char *)SvPV_nolen(ST(1)); int scope = (int)SvIV(ST(2)); const char * filter = (const char *)SvPV_nolen(ST(3)); char ** attrs = (char **)avref2charptrptr(ST(4)); int attrsonly = (int)SvIV(ST(5)); struct timeval timeout; LDAPMessage * res; int RETVAL; dXSTARG; timeout.tv_sec = atof((char *)SvPV(ST(6),na)); timeout.tv_usec = 0; RETVAL = ldap_search_st(ld, base, scope, filter, attrs, attrsonly, &timeout, &res); sv_setiv(ST(7), PTR2IV(res)); SvSETMAGIC(ST(7)); XSprePUSH; PUSHi((IV)RETVAL); if (attrs) ldap_value_free(attrs); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_set_filter_additions); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_set_filter_additions) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_set_filter_additions", "lfdp, prefix, suffix"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPFiltDesc * lfdp = INT2PTR(LDAPFiltDesc *,SvIV(ST(0))); char * prefix = (char *)SvPV_nolen(ST(1)); char * suffix = (char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_set_filter_additions(lfdp, prefix, suffix); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_set_lderrno); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_set_lderrno) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_set_lderrno", "ld, e, m, s"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int e = (int)SvIV(ST(1)); char * m = (char *)SvPV_nolen(ST(2)); char * s = (char *)SvPV_nolen(ST(3)); int RETVAL; dXSTARG; RETVAL = ldap_set_lderrno(ld, e, m, s); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_set_option); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_set_option) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_set_option", "ld, option, optdata"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int option = (int)SvIV(ST(1)); int optdata = (int)SvIV(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_set_option(ld, option, &optdata); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_set_rebind_proc); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_set_rebind_proc) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_set_rebind_proc", "ld, rebindproc"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); SV * rebindproc = ST(1); { if (SvTYPE(SvRV(rebindproc)) != SVt_PVCV) { ldap_set_rebind_proc(ld,NULL,NULL); } else { if (ldap_perl_rebindproc == (SV*)NULL) ldap_perl_rebindproc = newSVsv(rebindproc); else SvSetSV(ldap_perl_rebindproc,rebindproc); ldap_set_rebind_proc(ld,internal_rebind_proc,NULL); } } } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_set_default_rebind_proc); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_set_default_rebind_proc) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_set_default_rebind_proc", "ld, dn, pwd, auth"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); char * dn = (char *)SvPV_nolen(ST(1)); char * pwd = (char *)SvPV_nolen(ST(2)); int auth = (int)SvIV(ST(3)); { if ( ldap_default_rebind_dn != NULL ) { Safefree(ldap_default_rebind_dn); ldap_default_rebind_dn = NULL; } if ( ldap_default_rebind_pwd != NULL ) { Safefree(ldap_default_rebind_pwd); ldap_default_rebind_pwd = NULL; } ldap_default_rebind_dn = StrDup(dn); ldap_default_rebind_pwd = StrDup(pwd); ldap_default_rebind_auth = auth; ldap_set_rebind_proc(ld, (LDAP_REBINDPROC_CALLBACK *)&ldap_default_rebind_proc,NULL); } } XSRETURN_EMPTY; } XS(XS_Mozilla__LDAP__API_ldap_simple_bind); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_simple_bind) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_simple_bind", "ld, who, passwd"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * who = (const char *)SvPV_nolen(ST(1)); const char * passwd = (const char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_simple_bind(ld, who, passwd); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_simple_bind_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_simple_bind_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_simple_bind_s", "ld, who, passwd"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); const char * who = (const char *)SvPV_nolen(ST(1)); const char * passwd = (const char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_simple_bind_s(ld, who, passwd); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_sort_entries); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_sort_entries) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_sort_entries", "ld, chain, attr"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); LDAPMessage * chain = INT2PTR(LDAPMessage *,SvIV(ST(1))); char * attr = (char *)SvPV_nolen(ST(2)); int RETVAL; dXSTARG; { RETVAL = ldap_sort_entries(ld,&chain,attr,StrCaseCmp); } sv_setiv(ST(1), PTR2IV(chain)); SvSETMAGIC(ST(1)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_unbind); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_unbind) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_unbind", "ld"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_unbind(ld); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_unbind_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_unbind_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_unbind_s", "ld"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_unbind_s(ld); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_url_parse); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_url_parse) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_url_parse", "url"); PERL_UNUSED_VAR(cv); /* -W */ { char * url = (char *)SvPV_nolen(ST(0)); SV * RETVAL; { 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"; static char *options_key = "options"; SV* options = newSViv(realcomp->lud_options); 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); } } 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); hv_store(FullHash,options_key,strlen(options_key),options,0); ldap_free_urldesc(realcomp); } else { RETVAL = &sv_undef; } } ST(0) = RETVAL; sv_2mortal(ST(0)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_url_search); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_url_search) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_url_search", "ld, url, attrsonly"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); char * url = (char *)SvPV_nolen(ST(1)); int attrsonly = (int)SvIV(ST(2)); int RETVAL; dXSTARG; RETVAL = ldap_url_search(ld, url, attrsonly); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_url_search_s); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_url_search_s) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_url_search_s", "ld, url, attrsonly, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); char * url = (char *)SvPV_nolen(ST(1)); int attrsonly = (int)SvIV(ST(2)); LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(3))); int RETVAL; dXSTARG; RETVAL = ldap_url_search_s(ld, url, attrsonly, &res); sv_setiv(ST(3), PTR2IV(res)); SvSETMAGIC(ST(3)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_url_search_st); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_url_search_st) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_url_search_st", "ld, url, attrsonly, timeout, res"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); char * url = (char *)SvPV_nolen(ST(1)); int attrsonly = (int)SvIV(ST(2)); struct timeval timeout; LDAPMessage * res = INT2PTR(LDAPMessage *,SvIV(ST(4))); int RETVAL; dXSTARG; timeout.tv_sec = atof((char *)SvPV(ST(3),na)); timeout.tv_usec = 0; RETVAL = ldap_url_search_st(ld, url, attrsonly, &timeout, &res); sv_setiv(ST(4), PTR2IV(res)); SvSETMAGIC(ST(4)); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldap_version); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldap_version) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldap_version", "ver"); PERL_UNUSED_VAR(cv); /* -W */ { LDAPVersion * ver = INT2PTR(LDAPVersion *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldap_version(ver); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef USE_SSL #define XSubPPtmpAAAU 1 XS(XS_Mozilla__LDAP__API_ldapssl_client_init); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldapssl_client_init) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 2) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldapssl_client_init", "certdbpath, certdbhandle"); PERL_UNUSED_VAR(cv); /* -W */ { const char * certdbpath = (const char *)SvPV_nolen(ST(0)); void * certdbhandle = INT2PTR(void *,SvIV(ST(1))); int RETVAL; dXSTARG; RETVAL = ldapssl_client_init(certdbpath, certdbhandle); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #ifdef LDAPV3 #define XSubPPtmpAAAV 1 XS(XS_Mozilla__LDAP__API_ldapssl_clientauth_init); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldapssl_clientauth_init) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 5) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldapssl_clientauth_init", "certdbpath, certdbhandle, needkeydb, keydbpath, keydbhandle"); PERL_UNUSED_VAR(cv); /* -W */ { char * certdbpath = (char *)SvPV_nolen(ST(0)); void * certdbhandle = INT2PTR(void *,SvIV(ST(1))); int needkeydb = (int)SvIV(ST(2)); char * keydbpath = (char *)SvPV_nolen(ST(3)); void * keydbhandle = INT2PTR(void *,SvIV(ST(4))); int RETVAL; dXSTARG; RETVAL = ldapssl_clientauth_init(certdbpath, certdbhandle, needkeydb, keydbpath, keydbhandle); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldapssl_enable_clientauth); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldapssl_enable_clientauth) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 4) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldapssl_enable_clientauth", "ld, keynickname, keypasswd, certnickname"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); char * keynickname = (char *)SvPV_nolen(ST(1)); char * keypasswd = (char *)SvPV_nolen(ST(2)); char * certnickname = (char *)SvPV_nolen(ST(3)); int RETVAL; dXSTARG; RETVAL = ldapssl_enable_clientauth(ld, keynickname, keypasswd, certnickname); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif XS(XS_Mozilla__LDAP__API_ldapssl_init); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldapssl_init) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 3) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldapssl_init", "host, port, secure"); PERL_UNUSED_VAR(cv); /* -W */ { const char * host = (const char *)SvPV_nolen(ST(0)); int port = (int)SvIV(ST(1)); int secure = (int)SvIV(ST(2)); LDAP * RETVAL; dXSTARG; RETVAL = ldapssl_init(host, port, secure); XSprePUSH; PUSHi(PTR2IV(RETVAL)); } XSRETURN(1); } XS(XS_Mozilla__LDAP__API_ldapssl_install_routines); /* prototype to pass -Wmissing-prototypes */ XS(XS_Mozilla__LDAP__API_ldapssl_install_routines) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif if (items != 1) Perl_croak(aTHX_ "Usage: %s(%s)", "Mozilla::LDAP::API::ldapssl_install_routines", "ld"); PERL_UNUSED_VAR(cv); /* -W */ { LDAP * ld = INT2PTR(LDAP *,SvIV(ST(0))); int RETVAL; dXSTARG; RETVAL = ldapssl_install_routines(ld); XSprePUSH; PUSHi((IV)RETVAL); } XSRETURN(1); } #endif #ifdef __cplusplus extern "C" #endif XS(boot_Mozilla__LDAP__API); /* prototype to pass -Wmissing-prototypes */ XS(boot_Mozilla__LDAP__API) { #ifdef dVAR dVAR; dXSARGS; #else dXSARGS; #endif char* file = __FILE__; PERL_UNUSED_VAR(cv); /* -W */ PERL_UNUSED_VAR(items); /* -W */ XS_VERSION_BOOTCHECK ; newXSproto("Mozilla::LDAP::API::constant", XS_Mozilla__LDAP__API_constant, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_abandon", XS_Mozilla__LDAP__API_ldap_abandon, file, "$$"); #if XSubPPtmpAAAA newXSproto("Mozilla::LDAP::API::ldap_abandon_ext", XS_Mozilla__LDAP__API_ldap_abandon_ext, file, "$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_add", XS_Mozilla__LDAP__API_ldap_add, file, "$$$"); #if XSubPPtmpAAAB newXSproto("Mozilla::LDAP::API::ldap_add_ext", XS_Mozilla__LDAP__API_ldap_add_ext, file, "$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_add_ext_s", XS_Mozilla__LDAP__API_ldap_add_ext_s, file, "$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_add_s", XS_Mozilla__LDAP__API_ldap_add_s, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_ber_free", XS_Mozilla__LDAP__API_ldap_ber_free, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_bind", XS_Mozilla__LDAP__API_ldap_bind, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_bind_s", XS_Mozilla__LDAP__API_ldap_bind_s, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_compare", XS_Mozilla__LDAP__API_ldap_compare, file, "$$$$"); #if XSubPPtmpAAAC newXSproto("Mozilla::LDAP::API::ldap_compare_ext", XS_Mozilla__LDAP__API_ldap_compare_ext, file, "$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_compare_ext_s", XS_Mozilla__LDAP__API_ldap_compare_ext_s, file, "$$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_compare_s", XS_Mozilla__LDAP__API_ldap_compare_s, file, "$$$$"); #if XSubPPtmpAAAD newXSproto("Mozilla::LDAP::API::ldap_control_free", XS_Mozilla__LDAP__API_ldap_control_free, file, "$"); #endif #if XSubPPtmpAAAE newXSproto("Mozilla::LDAP::API::ldap_controls_count", XS_Mozilla__LDAP__API_ldap_controls_count, file, "$"); #endif #if XSubPPtmpAAAF newXSproto("Mozilla::LDAP::API::ldap_controls_free", XS_Mozilla__LDAP__API_ldap_controls_free, file, "$"); #endif newXSproto("Mozilla::LDAP::API::ldap_count_entries", XS_Mozilla__LDAP__API_ldap_count_entries, file, "$$"); #if XSubPPtmpAAAG newXSproto("Mozilla::LDAP::API::ldap_count_messages", XS_Mozilla__LDAP__API_ldap_count_messages, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_count_references", XS_Mozilla__LDAP__API_ldap_count_references, file, "$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_create_filter", XS_Mozilla__LDAP__API_ldap_create_filter, file, "$$$$$$$$"); #if XSubPPtmpAAAH newXSproto("Mozilla::LDAP::API::ldap_create_persistentsearch_control", XS_Mozilla__LDAP__API_ldap_create_persistentsearch_control, file, "$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_create_sort_control", XS_Mozilla__LDAP__API_ldap_create_sort_control, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_create_sort_keylist", XS_Mozilla__LDAP__API_ldap_create_sort_keylist, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_create_virtuallist_control", XS_Mozilla__LDAP__API_ldap_create_virtuallist_control, file, "$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_delete", XS_Mozilla__LDAP__API_ldap_delete, file, "$$"); #if XSubPPtmpAAAI newXSproto("Mozilla::LDAP::API::ldap_delete_ext", XS_Mozilla__LDAP__API_ldap_delete_ext, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_delete_ext_s", XS_Mozilla__LDAP__API_ldap_delete_ext_s, file, "$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_delete_s", XS_Mozilla__LDAP__API_ldap_delete_s, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_dn2ufn", XS_Mozilla__LDAP__API_ldap_dn2ufn, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_err2string", XS_Mozilla__LDAP__API_ldap_err2string, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_explode_dn", XS_Mozilla__LDAP__API_ldap_explode_dn, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_explode_rdn", XS_Mozilla__LDAP__API_ldap_explode_rdn, file, "$$"); #if XSubPPtmpAAAJ newXSproto("Mozilla::LDAP::API::ldap_extended_operation", XS_Mozilla__LDAP__API_ldap_extended_operation, file, "$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_extended_operation_s", XS_Mozilla__LDAP__API_ldap_extended_operation_s, file, "$$$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_first_attribute", XS_Mozilla__LDAP__API_ldap_first_attribute, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_first_entry", XS_Mozilla__LDAP__API_ldap_first_entry, file, "$$"); #if XSubPPtmpAAAK newXSproto("Mozilla::LDAP::API::ldap_first_message", XS_Mozilla__LDAP__API_ldap_first_message, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_first_reference", XS_Mozilla__LDAP__API_ldap_first_reference, file, "$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_free_friendlymap", XS_Mozilla__LDAP__API_ldap_free_friendlymap, file, "$"); #if XSubPPtmpAAAL newXSproto("Mozilla::LDAP::API::ldap_free_sort_keylist", XS_Mozilla__LDAP__API_ldap_free_sort_keylist, file, "$"); #endif newXSproto("Mozilla::LDAP::API::ldap_free_urldesc", XS_Mozilla__LDAP__API_ldap_free_urldesc, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_friendly_name", XS_Mozilla__LDAP__API_ldap_friendly_name, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_get_dn", XS_Mozilla__LDAP__API_ldap_get_dn, file, "$$"); #if XSubPPtmpAAAM newXSproto("Mozilla::LDAP::API::ldap_get_entry_controls", XS_Mozilla__LDAP__API_ldap_get_entry_controls, file, "$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_getfilter_free", XS_Mozilla__LDAP__API_ldap_getfilter_free, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_getfirstfilter", XS_Mozilla__LDAP__API_ldap_getfirstfilter, file, "$$$"); #if XSubPPtmpAAAN newXSproto("Mozilla::LDAP::API::ldap_get_lang_values", XS_Mozilla__LDAP__API_ldap_get_lang_values, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_get_lang_values_len", XS_Mozilla__LDAP__API_ldap_get_lang_values_len, file, "$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_get_lderrno", XS_Mozilla__LDAP__API_ldap_get_lderrno, file, "$;@"); newXSproto("Mozilla::LDAP::API::ldap_getnextfilter", XS_Mozilla__LDAP__API_ldap_getnextfilter, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_get_option", XS_Mozilla__LDAP__API_ldap_get_option, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_get_values", XS_Mozilla__LDAP__API_ldap_get_values, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_get_values_len", XS_Mozilla__LDAP__API_ldap_get_values_len, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_init", XS_Mozilla__LDAP__API_ldap_init, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_init_getfilter", XS_Mozilla__LDAP__API_ldap_init_getfilter, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_init_getfilter_buf", XS_Mozilla__LDAP__API_ldap_init_getfilter_buf, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_is_ldap_url", XS_Mozilla__LDAP__API_ldap_is_ldap_url, file, "$"); #if XSubPPtmpAAAO newXSproto("Mozilla::LDAP::API::ldap_memcache_destroy", XS_Mozilla__LDAP__API_ldap_memcache_destroy, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_memcache_flush", XS_Mozilla__LDAP__API_ldap_memcache_flush, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_memcache_get", XS_Mozilla__LDAP__API_ldap_memcache_get, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_memcache_init", XS_Mozilla__LDAP__API_ldap_memcache_init, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_memcache_set", XS_Mozilla__LDAP__API_ldap_memcache_set, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_memcache_update", XS_Mozilla__LDAP__API_ldap_memcache_update, file, "$"); #endif newXSproto("Mozilla::LDAP::API::ldap_memfree", XS_Mozilla__LDAP__API_ldap_memfree, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_modify", XS_Mozilla__LDAP__API_ldap_modify, file, "$$$"); #if XSubPPtmpAAAP newXSproto("Mozilla::LDAP::API::ldap_modify_ext", XS_Mozilla__LDAP__API_ldap_modify_ext, file, "$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_modify_ext_s", XS_Mozilla__LDAP__API_ldap_modify_ext_s, file, "$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_modify_s", XS_Mozilla__LDAP__API_ldap_modify_s, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_modrdn", XS_Mozilla__LDAP__API_ldap_modrdn, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_modrdn_s", XS_Mozilla__LDAP__API_ldap_modrdn_s, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_modrdn2", XS_Mozilla__LDAP__API_ldap_modrdn2, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_modrdn2_s", XS_Mozilla__LDAP__API_ldap_modrdn2_s, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_mods_free", XS_Mozilla__LDAP__API_ldap_mods_free, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_msgfree", XS_Mozilla__LDAP__API_ldap_msgfree, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_msgid", XS_Mozilla__LDAP__API_ldap_msgid, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_msgtype", XS_Mozilla__LDAP__API_ldap_msgtype, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_multisort_entries", XS_Mozilla__LDAP__API_ldap_multisort_entries, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_next_attribute", XS_Mozilla__LDAP__API_ldap_next_attribute, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_next_entry", XS_Mozilla__LDAP__API_ldap_next_entry, file, "$$"); #if XSubPPtmpAAAQ newXSproto("Mozilla::LDAP::API::ldap_next_message", XS_Mozilla__LDAP__API_ldap_next_message, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_next_reference", XS_Mozilla__LDAP__API_ldap_next_reference, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_entrychange_control", XS_Mozilla__LDAP__API_ldap_parse_entrychange_control, file, "$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_extended_result", XS_Mozilla__LDAP__API_ldap_parse_extended_result, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_reference", XS_Mozilla__LDAP__API_ldap_parse_reference, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_result", XS_Mozilla__LDAP__API_ldap_parse_result, file, "$$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_sasl_bind_result", XS_Mozilla__LDAP__API_ldap_parse_sasl_bind_result, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_sort_control", XS_Mozilla__LDAP__API_ldap_parse_sort_control, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_parse_virtuallist_control", XS_Mozilla__LDAP__API_ldap_parse_virtuallist_control, file, "$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_perror", XS_Mozilla__LDAP__API_ldap_perror, file, "$$"); #if XSubPPtmpAAAR newXSproto("Mozilla::LDAP::API::ldap_rename", XS_Mozilla__LDAP__API_ldap_rename, file, "$$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_rename_s", XS_Mozilla__LDAP__API_ldap_rename_s, file, "$$$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_result", XS_Mozilla__LDAP__API_ldap_result, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_result2error", XS_Mozilla__LDAP__API_ldap_result2error, file, "$$$"); #if XSubPPtmpAAAS newXSproto("Mozilla::LDAP::API::ldap_sasl_bind", XS_Mozilla__LDAP__API_ldap_sasl_bind, file, "$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_sasl_bind_s", XS_Mozilla__LDAP__API_ldap_sasl_bind_s, file, "$$$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_search", XS_Mozilla__LDAP__API_ldap_search, file, "$$$$$$"); #if XSubPPtmpAAAT newXSproto("Mozilla::LDAP::API::ldap_search_ext", XS_Mozilla__LDAP__API_ldap_search_ext, file, "$$$$$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_search_ext_s", XS_Mozilla__LDAP__API_ldap_search_ext_s, file, "$$$$$$$$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldap_search_s", XS_Mozilla__LDAP__API_ldap_search_s, file, "$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_search_st", XS_Mozilla__LDAP__API_ldap_search_st, file, "$$$$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_set_filter_additions", XS_Mozilla__LDAP__API_ldap_set_filter_additions, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_set_lderrno", XS_Mozilla__LDAP__API_ldap_set_lderrno, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_set_option", XS_Mozilla__LDAP__API_ldap_set_option, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_set_rebind_proc", XS_Mozilla__LDAP__API_ldap_set_rebind_proc, file, "$$"); newXSproto("Mozilla::LDAP::API::ldap_set_default_rebind_proc", XS_Mozilla__LDAP__API_ldap_set_default_rebind_proc, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_simple_bind", XS_Mozilla__LDAP__API_ldap_simple_bind, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_simple_bind_s", XS_Mozilla__LDAP__API_ldap_simple_bind_s, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_sort_entries", XS_Mozilla__LDAP__API_ldap_sort_entries, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_unbind", XS_Mozilla__LDAP__API_ldap_unbind, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_unbind_s", XS_Mozilla__LDAP__API_ldap_unbind_s, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_url_parse", XS_Mozilla__LDAP__API_ldap_url_parse, file, "$"); newXSproto("Mozilla::LDAP::API::ldap_url_search", XS_Mozilla__LDAP__API_ldap_url_search, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldap_url_search_s", XS_Mozilla__LDAP__API_ldap_url_search_s, file, "$$$$"); newXSproto("Mozilla::LDAP::API::ldap_url_search_st", XS_Mozilla__LDAP__API_ldap_url_search_st, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldap_version", XS_Mozilla__LDAP__API_ldap_version, file, "$"); #if XSubPPtmpAAAU newXSproto("Mozilla::LDAP::API::ldapssl_client_init", XS_Mozilla__LDAP__API_ldapssl_client_init, file, "$$"); #if XSubPPtmpAAAV newXSproto("Mozilla::LDAP::API::ldapssl_clientauth_init", XS_Mozilla__LDAP__API_ldapssl_clientauth_init, file, "$$$$$"); newXSproto("Mozilla::LDAP::API::ldapssl_enable_clientauth", XS_Mozilla__LDAP__API_ldapssl_enable_clientauth, file, "$$$$"); #endif newXSproto("Mozilla::LDAP::API::ldapssl_init", XS_Mozilla__LDAP__API_ldapssl_init, file, "$$$"); newXSproto("Mozilla::LDAP::API::ldapssl_install_routines", XS_Mozilla__LDAP__API_ldapssl_install_routines, file, "$"); #endif /* Initialisation Section */ if ( perldap_init() != 0) { fprintf(stderr, "Error loading Mozilla::LDAP::API: perldap_init failed\n"); exit(1); } #if XSubPPtmpAAAA #endif #if XSubPPtmpAAAB #endif #if XSubPPtmpAAAC #endif #if XSubPPtmpAAAD #endif #if XSubPPtmpAAAE #endif #if XSubPPtmpAAAF #endif #if XSubPPtmpAAAG #endif #if XSubPPtmpAAAH #endif #if XSubPPtmpAAAI #endif #if XSubPPtmpAAAJ #endif #if XSubPPtmpAAAK #endif #if XSubPPtmpAAAL #endif #if XSubPPtmpAAAM #endif #if XSubPPtmpAAAN #endif #if XSubPPtmpAAAO #endif #if XSubPPtmpAAAP #endif #if XSubPPtmpAAAQ #endif #if XSubPPtmpAAAR #endif #if XSubPPtmpAAAS #endif #if XSubPPtmpAAAT #endif #if XSubPPtmpAAAU #if XSubPPtmpAAAV #endif #endif /* End of Initialisation Section */ XSRETURN_YES; }