Openldap/SASL Interface

Functions to interface with a LDAP server. More...

Files
file	openldap.c
	Openldap/SASL Implementation.

Data Structures
struct	ldap_rdn
	LDAP Relative distingushed name linked list. More...
struct	ldap_attrval
	LDAP attribute value. More...
struct	ldap_attr
	LDAP attirbute. More...
struct	ldap_entry
	LDAP entry. More...
struct	ldap_results
	LDAP results. More...
struct	sasl_defaults
	SASL Paramaters used in authentification. More...
struct	ldap_simple
	LDAP Simple bind. More...
struct	ldap_conn
	LDAP connection. More...
struct	ldap_modify
	LDAP Modify structure. More...
struct	ldap_add
	LDAP Add structure. More...
struct	ldap_modval
	Linked list of mod values. More...
struct	ldap_modreq
	LDAP mod request. More...

Typedefs
typedef struct ldap_conn	ldap_conn
	Forward decleration of structure. More...
typedef struct ldap_modify	ldap_modify
	Forward decleration of structure. More...
typedef struct ldap_add	ldap_add
	Forward decleration of structure. More...

Enumerations
enum	ldap_starttls { LDAP_STARTTLS_NONE, LDAP_STARTTLS_ATTEMPT, LDAP_STARTTLS_ENFORCE }
	SSL connection requirements. More...
enum	ldap_attrtype { LDAP_ATTRTYPE_CHAR, LDAP_ATTRTYPE_B64, LDAP_ATTRTYPE_OCTET }
	LDAP attribute types. More...

Functions
struct ldap_conn *	ldap_connect (const char *uri, enum ldap_starttls starttls, int timelimit, int limit, int debug, int *err)
	Connect to a LDAP server. More...
int	ldap_simplebind (struct ldap_conn *ld, const char *dn, const char *passwd)
	Bind to the connection with simple bind requireing a distingushed name and password. More...
int	ldap_simplerebind (struct ldap_conn *ldap, const char *initialdn, const char *initialpw, const char *base, const char *filter, const char *uidrdn, const char *uid, const char *passwd)
	Bind to LDAP connection using rebind. More...
int	ldap_saslbind (struct ldap_conn *ld, const char *mech, const char *realm, const char *authcid, const char *passwd, const char *authzid)
	Bind to the server with SASL. More...
const char *	ldap_errmsg (int res)
	Return LDAP error for a ldap error. More...
struct ldap_results *	ldap_search_sub (struct ldap_conn *ld, const char *base, const char *filter, int b64enc, int *res,...)
	Search LDAP connection subtree. More...
struct ldap_results *	ldap_search_one (struct ldap_conn *ld, const char *base, const char *filter, int b64enc, int *res,...)
	Search LDAP connection one level. More...
struct ldap_results *	ldap_search_base (struct ldap_conn *ld, const char *base, const char *filter, int b64enc, int *res,...)
	Search LDAP connection base. More...
void	ldap_unref_attr (struct ldap_entry *entry, struct ldap_attr *attr)
	Remove a attribute from a entry. More...
void	ldap_unref_entry (struct ldap_results *results, struct ldap_entry *entry)
	Remove a entry from a result. More...
struct ldap_entry *	ldap_getentry (struct ldap_results *results, const char *dn)
	Find and return the entry from the results for a specific dn. More...
struct ldap_attr *	ldap_getattr (struct ldap_entry *entry, const char *attr)
	Find and return attribute in a entry. More...
struct ldap_modify *	ldap_modifyinit (const char *dn)
	Create a modification reference for a DN. More...
int	ldap_mod_del (struct ldap_modify *lmod, const char *attr,...)
	Delete values from a attribute. More...
int	ldap_mod_add (struct ldap_modify *lmod, const char *attr,...)
	Add values to a attribute. More...
int	ldap_mod_rep (struct ldap_modify *lmod, const char *attr,...)
	Replace a attribute. More...
int	ldap_domodify (struct ldap_conn *ld, struct ldap_modify *lmod)
	Apply the modification to the server. More...
int	ldap_mod_delattr (struct ldap_conn *ldap, const char *dn, const char *attr, const char *value)
	Delete a value from a attribute in a DN. More...
int	ldap_mod_remattr (struct ldap_conn *ldap, const char *dn, const char *attr)
	Delete a attribute from a DN. More...
int	ldap_mod_addattr (struct ldap_conn *ldap, const char *dn, const char *attr, const char *value)
	Add a value for a attribute in a DN. More...
int	ldap_mod_repattr (struct ldap_conn *ldap, const char *dn, const char *attr, const char *value)
	Replace the value of a attribute in a DN. More...
struct ldap_add *	ldap_addinit (const char *dn)
	Create a reference to add a new DN. More...
int	ldap_add_attr (struct ldap_add *ladd, const char *attr,...)
	Add a attribute to new DN. More...
int	ldap_doadd (struct ldap_conn *ld, struct ldap_add *ladd)
	Write new DN to server. More...

Detailed Description

Functions to interface with a LDAP server.

Typedef Documentation

typedef struct ldap_add ldap_add

Forward decleration of structure.

Definition at line 789 of file dtsapp.h.

typedef struct ldap_conn ldap_conn

Forward decleration of structure.

Definition at line 785 of file dtsapp.h.

typedef struct ldap_modify ldap_modify

Forward decleration of structure.

Definition at line 787 of file dtsapp.h.

Enumeration Type Documentation

enum ldap_attrtype

LDAP attribute types.

Enumerator
LDAP_ATTRTYPE_CHAR	Plain text.
LDAP_ATTRTYPE_B64	Base64 encoded.
LDAP_ATTRTYPE_OCTET	Binary data.

Definition at line 707 of file dtsapp.h.

                   {
    LDAP_ATTRTYPE_CHAR,
    LDAP_ATTRTYPE_B64,
    LDAP_ATTRTYPE_OCTET
};

enum ldap_starttls

SSL connection requirements.

Enumerator
LDAP_STARTTLS_NONE	SSL not attempted at all.
LDAP_STARTTLS_ATTEMPT	SSL attempted but not required.
LDAP_STARTTLS_ENFORCE	SSL is required.

Definition at line 697 of file dtsapp.h.

                   {
    LDAP_STARTTLS_NONE,
    LDAP_STARTTLS_ATTEMPT,
    LDAP_STARTTLS_ENFORCE
};

Function Documentation

int ldap_add_attr	(	struct ldap_add *	ladd,
		const char *	attr,
			...
	)

Add a attribute to new DN.

Parameters

ladd	Reference to new DN structure.
attr	Attribute to add.
...	NULL terminated list of values.

Returns

0 on success.

Definition at line 1500 of file openldap.c.

References objunref().

                                                                       {
    va_list a_list;
    char *val;
    struct ldap_modreq *modr;

    if (!(modr = getaddreq(ladd, attr))) {
        return 1;
    }

    va_start(a_list, attr);
    while((val = va_arg(a_list, void *))) {
        if (add_modifyval(modr, val)) {
            objunref(modr);
            return(1);
        }
    }

    objunref(modr);
    va_end(a_list);
    return 0;
}

struct ldap_add* ldap_addinit

(

const char *

dn

)

Create a reference to add a new DN.

Parameters

dn	DN to be created.

Returns

Reference to a structure to configure for adding a new dn.

Definition at line 1462 of file openldap.c.

References ALLOC_CONST, ldap_add::bl, create_bucketlist(), ldap_add::dn, objalloc(), and objunref().

                                                     {
    struct ldap_add *mod;

    if (!(mod = objalloc(sizeof(*mod), free_add))) {
        return NULL;
    }

    ALLOC_CONST(mod->dn, dn);
    if (!mod->dn) {
        objunref(mod);
        return NULL;
    }

    if (!(mod->bl = create_bucketlist(4, modify_hash))) {
        objunref(mod);
        return NULL;
    }

    return mod;
}

struct ldap_conn* ldap_connect	(	const char *	uri,
		enum ldap_starttls	starttls,
		int	timelimit,
		int	limit,
		int	debug,
		int *	err
	)

Connect to a LDAP server.

Parameters

uri	Server to connect too.
starttls	Starttls flags to disallow,allow or enforce SSL.
timelimit	Query timelimit.
limit	Results limit.
debug	Set LDAP_OPT_DEBUG_LEVEL and LBER_OPT_DEBUG_LEVEL to this level.
err	Pointer to a int that will contain the ldap error on failure.

Returns

Reference to LDAP connection if its NULL the error is returned in err.

Definition at line 335 of file openldap.c.

References ldap_conn::ldap, LDAP_STARTTLS_ENFORCE, LDAP_STARTTLS_NONE, ldap_conn::limit, objalloc(), objunref(), ldap_conn::sasl, ldap_conn::sctrlsp, ldap_conn::timelim, and ldap_conn::uri.

                                                                                                                                   {
    struct ldap_conn *ld;
    int version = 3;
    int res, sslres;
    struct timeval timeout;

    if (!(ld = objalloc(sizeof(*ld), free_ldapconn))) {
        return NULL;
    }

    ld->uri = strdup(uri);
    ld->sctrlsp = NULL;
    ld->timelim = timelimit;
    ld->limit = limit;
    ld->sasl = NULL;

    if ((res = ldap_initialize(&ld->ldap, ld->uri) != LDAP_SUCCESS)) {
        objunref(ld);
        ld = NULL;
    } else {
        if (debug) {
            ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &debug);
            ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &debug);
        }
        if (timelimit) {
            timeout.tv_sec = timelimit;
            timeout.tv_usec = 0;
            ldap_set_option(ld->ldap, LDAP_OPT_NETWORK_TIMEOUT, (void *)&timeout);
        }
        ldap_set_option(ld->ldap, LDAP_OPT_PROTOCOL_VERSION, &version);
        ldap_set_option(ld->ldap, LDAP_OPT_REFERRALS, (void *)LDAP_OPT_ON);
        ldap_set_rebind_proc(ld->ldap, ldap_rebind_proc, ld);

        if ((starttls != LDAP_STARTTLS_NONE) & !ldap_tls_inplace(ld->ldap) && (sslres = ldap_start_tls_s(ld->ldap, ld->sctrlsp, NULL))) {
            if (starttls == LDAP_STARTTLS_ENFORCE) {
                objunref(ld);
                ld = NULL;
                res = sslres;
            }
        }
    }
    *err = res;
    return ld;
}

int ldap_doadd	(	struct ldap_conn *	ld,
		struct ldap_add *	ladd
	)

Write new DN to server.

Parameters

ld	Reference to connection to the LDAP server.
ladd	Reference to new DN to commit to server.

Returns

non zero LDAP error on failure.

Definition at line 1526 of file openldap.c.

References ldap_add::bl, bucket_list_cnt(), ldap_add::dn, init_bucket_loop(), ldap_conn::ldap, next_bucket_loop(), objlock(), objunlock(), objunref(), and ldap_conn::sctrlsp.

                                                                   {
    struct bucket_loop *bloop;
    struct ldap_modreq *modr;
    LDAPMod **modarr, **tmp, *item;
    int tot=0, res;

    tot = bucket_list_cnt(ladd->bl);
    tmp = modarr = calloc(sizeof(void *), (tot+1));

    bloop = init_bucket_loop(ladd->bl);
    while(bloop && ((modr = next_bucket_loop(bloop)))) {
        if (!(item = ldap_reqtoarr(modr, -1))) {
            ldap_mods_free(modarr, 1);
            return LDAP_NO_MEMORY;
        }
        *tmp = item;
        tmp++;
        objunref(modr);
    }
    objunref(bloop);
    *tmp = NULL;

    objlock(ld);
    res = ldap_modify_ext_s(ld->ldap, ladd->dn, modarr, ld->sctrlsp, NULL);
    objunlock(ld);
    ldap_mods_free(modarr, 1);

    return res;
}

int ldap_domodify	(	struct ldap_conn *	ld,
		struct ldap_modify *	lmod
	)

Apply the modification to the server.

Parameters

ld	Reference to LDAP connection.
lmod	Reference to modification structure.

Returns

Non zero ldap error on error.

Definition at line 1339 of file openldap.c.

References ldap_modify::bl, bucket_list_cnt(), ldap_modreq::cnt, ldap_modify::dn, init_bucket_loop(), ldap_conn::ldap, next_bucket_loop(), objlock(), objref(), objunlock(), objunref(), and ldap_conn::sctrlsp.

Referenced by ldap_mod_addattr(), ldap_mod_delattr(), and ldap_mod_repattr().

                                                                         {
    struct bucket_loop *bloop;
    struct ldap_modreq *modr;
    LDAPMod **modarr, **tmp, *item;
    int cnt, tot=0, res;

    if (!objref(ld)) {
        return LDAP_UNAVAILABLE;
    }

    for(cnt = 0; cnt < 3; cnt++) {
        tot += bucket_list_cnt(lmod->bl[cnt]);
    }
    tmp = modarr = calloc(sizeof(void *), (tot+1));

    for(cnt = 0; cnt < 3; cnt++) {
        bloop = init_bucket_loop(lmod->bl[cnt]);
        while(bloop && ((modr = next_bucket_loop(bloop)))) {
            if (!(item = ldap_reqtoarr(modr, cnt))) {
                ldap_mods_free(modarr, 1);
                objunref(ld);
                return LDAP_NO_MEMORY;
            }
            *tmp = item;
            tmp++;
            objunref(modr);
        }
        objunref(bloop);
    }
    *tmp = NULL;

    objlock(ld);
    res = ldap_modify_ext_s(ld->ldap, lmod->dn, modarr, ld->sctrlsp, NULL);
    objunlock(ld);
    ldap_mods_free(modarr, 1);
    objunref(ld);
    return res;
}

const char* ldap_errmsg

(

int

res

)

Return LDAP error for a ldap error.

Parameters

res	LDAP error id.

Returns

Error string.

Definition at line 576 of file openldap.c.

                                        {
    return ldap_err2string(res);
}

struct ldap_attr* ldap_getattr	(	struct ldap_entry *	entry,
		const char *	attr
	)

Find and return attribute in a entry.

Parameters

entry	Entry to return attribute from.
attr	Atttribute to return.

Returns

Attribute reference matching attr.

Definition at line 1108 of file openldap.c.

References ldap_entry::attrs, and bucket_list_find_key().

                                                                                  {
    if (!entry || !entry->attrs) {
        return NULL;
    }
    return (struct ldap_attr *)bucket_list_find_key(entry->attrs, attr);
}

struct ldap_entry* ldap_getentry	(	struct ldap_results *	results,
		const char *	dn
	)

Find and return the entry from the results for a specific dn.

Parameters

results	Results to search in.
dn	DN search for.

Returns

Entry for a DN in the results or NULL.

Definition at line 1096 of file openldap.c.

References bucket_list_find_key(), and ldap_results::entries.

                                                                                      {
    if (!results || !dn) {
        return NULL;
    }
    return (struct ldap_entry *)bucket_list_find_key(results->entries, dn);
}

int ldap_mod_add	(	struct ldap_modify *	lmod,
		const char *	attr,
			...
	)

Add values to a attribute.

Parameters

lmod	LDAP modification referenece.
attr	Attribute to modify.
...	Values to add.

Returns

Zero on success.

Definition at line 1238 of file openldap.c.

References objunref().

Referenced by ldap_mod_addattr().

                                                                         {
    va_list a_list;
    char *val;
    struct ldap_modreq *modr;

    if (!(modr = getmodreq(lmod, attr, LDAP_MOD_ADD))) {
        return 1;
    }

    va_start(a_list, attr);
    while((val = va_arg(a_list, void *))) {
        if (add_modifyval(modr, val)) {
            objunref(modr);
            return(1);
        }
    }

    objunref(modr);
    va_end(a_list);
    return 0;
}

int ldap_mod_addattr	(	struct ldap_conn *	ldap,
		const char *	dn,
		const char *	attr,
		const char *	value
	)

Add a value for a attribute in a DN.

Parameters

ldap	Reference to the connection.
dn	DN to remove values from.
attr	Attribute to add value to.
value	Value to remove from attribute.

Returns

Non zero ldap error on failure

Definition at line 1416 of file openldap.c.

References ldap_domodify(), ldap_mod_add(), ldap_modifyinit(), and objunref().

                                                                                                         {
    int res = 0;
    struct ldap_modify *lmod;

    if (!(lmod = ldap_modifyinit(dn))) {
        return LDAP_NO_MEMORY;
    }

    if (ldap_mod_add(lmod, attr, value, NULL)) {
        objunref(lmod);
        return LDAP_NO_MEMORY;
    }

    res = ldap_domodify(ldap, lmod);
    objunref(lmod);
    return res;
}

int ldap_mod_del	(	struct ldap_modify *	lmod,
		const char *	attr,
			...
	)

Delete values from a attribute.

Parameters

lmod	LDAP modification referenece.
attr	Attribute to modify.
...	Values to remove.

Returns

Zero on success.

Definition at line 1211 of file openldap.c.

References objunref().

Referenced by ldap_mod_delattr().

                                                                         {
    va_list a_list;
    char *val;
    struct ldap_modreq *modr;

    if (!(modr = getmodreq(lmod, attr, LDAP_MOD_DELETE))) {
        return 1;
    }

    va_start(a_list, attr);
    while((val = va_arg(a_list, void *))) {
        if (add_modifyval(modr, val)) {
            objunref(modr);
            return(1);
        }
    }

    objunref(modr);
    va_end(a_list);
    return 0;
}

int ldap_mod_delattr	(	struct ldap_conn *	ldap,
		const char *	dn,
		const char *	attr,
		const char *	value
	)

Delete a value from a attribute in a DN.

Parameters

ldap	Reference to the connection.
dn	DN to remove values from.
attr	Attribute to remove values from.
value	Value to remove from attribute.

Returns

Non zero ldap error on failure

Definition at line 1384 of file openldap.c.

References ldap_domodify(), ldap_mod_del(), ldap_modifyinit(), and objunref().

Referenced by ldap_mod_remattr().

                                                                                                         {
    struct ldap_modify *lmod;
    int res;

    if (!(lmod = ldap_modifyinit(dn))) {
        return LDAP_NO_MEMORY;
    }
    if (ldap_mod_del(lmod, attr, value, NULL)) {
        objunref(lmod);
        return LDAP_NO_MEMORY;
    }

    res = ldap_domodify(ldap, lmod);
    objunref(lmod);
    return res;
}

int ldap_mod_remattr	(	struct ldap_conn *	ldap,
		const char *	dn,
		const char *	attr
	)

Delete a attribute from a DN.

Parameters

ldap	Reference to the connection.
dn	DN to remove attribute from.
attr	Attribute to remove.

Returns

Non zero ldap error on failure

Definition at line 1406 of file openldap.c.

References ldap_mod_delattr().

                                                                                      {
    return ldap_mod_delattr(ldap, dn, attr, NULL);
}

int ldap_mod_rep	(	struct ldap_modify *	lmod,
		const char *	attr,
			...
	)

Replace a attribute.

Parameters

lmod	LDAP modification referenece.
attr	Attribute to modify.
...	Values to replace.

Returns

Zero on success.

Definition at line 1265 of file openldap.c.

References objunref().

Referenced by ldap_mod_repattr().

                                                                         {
    va_list a_list;
    char *val;
    struct ldap_modreq *modr;

    if (!(modr = getmodreq(lmod, attr, LDAP_MOD_REPLACE))) {
        return 1;
    }

    va_start(a_list, attr);
    while((val = va_arg(a_list, void *))) {
        if (add_modifyval(modr, val)) {
            objunref(modr);
            return(1);
        }
    }

    objunref(modr);
    va_end(a_list);
    return 0;
}

int ldap_mod_repattr	(	struct ldap_conn *	ldap,
		const char *	dn,
		const char *	attr,
		const char *	value
	)

Replace the value of a attribute in a DN.

Parameters

ldap	Reference to the connection.
dn	DN to replace attribute in.
attr	Attribute to replace.
value	Value to replace attr with.

Returns

Non zero ldap error on failure

Definition at line 1441 of file openldap.c.

References ldap_domodify(), ldap_mod_rep(), ldap_modifyinit(), and objunref().

                                                                                                         {
    struct ldap_modify *lmod;
    int res;

    if (!(lmod = ldap_modifyinit(dn))) {
        return LDAP_NO_MEMORY;
    }

    if (ldap_mod_rep(lmod, attr, value, NULL)) {
        objunref(lmod);
        return LDAP_NO_MEMORY;
    }

    res = ldap_domodify(ldap, lmod);
    objunref(lmod);
    return res;
}

struct ldap_modify* ldap_modifyinit

(

const char *

dn

)

Create a modification reference for a DN.

Parameters

dn	DN to modify.

Returns

Reference to a modification structure used to modify a DN.

Definition at line 1118 of file openldap.c.

References ALLOC_CONST, ldap_modify::bl, create_bucketlist(), ldap_modify::dn, objalloc(), and objunref().

Referenced by ldap_mod_addattr(), ldap_mod_delattr(), and ldap_mod_repattr().

                                                           {
    struct ldap_modify *mod;
    int cnt;

    if (!(mod = objalloc(sizeof(*mod), free_modify))) {
        return NULL;
    }

    ALLOC_CONST(mod->dn, dn);
    if (!mod->dn) {
        objunref(mod);
        return NULL;
    }

    for(cnt=0; cnt < 3; cnt++) {
        if (!(mod->bl[cnt] = create_bucketlist(4, modify_hash))) {
            objunref(mod);
            return NULL;
        }
    }

    return mod;
}

int ldap_saslbind	(	struct ldap_conn *	ld,
		const char *	mech,
		const char *	realm,
		const char *	authcid,
		const char *	passwd,
		const char *	authzid
	)

Bind to the server with SASL.

Parameters

ld	Reference to LDAP connection.
mech	SASL mechanisim.
realm	SASL realm.
authcid	SASL auth id.
passwd	Password for authid.
authzid	Proxy authid.

Returns

-1 on error.

Definition at line 524 of file openldap.c.

References ALLOC_CONST, sasl_defaults::authcid, sasl_defaults::authzid, ldap_conn::ldap, sasl_defaults::mech, objalloc(), objlock(), objref(), objunlock(), objunref(), sasl_defaults::passwd, sasl_defaults::realm, ldap_conn::sasl, and ldap_conn::sctrlsp.

                                                                                                                                                   {
    struct sasl_defaults *sasl;
    int res, sasl_flags = LDAP_SASL_AUTOMATIC | LDAP_SASL_QUIET;

    if (!objref(ld)) {
        return LDAP_UNAVAILABLE;
    }

    if (!(sasl = objalloc(sizeof(*sasl), free_sasl))) {
        return LDAP_NO_MEMORY;
    }

    ALLOC_CONST(sasl->passwd, passwd);

    if (mech) {
        ALLOC_CONST(sasl->mech, mech);
    } else {
        ldap_get_option(ld->ldap, LDAP_OPT_X_SASL_MECH, &sasl->mech);
    }

    if (realm) {
        ALLOC_CONST(sasl->realm, realm);
    } else {
        ldap_get_option(ld->ldap, LDAP_OPT_X_SASL_REALM, &sasl->realm );
    }

    if (authcid) {
        ALLOC_CONST(sasl->authcid, authcid);
    } else {
        ldap_get_option(ld->ldap, LDAP_OPT_X_SASL_AUTHCID, &sasl->authcid );
    }

    if (authzid) {
        ALLOC_CONST(sasl->authzid, authzid);
    } else {
        ldap_get_option(ld->ldap, LDAP_OPT_X_SASL_AUTHZID, &sasl->authzid );
    }

    objlock(ld);
    if (ld->sasl) {
        objunref(ld->sasl);
    }
    ld->sasl = sasl;
    res = ldap_sasl_interactive_bind_s(ld->ldap, NULL, sasl->mech, ld->sctrlsp , NULL, sasl_flags, dts_sasl_interact, sasl);
    objunlock(ld);
    objunref(ld);
    return res;
}

struct ldap_results* ldap_search_base	(	struct ldap_conn *	ld,
		const char *	base,
		const char *	filter,
		int	b64enc,
		int *	res,
			...
	)

Search LDAP connection base.

Parameters

ld	Reference to LDAP connection.
base	Search base dn.
filter	Search filter.
b64enc	Base 64 encode attributes.
res	Pointer containing LDAP error.
...	NULL termincated list of attributes to include.

Returns

Search results structure.

Definition at line 669 of file openldap.c.

                                                                                                                                    {
    va_list a_list;
    char *attr, **tmp, **attrs = NULL;
    int cnt = 1;

    va_start(a_list, res);
    while (( attr=va_arg(a_list, void *))) {
        cnt++;
    }
    va_end(a_list);

    if (cnt > 1) {
        tmp = attrs = malloc(sizeof(void *)*cnt);

        va_start(a_list, res);
        while (( attr=va_arg(a_list, char *))) {
            *tmp = attr;
            tmp++;
        }
        va_end(a_list);
        *tmp=NULL;
    }

    return _dtsldapsearch(ld, base, LDAP_SCOPE_BASE, filter, attrs, b64enc, res);
}

struct ldap_results* ldap_search_one	(	struct ldap_conn *	ld,
		const char *	base,
		const char *	filter,
		int	b64enc,
		int *	res,
			...
	)

Search LDAP connection one level.

Parameters

ld	Reference to LDAP connection.
base	Search base dn.
filter	Search filter.
b64enc	Base 64 encode attributes.
res	Pointer containing LDAP error.
...	NULL termincated list of attributes to include.

Returns

Search results structure.

Definition at line 635 of file openldap.c.

                                                                                                                                   {
    va_list a_list;
    char *attr, **tmp, **attrs = NULL;
    int cnt = 1;

    va_start(a_list, res);
    while (( attr=va_arg(a_list, void *))) {
        cnt++;
    }
    va_end(a_list);

    if (cnt > 1) {
        tmp = attrs = malloc(sizeof(void *)*cnt);

        va_start(a_list, res);
        while (( attr=va_arg(a_list, char *))) {
            *tmp = attr;
            tmp++;
        }
        va_end(a_list);
        *tmp=NULL;
    }

    return _dtsldapsearch(ld, base, LDAP_SCOPE_ONELEVEL, filter, attrs, b64enc, res);
}

struct ldap_results* ldap_search_sub	(	struct ldap_conn *	ld,
		const char *	base,
		const char *	filter,
		int	b64enc,
		int *	res,
			...
	)

Search LDAP connection subtree.

Parameters

ld	Reference to LDAP connection.
base	Search base dn.
filter	Search filter.
b64enc	Base 64 encode attributes.
res	Pointer containing LDAP error.
...	NULL termincated list of attributes to include.

Returns

Search results structure.

Definition at line 601 of file openldap.c.

Referenced by ldap_simplerebind().

                                                                                                                                   {
    va_list a_list;
    char *attr, **tmp, **attrs = NULL;
    int cnt = 1;

    va_start(a_list, res);
    while (( attr=va_arg(a_list, void *))) {
        cnt++;
    }
    va_end(a_list);

    if (cnt > 1) {
        tmp = attrs = malloc(sizeof(void *)*cnt);

        va_start(a_list, res);
        while (( attr=va_arg(a_list, char *))) {
            *tmp = attr;
            tmp++;
        }
        va_end(a_list);
        *tmp=NULL;
    }

    return _dtsldapsearch(ld, base, LDAP_SCOPE_SUBTREE, filter, attrs, b64enc, res);
}

int ldap_simplebind	(	struct ldap_conn *	ld,
		const char *	dn,
		const char *	passwd
	)

Bind to the connection with simple bind requireing a distingushed name and password.

Parameters

ld	LDAP connection to bind to.
dn	Distinguished name to bind with.
passwd	Password for dn.

Returns

-1 on error.

Definition at line 434 of file openldap.c.

References ldap_simple::cred, ldap_simple::dn, ldap_conn::ldap, objalloc(), objlock(), objref(), objunlock(), objunref(), ldap_conn::sctrlsp, and ldap_conn::simple.

Referenced by ldap_simplerebind().

                                                                                     {
    struct ldap_simple *simple;
    struct berval *cred;
    int res, len = 0;

    if (!objref(ld)) {
        return LDAP_UNAVAILABLE;
    }

    if (passwd) {
        len = strlen(passwd);
    }
    simple = objalloc(sizeof(*simple), free_simple);
    cred = calloc(sizeof(*cred), 1);
    cred->bv_val = malloc(len);
    memcpy(cred->bv_val, passwd, len);
    cred->bv_len=len;
    simple->cred = cred;
    simple->dn = strdup(dn);

    objlock(ld);
    if (ld->simple) {
        objunref(ld->simple);
    }
    ld->simple = simple;
    res = ldap_sasl_bind_s(ld->ldap, simple->dn, LDAP_SASL_SIMPLE, simple->cred, ld->sctrlsp, NULL, NULL);
    objunlock(ld);
    objunref(ld);
    return res;
}

int ldap_simplerebind	(	struct ldap_conn *	ldap,
		const char *	initialdn,
		const char *	initialpw,
		const char *	base,
		const char *	filter,
		const char *	uidrdn,
		const char *	uid,
		const char *	passwd
	)

Bind to LDAP connection using rebind.

Bind to a connection with a lower privlidge distingushed name and password search for a user dn, bind to the connection with the retrieved dn and user password.

Parameters

ldap	LDAP connection to bind too.
initialdn	Initial dn to bind with.
initialpw	Password for the initial dn.
base	Search base to find user.
filter	LDAP filter to apply to find user.
uidrdn	Attribute containing user id.
uid	To search and bind as.
passwd	Password for the user id.

Returns

-1 on error.

Definition at line 478 of file openldap.c.

References ldap_results::count, ldap_entry::dn, ldap_results::first_entry, ldap_search_sub(), ldap_simplebind(), objref(), and objunref().

                                                                                      {
    int res, flen;
    struct ldap_results *results;
    const char *sfilt;

    if (!objref(ldap)) {
        return LDAP_UNAVAILABLE;
    }

    if ((res = ldap_simplebind(ldap, initialdn, initialpw))) {
        objunref(ldap);
        return res;
    }

    flen=strlen(uidrdn) + strlen(filter) + strlen(uid) + 7;
    sfilt = malloc(flen);
    snprintf((char *)sfilt, flen, "(&(%s=%s)%s)", uidrdn, uid, filter);

    if (!(results = ldap_search_sub(ldap, base, sfilt, 0, &res, uidrdn, NULL))) {
        free((void *)sfilt);
        objunref(ldap);
        return res;
    }
    free((void *)sfilt);

    if (results->count != 1) {
        objunref(results);
        objunref(ldap);
        return LDAP_INAPPROPRIATE_AUTH;
    }

    res = ldap_simplebind(ldap, results->first_entry->dn, passwd);
    objunref(ldap);
    objunref(results);
    return res;
}

void ldap_unref_attr	(	struct ldap_entry *	entry,
		struct ldap_attr *	attr
	)

Remove a attribute from a entry.

Parameters

entry	The entry to remove attr from.
attr	Attribute to remove.

Definition at line 1059 of file openldap.c.

References ldap_entry::attrs, ldap_entry::first_attr, ldap_attr::next, objcnt(), objunref(), and remove_bucket_item().

                                                                              {
    if (!entry || !attr) {
        return;
    }

    if (objcnt(attr) > 1) {
        objunref(attr);
    } else {
        if (attr == entry->first_attr) {
            entry->first_attr = attr->next;
        }
        remove_bucket_item(entry->attrs, attr);
    }
}

void ldap_unref_entry	(	struct ldap_results *	results,
		struct ldap_entry *	entry
	)

Remove a entry from a result.

Parameters

results	The result to remove entry from.
entry	Entry to remove.

Definition at line 1077 of file openldap.c.

References ldap_results::entries, ldap_results::first_entry, ldap_entry::next, objcnt(), objunref(), and remove_bucket_item().

                                                                                     {
    if (!results || !entry) {
        return;
    }

    if (objcnt(entry) > 1) {
        objunref(entry);
    } else {
        if (entry == results->first_entry) {
            results->first_entry = entry->next;
        }
        remove_bucket_item(results->entries, entry);
    }
}