upstream/openldap
1
0
Fork 0
mirror of https://git.openldap.org/openldap/openldap.git synced 2025-12-21 07:09:34 -05:00
Code Issues Projects Releases Packages Wiki Activity Actions

ITS#9001 manual changes

Browse source
This commit is contained in:
Ondřej Kuzník 2021-03-24 13:04:43 +00:00
parent 51c444b065
commit e36d1e31c5
67 changed files with 480 additions and 485 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
contrib/slapd-modules/authzid/authzid.c
View file

@ -71,7 +71,7 @@ authzid_conn_find( Connection *c )
authzid_conn_t *ac = NULL, tmp = { 0 }; authzid_conn_t *ac = NULL, tmp = { 0 };
tmp.conn = c; tmp.conn = c;
ac = (authzid_conn_t *)avl_find( authzid_tree, (caddr_t)&tmp, authzid_conn_cmp ); ac = (authzid_conn_t *)ldap_avl_find( authzid_tree, (caddr_t)&tmp, authzid_conn_cmp );
if ( ac == NULL || ( ac != NULL && ac->refcnt != 0 ) ) { if ( ac == NULL || ( ac != NULL && ac->refcnt != 0 ) ) {
ac = NULL; ac = NULL;
} }
@ -121,7 +121,7 @@ authzid_conn_insert( Connection *c, char flag )
ac->conn = c; ac->conn = c;
ac->refcnt = 0; ac->refcnt = 0;
ac->authzid_flag = flag; ac->authzid_flag = flag;
rc = avl_insert( &authzid_tree, (caddr_t)ac, rc = ldap_avl_insert( &authzid_tree, (caddr_t)ac,
authzid_conn_cmp, authzid_conn_dup ); authzid_conn_cmp, authzid_conn_dup );
ldap_pvt_thread_mutex_unlock( &authzid_mutex ); ldap_pvt_thread_mutex_unlock( &authzid_mutex );
@ -139,7 +139,7 @@ authzid_conn_remove( Connection *c )
ldap_pvt_thread_mutex_unlock( &authzid_mutex ); ldap_pvt_thread_mutex_unlock( &authzid_mutex );
return -1; return -1;
} }
tmp = avl_delete( &authzid_tree, (caddr_t)ac, authzid_conn_cmp ); tmp = ldap_avl_delete( &authzid_tree, (caddr_t)ac, authzid_conn_cmp );
ldap_pvt_thread_mutex_unlock( &authzid_mutex ); ldap_pvt_thread_mutex_unlock( &authzid_mutex );
assert( tmp == ac ); assert( tmp == ac );

6
contrib/slapd-modules/vc/vc.c
View file

@ -281,7 +281,7 @@ vc_exop(
AC_MEMCPY( (char *)&tmp.conn, (const char *)cookie.bv_val, cookie.bv_len ); AC_MEMCPY( (char *)&tmp.conn, (const char *)cookie.bv_val, cookie.bv_len );
ldap_pvt_thread_mutex_lock( &vc_mutex ); ldap_pvt_thread_mutex_lock( &vc_mutex );
conn = (vc_conn_t *)avl_find( vc_tree, (caddr_t)&tmp, vc_conn_cmp ); conn = (vc_conn_t *)ldap_avl_find( vc_tree, (caddr_t)&tmp, vc_conn_cmp );
if ( conn == NULL || ( conn != NULL && conn->refcnt != 0 ) ) { if ( conn == NULL || ( conn != NULL && conn->refcnt != 0 ) ) {
conn = NULL; conn = NULL;
ldap_pvt_thread_mutex_unlock( &vc_mutex ); ldap_pvt_thread_mutex_unlock( &vc_mutex );
@ -376,7 +376,7 @@ done:;
conn->conn = conn; conn->conn = conn;
conn->refcnt--; conn->refcnt--;
ldap_pvt_thread_mutex_lock( &vc_mutex ); ldap_pvt_thread_mutex_lock( &vc_mutex );
rc = avl_insert( &vc_tree, (caddr_t)conn, rc = ldap_avl_insert( &vc_tree, (caddr_t)conn,
vc_conn_cmp, vc_conn_dup ); vc_conn_cmp, vc_conn_dup );
ldap_pvt_thread_mutex_unlock( &vc_mutex ); ldap_pvt_thread_mutex_unlock( &vc_mutex );
assert( rc == 0 ); assert( rc == 0 );
@ -392,7 +392,7 @@ done:;
vc_conn_t *tmp; vc_conn_t *tmp;
ldap_pvt_thread_mutex_lock( &vc_mutex ); ldap_pvt_thread_mutex_lock( &vc_mutex );
tmp = avl_delete( &vc_tree, (caddr_t)conn, vc_conn_cmp ); tmp = ldap_avl_delete( &vc_tree, (caddr_t)conn, vc_conn_cmp );
ldap_pvt_thread_mutex_unlock( &vc_mutex ); ldap_pvt_thread_mutex_unlock( &vc_mutex );
} }
SLAP_FREE( conn ); SLAP_FREE( conn );

52
include/avl.h → include/ldap_avl.h
View file

@ -1,4 +1,4 @@
/* avl.h - avl tree definitions */ /* ldap_avl.h - avl tree definitions */
/* $OpenLDAP$ */ /* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>. /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
* *
@ -73,15 +73,15 @@ struct tavlnode {
#define AVL_THREAD 1 #define AVL_THREAD 1
/* avl routines */ /* avl routines */
#define avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data) #define ldap_avl_getone(x) ((x) == 0 ? 0 : (x)->avl_data)
#define avl_onenode(x) ((x) == 0 || ((x)->avl_left == 0 && (x)->avl_right == 0)) #define ldap_avl_onenode(x) ((x) == 0 || ((x)->avl_left == 0 && (x)->avl_right == 0))
#endif /* AVL_INTERNALS */ #endif /* AVL_INTERNALS */
#define avl_child(x,dir) ((x)->avl_bits[dir]) == AVL_CHILD ? \ #define ldap_avl_child(x,dir) ((x)->avl_bits[dir]) == AVL_CHILD ? \
(x)->avl_link[dir] : NULL (x)->avl_link[dir] : NULL
#define avl_lchild(x) avl_child(x,0) #define ldap_avl_lchild(x) ldap_avl_child(x,0)
#define avl_rchild(x) avl_child(x,1) #define ldap_avl_rchild(x) ldap_avl_child(x,1)
typedef int (*AVL_APPLY) LDAP_P((void *, void*)); typedef int (*AVL_APPLY) LDAP_P((void *, void*));
typedef int (*AVL_CMP) LDAP_P((const void*, const void*)); typedef int (*AVL_CMP) LDAP_P((const void*, const void*));
@ -89,69 +89,69 @@ typedef int (*AVL_DUP) LDAP_P((void*, void*));
typedef void (*AVL_FREE) LDAP_P((void*)); typedef void (*AVL_FREE) LDAP_P((void*));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree )); ldap_avl_free LDAP_P(( Avlnode *root, AVL_FREE dfree ));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP)); ldap_avl_insert LDAP_P((Avlnode **, void*, AVL_CMP, AVL_DUP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
avl_delete LDAP_P((Avlnode **, void*, AVL_CMP)); ldap_avl_delete LDAP_P((Avlnode **, void*, AVL_CMP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
avl_find LDAP_P((Avlnode *, const void*, AVL_CMP)); ldap_avl_find LDAP_P((Avlnode *, const void*, AVL_CMP));
LDAP_AVL_F( Avlnode* ) LDAP_AVL_F( Avlnode* )
avl_find2 LDAP_P((Avlnode *, const void*, AVL_CMP)); ldap_avl_find2 LDAP_P((Avlnode *, const void*, AVL_CMP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP)); ldap_avl_find_lin LDAP_P((Avlnode *, const void*, AVL_CMP));
#ifdef AVL_NONREENTRANT #ifdef AVL_NONREENTRANT
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
avl_getfirst LDAP_P((Avlnode *)); ldap_avl_getfirst LDAP_P((Avlnode *));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
avl_getnext LDAP_P((void)); ldap_avl_getnext LDAP_P((void));
#endif #endif
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_dup_error LDAP_P((void*, void*)); ldap_avl_dup_error LDAP_P((void*, void*));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_dup_ok LDAP_P((void*, void*)); ldap_avl_dup_ok LDAP_P((void*, void*));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int)); ldap_avl_apply LDAP_P((Avlnode *, AVL_APPLY, void*, int, int));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int)); ldap_avl_prefixapply LDAP_P((Avlnode *, void*, AVL_CMP, void*, AVL_CMP, void*, int));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
tavl_free LDAP_P(( TAvlnode *root, AVL_FREE dfree )); ldap_tavl_free LDAP_P(( TAvlnode *root, AVL_FREE dfree ));
LDAP_AVL_F( int ) LDAP_AVL_F( int )
tavl_insert LDAP_P((TAvlnode **, void*, AVL_CMP, AVL_DUP)); ldap_tavl_insert LDAP_P((TAvlnode **, void*, AVL_CMP, AVL_DUP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
tavl_delete LDAP_P((TAvlnode **, void*, AVL_CMP)); ldap_tavl_delete LDAP_P((TAvlnode **, void*, AVL_CMP));
LDAP_AVL_F( void* ) LDAP_AVL_F( void* )
tavl_find LDAP_P((TAvlnode *, const void*, AVL_CMP)); ldap_tavl_find LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( TAvlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_find2 LDAP_P((TAvlnode *, const void*, AVL_CMP)); ldap_tavl_find2 LDAP_P((TAvlnode *, const void*, AVL_CMP));
LDAP_AVL_F( TAvlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_find3 LDAP_P((TAvlnode *, const void*, AVL_CMP, int *ret)); ldap_tavl_find3 LDAP_P((TAvlnode *, const void*, AVL_CMP, int *ret));
#define TAVL_DIR_LEFT 0 #define TAVL_DIR_LEFT 0
#define TAVL_DIR_RIGHT 1 #define TAVL_DIR_RIGHT 1
LDAP_AVL_F( TAvlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_end LDAP_P((TAvlnode *, int direction)); ldap_tavl_end LDAP_P((TAvlnode *, int direction));
LDAP_AVL_F( TAvlnode* ) LDAP_AVL_F( TAvlnode* )
tavl_next LDAP_P((TAvlnode *, int direction)); ldap_tavl_next LDAP_P((TAvlnode *, int direction));
/* apply traversal types */ /* apply traversal types */
#define AVL_PREORDER 1 #define AVL_PREORDER 1

11
libraries/libldap/Makefile.in
View file

@ -15,7 +15,7 @@
LIBRARY = libldap.la LIBRARY = libldap.la
PROGRAMS = apitest dntest ftest ltest urltest PROGRAMS = apitest dntest ftest ltest urltest testavl
SRCS = bind.c open.c result.c error.c compare.c search.c \ SRCS = bind.c open.c result.c error.c compare.c search.c \
controls.c messages.c references.c extended.c cyrus.c \ controls.c messages.c references.c extended.c cyrus.c \
@ -31,7 +31,7 @@ SRCS = bind.c open.c result.c error.c compare.c search.c \
assertion.c deref.c ldifutil.c ldif.c fetch.c lbase64.c \ assertion.c deref.c ldifutil.c ldif.c fetch.c lbase64.c \
msctrl.c psearchctrl.c threads.c rdwr.c tpool.c rq.c \ msctrl.c psearchctrl.c threads.c rdwr.c tpool.c rq.c \
thr_posix.c thr_thr.c thr_nt.c thr_pth.c thr_debug.c \ thr_posix.c thr_thr.c thr_nt.c thr_pth.c thr_debug.c \
account_usability.c account_usability.c avl.c tavl.c testavl.c
OBJS = bind.lo open.lo result.lo error.lo compare.lo search.lo \ OBJS = bind.lo open.lo result.lo error.lo compare.lo search.lo \
controls.lo messages.lo references.lo extended.lo cyrus.lo \ controls.lo messages.lo references.lo extended.lo cyrus.lo \
@ -47,7 +47,7 @@ OBJS = bind.lo open.lo result.lo error.lo compare.lo search.lo \
assertion.lo deref.lo ldifutil.lo ldif.lo fetch.lo lbase64.lo \ assertion.lo deref.lo ldifutil.lo ldif.lo fetch.lo lbase64.lo \
msctrl.lo psearchctrl.lo threads.lo rdwr.lo tpool.lo rq.lo \ msctrl.lo psearchctrl.lo threads.lo rdwr.lo tpool.lo rq.lo \
thr_posix.lo thr_thr.lo thr_nt.lo thr_pth.lo thr_debug.lo \ thr_posix.lo thr_thr.lo thr_nt.lo thr_pth.lo thr_debug.lo \
account_usability.lo account_usability.lo avl.lo tavl.lo
LDAP_INCDIR= ../../include LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries LDAP_LIBDIR= ../../libraries
@ -70,9 +70,14 @@ ftest: $(XLIBS) ftest.o
$(LTLINK) -o $@ ftest.o $(LIBS) $(LTLINK) -o $@ ftest.o $(LIBS)
ltest: $(XLIBS) test.o ltest: $(XLIBS) test.o
$(LTLINK) -o $@ test.o $(LIBS) $(LTLINK) -o $@ test.o $(LIBS)
testavl: $(XLIBS) testavl.o
$(LTLINK) -o $@ testavl.o $(LIBS)
testtavl: $(XLIBS) testtavl.o
$(LTLINK) -o $@ testtavl.o $(LIBS)
urltest: $(XLIBS) urltest.o urltest: $(XLIBS) urltest.o
$(LTLINK) -o $@ urltest.o $(LIBS) $(LTLINK) -o $@ urltest.o $(LIBS)
CFFILES=ldap.conf CFFILES=ldap.conf
install-local: $(CFFILES) FORCE install-local: $(CFFILES) FORCE

80
libraries/liblutil/avl.c → libraries/libldap/avl.c
View file

@ -2,7 +2,7 @@
/* $OpenLDAP$ */ /* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>. /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
* *
* Copyright 1998-2021 The OpenLDAP Foundation. * Copyright 1998-2020 The OpenLDAP Foundation.
* All rights reserved. * All rights reserved.
* *
* Redistribution and use in source and binary forms, with or without * Redistribution and use in source and binary forms, with or without
@ -47,7 +47,7 @@
#endif #endif
#define AVL_INTERNAL #define AVL_INTERNAL
#include "avl.h" #include "ldap_avl.h"
/* Maximum tree depth this host's address space could support */ /* Maximum tree depth this host's address space could support */
#define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT) #define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT)
@ -55,13 +55,13 @@
static const int avl_bfs[] = {LH, RH}; static const int avl_bfs[] = {LH, RH};
/* /*
* avl_insert -- insert a node containing data data into the avl tree * ldap_avl_insert -- insert a node containing data data into the avl tree
* with root root. fcmp is a function to call to compare the data portion * with root root. fcmp is a function to call to compare the data portion
* of two nodes. it should take two arguments and return <, >, or == 0, * of two nodes. it should take two arguments and return <, >, or == 0,
* depending on whether its first argument is <, >, or == its second * depending on whether its first argument is <, >, or == its second
* argument (like strcmp, e.g.). fdup is a function to call when a duplicate * argument (like strcmp, e.g.). fdup is a function to call when a duplicate
* node is inserted. it should return 0, or -1 and its return value * node is inserted. it should return 0, or -1 and its return value
* will be the return value from avl_insert in the case of a duplicate node. * will be the return value from ldap_avl_insert in the case of a duplicate node.
* the function will be called with the original node's data as its first * the function will be called with the original node's data as its first
* argument and with the incoming duplicate node's data as its second * argument and with the incoming duplicate node's data as its second
* argument. this could be used, for example, to keep a count with each * argument. this could be used, for example, to keep a count with each
@ -70,7 +70,7 @@ static const int avl_bfs[] = {LH, RH};
* NOTE: this routine may malloc memory * NOTE: this routine may malloc memory
*/ */
int int
avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup ) ldap_avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
{ {
Avlnode *t, *p, *s, *q, *r; Avlnode *t, *p, *s, *q, *r;
int a, cmp, ncmp; int a, cmp, ncmp;
@ -180,7 +180,7 @@ avl_insert( Avlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
} }
void* void*
avl_delete( Avlnode **root, void* data, AVL_CMP fcmp ) ldap_avl_delete( Avlnode **root, void* data, AVL_CMP fcmp )
{ {
Avlnode *p, *q, *r, *top; Avlnode *p, *q, *r, *top;
int side, side_bf, shorter, nside; int side, side_bf, shorter, nside;
@ -411,7 +411,7 @@ avl_preapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
} }
/* /*
* avl_apply -- avl tree root is traversed, function fn is called with * ldap_avl_apply -- avl tree root is traversed, function fn is called with
* arguments arg and the data portion of each node. if fn returns stopflag, * arguments arg and the data portion of each node. if fn returns stopflag,
* the traversal is cut short, otherwise it continues. Do not use -6 as * the traversal is cut short, otherwise it continues. Do not use -6 as
* a stopflag, as this is what is used to indicate the traversal ran out * a stopflag, as this is what is used to indicate the traversal ran out
@ -419,7 +419,7 @@ avl_preapply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag )
*/ */
int int
avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type ) ldap_avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type )
{ {
switch ( type ) { switch ( type ) {
case AVL_INORDER: case AVL_INORDER:
@ -437,18 +437,18 @@ avl_apply( Avlnode *root, AVL_APPLY fn, void* arg, int stopflag, int type )
} }
/* /*
* avl_prefixapply - traverse avl tree root, applying function fprefix * ldap_avl_prefixapply - traverse avl tree root, applying function fprefix
* to any nodes that match. fcmp is called with data as its first arg * to any nodes that match. fcmp is called with data as its first arg
* and the current node's data as its second arg. it should return * and the current node's data as its second arg. it should return
* 0 if they match, < 0 if data is less, and > 0 if data is greater. * 0 if they match, < 0 if data is less, and > 0 if data is greater.
* the idea is to efficiently find all nodes that are prefixes of * the idea is to efficiently find all nodes that are prefixes of
* some key... Like avl_apply, this routine also takes a stopflag * some key... Like ldap_avl_apply, this routine also takes a stopflag
* and will return prematurely if fmatch returns this value. Otherwise, * and will return prematurely if fmatch returns this value. Otherwise,
* AVL_NOMORE is returned. * AVL_NOMORE is returned.
*/ */
int int
avl_prefixapply( ldap_avl_prefixapply(
Avlnode *root, Avlnode *root,
void* data, void* data,
AVL_CMP fmatch, AVL_CMP fmatch,
@ -469,23 +469,23 @@ avl_prefixapply(
return( stopflag ); return( stopflag );
if ( root->avl_left != 0 ) if ( root->avl_left != 0 )
if ( avl_prefixapply( root->avl_left, data, fmatch, if ( ldap_avl_prefixapply( root->avl_left, data, fmatch,
marg, fcmp, carg, stopflag ) == stopflag ) marg, fcmp, carg, stopflag ) == stopflag )
return( stopflag ); return( stopflag );
if ( root->avl_right != 0 ) if ( root->avl_right != 0 )
return( avl_prefixapply( root->avl_right, data, fmatch, return( ldap_avl_prefixapply( root->avl_right, data, fmatch,
marg, fcmp, carg, stopflag ) ); marg, fcmp, carg, stopflag ) );
else else
return( AVL_NOMORE ); return( AVL_NOMORE );
} else if ( cmp < 0 ) { } else if ( cmp < 0 ) {
if ( root->avl_left != 0 ) if ( root->avl_left != 0 )
return( avl_prefixapply( root->avl_left, data, fmatch, return( ldap_avl_prefixapply( root->avl_left, data, fmatch,
marg, fcmp, carg, stopflag ) ); marg, fcmp, carg, stopflag ) );
} else { } else {
if ( root->avl_right != 0 ) if ( root->avl_right != 0 )
return( avl_prefixapply( root->avl_right, data, fmatch, return( ldap_avl_prefixapply( root->avl_right, data, fmatch,
marg, fcmp, carg, stopflag ) ); marg, fcmp, carg, stopflag ) );
} }
@ -493,13 +493,13 @@ avl_prefixapply(
} }
/* /*
* avl_free -- traverse avltree root, freeing the memory it is using. * ldap_avl_free -- traverse avltree root, freeing the memory it is using.
* the dfree() is called to free the data portion of each node. The * the dfree() is called to free the data portion of each node. The
* number of items actually freed is returned. * number of items actually freed is returned.
*/ */
int int
avl_free( Avlnode *root, AVL_FREE dfree ) ldap_avl_free( Avlnode *root, AVL_FREE dfree )
{ {
int nleft, nright; int nleft, nright;
@ -508,10 +508,10 @@ avl_free( Avlnode *root, AVL_FREE dfree )
nleft = nright = 0; nleft = nright = 0;
if ( root->avl_left != 0 ) if ( root->avl_left != 0 )
nleft = avl_free( root->avl_left, dfree ); nleft = ldap_avl_free( root->avl_left, dfree );
if ( root->avl_right != 0 ) if ( root->avl_right != 0 )
nright = avl_free( root->avl_right, dfree ); nright = ldap_avl_free( root->avl_right, dfree );
if ( dfree ) if ( dfree )
(*dfree)( root->avl_data ); (*dfree)( root->avl_data );
@ -521,14 +521,14 @@ avl_free( Avlnode *root, AVL_FREE dfree )
} }
/* /*
* avl_find -- search avltree root for a node with data data. the function * ldap_avl_find -- search avltree root for a node with data data. the function
* cmp is used to compare things. it is called with data as its first arg * cmp is used to compare things. it is called with data as its first arg
* and the current node data as its second. it should return 0 if they match, * and the current node data as its second. it should return 0 if they match,
* < 0 if arg1 is less than arg2 and > 0 if arg1 is greater than arg2. * < 0 if arg1 is less than arg2 and > 0 if arg1 is greater than arg2.
*/ */
Avlnode * Avlnode *
avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp ) ldap_avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
@ -540,7 +540,7 @@ avl_find2( Avlnode *root, const void *data, AVL_CMP fcmp )
} }
void* void*
avl_find( Avlnode *root, const void* data, AVL_CMP fcmp ) ldap_avl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
@ -553,14 +553,14 @@ avl_find( Avlnode *root, const void* data, AVL_CMP fcmp )
} }
/* /*
* avl_find_lin -- search avltree root linearly for a node with data data. * ldap_avl_find_lin -- search avltree root linearly for a node with data data.
* the function cmp is used to compare things. it is called with data as its * the function cmp is used to compare things. it is called with data as its
* first arg and the current node data as its second. it should return 0 if * first arg and the current node data as its second. it should return 0 if
* they match, non-zero otherwise. * they match, non-zero otherwise.
*/ */
void* void*
avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp ) ldap_avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp )
{ {
void* res; void* res;
@ -571,21 +571,21 @@ avl_find_lin( Avlnode *root, const void* data, AVL_CMP fcmp )
return( root->avl_data ); return( root->avl_data );
if ( root->avl_left != 0 ) if ( root->avl_left != 0 )
if ( (res = avl_find_lin( root->avl_left, data, fcmp )) if ( (res = ldap_avl_find_lin( root->avl_left, data, fcmp ))
!= NULL ) != NULL )
return( res ); return( res );
if ( root->avl_right == 0 ) if ( root->avl_right == 0 )
return( NULL ); return( NULL );
else else
return( avl_find_lin( root->avl_right, data, fcmp ) ); return( ldap_avl_find_lin( root->avl_right, data, fcmp ) );
} }
/* NON-REENTRANT INTERFACE */ /* NON-REENTRANT INTERFACE */
static void* *avl_list; static void* *avl_list;
static int avl_maxlist; static int avl_maxlist;
static int avl_nextlist; static int ldap_avl_nextlist;
#define AVL_GRABSIZE 100 #define AVL_GRABSIZE 100
@ -611,61 +611,61 @@ avl_buildlist( void* data, void* arg )
} }
/* /*
* avl_getfirst() and avl_getnext() are provided as alternate tree * ldap_avl_getfirst() and ldap_avl_getnext() are provided as alternate tree
* traversal methods, to be used when a single function cannot be * traversal methods, to be used when a single function cannot be
* provided to be called with every node in the tree. avl_getfirst() * provided to be called with every node in the tree. ldap_avl_getfirst()
* traverses the tree and builds a linear list of all the nodes, * traverses the tree and builds a linear list of all the nodes,
* returning the first node. avl_getnext() returns the next thing * returning the first node. ldap_avl_getnext() returns the next thing
* on the list built by avl_getfirst(). This means that avl_getfirst() * on the list built by ldap_avl_getfirst(). This means that ldap_avl_getfirst()
* can take a while, and that the tree should not be messed with while * can take a while, and that the tree should not be messed with while
* being traversed in this way, and that multiple traversals (even of * being traversed in this way, and that multiple traversals (even of
* different trees) cannot be active at once. * different trees) cannot be active at once.
*/ */
void* void*
avl_getfirst( Avlnode *root ) ldap_avl_getfirst( Avlnode *root )
{ {
if ( avl_list ) { if ( avl_list ) {
ber_memfree( (char *) avl_list); ber_memfree( (char *) avl_list);
avl_list = (void* *) 0; avl_list = (void* *) 0;
} }
avl_maxlist = 0; avl_maxlist = 0;
avl_nextlist = 0; ldap_avl_nextlist = 0;
if ( root == 0 ) if ( root == 0 )
return( 0 ); return( 0 );
(void) avl_apply( root, avl_buildlist, (void*) 0, -1, AVL_INORDER ); (void) ldap_avl_apply( root, avl_buildlist, (void*) 0, -1, AVL_INORDER );
return( avl_list[ avl_nextlist++ ] ); return( avl_list[ ldap_avl_nextlist++ ] );
} }
void* void*
avl_getnext( void ) ldap_avl_getnext( void )
{ {
if ( avl_list == 0 ) if ( avl_list == 0 )
return( 0 ); return( 0 );
if ( avl_nextlist == avl_maxlist ) { if ( ldap_avl_nextlist == avl_maxlist ) {
ber_memfree( (void*) avl_list); ber_memfree( (void*) avl_list);
avl_list = (void* *) 0; avl_list = (void* *) 0;
return( 0 ); return( 0 );
} }
return( avl_list[ avl_nextlist++ ] ); return( avl_list[ ldap_avl_nextlist++ ] );
} }
/* end non-reentrant code */ /* end non-reentrant code */
int int
avl_dup_error( void* left, void* right ) ldap_avl_dup_error( void* left, void* right )
{ {
return( -1 ); return( -1 );
} }
int int
avl_dup_ok( void* left, void* right ) ldap_avl_dup_ok( void* left, void* right )
{ {
return( 0 ); return( 0 );
} }

44
libraries/liblutil/tavl.c → libraries/libldap/tavl.c
View file

@ -2,7 +2,7 @@
/* $OpenLDAP$ */ /* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>. /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
* *
* Copyright 2005-2021 The OpenLDAP Foundation. * Copyright 2005-2020 The OpenLDAP Foundation.
* Portions Copyright (c) 2005 by Howard Chu, Symas Corp. * Portions Copyright (c) 2005 by Howard Chu, Symas Corp.
* All rights reserved. * All rights reserved.
* *
@ -34,7 +34,7 @@
#endif #endif
#define AVL_INTERNAL #define AVL_INTERNAL
#include "avl.h" #include "ldap_avl.h"
/* Maximum tree depth this host's address space could support */ /* Maximum tree depth this host's address space could support */
#define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT) #define MAX_TREE_DEPTH (sizeof(void *) * CHAR_BIT)
@ -45,13 +45,13 @@ static const int avl_bfs[] = {LH, RH};
* Threaded AVL trees - for fast in-order traversal of nodes. * Threaded AVL trees - for fast in-order traversal of nodes.
*/ */
/* /*
* tavl_insert -- insert a node containing data data into the avl tree * ldap_tavl_insert -- insert a node containing data data into the avl tree
* with root root. fcmp is a function to call to compare the data portion * with root root. fcmp is a function to call to compare the data portion
* of two nodes. it should take two arguments and return <, >, or == 0, * of two nodes. it should take two arguments and return <, >, or == 0,
* depending on whether its first argument is <, >, or == its second * depending on whether its first argument is <, >, or == its second
* argument (like strcmp, e.g.). fdup is a function to call when a duplicate * argument (like strcmp, e.g.). fdup is a function to call when a duplicate
* node is inserted. it should return 0, or -1 and its return value * node is inserted. it should return 0, or -1 and its return value
* will be the return value from avl_insert in the case of a duplicate node. * will be the return value from ldap_avl_insert in the case of a duplicate node.
* the function will be called with the original node's data as its first * the function will be called with the original node's data as its first
* argument and with the incoming duplicate node's data as its second * argument and with the incoming duplicate node's data as its second
* argument. this could be used, for example, to keep a count with each * argument. this could be used, for example, to keep a count with each
@ -60,7 +60,7 @@ static const int avl_bfs[] = {LH, RH};
* NOTE: this routine may malloc memory * NOTE: this routine may malloc memory
*/ */
int int
tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup ) ldap_tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
{ {
TAvlnode *t, *p, *s, *q, *r; TAvlnode *t, *p, *s, *q, *r;
int a, cmp, ncmp; int a, cmp, ncmp;
@ -88,7 +88,7 @@ tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
return (*fdup)( p->avl_data, data ); return (*fdup)( p->avl_data, data );
cmp = (cmp > 0); cmp = (cmp > 0);
q = avl_child( p, cmp ); q = ldap_avl_child( p, cmp );
if (q == NULL) { if (q == NULL) {
/* insert */ /* insert */
if (( q = (TAvlnode *) ber_memalloc( sizeof( TAvlnode ))) == NULL ) { if (( q = (TAvlnode *) ber_memalloc( sizeof( TAvlnode ))) == NULL ) {
@ -187,7 +187,7 @@ tavl_insert( TAvlnode ** root, void *data, AVL_CMP fcmp, AVL_DUP fdup )
} }
void* void*
tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp ) ldap_tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
{ {
TAvlnode *p, *q, *r, *top; TAvlnode *p, *q, *r, *top;
int side, side_bf, shorter, nside = -1; int side, side_bf, shorter, nside = -1;
@ -418,22 +418,22 @@ tavl_delete( TAvlnode **root, void* data, AVL_CMP fcmp )
} }
/* /*
* tavl_free -- traverse avltree root, freeing the memory it is using. * ldap_tavl_free -- traverse avltree root, freeing the memory it is using.
* the dfree() is called to free the data portion of each node. The * the dfree() is called to free the data portion of each node. The
* number of items actually freed is returned. * number of items actually freed is returned.
*/ */
int int
tavl_free( TAvlnode *root, AVL_FREE dfree ) ldap_tavl_free( TAvlnode *root, AVL_FREE dfree )
{ {
int nleft, nright; int nleft, nright;
if ( root == 0 ) if ( root == 0 )
return( 0 ); return( 0 );
nleft = tavl_free( avl_lchild( root ), dfree ); nleft = ldap_tavl_free( ldap_avl_lchild( root ), dfree );
nright = tavl_free( avl_rchild( root ), dfree ); nright = ldap_tavl_free( ldap_avl_rchild( root ), dfree );
if ( dfree ) if ( dfree )
(*dfree)( root->avl_data ); (*dfree)( root->avl_data );
@ -443,19 +443,19 @@ tavl_free( TAvlnode *root, AVL_FREE dfree )
} }
/* /*
* tavl_find -- search avltree root for a node with data data. the function * ldap_tavl_find -- search avltree root for a node with data data. the function
* cmp is used to compare things. it is called with data as its first arg * cmp is used to compare things. it is called with data as its first arg
* and the current node data as its second. it should return 0 if they match, * and the current node data as its second. it should return 0 if they match,
* < 0 if arg1 is less than arg2 and > 0 if arg1 is greater than arg2. * < 0 if arg1 is less than arg2 and > 0 if arg1 is greater than arg2.
*/ */
/* /*
* tavl_find2 - returns TAvlnode instead of data pointer. * ldap_tavl_find2 - returns TAvlnode instead of data pointer.
* tavl_find3 - as above, but returns TAvlnode even if no match is found. * ldap_tavl_find3 - as above, but returns TAvlnode even if no match is found.
* also set *ret = last comparison result, or -1 if root == NULL. * also set *ret = last comparison result, or -1 if root == NULL.
*/ */
TAvlnode * TAvlnode *
tavl_find3( TAvlnode *root, const void *data, AVL_CMP fcmp, int *ret ) ldap_tavl_find3( TAvlnode *root, const void *data, AVL_CMP fcmp, int *ret )
{ {
int cmp = -1, dir; int cmp = -1, dir;
TAvlnode *prev = root; TAvlnode *prev = root;
@ -463,32 +463,32 @@ tavl_find3( TAvlnode *root, const void *data, AVL_CMP fcmp, int *ret )
while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) { while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) {
prev = root; prev = root;
dir = cmp > 0; dir = cmp > 0;
root = avl_child( root, dir ); root = ldap_avl_child( root, dir );
} }
*ret = cmp; *ret = cmp;
return root ? root : prev; return root ? root : prev;
} }
TAvlnode * TAvlnode *
tavl_find2( TAvlnode *root, const void *data, AVL_CMP fcmp ) ldap_tavl_find2( TAvlnode *root, const void *data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) { while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) {
cmp = cmp > 0; cmp = cmp > 0;
root = avl_child( root, cmp ); root = ldap_avl_child( root, cmp );
} }
return root; return root;
} }
void* void*
tavl_find( TAvlnode *root, const void* data, AVL_CMP fcmp ) ldap_tavl_find( TAvlnode *root, const void* data, AVL_CMP fcmp )
{ {
int cmp; int cmp;
while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) { while ( root != 0 && (cmp = (*fcmp)( data, root->avl_data )) != 0 ) {
cmp = cmp > 0; cmp = cmp > 0;
root = avl_child( root, cmp ); root = ldap_avl_child( root, cmp );
} }
return( root ? root->avl_data : 0 ); return( root ? root->avl_data : 0 );
@ -496,7 +496,7 @@ tavl_find( TAvlnode *root, const void* data, AVL_CMP fcmp )
/* Return the leftmost or rightmost node in the tree */ /* Return the leftmost or rightmost node in the tree */
TAvlnode * TAvlnode *
tavl_end( TAvlnode *root, int dir ) ldap_tavl_end( TAvlnode *root, int dir )
{ {
if ( root ) { if ( root ) {
while ( root->avl_bits[dir] == AVL_CHILD ) while ( root->avl_bits[dir] == AVL_CHILD )
@ -507,7 +507,7 @@ tavl_end( TAvlnode *root, int dir )
/* Return the next node in the given direction */ /* Return the next node in the given direction */
TAvlnode * TAvlnode *
tavl_next( TAvlnode *root, int dir ) ldap_tavl_next( TAvlnode *root, int dir )
{ {
if ( root ) { if ( root ) {
int c = root->avl_bits[dir]; int c = root->avl_bits[dir];

16
libraries/liblutil/testavl.c → libraries/libldap/testavl.c
View file

@ -37,7 +37,7 @@
#define AVL_INTERNAL #define AVL_INTERNAL
#define AVL_NONREENTRANT #define AVL_NONREENTRANT
#include "avl.h" #include "ldap_avl.h"
static void ravl_print LDAP_P(( Avlnode *root, int depth )); static void ravl_print LDAP_P(( Avlnode *root, int depth ));
static void myprint LDAP_P(( Avlnode *root )); static void myprint LDAP_P(( Avlnode *root ));
@ -55,7 +55,7 @@ main( int argc, char **argv )
while ( fgets( command, sizeof( command ), stdin ) != NULL ) { while ( fgets( command, sizeof( command ), stdin ) != NULL ) {
switch( *command ) { switch( *command ) {
case 'n': /* new tree */ case 'n': /* new tree */
( void ) avl_free( tree, free ); ( void ) ldap_avl_free( tree, free );
tree = NULL; tree = NULL;
break; break;
case 'p': /* print */ case 'p': /* print */
@ -64,9 +64,9 @@ main( int argc, char **argv )
case 't': /* traverse with first, next */ case 't': /* traverse with first, next */
#ifdef AVL_NONREENTRANT #ifdef AVL_NONREENTRANT
printf( "***\n" ); printf( "***\n" );
for ( p = (char * ) avl_getfirst( tree ); for ( p = (char * ) ldap_avl_getfirst( tree );
p != NULL; p != NULL;
p = (char *) avl_getnext()) p = (char *) ldap_avl_getnext())
printf( "%s\n", p ); printf( "%s\n", p );
printf( "***\n" ); printf( "***\n" );
#else #else
@ -78,7 +78,7 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( (p = (char *) avl_find( tree, name, avl_strcmp )) if ( (p = (char *) ldap_avl_find( tree, name, avl_strcmp ))
== NULL ) == NULL )
printf( "Not found.\n\n" ); printf( "Not found.\n\n" );
else else
@ -89,8 +89,8 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( avl_insert( &tree, strdup( name ), avl_strcmp, if ( ldap_avl_insert( &tree, strdup( name ), avl_strcmp,
avl_dup_error ) != 0 ) ldap_avl_dup_error ) != 0 )
printf( "\nNot inserted!\n" ); printf( "\nNot inserted!\n" );
break; break;
case 'd': /* delete */ case 'd': /* delete */
@ -98,7 +98,7 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( avl_delete( &tree, name, avl_strcmp ) == NULL ) if ( ldap_avl_delete( &tree, name, avl_strcmp ) == NULL )
printf( "\nNot found!\n" ); printf( "\nNot found!\n" );
break; break;
case 'q': /* quit */ case 'q': /* quit */

16
libraries/liblutil/testtavl.c → libraries/libldap/testtavl.c
View file

@ -37,7 +37,7 @@
#include <ac/string.h> #include <ac/string.h>
#define AVL_INTERNAL #define AVL_INTERNAL
#include "avl.h" #include "ldap_avl.h"
static void ravl_print LDAP_P(( TAvlnode *root, int depth, int thread )); static void ravl_print LDAP_P(( TAvlnode *root, int depth, int thread ));
static void myprint LDAP_P(( TAvlnode *root )); static void myprint LDAP_P(( TAvlnode *root ));
@ -55,7 +55,7 @@ main( int argc, char **argv )
while ( fgets( command, sizeof( command ), stdin ) != NULL ) { while ( fgets( command, sizeof( command ), stdin ) != NULL ) {
switch( *command ) { switch( *command ) {
case 'n': /* new tree */ case 'n': /* new tree */
( void ) tavl_free( tree, free ); ( void ) ldap_tavl_free( tree, free );
tree = NULL; tree = NULL;
break; break;
case 'p': /* print */ case 'p': /* print */
@ -63,9 +63,9 @@ main( int argc, char **argv )
break; break;
case 't': /* traverse with first, next */ case 't': /* traverse with first, next */
printf( "***\n" ); printf( "***\n" );
for ( n = tavl_end( tree, TAVL_DIR_LEFT ); for ( n = ldap_tavl_end( tree, TAVL_DIR_LEFT );
n != NULL; n != NULL;
n = tavl_next( n, TAVL_DIR_RIGHT )) n = ldap_tavl_next( n, TAVL_DIR_RIGHT ))
printf( "%s\n", n->avl_data ); printf( "%s\n", n->avl_data );
printf( "***\n" ); printf( "***\n" );
break; break;
@ -74,7 +74,7 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( (p = (char *) tavl_find( tree, name, avl_strcmp )) if ( (p = (char *) ldap_tavl_find( tree, name, avl_strcmp ))
== NULL ) == NULL )
printf( "Not found.\n\n" ); printf( "Not found.\n\n" );
else else
@ -85,8 +85,8 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( tavl_insert( &tree, strdup( name ), avl_strcmp, if ( ldap_tavl_insert( &tree, strdup( name ), avl_strcmp,
avl_dup_error ) != 0 ) ldap_avl_dup_error ) != 0 )
printf( "\nNot inserted!\n" ); printf( "\nNot inserted!\n" );
break; break;
case 'd': /* delete */ case 'd': /* delete */
@ -94,7 +94,7 @@ main( int argc, char **argv )
if ( fgets( name, sizeof( name ), stdin ) == NULL ) if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS ); exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0'; name[ strlen( name ) - 1 ] = '\0';
if ( tavl_delete( &tree, name, avl_strcmp ) == NULL ) if ( ldap_tavl_delete( &tree, name, avl_strcmp ) == NULL )
printf( "\nNot found!\n" ); printf( "\nNot found!\n" );
break; break;
case 'q': /* quit */ case 'q': /* quit */

10
libraries/liblutil/Makefile.in
View file

@ -14,7 +14,6 @@
## <http://www.OpenLDAP.org/license.html>. ## <http://www.OpenLDAP.org/license.html>.
LIBRARY = liblutil.a LIBRARY = liblutil.a
PROGRAM = testavl
LDAP_INCDIR= ../../include LDAP_INCDIR= ../../include
LDAP_LIBDIR= ../../libraries LDAP_LIBDIR= ../../libraries
@ -29,23 +28,14 @@ XLIBS = $(LIBRARY) $(LDAP_LIBLBER_LA)
SRCS = base64.c entropy.c sasl.c signal.c hash.c passfile.c \ SRCS = base64.c entropy.c sasl.c signal.c hash.c passfile.c \
md5.c passwd.c sha1.c getpass.c lockf.c utils.c uuid.c sockpair.c \ md5.c passwd.c sha1.c getpass.c lockf.c utils.c uuid.c sockpair.c \
avl.c tavl.c \
testavl.c \
meter.c \ meter.c \
@LIBSRCS@ $(@PLAT@_SRCS) @LIBSRCS@ $(@PLAT@_SRCS)
OBJS = base64.o entropy.o sasl.o signal.o hash.o passfile.o \ OBJS = base64.o entropy.o sasl.o signal.o hash.o passfile.o \
md5.o passwd.o sha1.o getpass.o lockf.o utils.o uuid.o sockpair.o \ md5.o passwd.o sha1.o getpass.o lockf.o utils.o uuid.o sockpair.o \
avl.o tavl.o \
meter.o \ meter.o \
@LIBOBJS@ $(@PLAT@_OBJS) @LIBOBJS@ $(@PLAT@_OBJS)
testavl: $(XLIBS) testavl.o
$(LTLINK) -o $@ testavl.o $(LIBS)
testtavl: $(XLIBS) testtavl.o
$(LTLINK) -o $@ testtavl.o $(LIBS)
# These rules are for a Mingw32 build, specifically. # These rules are for a Mingw32 build, specifically.
# It's ok for them to be here because the clean rule is harmless, and # It's ok for them to be here because the clean rule is harmless, and
# slapdmsg.res won't get built unless it's declared in OBJS. # slapdmsg.res won't get built unless it's declared in OBJS.

4
libraries/librewrite/config.c
View file

@ -351,7 +351,7 @@ rewrite_builtin_map_insert(
/* /*
* May need a mutex? * May need a mutex?
*/ */
return avl_insert( &info->li_maps, ( caddr_t )map, return ldap_avl_insert( &info->li_maps, ( caddr_t )map,
rewrite_builtin_map_cmp, rewrite_builtin_map_cmp,
rewrite_builtin_map_dup ); rewrite_builtin_map_dup );
} }
@ -372,7 +372,7 @@ rewrite_builtin_map_find(
tmp.lb_name = ( char * )name; tmp.lb_name = ( char * )name;
return ( struct rewrite_builtin_map * )avl_find( info->li_maps, return ( struct rewrite_builtin_map * )ldap_avl_find( info->li_maps,
( caddr_t )&tmp, rewrite_builtin_map_cmp ); ( caddr_t )&tmp, rewrite_builtin_map_cmp );
} }

4
libraries/librewrite/context.c
View file

@ -85,7 +85,7 @@ rewrite_context_find(
* Fetches the required rewrite context * Fetches the required rewrite context
*/ */
c.lc_name = (char *)rewriteContext; c.lc_name = (char *)rewriteContext;
context = (struct rewrite_context *)avl_find( info->li_context, context = (struct rewrite_context *)ldap_avl_find( info->li_context,
(caddr_t)&c, rewrite_context_cmp ); (caddr_t)&c, rewrite_context_cmp );
if ( context == NULL ) { if ( context == NULL ) {
return NULL; return NULL;
@ -144,7 +144,7 @@ rewrite_context_create(
/* /*
* Add context to tree * Add context to tree
*/ */
rc = avl_insert( &info->li_context, (caddr_t)context, rc = ldap_avl_insert( &info->li_context, (caddr_t)context,
rewrite_context_cmp, rewrite_context_dup ); rewrite_context_cmp, rewrite_context_dup );
if ( rc == -1 ) { if ( rc == -1 ) {
free( context->lc_rule ); free( context->lc_rule );

8
libraries/librewrite/info.c
View file

@ -81,13 +81,13 @@ rewrite_info_init(
#ifdef USE_REWRITE_LDAP_PVT_THREADS #ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( ldap_pvt_thread_rdwr_init( &info->li_cookies_mutex ) ) { if ( ldap_pvt_thread_rdwr_init( &info->li_cookies_mutex ) ) {
avl_free( info->li_context, rewrite_context_free ); ldap_avl_free( info->li_context, rewrite_context_free );
free( info ); free( info );
return NULL; return NULL;
} }
if ( ldap_pvt_thread_rdwr_init( &info->li_params_mutex ) ) { if ( ldap_pvt_thread_rdwr_init( &info->li_params_mutex ) ) {
ldap_pvt_thread_rdwr_destroy( &info->li_cookies_mutex ); ldap_pvt_thread_rdwr_destroy( &info->li_cookies_mutex );
avl_free( info->li_context, rewrite_context_free ); ldap_avl_free( info->li_context, rewrite_context_free );
free( info ); free( info );
return NULL; return NULL;
} }
@ -112,12 +112,12 @@ rewrite_info_delete(
info = *pinfo; info = *pinfo;
if ( info->li_context ) { if ( info->li_context ) {
avl_free( info->li_context, rewrite_context_free ); ldap_avl_free( info->li_context, rewrite_context_free );
} }
info->li_context = NULL; info->li_context = NULL;
if ( info->li_maps ) { if ( info->li_maps ) {
avl_free( info->li_maps, rewrite_builtin_map_free ); ldap_avl_free( info->li_maps, rewrite_builtin_map_free );
} }
info->li_maps = NULL; info->li_maps = NULL;

2
libraries/librewrite/params.c
View file

@ -135,7 +135,7 @@ rewrite_param_destroy(
ldap_pvt_thread_rdwr_wlock( &info->li_params_mutex ); ldap_pvt_thread_rdwr_wlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */ #endif /* USE_REWRITE_LDAP_PVT_THREADS */
avl_free( info->li_params, rewrite_param_free ); ldap_avl_free( info->li_params, rewrite_param_free );
info->li_params = NULL; info->li_params = NULL;
#ifdef USE_REWRITE_LDAP_PVT_THREADS #ifdef USE_REWRITE_LDAP_PVT_THREADS

2
libraries/librewrite/rewrite-int.h
View file

@ -36,7 +36,7 @@
#define LDAP_DEFINE_LDAP_DEBUG #define LDAP_DEFINE_LDAP_DEBUG
#include <ldap_log.h> #include <ldap_log.h>
#include <lutil.h> #include <lutil.h>
#include <avl.h> #include <ldap_avl.h>
#include <rewrite.h> #include <rewrite.h>

10
libraries/librewrite/session.c
View file

@ -88,7 +88,7 @@ rewrite_session_init(
#endif /* USE_REWRITE_LDAP_PVT_THREADS */ #endif /* USE_REWRITE_LDAP_PVT_THREADS */
tmp.ls_cookie = ( void * )cookie; tmp.ls_cookie = ( void * )cookie;
session = ( struct rewrite_session * )avl_find( info->li_cookies, session = ( struct rewrite_session * )ldap_avl_find( info->li_cookies,
( caddr_t )&tmp, rewrite_cookie_cmp ); ( caddr_t )&tmp, rewrite_cookie_cmp );
if ( session ) { if ( session ) {
session->ls_count++; session->ls_count++;
@ -122,7 +122,7 @@ rewrite_session_init(
} }
#endif /* USE_REWRITE_LDAP_PVT_THREADS */ #endif /* USE_REWRITE_LDAP_PVT_THREADS */
rc = avl_insert( &info->li_cookies, ( caddr_t )session, rc = ldap_avl_insert( &info->li_cookies, ( caddr_t )session,
rewrite_cookie_cmp, rewrite_cookie_dup ); rewrite_cookie_cmp, rewrite_cookie_dup );
info->li_num_cookies++; info->li_num_cookies++;
@ -161,7 +161,7 @@ rewrite_session_find(
#ifdef USE_REWRITE_LDAP_PVT_THREADS #ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_rlock( &info->li_cookies_mutex ); ldap_pvt_thread_rdwr_rlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */ #endif /* USE_REWRITE_LDAP_PVT_THREADS */
session = ( struct rewrite_session * )avl_find( info->li_cookies, session = ( struct rewrite_session * )ldap_avl_find( info->li_cookies,
( caddr_t )&tmp, rewrite_cookie_cmp ); ( caddr_t )&tmp, rewrite_cookie_cmp );
#ifdef USE_REWRITE_LDAP_PVT_THREADS #ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( session ) { if ( session ) {
@ -376,7 +376,7 @@ rewrite_session_delete(
* There is nothing to delete in the return value * There is nothing to delete in the return value
*/ */
tmp.ls_cookie = ( void * )cookie; tmp.ls_cookie = ( void * )cookie;
avl_delete( &info->li_cookies, ( caddr_t )&tmp, rewrite_cookie_cmp ); ldap_avl_delete( &info->li_cookies, ( caddr_t )&tmp, rewrite_cookie_cmp );
free( session ); free( session );
@ -407,7 +407,7 @@ rewrite_session_destroy(
* Should call per-session destruction routine ... * Should call per-session destruction routine ...
*/ */
count = avl_free( info->li_cookies, rewrite_session_free ); count = ldap_avl_free( info->li_cookies, rewrite_session_free );
info->li_cookies = NULL; info->li_cookies = NULL;
#if 0 #if 0

8
libraries/librewrite/var.c
View file

@ -94,7 +94,7 @@ rewrite_var_delete(
Avlnode *tree Avlnode *tree
) )
{ {
avl_free( tree, rewrite_var_free ); ldap_avl_free( tree, rewrite_var_free );
return REWRITE_SUCCESS; return REWRITE_SUCCESS;
} }
@ -112,7 +112,7 @@ rewrite_var_find(
assert( name != NULL ); assert( name != NULL );
var.lv_name = ( char * )name; var.lv_name = ( char * )name;
return ( struct rewrite_var * )avl_find( tree, return ( struct rewrite_var * )ldap_avl_find( tree,
( caddr_t )&var, rewrite_var_cmp ); ( caddr_t )&var, rewrite_var_cmp );
} }
@ -223,12 +223,12 @@ rewrite_var_insert_f(
var->lv_value.bv_val = (char *)value; var->lv_value.bv_val = (char *)value;
} }
var->lv_value.bv_len = strlen( value ); var->lv_value.bv_len = strlen( value );
rc = avl_insert( tree, ( caddr_t )var, rc = ldap_avl_insert( tree, ( caddr_t )var,
rewrite_var_cmp, rewrite_var_dup ); rewrite_var_cmp, rewrite_var_dup );
cleanup:; cleanup:;
if ( rc != 0 && var ) { if ( rc != 0 && var ) {
avl_delete( tree, ( caddr_t )var, rewrite_var_cmp ); ldap_avl_delete( tree, ( caddr_t )var, rewrite_var_cmp );
rewrite_var_free( var ); rewrite_var_free( var );
var = NULL; var = NULL;
} }

40
servers/lloadd/bind.c
View file

@ -207,7 +207,7 @@ request_bind( LloadConnection *client, LloadOperation *op )
client->c_connid, pin ); client->c_connid, pin );
pinned_op = pinned_op =
tavl_delete( &client->c_ops, &needle, operation_client_cmp ); ldap_tavl_delete( &client->c_ops, &needle, operation_client_cmp );
if ( pinned_op ) { if ( pinned_op ) {
assert( op->o_tag == pinned_op->o_tag ); assert( op->o_tag == pinned_op->o_tag );
@ -225,12 +225,12 @@ request_bind( LloadConnection *client, LloadOperation *op )
/* No one has seen this operation yet, plant the pin back in its stead */ /* No one has seen this operation yet, plant the pin back in its stead */
client->c_n_ops_executing--; client->c_n_ops_executing--;
op->o_res = LLOAD_OP_COMPLETED; op->o_res = LLOAD_OP_COMPLETED;
tavl_delete( &client->c_ops, op, operation_client_cmp ); ldap_tavl_delete( &client->c_ops, op, operation_client_cmp );
op->o_client = NULL; op->o_client = NULL;
assert( op->o_upstream == NULL ); assert( op->o_upstream == NULL );
rc = tavl_insert( &client->c_ops, pinned_op, operation_client_cmp, rc = ldap_tavl_insert( &client->c_ops, pinned_op, operation_client_cmp,
avl_dup_error ); ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
/* No one has seen this operation yet */ /* No one has seen this operation yet */
@ -244,7 +244,7 @@ request_bind( LloadConnection *client, LloadOperation *op )
} }
} }
tavl_delete( &client->c_ops, op, operation_client_cmp ); ldap_tavl_delete( &client->c_ops, op, operation_client_cmp );
client->c_n_ops_executing--; client->c_n_ops_executing--;
client_reset( client ); client_reset( client );
@ -326,7 +326,7 @@ request_bind( LloadConnection *client, LloadOperation *op )
goto fail; goto fail;
} }
rc = tavl_insert( &client->c_ops, op, operation_client_cmp, avl_dup_error ); rc = ldap_tavl_insert( &client->c_ops, op, operation_client_cmp, ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
client->c_n_ops_executing++; client->c_n_ops_executing++;
CONNECTION_UNLOCK(client); CONNECTION_UNLOCK(client);
@ -413,7 +413,7 @@ request_bind( LloadConnection *client, LloadOperation *op )
} }
if ( pin ) { if ( pin ) {
tavl_delete( &upstream->c_ops, op, operation_upstream_cmp ); ldap_tavl_delete( &upstream->c_ops, op, operation_upstream_cmp );
if ( tag == LDAP_AUTH_SIMPLE ) { if ( tag == LDAP_AUTH_SIMPLE ) {
pin = op->o_pin_id = 0; pin = op->o_pin_id = 0;
} }
@ -468,8 +468,8 @@ request_bind( LloadConnection *client, LloadOperation *op )
"added bind from client connid=%lu to upstream connid=%lu " "added bind from client connid=%lu to upstream connid=%lu "
"as msgid=%d\n", "as msgid=%d\n",
op->o_client_connid, op->o_upstream_connid, op->o_upstream_msgid ); op->o_client_connid, op->o_upstream_connid, op->o_upstream_msgid );
if ( tavl_insert( &upstream->c_ops, op, operation_upstream_cmp, if ( ldap_tavl_insert( &upstream->c_ops, op, operation_upstream_cmp,
avl_dup_error ) ) { ldap_avl_dup_error ) ) {
assert(0); assert(0);
} }
upstream->c_state = LLOAD_C_BINDING; upstream->c_state = LLOAD_C_BINDING;
@ -527,7 +527,7 @@ finish_sasl_bind(
int rc; int rc;
CONNECTION_ASSERT_LOCKED(upstream); CONNECTION_ASSERT_LOCKED(upstream);
removed = tavl_delete( &upstream->c_ops, op, operation_upstream_cmp ); removed = ldap_tavl_delete( &upstream->c_ops, op, operation_upstream_cmp );
if ( !removed ) { if ( !removed ) {
assert( upstream->c_state != LLOAD_C_BINDING ); assert( upstream->c_state != LLOAD_C_BINDING );
/* FIXME: has client replaced this bind since? */ /* FIXME: has client replaced this bind since? */
@ -563,8 +563,8 @@ finish_sasl_bind(
op->o_ber = ber; op->o_ber = ber;
/* Could we have been unlinked in the meantime? */ /* Could we have been unlinked in the meantime? */
rc = tavl_insert( rc = ldap_tavl_insert(
&upstream->c_ops, op, operation_upstream_cmp, avl_dup_error ); &upstream->c_ops, op, operation_upstream_cmp, ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
CONNECTION_UNLOCK(upstream); CONNECTION_UNLOCK(upstream);
@ -623,7 +623,7 @@ handle_bind_response(
} }
CONNECTION_LOCK(upstream); CONNECTION_LOCK(upstream);
if ( !tavl_find( upstream->c_ops, op, operation_upstream_cmp ) ) { if ( !ldap_tavl_find( upstream->c_ops, op, operation_upstream_cmp ) ) {
/* /*
* operation might not be found because: * operation might not be found because:
* - it has timed out (only happens when debugging/hung/...) * - it has timed out (only happens when debugging/hung/...)
@ -658,10 +658,10 @@ handle_bind_response(
op->o_pin_id = 0; op->o_pin_id = 0;
} else if ( result == LDAP_SASL_BIND_IN_PROGRESS ) { } else if ( result == LDAP_SASL_BIND_IN_PROGRESS ) {
tavl_delete( &upstream->c_ops, op, operation_upstream_cmp ); ldap_tavl_delete( &upstream->c_ops, op, operation_upstream_cmp );
op->o_upstream_msgid = 0; op->o_upstream_msgid = 0;
rc = tavl_insert( rc = ldap_tavl_insert(
&upstream->c_ops, op, operation_upstream_cmp, avl_dup_error ); &upstream->c_ops, op, operation_upstream_cmp, ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
} else { } else {
int sasl_finished = 0; int sasl_finished = 0;
@ -687,7 +687,7 @@ handle_bind_response(
} }
CONNECTION_LOCK(client); CONNECTION_LOCK(client);
removed = tavl_delete( &client->c_ops, op, operation_client_cmp ); removed = ldap_tavl_delete( &client->c_ops, op, operation_client_cmp );
assert( !removed || op == removed ); assert( !removed || op == removed );
if ( client->c_state == LLOAD_C_BINDING ) { if ( client->c_state == LLOAD_C_BINDING ) {
@ -696,8 +696,8 @@ handle_bind_response(
case LDAP_SASL_BIND_IN_PROGRESS: case LDAP_SASL_BIND_IN_PROGRESS:
op->o_saved_msgid = op->o_client_msgid; op->o_saved_msgid = op->o_client_msgid;
op->o_client_msgid = 0; op->o_client_msgid = 0;
rc = tavl_insert( &client->c_ops, op, operation_client_cmp, rc = ldap_tavl_insert( &client->c_ops, op, operation_client_cmp,
avl_dup_error ); ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
break; break;
case LDAP_SUCCESS: case LDAP_SUCCESS:
@ -813,7 +813,7 @@ handle_whoami_response(
} }
} }
removed = tavl_delete( &client->c_ops, op, operation_client_cmp ); removed = ldap_tavl_delete( &client->c_ops, op, operation_client_cmp );
assert( !removed || op == removed ); assert( !removed || op == removed );
op->o_pin_id = 0; op->o_pin_id = 0;
if ( removed ) { if ( removed ) {

8
servers/lloadd/client.c
View file

@ -51,7 +51,7 @@ request_abandon( LloadConnection *c, LloadOperation *op )
} }
CONNECTION_LOCK(c); CONNECTION_LOCK(c);
request = tavl_find( c->c_ops, &needle, operation_client_cmp ); request = ldap_tavl_find( c->c_ops, &needle, operation_client_cmp );
if ( !request ) { if ( !request ) {
Debug( LDAP_DEBUG_STATS, "request_abandon: " Debug( LDAP_DEBUG_STATS, "request_abandon: "
"connid=%lu msgid=%d requests abandon of an operation " "connid=%lu msgid=%d requests abandon of an operation "
@ -152,8 +152,8 @@ request_process( LloadConnection *client, LloadOperation *op )
upstream->c_pendingber = output; upstream->c_pendingber = output;
op->o_upstream_msgid = msgid = upstream->c_next_msgid++; op->o_upstream_msgid = msgid = upstream->c_next_msgid++;
rc = tavl_insert( rc = ldap_tavl_insert(
&upstream->c_ops, op, operation_upstream_cmp, avl_dup_error ); &upstream->c_ops, op, operation_upstream_cmp, ldap_avl_dup_error );
CONNECTION_UNLOCK(upstream); CONNECTION_UNLOCK(upstream);
Debug( LDAP_DEBUG_TRACE, "request_process: " Debug( LDAP_DEBUG_TRACE, "request_process: "
@ -505,7 +505,7 @@ client_reset( LloadConnection *c )
CONNECTION_UNLOCK(c); CONNECTION_UNLOCK(c);
if ( root ) { if ( root ) {
freed = tavl_free( root, (AVL_FREE)operation_abandon ); freed = ldap_tavl_free( root, (AVL_FREE)operation_abandon );
Debug( LDAP_DEBUG_TRACE, "client_reset: " Debug( LDAP_DEBUG_TRACE, "client_reset: "
"dropped %ld operations\n", "dropped %ld operations\n",
freed ); freed );

2
servers/lloadd/connection.c
View file

@ -526,7 +526,7 @@ lload_connection_close( LloadConnection *c, void *arg )
c->c_state = LLOAD_C_CLOSING; c->c_state = LLOAD_C_CLOSING;
do { do {
TAvlnode *node = tavl_end( c->c_ops, TAVL_DIR_LEFT ); TAvlnode *node = ldap_tavl_end( c->c_ops, TAVL_DIR_LEFT );
op = node->avl_data; op = node->avl_data;
/* Close operations that would need client action to resolve, /* Close operations that would need client action to resolve,

8
servers/lloadd/extended.c
View file

@ -38,7 +38,7 @@ handle_starttls( LloadConnection *c, LloadOperation *op )
int rc = LDAP_SUCCESS; int rc = LDAP_SUCCESS;
CONNECTION_LOCK(c); CONNECTION_LOCK(c);
found = tavl_delete( &c->c_ops, op, operation_client_cmp ); found = ldap_tavl_delete( &c->c_ops, op, operation_client_cmp );
assert( op == found ); assert( op == found );
c->c_n_ops_executing--; c->c_n_ops_executing--;
@ -138,7 +138,7 @@ request_extended( LloadConnection *c, LloadOperation *op )
needle.oid = bv; needle.oid = bv;
handler = avl_find( lload_exop_handlers, &needle, exop_handler_cmp ); handler = ldap_avl_find( lload_exop_handlers, &needle, exop_handler_cmp );
if ( handler ) { if ( handler ) {
Debug( LDAP_DEBUG_TRACE, "request_extended: " Debug( LDAP_DEBUG_TRACE, "request_extended: "
"handling exop OID %.*s internally\n", "handling exop OID %.*s internally\n",
@ -174,8 +174,8 @@ lload_register_exop_handlers( struct lload_exop_handlers_t *handler )
Debug( LDAP_DEBUG_TRACE, "lload_register_exop_handlers: " Debug( LDAP_DEBUG_TRACE, "lload_register_exop_handlers: "
"registering handler for exop oid=%s\n", "registering handler for exop oid=%s\n",
handler->oid.bv_val ); handler->oid.bv_val );
if ( avl_insert( &lload_exop_handlers, handler, exop_handler_cmp, if ( ldap_avl_insert( &lload_exop_handlers, handler, exop_handler_cmp,
avl_dup_error ) ) { ldap_avl_dup_error ) ) {
Debug( LDAP_DEBUG_ANY, "lload_register_exop_handlers: " Debug( LDAP_DEBUG_ANY, "lload_register_exop_handlers: "
"failed to register handler for exop oid=%s\n", "failed to register handler for exop oid=%s\n",
handler->oid.bv_val ); handler->oid.bv_val );

2
servers/lloadd/lload.h
View file

@ -40,7 +40,7 @@
#include <ac/time.h> #include <ac/time.h>
#include <ac/param.h> #include <ac/param.h>
#include "avl.h" #include "ldap_avl.h"
#include "../servers/slapd/slap.h" #include "../servers/slapd/slap.h"
#include "../slapd/back-monitor/back-monitor.h" #include "../slapd/back-monitor/back-monitor.h"

2
servers/lloadd/main.c
View file

@ -903,7 +903,7 @@ stop:
if ( global_host ) ch_free( global_host ); if ( global_host ) ch_free( global_host );
/* kludge, get symbols referenced */ /* kludge, get symbols referenced */
tavl_free( NULL, NULL ); ldap_tavl_free( NULL, NULL );
MAIN_RETURN(rc); MAIN_RETURN(rc);
} }

22
servers/lloadd/operation.c
View file

@ -151,7 +151,7 @@ operation_init( LloadConnection *c, BerElement *ber )
} }
CONNECTION_ASSERT_LOCKED(c); CONNECTION_ASSERT_LOCKED(c);
rc = tavl_insert( &c->c_ops, op, operation_client_cmp, avl_dup_error ); rc = ldap_tavl_insert( &c->c_ops, op, operation_client_cmp, ldap_avl_dup_error );
if ( rc ) { if ( rc ) {
Debug( LDAP_DEBUG_PACKETS, "operation_init: " Debug( LDAP_DEBUG_PACKETS, "operation_init: "
"several operations with same msgid=%d in-flight " "several operations with same msgid=%d in-flight "
@ -167,7 +167,7 @@ operation_init( LloadConnection *c, BerElement *ber )
break; break;
} }
if ( rc ) { if ( rc ) {
tavl_delete( &c->c_ops, op, operation_client_cmp ); ldap_tavl_delete( &c->c_ops, op, operation_client_cmp );
goto fail; goto fail;
} }
@ -269,7 +269,7 @@ operation_unlink_client( LloadOperation *op, LloadConnection *client )
op, op->o_client_msgid, op->o_client_connid ); op, op->o_client_msgid, op->o_client_connid );
CONNECTION_LOCK(client); CONNECTION_LOCK(client);
if ( (removed = tavl_delete( if ( (removed = ldap_tavl_delete(
&client->c_ops, op, operation_client_cmp )) ) { &client->c_ops, op, operation_client_cmp )) ) {
result = LLOAD_OP_DETACHING_CLIENT; result = LLOAD_OP_DETACHING_CLIENT;
@ -312,7 +312,7 @@ operation_unlink_upstream( LloadOperation *op, LloadConnection *upstream )
op, op->o_upstream_msgid, op->o_upstream_connid ); op, op->o_upstream_msgid, op->o_upstream_connid );
CONNECTION_LOCK(upstream); CONNECTION_LOCK(upstream);
if ( (removed = tavl_delete( if ( (removed = ldap_tavl_delete(
&upstream->c_ops, op, operation_upstream_cmp )) ) { &upstream->c_ops, op, operation_upstream_cmp )) ) {
result |= LLOAD_OP_DETACHING_UPSTREAM; result |= LLOAD_OP_DETACHING_UPSTREAM;
@ -525,13 +525,13 @@ connection_timeout( LloadConnection *upstream, void *arg )
int rc, nops = 0; int rc, nops = 0;
CONNECTION_LOCK(upstream); CONNECTION_LOCK(upstream);
for ( node = tavl_end( upstream->c_ops, TAVL_DIR_LEFT ); node && for ( node = ldap_tavl_end( upstream->c_ops, TAVL_DIR_LEFT ); node &&
((LloadOperation *)node->avl_data)->o_start < ((LloadOperation *)node->avl_data)->o_start <
threshold; /* shortcut */ threshold; /* shortcut */
node = next ) { node = next ) {
LloadOperation *found_op; LloadOperation *found_op;
next = tavl_next( node, TAVL_DIR_RIGHT ); next = ldap_tavl_next( node, TAVL_DIR_RIGHT );
op = node->avl_data; op = node->avl_data;
/* Have we received another response since? */ /* Have we received another response since? */
@ -540,7 +540,7 @@ connection_timeout( LloadConnection *upstream, void *arg )
} }
op->o_res = LLOAD_OP_FAILED; op->o_res = LLOAD_OP_FAILED;
found_op = tavl_delete( &upstream->c_ops, op, operation_upstream_cmp ); found_op = ldap_tavl_delete( &upstream->c_ops, op, operation_upstream_cmp );
assert( op == found_op ); assert( op == found_op );
if ( upstream->c_state == LLOAD_C_BINDING ) { if ( upstream->c_state == LLOAD_C_BINDING ) {
@ -552,7 +552,7 @@ connection_timeout( LloadConnection *upstream, void *arg )
} }
} }
rc = tavl_insert( &ops, op, operation_upstream_cmp, avl_dup_error ); rc = ldap_tavl_insert( &ops, op, operation_upstream_cmp, ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
Debug( LDAP_DEBUG_STATS2, "connection_timeout: " Debug( LDAP_DEBUG_STATS2, "connection_timeout: "
@ -579,8 +579,8 @@ connection_timeout( LloadConnection *upstream, void *arg )
b->b_n_ops_executing -= nops; b->b_n_ops_executing -= nops;
checked_unlock( &b->b_mutex ); checked_unlock( &b->b_mutex );
for ( node = tavl_end( ops, TAVL_DIR_LEFT ); node; for ( node = ldap_tavl_end( ops, TAVL_DIR_LEFT ); node;
node = tavl_next( node, TAVL_DIR_RIGHT ) ) { node = ldap_tavl_next( node, TAVL_DIR_RIGHT ) ) {
op = node->avl_data; op = node->avl_data;
operation_send_reject( op, operation_send_reject( op,
@ -607,7 +607,7 @@ connection_timeout( LloadConnection *upstream, void *arg )
} }
/* just dispose of the AVL, most operations should already be gone */ /* just dispose of the AVL, most operations should already be gone */
tavl_free( ops, NULL ); ldap_tavl_free( ops, NULL );
return LDAP_SUCCESS; return LDAP_SUCCESS;
} }

4
servers/lloadd/upstream.c
View file

@ -183,7 +183,7 @@ handle_one_response( LloadConnection *c )
CONNECTION_LOCK(c); CONNECTION_LOCK(c);
if ( needle.o_upstream_msgid == 0 ) { if ( needle.o_upstream_msgid == 0 ) {
return handle_unsolicited( c, ber ); return handle_unsolicited( c, ber );
} else if ( !( op = tavl_find( } else if ( !( op = ldap_tavl_find(
c->c_ops, &needle, operation_upstream_cmp ) ) ) { c->c_ops, &needle, operation_upstream_cmp ) ) ) {
/* Already abandoned, do nothing */ /* Already abandoned, do nothing */
CONNECTION_UNLOCK(c); CONNECTION_UNLOCK(c);
@ -1008,7 +1008,7 @@ upstream_unlink( LloadConnection *c )
CONNECTION_UNLOCK(c); CONNECTION_UNLOCK(c);
freed = tavl_free( root, (AVL_FREE)operation_lost_upstream ); freed = ldap_tavl_free( root, (AVL_FREE)operation_lost_upstream );
assert( freed == executing ); assert( freed == executing );
/* /*

24
servers/slapd/at.c
View file

@ -123,18 +123,18 @@ at_bvfind( struct berval *name )
struct aindexrec *air; struct aindexrec *air;
if ( attr_cache ) { if ( attr_cache ) {
air = avl_find( attr_cache, name, attr_index_name_cmp ); air = ldap_avl_find( attr_cache, name, attr_index_name_cmp );
if ( air ) return air->air_at; if ( air ) return air->air_at;
} }
air = avl_find( attr_index, name, attr_index_name_cmp ); air = ldap_avl_find( attr_index, name, attr_index_name_cmp );
if ( air ) { if ( air ) {
if ( air->air_at->sat_flags & SLAP_AT_DELETED ) { if ( air->air_at->sat_flags & SLAP_AT_DELETED ) {
air = NULL; air = NULL;
} else if (( slapMode & SLAP_TOOL_MODE ) && at_oc_cache ) { } else if (( slapMode & SLAP_TOOL_MODE ) && at_oc_cache ) {
avl_insert( &attr_cache, (caddr_t) air, ldap_avl_insert( &attr_cache, (caddr_t) air,
attr_index_cmp, avl_dup_error ); attr_index_cmp, ldap_avl_dup_error );
} }
} }
@ -239,7 +239,7 @@ at_delete_names( AttributeType *at )
ber_str2bv( *names, 0, 0, &tmpair.air_name ); ber_str2bv( *names, 0, 0, &tmpair.air_name );
tmpair.air_at = at; tmpair.air_at = at;
air = (struct aindexrec *)avl_delete( &attr_index, air = (struct aindexrec *)ldap_avl_delete( &attr_index,
(caddr_t)&tmpair, attr_index_cmp ); (caddr_t)&tmpair, attr_index_cmp );
assert( air != NULL ); assert( air != NULL );
ldap_memfree( air ); ldap_memfree( air );
@ -325,7 +325,7 @@ at_destroy( void )
at_delete_names( a ); at_delete_names( a );
} }
avl_free(attr_index, at_destroy_one); ldap_avl_free(attr_index, at_destroy_one);
if ( slap_schema.si_at_undefined ) { if ( slap_schema.si_at_undefined ) {
ad_destroy(slap_schema.si_at_undefined->sat_ad); ad_destroy(slap_schema.si_at_undefined->sat_ad);
@ -451,7 +451,7 @@ at_insert(
air->air_at = sat; air->air_at = sat;
air_old = NULL; air_old = NULL;
if ( avl_insert( &attr_index, (caddr_t) air, if ( ldap_avl_insert( &attr_index, (caddr_t) air,
attr_index_cmp, at_dup_error ) ) attr_index_cmp, at_dup_error ) )
{ {
AttributeType *old_sat; AttributeType *old_sat;
@ -515,8 +515,8 @@ at_insert(
ch_calloc( 1, sizeof(struct aindexrec) ); ch_calloc( 1, sizeof(struct aindexrec) );
ber_str2bv( *names, 0, 0, &air->air_name ); ber_str2bv( *names, 0, 0, &air->air_name );
air->air_at = sat; air->air_at = sat;
if ( avl_insert( &attr_index, (caddr_t) air, if ( ldap_avl_insert( &attr_index, (caddr_t) air,
attr_index_cmp, avl_dup_error ) ) attr_index_cmp, ldap_avl_dup_error ) )
{ {
AttributeType *old_sat; AttributeType *old_sat;
int rc; int rc;
@ -535,7 +535,7 @@ at_insert(
names--; names--;
ber_str2bv( *names, 0, 0, &tmpair.air_name ); ber_str2bv( *names, 0, 0, &tmpair.air_name );
tmpair.air_at = sat; tmpair.air_at = sat;
air = (struct aindexrec *)avl_delete( &attr_index, air = (struct aindexrec *)ldap_avl_delete( &attr_index,
(caddr_t)&tmpair, attr_index_cmp ); (caddr_t)&tmpair, attr_index_cmp );
assert( air != NULL ); assert( air != NULL );
ldap_memfree( air ); ldap_memfree( air );
@ -546,7 +546,7 @@ at_insert(
ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name ); ber_str2bv( sat->sat_oid, 0, 0, &tmpair.air_name );
tmpair.air_at = sat; tmpair.air_at = sat;
air = (struct aindexrec *)avl_delete( &attr_index, air = (struct aindexrec *)ldap_avl_delete( &attr_index,
(caddr_t)&tmpair, attr_index_cmp ); (caddr_t)&tmpair, attr_index_cmp );
assert( air != NULL ); assert( air != NULL );
ldap_memfree( air ); ldap_memfree( air );
@ -973,7 +973,7 @@ static void
at_index_print( void ) at_index_print( void )
{ {
printf("Printing attribute type index:\n"); printf("Printing attribute type index:\n");
(void) avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER ); (void) ldap_avl_apply( attr_index, at_index_printnode, 0, -1, AVL_INORDER );
} }
#endif #endif
#endif #endif

8
servers/slapd/back-asyncmeta/dncache.c
View file

@ -101,7 +101,7 @@ asyncmeta_dncache_get_target(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = ( metadncacheentry_t * )avl_find( cache->tree, entry = ( metadncacheentry_t * )ldap_avl_find( cache->tree,
( caddr_t )&tmp_entry, asyncmeta_dncache_cmp ); ( caddr_t )&tmp_entry, asyncmeta_dncache_cmp );
if ( entry != NULL ) { if ( entry != NULL ) {
@ -157,7 +157,7 @@ asyncmeta_dncache_update_entry(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = ( metadncacheentry_t * )avl_find( cache->tree, entry = ( metadncacheentry_t * )ldap_avl_find( cache->tree,
( caddr_t )&tmp_entry, asyncmeta_dncache_cmp ); ( caddr_t )&tmp_entry, asyncmeta_dncache_cmp );
if ( entry != NULL ) { if ( entry != NULL ) {
@ -179,7 +179,7 @@ asyncmeta_dncache_update_entry(
entry->target = target; entry->target = target;
entry->lastupdated = curr_time; entry->lastupdated = curr_time;
err = avl_insert( &cache->tree, ( caddr_t )entry, err = ldap_avl_insert( &cache->tree, ( caddr_t )entry,
asyncmeta_dncache_cmp, asyncmeta_dncache_dup ); asyncmeta_dncache_cmp, asyncmeta_dncache_dup );
} }
@ -203,7 +203,7 @@ asyncmeta_dncache_delete_entry(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = avl_delete( &cache->tree, ( caddr_t )&tmp_entry, entry = ldap_avl_delete( &cache->tree, ( caddr_t )&tmp_entry,
asyncmeta_dncache_cmp ); asyncmeta_dncache_cmp );
ldap_pvt_thread_mutex_unlock( &cache->mutex ); ldap_pvt_thread_mutex_unlock( &cache->mutex );

2
servers/slapd/back-asyncmeta/init.c
View file

@ -432,7 +432,7 @@ asyncmeta_back_db_destroy(
ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );
if ( mi->mi_cache.tree ) { if ( mi->mi_cache.tree ) {
avl_free( mi->mi_cache.tree, asyncmeta_dncache_free ); ldap_avl_free( mi->mi_cache.tree, asyncmeta_dncache_free );
} }
ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex ); ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );

18
servers/slapd/back-ldap/bind.c
View file

@ -118,10 +118,10 @@ ldap_back_print_conntree( ldapinfo_t *li, char *msg )
fprintf( stderr, "\t(empty)\n" ); fprintf( stderr, "\t(empty)\n" );
} else { } else {
TAvlnode *edge = tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT ); TAvlnode *edge = ldap_tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
ldap_back_conn_print( (ldapconn_t *)edge->avl_data ); ldap_back_conn_print( (ldapconn_t *)edge->avl_data );
edge = tavl_next( edge, TAVL_DIR_RIGHT ); edge = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
} }
} }
@ -179,7 +179,7 @@ ldap_back_conn_delete( ldapinfo_t *li, ldapconn_t *lc )
if ( LDAP_BACK_CONN_CACHED( lc ) ) { if ( LDAP_BACK_CONN_CACHED( lc ) ) {
assert( !LDAP_BACK_CONN_TAINTED( lc ) ); assert( !LDAP_BACK_CONN_TAINTED( lc ) );
tmplc = tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc, tmplc = ldap_tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc,
ldap_back_conndnlc_cmp ); ldap_back_conndnlc_cmp );
assert( tmplc == lc ); assert( tmplc == lc );
LDAP_BACK_CONN_CACHED_CLEAR( lc ); LDAP_BACK_CONN_CACHED_CLEAR( lc );
@ -333,7 +333,7 @@ retry_lock:;
/* delete all cached connections with the current connection */ /* delete all cached connections with the current connection */
if ( LDAP_BACK_SINGLECONN( li ) ) { if ( LDAP_BACK_SINGLECONN( li ) ) {
while ( ( tmplc = tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc, ldap_back_conn_cmp ) ) != NULL ) while ( ( tmplc = ldap_tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)lc, ldap_back_conn_cmp ) ) != NULL )
{ {
assert( !LDAP_BACK_PCONN_ISPRIV( lc ) ); assert( !LDAP_BACK_PCONN_ISPRIV( lc ) );
Debug( LDAP_DEBUG_TRACE, Debug( LDAP_DEBUG_TRACE,
@ -361,7 +361,7 @@ retry_lock:;
if ( be_isroot_dn( op->o_bd, &op->o_req_ndn ) ) { if ( be_isroot_dn( op->o_bd, &op->o_req_ndn ) ) {
LDAP_BACK_PCONN_ROOTDN_SET( lc, op ); LDAP_BACK_PCONN_ROOTDN_SET( lc, op );
} }
lerr = tavl_insert( &li->li_conninfo.lai_tree, (caddr_t)lc, lerr = ldap_tavl_insert( &li->li_conninfo.lai_tree, (caddr_t)lc,
ldap_back_conndn_cmp, ldap_back_conndn_dup ); ldap_back_conndn_cmp, ldap_back_conndn_dup );
} }
@ -924,7 +924,7 @@ retry_lock:
} else { } else {
/* Searches for a ldapconn in the avl tree */ /* Searches for a ldapconn in the avl tree */
lc = (ldapconn_t *)tavl_find( li->li_conninfo.lai_tree, lc = (ldapconn_t *)ldap_tavl_find( li->li_conninfo.lai_tree,
(caddr_t)&lc_curr, ldap_back_conndn_cmp ); (caddr_t)&lc_curr, ldap_back_conndn_cmp );
} }
@ -1070,7 +1070,7 @@ retry_lock:
rs->sr_err = 0; rs->sr_err = 0;
} else { } else {
rs->sr_err = tavl_insert( &li->li_conninfo.lai_tree, (caddr_t)lc, rs->sr_err = ldap_tavl_insert( &li->li_conninfo.lai_tree, (caddr_t)lc,
ldap_back_conndn_cmp, ldap_back_conndn_dup ); ldap_back_conndn_cmp, ldap_back_conndn_dup );
LDAP_BACK_CONN_CACHED_SET( lc ); LDAP_BACK_CONN_CACHED_SET( lc );
} }
@ -3111,9 +3111,9 @@ ldap_back_conn_prune( ldapinfo_t *li )
} }
} }
edge = tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapconn_t *lc = (ldapconn_t *)edge->avl_data; ldapconn_t *lc = (ldapconn_t *)edge->avl_data;
time_t conn_expires = ldap_back_conn_expire_time( li, lc ); time_t conn_expires = ldap_back_conn_expire_time( li, lc );

30
servers/slapd/back-ldap/chain.c
View file

@ -564,7 +564,7 @@ Document: RFC 4511
/* Searches for a ldapinfo in the avl tree */ /* Searches for a ldapinfo in the avl tree */
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
lip = (ldapinfo_t *)tavl_find( lc->lc_lai.lai_tree, lip = (ldapinfo_t *)ldap_tavl_find( lc->lc_lai.lai_tree,
(caddr_t)&li, ldap_chain_uri_cmp ); (caddr_t)&li, ldap_chain_uri_cmp );
ldap_pvt_thread_mutex_unlock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_unlock( &lc->lc_lai.lai_mutex );
@ -596,7 +596,7 @@ Document: RFC 4511
if ( LDAP_CHAIN_CACHE_URI( lc ) ) { if ( LDAP_CHAIN_CACHE_URI( lc ) ) {
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
if ( tavl_insert( &lc->lc_lai.lai_tree, if ( ldap_tavl_insert( &lc->lc_lai.lai_tree,
(caddr_t)lip, ldap_chain_uri_cmp, ldap_chain_uri_dup ) ) (caddr_t)lip, ldap_chain_uri_cmp, ldap_chain_uri_dup ) )
{ {
/* someone just inserted another; /* someone just inserted another;
@ -836,7 +836,7 @@ ldap_chain_search(
/* Searches for a ldapinfo in the avl tree */ /* Searches for a ldapinfo in the avl tree */
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
lip = (ldapinfo_t *)tavl_find( lc->lc_lai.lai_tree, lip = (ldapinfo_t *)ldap_tavl_find( lc->lc_lai.lai_tree,
(caddr_t)&li, ldap_chain_uri_cmp ); (caddr_t)&li, ldap_chain_uri_cmp );
ldap_pvt_thread_mutex_unlock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_unlock( &lc->lc_lai.lai_mutex );
@ -869,7 +869,7 @@ ldap_chain_search(
if ( LDAP_CHAIN_CACHE_URI( lc ) ) { if ( LDAP_CHAIN_CACHE_URI( lc ) ) {
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
if ( tavl_insert( &lc->lc_lai.lai_tree, if ( ldap_tavl_insert( &lc->lc_lai.lai_tree,
(caddr_t)lip, ldap_chain_uri_cmp, ldap_chain_uri_dup ) ) (caddr_t)lip, ldap_chain_uri_cmp, ldap_chain_uri_dup ) )
{ {
/* someone just inserted another; /* someone just inserted another;
@ -1408,7 +1408,7 @@ fail:
li->li_uri = ch_strdup( at->a_vals[ 0 ].bv_val ); li->li_uri = ch_strdup( at->a_vals[ 0 ].bv_val );
value_add_one( &li->li_bvuri, &at->a_vals[ 0 ] ); value_add_one( &li->li_bvuri, &at->a_vals[ 0 ] );
if ( tavl_insert( &lc->lc_lai.lai_tree, (caddr_t)li, if ( ldap_tavl_insert( &lc->lc_lai.lai_tree, (caddr_t)li,
ldap_chain_uri_cmp, ldap_chain_uri_dup ) ) ldap_chain_uri_cmp, ldap_chain_uri_dup ) )
{ {
Debug( LDAP_DEBUG_ANY, "slapd-chain: " Debug( LDAP_DEBUG_ANY, "slapd-chain: "
@ -1468,9 +1468,9 @@ chain_cfadd( Operation *op, SlapReply *rs, Entry *p, ConfigArgs *ca )
ldap_chain_cfadd_apply( lc->lc_common_li, op, rs, p, ca, count++ ); ldap_chain_cfadd_apply( lc->lc_common_li, op, rs, p, ca, count++ );
edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
ldap_chain_cfadd_apply( li, op, rs, p, ca, count++ ); ldap_chain_cfadd_apply( li, op, rs, p, ca, count++ );
edge = next; edge = next;
@ -1494,8 +1494,8 @@ chain_lddel( CfEntryInfo *ce, Operation *op )
ldapinfo_t *li = (ldapinfo_t *) ce->ce_be->be_private; ldapinfo_t *li = (ldapinfo_t *) ce->ce_be->be_private;
if ( li != lc->lc_common_li ) { if ( li != lc->lc_common_li ) {
if (! tavl_delete( &lc->lc_lai.lai_tree, li, ldap_chain_uri_cmp ) ) { if (! ldap_tavl_delete( &lc->lc_lai.lai_tree, li, ldap_chain_uri_cmp ) ) {
Debug( LDAP_DEBUG_ANY, "slapd-chain: avl_delete failed. " Debug( LDAP_DEBUG_ANY, "slapd-chain: ldap_avl_delete failed. "
"\"%s\" not found.\n", li->li_uri ); "\"%s\" not found.\n", li->li_uri );
return -1; return -1;
} }
@ -1903,7 +1903,7 @@ private_destroy:;
goto private_destroy; goto private_destroy;
} }
if ( tavl_insert( &lc->lc_lai.lai_tree, if ( ldap_tavl_insert( &lc->lc_lai.lai_tree,
(caddr_t)lc->lc_cfg_li, (caddr_t)lc->lc_cfg_li,
ldap_chain_uri_cmp, ldap_chain_uri_dup ) ) ldap_chain_uri_cmp, ldap_chain_uri_dup ) )
{ {
@ -1955,9 +1955,9 @@ ldap_chain_db_func(
} }
if ( lc->lc_lai.lai_tree != NULL ) { if ( lc->lc_lai.lai_tree != NULL ) {
TAvlnode *edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); TAvlnode *edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
db.be_private = (void *)li; db.be_private = (void *)li;
rc = func( &db, NULL ); rc = func( &db, NULL );
@ -2032,7 +2032,7 @@ ldap_chain_db_destroy(
rc = ldap_chain_db_func( be, db_destroy ); rc = ldap_chain_db_func( be, db_destroy );
if ( lc ) { if ( lc ) {
tavl_free( lc->lc_lai.lai_tree, NULL ); ldap_tavl_free( lc->lc_lai.lai_tree, NULL );
ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex );
ch_free( lc ); ch_free( lc );
} }
@ -2160,9 +2160,9 @@ ldap_chain_connection_destroy(
be->be_private = NULL; be->be_private = NULL;
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
be->be_private = (void *)li; be->be_private = (void *)li;
rc = lback->bi_connection_destroy( be, conn ); rc = lback->bi_connection_destroy( be, conn );

2
servers/slapd/back-ldap/config.c
View file

@ -1387,7 +1387,7 @@ ldap_back_cf_gen( ConfigArgs *c )
/* NOTE: don't worry about locking: if we got here, /* NOTE: don't worry about locking: if we got here,
* other threads are suspended. */ * other threads are suspended. */
if ( li->li_conninfo.lai_tree != NULL ) { if ( li->li_conninfo.lai_tree != NULL ) {
tavl_free( li->li_conninfo.lai_tree, ldap_back_conn_free ); ldap_tavl_free( li->li_conninfo.lai_tree, ldap_back_conn_free );
li->li_conninfo.lai_tree = NULL; li->li_conninfo.lai_tree = NULL;
} }

18
servers/slapd/back-ldap/distproc.c
View file

@ -432,7 +432,7 @@ distproc_ldadd( CfEntryInfo *p, Entry *e, ConfigArgs *ca )
if ( lc->lc_common_li == NULL ) { if ( lc->lc_common_li == NULL ) {
lc->lc_common_li = li; lc->lc_common_li = li;
} else if ( tavl_insert( &lc->lc_lai.lai_tree, (caddr_t)li, } else if ( ldap_tavl_insert( &lc->lc_lai.lai_tree, (caddr_t)li,
ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) ) ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) )
{ {
Debug( LDAP_DEBUG_ANY, "slapd-distproc: " Debug( LDAP_DEBUG_ANY, "slapd-distproc: "
@ -504,9 +504,9 @@ distproc_cfadd( Operation *op, SlapReply *rs, Entry *p, ConfigArgs *ca )
ldap_distproc_cfadd_apply( lc->lc_common_li, op, rs, p, ca, count++ ); ldap_distproc_cfadd_apply( lc->lc_common_li, op, rs, p, ca, count++ );
edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
ldap_distproc_cfadd_apply( li, op, rs, p, ca, count++ ); ldap_distproc_cfadd_apply( li, op, rs, p, ca, count++ );
edge = next; edge = next;
@ -680,7 +680,7 @@ private_destroy:;
goto private_destroy; goto private_destroy;
} }
if ( tavl_insert( &lc->lc_lai.lai_tree, if ( ldap_tavl_insert( &lc->lc_lai.lai_tree,
(caddr_t)lc->lc_cfg_li, (caddr_t)lc->lc_cfg_li,
ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) ) ldap_distproc_uri_cmp, ldap_distproc_uri_dup ) )
{ {
@ -732,9 +732,9 @@ ldap_distproc_db_func(
} }
if ( lc->lc_lai.lai_tree != NULL ) { if ( lc->lc_lai.lai_tree != NULL ) {
TAvlnode *edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); TAvlnode *edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
be->be_private = (void *)li; be->be_private = (void *)li;
rc = func( &db, NULL ); rc = func( &db, NULL );
@ -779,7 +779,7 @@ ldap_distproc_db_destroy(
rc = ldap_distproc_db_func( be, db_destroy ); rc = ldap_distproc_db_func( be, db_destroy );
if ( lc ) { if ( lc ) {
tavl_free( lc->lc_lai.lai_tree, NULL ); ldap_tavl_free( lc->lc_lai.lai_tree, NULL );
ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex );
ch_free( lc ); ch_free( lc );
} }
@ -863,9 +863,9 @@ ldap_distproc_connection_destroy(
be->be_private = NULL; be->be_private = NULL;
ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex ); ldap_pvt_thread_mutex_lock( &lc->lc_lai.lai_mutex );
edge = tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( lc->lc_lai.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapinfo_t *li = (ldapinfo_t *)edge->avl_data; ldapinfo_t *li = (ldapinfo_t *)edge->avl_data;
be->be_private = (void *)li; be->be_private = (void *)li;
rc = lback->bi_connection_destroy( be, conn ); rc = lback->bi_connection_destroy( be, conn );

2
servers/slapd/back-ldap/init.c
View file

@ -336,7 +336,7 @@ ldap_back_db_destroy( Backend *be, ConfigReply *cr )
li->li_idassert_authz = NULL; li->li_idassert_authz = NULL;
} }
if ( li->li_conninfo.lai_tree ) { if ( li->li_conninfo.lai_tree ) {
tavl_free( li->li_conninfo.lai_tree, ldap_back_conn_free ); ldap_tavl_free( li->li_conninfo.lai_tree, ldap_back_conn_free );
} }
for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) { for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
while ( !LDAP_TAILQ_EMPTY( &li->li_conn_priv[ i ].lic_priv ) ) { while ( !LDAP_TAILQ_EMPTY( &li->li_conn_priv[ i ].lic_priv ) ) {

4
servers/slapd/back-ldap/monitor.c
View file

@ -565,9 +565,9 @@ ldap_back_monitor_conn_create(
} }
} }
edge = tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT ); edge = ldap_tavl_end( li->li_conninfo.lai_tree, TAVL_DIR_LEFT );
while ( edge ) { while ( edge ) {
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
ldapconn_t *lc = (ldapconn_t *)edge->avl_data; ldapconn_t *lc = (ldapconn_t *)edge->avl_data;
ldap_back_monitor_conn_entry( lc, arg ); ldap_back_monitor_conn_entry( lc, arg );
edge = next; edge = next;

2
servers/slapd/back-ldap/unbind.c
View file

@ -51,7 +51,7 @@ ldap_back_conn_destroy(
#if LDAP_BACK_PRINT_CONNTREE > 0 #if LDAP_BACK_PRINT_CONNTREE > 0
ldap_back_print_conntree( li, ">>> ldap_back_conn_destroy" ); ldap_back_print_conntree( li, ">>> ldap_back_conn_destroy" );
#endif /* LDAP_BACK_PRINT_CONNTREE */ #endif /* LDAP_BACK_PRINT_CONNTREE */
while ( ( lc = tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)&lc_curr, ldap_back_conn_cmp ) ) != NULL ) while ( ( lc = ldap_tavl_delete( &li->li_conninfo.lai_tree, (caddr_t)&lc_curr, ldap_back_conn_cmp ) ) != NULL )
{ {
assert( !LDAP_BACK_PCONN_ISPRIV( lc ) ); assert( !LDAP_BACK_PCONN_ISPRIV( lc ) );
Debug( LDAP_DEBUG_TRACE, Debug( LDAP_DEBUG_TRACE,

8
servers/slapd/back-mdb/monitor.c
View file

@ -601,7 +601,7 @@ mdb_monitor_db_destroy( BackendDB *be )
/* TODO: free tree */ /* TODO: free tree */
ldap_pvt_thread_mutex_destroy( &mdb->mi_idx_mutex ); ldap_pvt_thread_mutex_destroy( &mdb->mi_idx_mutex );
avl_free( mdb->mi_idx, ch_free ); ldap_avl_free( mdb->mi_idx, ch_free );
#endif /* MDB_MONITOR_IDX */ #endif /* MDB_MONITOR_IDX */
return 0; return 0;
@ -690,14 +690,14 @@ mdb_monitor_idx_add(
ldap_pvt_thread_mutex_lock( &mdb->mi_idx_mutex ); ldap_pvt_thread_mutex_lock( &mdb->mi_idx_mutex );
idx = (monitor_idx_t *)avl_find( mdb->mi_idx, idx = (monitor_idx_t *)ldap_avl_find( mdb->mi_idx,
(caddr_t)&idx_dummy, monitor_idx_cmp ); (caddr_t)&idx_dummy, monitor_idx_cmp );
if ( idx == NULL ) { if ( idx == NULL ) {
idx = (monitor_idx_t *)ch_calloc( sizeof( monitor_idx_t ), 1 ); idx = (monitor_idx_t *)ch_calloc( sizeof( monitor_idx_t ), 1 );
idx->idx_ad = desc; idx->idx_ad = desc;
idx->idx_count[ key ] = 1; idx->idx_count[ key ] = 1;
switch ( avl_insert( &mdb->mi_idx, (caddr_t)idx, switch ( ldap_avl_insert( &mdb->mi_idx, (caddr_t)idx,
monitor_idx_cmp, monitor_idx_dup ) ) monitor_idx_cmp, monitor_idx_dup ) )
{ {
case 0: case 0:
@ -777,7 +777,7 @@ mdb_monitor_idx_entry_add(
ldap_pvt_thread_mutex_lock( &mdb->mi_idx_mutex ); ldap_pvt_thread_mutex_lock( &mdb->mi_idx_mutex );
avl_apply( mdb->mi_idx, mdb_monitor_idx_apply, ldap_avl_apply( mdb->mi_idx, mdb_monitor_idx_apply,
&vals, -1, AVL_INORDER ); &vals, -1, AVL_INORDER );
ldap_pvt_thread_mutex_unlock( &mdb->mi_idx_mutex ); ldap_pvt_thread_mutex_unlock( &mdb->mi_idx_mutex );

12
servers/slapd/back-mdb/tools.c
View file

@ -1370,12 +1370,12 @@ mdb_tool_idl_flush_db( MDB_txn *txn, AttrInfo *ai, AttrIxInfo *ax )
int rc; int rc;
mdb_cursor_open( txn, ai->ai_dbi, &mc ); mdb_cursor_open( txn, ai->ai_dbi, &mc );
root = tavl_end( ai->ai_root, TAVL_DIR_LEFT ); root = ldap_tavl_end( ai->ai_root, TAVL_DIR_LEFT );
do { do {
rc = mdb_tool_idl_flush_one( mc, ax, root->avl_data ); rc = mdb_tool_idl_flush_one( mc, ax, root->avl_data );
if ( rc != -1 ) if ( rc != -1 )
rc = 0; rc = 0;
} while ((root = tavl_next(root, TAVL_DIR_RIGHT))); } while ((root = ldap_tavl_next(root, TAVL_DIR_RIGHT)));
mdb_cursor_close( mc ); mdb_cursor_close( mc );
return rc; return rc;
@ -1391,7 +1391,7 @@ mdb_tool_idl_flush( BackendDB *be, MDB_txn *txn )
for ( i=0; i < mdb->mi_nattrs; i++ ) { for ( i=0; i < mdb->mi_nattrs; i++ ) {
if ( !mdb->mi_attrs[i]->ai_root ) continue; if ( !mdb->mi_attrs[i]->ai_root ) continue;
rc = mdb_tool_idl_flush_db( txn, mdb->mi_attrs[i], mdb_tool_axinfo[i % mdb_tool_threads] ); rc = mdb_tool_idl_flush_db( txn, mdb->mi_attrs[i], mdb_tool_axinfo[i % mdb_tool_threads] );
tavl_free(mdb->mi_attrs[i]->ai_root, NULL); ldap_tavl_free(mdb->mi_attrs[i]->ai_root, NULL);
mdb->mi_attrs[i]->ai_root = NULL; mdb->mi_attrs[i]->ai_root = NULL;
if ( rc ) if ( rc )
break; break;
@ -1416,7 +1416,7 @@ int mdb_tool_idl_add(
dbi = ai->ai_dbi; dbi = ai->ai_dbi;
for (i=0; keys[i].bv_val; i++) { for (i=0; keys[i].bv_val; i++) {
itmp.kstr = keys[i]; itmp.kstr = keys[i];
ic = tavl_find( ai->ai_root, &itmp, mdb_tool_idl_cmp ); ic = ldap_tavl_find( ai->ai_root, &itmp, mdb_tool_idl_cmp );
/* No entry yet, create one */ /* No entry yet, create one */
if ( !ic ) { if ( !ic ) {
@ -1438,8 +1438,8 @@ int mdb_tool_idl_add(
ic->count = 0; ic->count = 0;
ic->offset = 0; ic->offset = 0;
ic->flags = 0; ic->flags = 0;
tavl_insert( &ai->ai_root, ic, mdb_tool_idl_cmp, ldap_tavl_insert( &ai->ai_root, ic, mdb_tool_idl_cmp,
avl_dup_error ); ldap_avl_dup_error );
/* load existing key count here */ /* load existing key count here */
key.mv_size = keys[i].bv_len; key.mv_size = keys[i].bv_len;

4
servers/slapd/back-meta/bind.c
View file

@ -212,7 +212,7 @@ meta_back_bind( Operation *op, SlapReply *rs )
if ( LDAP_BACK_SINGLECONN( mi ) ) { if ( LDAP_BACK_SINGLECONN( mi ) ) {
metaconn_t *tmpmc; metaconn_t *tmpmc;
while ( ( tmpmc = tavl_delete( &mi->mi_conninfo.lai_tree, (caddr_t)mc, meta_back_conn_cmp ) ) != NULL ) while ( ( tmpmc = ldap_tavl_delete( &mi->mi_conninfo.lai_tree, (caddr_t)mc, meta_back_conn_cmp ) ) != NULL )
{ {
assert( !LDAP_BACK_PCONN_ISPRIV( mc ) ); assert( !LDAP_BACK_PCONN_ISPRIV( mc ) );
Debug( LDAP_DEBUG_TRACE, Debug( LDAP_DEBUG_TRACE,
@ -235,7 +235,7 @@ meta_back_bind( Operation *op, SlapReply *rs )
} }
ber_bvreplace( &mc->mc_local_ndn, &op->o_req_ndn ); ber_bvreplace( &mc->mc_local_ndn, &op->o_req_ndn );
lerr = tavl_insert( &mi->mi_conninfo.lai_tree, (caddr_t)mc, lerr = ldap_tavl_insert( &mi->mi_conninfo.lai_tree, (caddr_t)mc,
meta_back_conndn_cmp, meta_back_conndn_dup ); meta_back_conndn_cmp, meta_back_conndn_dup );
#if META_BACK_PRINT_CONNTREE > 0 #if META_BACK_PRINT_CONNTREE > 0
meta_back_print_conntree( mi, "<<< meta_back_bind" ); meta_back_print_conntree( mi, "<<< meta_back_bind" );

8
servers/slapd/back-meta/config.c
View file

@ -3073,8 +3073,8 @@ ldap_back_map_config(
} }
} }
if ( (src[ 0 ] != '\0' && avl_find( map->map, (caddr_t)&mapping[ 0 ], mapping_cmp ) != NULL) if ( (src[ 0 ] != '\0' && ldap_avl_find( map->map, (caddr_t)&mapping[ 0 ], mapping_cmp ) != NULL)
|| avl_find( map->remap, (caddr_t)&mapping[ 1 ], mapping_cmp ) != NULL) || ldap_avl_find( map->remap, (caddr_t)&mapping[ 1 ], mapping_cmp ) != NULL)
{ {
snprintf( c->cr_msg, sizeof( c->cr_msg ), snprintf( c->cr_msg, sizeof( c->cr_msg ),
"duplicate mapping found." ); "duplicate mapping found." );
@ -3083,10 +3083,10 @@ ldap_back_map_config(
} }
if ( src[ 0 ] != '\0' ) { if ( src[ 0 ] != '\0' ) {
avl_insert( &map->map, (caddr_t)&mapping[ 0 ], ldap_avl_insert( &map->map, (caddr_t)&mapping[ 0 ],
mapping_cmp, mapping_dup ); mapping_cmp, mapping_dup );
} }
avl_insert( &map->remap, (caddr_t)&mapping[ 1 ], ldap_avl_insert( &map->remap, (caddr_t)&mapping[ 1 ],
mapping_cmp, mapping_dup ); mapping_cmp, mapping_dup );
success_return:; success_return:;

12
servers/slapd/back-meta/conn.c
View file

@ -830,7 +830,7 @@ meta_back_retry(
} else { } else {
/* FIXME: check if in tree, for consistency? */ /* FIXME: check if in tree, for consistency? */
(void)tavl_delete( &mi->mi_conninfo.lai_tree, (void)ldap_tavl_delete( &mi->mi_conninfo.lai_tree,
( caddr_t )mc, meta_back_conndnmc_cmp ); ( caddr_t )mc, meta_back_conndnmc_cmp );
} }
LDAP_BACK_CONN_CACHED_CLEAR( mc ); LDAP_BACK_CONN_CACHED_CLEAR( mc );
@ -1155,7 +1155,7 @@ retry_lock:;
} else { } else {
mc = (metaconn_t *)tavl_find( mi->mi_conninfo.lai_tree, mc = (metaconn_t *)ldap_tavl_find( mi->mi_conninfo.lai_tree,
(caddr_t)&mc_curr, meta_back_conndn_cmp ); (caddr_t)&mc_curr, meta_back_conndn_cmp );
} }
@ -1200,7 +1200,7 @@ retry_lock:;
} }
} else { } else {
(void)tavl_delete( &mi->mi_conninfo.lai_tree, (void)ldap_tavl_delete( &mi->mi_conninfo.lai_tree,
(caddr_t)mc, meta_back_conndnmc_cmp ); (caddr_t)mc, meta_back_conndnmc_cmp );
} }
@ -1420,7 +1420,7 @@ retry_lock:;
if ( !( sendok & LDAP_BACK_BINDING ) ) { if ( !( sendok & LDAP_BACK_BINDING ) ) {
retry_lock2:; retry_lock2:;
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
mc = (metaconn_t *)tavl_find( mi->mi_conninfo.lai_tree, mc = (metaconn_t *)ldap_tavl_find( mi->mi_conninfo.lai_tree,
(caddr_t)&mc_curr, meta_back_conndn_cmp ); (caddr_t)&mc_curr, meta_back_conndn_cmp );
if ( mc != NULL ) { if ( mc != NULL ) {
/* catch taint errors */ /* catch taint errors */
@ -1669,7 +1669,7 @@ done:;
rs->sr_err = 0; rs->sr_err = 0;
} else if ( !( sendok & LDAP_BACK_BINDING ) ) { } else if ( !( sendok & LDAP_BACK_BINDING ) ) {
err = tavl_insert( &mi->mi_conninfo.lai_tree, ( caddr_t )mc, err = ldap_tavl_insert( &mi->mi_conninfo.lai_tree, ( caddr_t )mc,
meta_back_conndn_cmp, meta_back_conndn_dup ); meta_back_conndn_cmp, meta_back_conndn_dup );
LDAP_BACK_CONN_CACHED_SET( mc ); LDAP_BACK_CONN_CACHED_SET( mc );
} }
@ -1786,7 +1786,7 @@ meta_back_release_conn_lock(
} else if ( LDAP_BACK_CONN_CACHED( mc ) ) { } else if ( LDAP_BACK_CONN_CACHED( mc ) ) {
metaconn_t *tmpmc; metaconn_t *tmpmc;
tmpmc = tavl_delete( &mi->mi_conninfo.lai_tree, tmpmc = ldap_tavl_delete( &mi->mi_conninfo.lai_tree,
( caddr_t )mc, meta_back_conndnmc_cmp ); ( caddr_t )mc, meta_back_conndnmc_cmp );
/* Overparanoid, but useful... */ /* Overparanoid, but useful... */

8
servers/slapd/back-meta/dncache.c
View file

@ -101,7 +101,7 @@ meta_dncache_get_target(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = ( metadncacheentry_t * )avl_find( cache->tree, entry = ( metadncacheentry_t * )ldap_avl_find( cache->tree,
( caddr_t )&tmp_entry, meta_dncache_cmp ); ( caddr_t )&tmp_entry, meta_dncache_cmp );
if ( entry != NULL ) { if ( entry != NULL ) {
@ -157,7 +157,7 @@ meta_dncache_update_entry(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = ( metadncacheentry_t * )avl_find( cache->tree, entry = ( metadncacheentry_t * )ldap_avl_find( cache->tree,
( caddr_t )&tmp_entry, meta_dncache_cmp ); ( caddr_t )&tmp_entry, meta_dncache_cmp );
if ( entry != NULL ) { if ( entry != NULL ) {
@ -179,7 +179,7 @@ meta_dncache_update_entry(
entry->target = target; entry->target = target;
entry->lastupdated = curr_time; entry->lastupdated = curr_time;
err = avl_insert( &cache->tree, ( caddr_t )entry, err = ldap_avl_insert( &cache->tree, ( caddr_t )entry,
meta_dncache_cmp, meta_dncache_dup ); meta_dncache_cmp, meta_dncache_dup );
} }
@ -209,7 +209,7 @@ meta_dncache_delete_entry(
tmp_entry.dn = *ndn; tmp_entry.dn = *ndn;
ldap_pvt_thread_mutex_lock( &cache->mutex ); ldap_pvt_thread_mutex_lock( &cache->mutex );
entry = avl_delete( &cache->tree, ( caddr_t )&tmp_entry, entry = ldap_avl_delete( &cache->tree, ( caddr_t )&tmp_entry,
meta_dncache_cmp ); meta_dncache_cmp );
ldap_pvt_thread_mutex_unlock( &cache->mutex ); ldap_pvt_thread_mutex_unlock( &cache->mutex );

8
servers/slapd/back-meta/init.c
View file

@ -320,8 +320,8 @@ mapping_dst_free(
void void
meta_back_map_free( struct ldapmap *lm ) meta_back_map_free( struct ldapmap *lm )
{ {
avl_free( lm->remap, mapping_dst_free ); ldap_avl_free( lm->remap, mapping_dst_free );
avl_free( lm->map, mapping_free ); ldap_avl_free( lm->map, mapping_free );
lm->remap = NULL; lm->remap = NULL;
lm->map = NULL; lm->map = NULL;
} }
@ -405,7 +405,7 @@ meta_back_db_destroy(
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
if ( mi->mi_conninfo.lai_tree ) { if ( mi->mi_conninfo.lai_tree ) {
tavl_free( mi->mi_conninfo.lai_tree, meta_back_conn_free ); ldap_tavl_free( mi->mi_conninfo.lai_tree, meta_back_conn_free );
} }
for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) { for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
while ( !LDAP_TAILQ_EMPTY( &mi->mi_conn_priv[ i ].mic_priv ) ) { while ( !LDAP_TAILQ_EMPTY( &mi->mi_conn_priv[ i ].mic_priv ) ) {
@ -441,7 +441,7 @@ meta_back_db_destroy(
ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );
if ( mi->mi_cache.tree ) { if ( mi->mi_cache.tree ) {
avl_free( mi->mi_cache.tree, meta_dncache_free ); ldap_avl_free( mi->mi_cache.tree, meta_dncache_free );
} }
ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex ); ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );

6
servers/slapd/back-meta/map.c
View file

@ -100,9 +100,9 @@ ldap_back_map_init ( struct ldapmap *lm, struct ldapmapping **m )
mapping[1].src = mapping[0].src; mapping[1].src = mapping[0].src;
mapping[1].dst = mapping[0].dst; mapping[1].dst = mapping[0].dst;
avl_insert( &lm->map, (caddr_t)&mapping[0], ldap_avl_insert( &lm->map, (caddr_t)&mapping[0],
mapping_cmp, mapping_dup ); mapping_cmp, mapping_dup );
avl_insert( &lm->remap, (caddr_t)&mapping[1], ldap_avl_insert( &lm->remap, (caddr_t)&mapping[1],
mapping_cmp, mapping_dup ); mapping_cmp, mapping_dup );
*m = mapping; *m = mapping;
} }
@ -133,7 +133,7 @@ ldap_back_mapping ( struct ldapmap *map, struct berval *s, struct ldapmapping **
} }
fmapping.src = *s; fmapping.src = *s;
*m = (struct ldapmapping *)avl_find( tree, (caddr_t)&fmapping, mapping_cmp ); *m = (struct ldapmapping *)ldap_avl_find( tree, (caddr_t)&fmapping, mapping_cmp );
if ( *m == NULL ) { if ( *m == NULL ) {
return map->drop_missing; return map->drop_missing;
} }

2
servers/slapd/back-meta/unbind.c
View file

@ -54,7 +54,7 @@ meta_back_conn_destroy(
#if META_BACK_PRINT_CONNTREE > 0 #if META_BACK_PRINT_CONNTREE > 0
meta_back_print_conntree( mi, ">>> meta_back_conn_destroy" ); meta_back_print_conntree( mi, ">>> meta_back_conn_destroy" );
#endif /* META_BACK_PRINT_CONNTREE */ #endif /* META_BACK_PRINT_CONNTREE */
while ( ( mc = tavl_delete( &mi->mi_conninfo.lai_tree, ( caddr_t )&mc_curr, meta_back_conn_cmp ) ) != NULL ) while ( ( mc = ldap_tavl_delete( &mi->mi_conninfo.lai_tree, ( caddr_t )&mc_curr, meta_back_conn_cmp ) ) != NULL )
{ {
assert( !LDAP_BACK_PCONN_ISPRIV( mc ) ); assert( !LDAP_BACK_PCONN_ISPRIV( mc ) );
Debug( LDAP_DEBUG_TRACE, Debug( LDAP_DEBUG_TRACE,

2
servers/slapd/back-monitor/back-monitor.h
View file

@ -24,7 +24,7 @@
#include <ldap_pvt.h> #include <ldap_pvt.h>
#include <ldap_pvt_thread.h> #include <ldap_pvt_thread.h>
#include <avl.h> #include <ldap_avl.h>
#include <slap.h> #include <slap.h>
LDAP_BEGIN_DECL LDAP_BEGIN_DECL

14
servers/slapd/back-monitor/cache.c
View file

@ -91,7 +91,7 @@ monitor_cache_add(
mc->mc_ndn = e->e_nname; mc->mc_ndn = e->e_nname;
mc->mc_e = e; mc->mc_e = e;
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
rc = avl_insert( &mi->mi_cache, ( caddr_t )mc, rc = ldap_avl_insert( &mi->mi_cache, ( caddr_t )mc,
monitor_cache_cmp, monitor_cache_dup ); monitor_cache_cmp, monitor_cache_dup );
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
@ -153,7 +153,7 @@ monitor_cache_get(
tmp_mc.mc_ndn = *ndn; tmp_mc.mc_ndn = *ndn;
retry:; retry:;
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
mc = ( monitor_cache_t * )avl_find( mi->mi_cache, mc = ( monitor_cache_t * )ldap_avl_find( mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp ); ( caddr_t )&tmp_mc, monitor_cache_cmp );
if ( mc != NULL ) { if ( mc != NULL ) {
@ -196,7 +196,7 @@ retry:;
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
tmp_mc.mc_ndn = *ndn; tmp_mc.mc_ndn = *ndn;
mc = ( monitor_cache_t * )avl_find( mi->mi_cache, mc = ( monitor_cache_t * )ldap_avl_find( mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp ); ( caddr_t )&tmp_mc, monitor_cache_cmp );
if ( mc != NULL ) { if ( mc != NULL ) {
@ -208,7 +208,7 @@ retry:;
} }
tmp_mc.mc_ndn = pndn; tmp_mc.mc_ndn = pndn;
pmc = ( monitor_cache_t * )avl_find( mi->mi_cache, pmc = ( monitor_cache_t * )ldap_avl_find( mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp ); ( caddr_t )&tmp_mc, monitor_cache_cmp );
if ( pmc != NULL ) { if ( pmc != NULL ) {
monitor_entry_t *mp = (monitor_entry_t *)mc->mc_e->e_private, monitor_entry_t *mp = (monitor_entry_t *)mc->mc_e->e_private,
@ -248,7 +248,7 @@ retry:;
monitor_cache_t *tmpmc; monitor_cache_t *tmpmc;
tmp_mc.mc_ndn = *ndn; tmp_mc.mc_ndn = *ndn;
tmpmc = avl_delete( &mi->mi_cache, tmpmc = ldap_avl_delete( &mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp ); ( caddr_t )&tmp_mc, monitor_cache_cmp );
assert( tmpmc == mc ); assert( tmpmc == mc );
@ -367,7 +367,7 @@ monitor_cache_release(
/* volatile entries do not return to cache */ /* volatile entries do not return to cache */
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
tmp_mc.mc_ndn = e->e_nname; tmp_mc.mc_ndn = e->e_nname;
mc = avl_delete( &mi->mi_cache, mc = ldap_avl_delete( &mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp ); ( caddr_t )&tmp_mc, monitor_cache_cmp );
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex ); ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
if ( mc != NULL ) { if ( mc != NULL ) {
@ -430,7 +430,7 @@ monitor_cache_destroy(
monitor_info_t *mi ) monitor_info_t *mi )
{ {
if ( mi->mi_cache ) { if ( mi->mi_cache ) {
avl_free( mi->mi_cache, monitor_entry_destroy ); ldap_avl_free( mi->mi_cache, monitor_entry_destroy );
} }
return 0; return 0;

4
servers/slapd/back-sql/delete.c
View file

@ -68,7 +68,7 @@ backsql_delete_all_attrs(
bda.dbh = dbh; bda.dbh = dbh;
bda.e_id = eid; bda.e_id = eid;
rc = avl_apply( eid->eid_oc->bom_attrs, backsql_delete_attr_f, &bda, rc = ldap_avl_apply( eid->eid_oc->bom_attrs, backsql_delete_attr_f, &bda,
BACKSQL_AVL_STOP, AVL_INORDER ); BACKSQL_AVL_STOP, AVL_INORDER );
if ( rc == BACKSQL_AVL_STOP ) { if ( rc == BACKSQL_AVL_STOP ) {
return rs->sr_err; return rs->sr_err;
@ -95,7 +95,7 @@ backsql_delete_int(
sth = *sthp; sth = *sthp;
/* avl_apply ... */ /* ldap_avl_apply ... */
rs->sr_err = backsql_delete_all_attrs( op, rs, dbh, eid ); rs->sr_err = backsql_delete_all_attrs( op, rs, dbh, eid );
if ( rs->sr_err != LDAP_SUCCESS ) { if ( rs->sr_err != LDAP_SUCCESS ) {
goto done; goto done;

2
servers/slapd/back-sql/entry-id.c
View file

@ -949,7 +949,7 @@ backsql_id2entry( backsql_srch_info *bsi, backsql_entryID *eid )
{ {
Debug( LDAP_DEBUG_TRACE, "backsql_id2entry(): " Debug( LDAP_DEBUG_TRACE, "backsql_id2entry(): "
"retrieving all attributes\n" ); "retrieving all attributes\n" );
avl_apply( bsi->bsi_oc->bom_attrs, backsql_get_attr_vals, ldap_avl_apply( bsi->bsi_oc->bom_attrs, backsql_get_attr_vals,
bsi, 0, AVL_INORDER ); bsi, 0, AVL_INORDER );
} else { } else {

26
servers/slapd/back-sql/schema-map.c
View file

@ -267,7 +267,7 @@ backsql_add_sysmaps( backsql_info *bi, backsql_oc_map_rec *oc_map )
at_map->bam_next = NULL; at_map->bam_next = NULL;
backsql_make_attr_query( bi, oc_map, at_map ); backsql_make_attr_query( bi, oc_map, at_map );
if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) { if ( ldap_avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): " Debug( LDAP_DEBUG_TRACE, "backsql_add_sysmaps(): "
"duplicate attribute \"%s\" in objectClass \"%s\" map\n", "duplicate attribute \"%s\" in objectClass \"%s\" map\n",
at_map->bam_ad->ad_cname.bv_val, at_map->bam_ad->ad_cname.bv_val,
@ -450,7 +450,7 @@ backsql_oc_get_attr_mapping( void *v_oc, void *v_bas )
"preconstructed query \"%s\"\n", "preconstructed query \"%s\"\n",
at_map->bam_query ); at_map->bam_query );
at_map->bam_next = NULL; at_map->bam_next = NULL;
if ( avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) { if ( ldap_avl_insert( &oc_map->bom_attrs, at_map, backsql_cmp_attr, backsql_dup_attr ) == BACKSQL_DUPLICATE ) {
Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): " Debug( LDAP_DEBUG_TRACE, "backsql_oc_get_attr_mapping(): "
"duplicate attribute \"%s\" " "duplicate attribute \"%s\" "
"in objectClass \"%s\" map\n", "in objectClass \"%s\" map\n",
@ -652,14 +652,14 @@ backsql_load_schema_map( backsql_info *bi, SQLHDBC dbh )
*/ */
oc_map->bom_attrs = NULL; oc_map->bom_attrs = NULL;
if ( avl_insert( &bi->sql_oc_by_oc, oc_map, backsql_cmp_oc, avl_dup_error ) == -1 ) { if ( ldap_avl_insert( &bi->sql_oc_by_oc, oc_map, backsql_cmp_oc, ldap_avl_dup_error ) == -1 ) {
Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): " Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
"duplicate objectClass \"%s\" in objectClass map\n", "duplicate objectClass \"%s\" in objectClass map\n",
oc_map->bom_oc->soc_cname.bv_val ); oc_map->bom_oc->soc_cname.bv_val );
ch_free( oc_map ); ch_free( oc_map );
return LDAP_OTHER; return LDAP_OTHER;
} }
if ( avl_insert( &bi->sql_oc_by_id, oc_map, backsql_cmp_oc_id, avl_dup_error ) == -1 ) { if ( ldap_avl_insert( &bi->sql_oc_by_id, oc_map, backsql_cmp_oc_id, ldap_avl_dup_error ) == -1 ) {
Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): " Debug( LDAP_DEBUG_TRACE, "backsql_load_schema_map(): "
"duplicate objectClass \"%s\" in objectClass by ID map\n", "duplicate objectClass \"%s\" in objectClass by ID map\n",
oc_map->bom_oc->soc_cname.bv_val ); oc_map->bom_oc->soc_cname.bv_val );
@ -723,7 +723,7 @@ backsql_load_schema_map( backsql_info *bi, SQLHDBC dbh )
bas.bas_oc_id = &oc_id; bas.bas_oc_id = &oc_id;
bas.bas_rc = LDAP_SUCCESS; bas.bas_rc = LDAP_SUCCESS;
(void)avl_apply( bi->sql_oc_by_oc, backsql_oc_get_attr_mapping, (void)ldap_avl_apply( bi->sql_oc_by_oc, backsql_oc_get_attr_mapping,
&bas, BACKSQL_AVL_STOP, AVL_INORDER ); &bas, BACKSQL_AVL_STOP, AVL_INORDER );
SQLFreeStmt( sth, SQL_DROP ); SQLFreeStmt( sth, SQL_DROP );
@ -747,7 +747,7 @@ backsql_oc2oc( backsql_info *bi, ObjectClass *oc )
#endif /* BACKSQL_TRACE */ #endif /* BACKSQL_TRACE */
tmp.bom_oc = oc; tmp.bom_oc = oc;
res = (backsql_oc_map_rec *)avl_find( bi->sql_oc_by_oc, &tmp, backsql_cmp_oc ); res = (backsql_oc_map_rec *)ldap_avl_find( bi->sql_oc_by_oc, &tmp, backsql_cmp_oc );
#ifdef BACKSQL_TRACE #ifdef BACKSQL_TRACE
if ( res != NULL ) { if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): " Debug( LDAP_DEBUG_TRACE, "<==backsql_oc2oc(): "
@ -778,7 +778,7 @@ backsql_name2oc( backsql_info *bi, struct berval *oc_name )
return NULL; return NULL;
} }
res = (backsql_oc_map_rec *)avl_find( bi->sql_oc_by_oc, &tmp, backsql_cmp_oc ); res = (backsql_oc_map_rec *)ldap_avl_find( bi->sql_oc_by_oc, &tmp, backsql_cmp_oc );
#ifdef BACKSQL_TRACE #ifdef BACKSQL_TRACE
if ( res != NULL ) { if ( res != NULL ) {
Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): " Debug( LDAP_DEBUG_TRACE, "<==oc_with_name(): "
@ -804,7 +804,7 @@ backsql_id2oc( backsql_info *bi, unsigned long id )
#endif /* BACKSQL_TRACE */ #endif /* BACKSQL_TRACE */
tmp.bom_id = id; tmp.bom_id = id;
res = (backsql_oc_map_rec *)avl_find( bi->sql_oc_by_id, &tmp, res = (backsql_oc_map_rec *)ldap_avl_find( bi->sql_oc_by_id, &tmp,
backsql_cmp_oc_id ); backsql_cmp_oc_id );
#ifdef BACKSQL_TRACE #ifdef BACKSQL_TRACE
@ -833,7 +833,7 @@ backsql_ad2at( backsql_oc_map_rec* objclass, AttributeDescription *ad )
#endif /* BACKSQL_TRACE */ #endif /* BACKSQL_TRACE */
tmp.bam_ad = ad; tmp.bam_ad = ad;
res = (backsql_at_map_rec *)avl_find( objclass->bom_attrs, &tmp, res = (backsql_at_map_rec *)ldap_avl_find( objclass->bom_attrs, &tmp,
backsql_cmp_attr ); backsql_cmp_attr );
#ifdef BACKSQL_TRACE #ifdef BACKSQL_TRACE
@ -921,7 +921,7 @@ backsql_supad2at( backsql_oc_map_rec *objclass, AttributeDescription *supad,
va.ad = supad; va.ad = supad;
rc = avl_apply( objclass->bom_attrs, supad2at_f, &va, rc = ldap_avl_apply( objclass->bom_attrs, supad2at_f, &va,
SUPAD2AT_STOP, AVL_INORDER ); SUPAD2AT_STOP, AVL_INORDER );
if ( rc == SUPAD2AT_STOP ) { if ( rc == SUPAD2AT_STOP ) {
return -1; return -1;
@ -983,7 +983,7 @@ backsql_free_oc( void *v_oc )
Debug( LDAP_DEBUG_TRACE, "==>free_oc(): \"%s\"\n", Debug( LDAP_DEBUG_TRACE, "==>free_oc(): \"%s\"\n",
BACKSQL_OC_NAME( oc ) ); BACKSQL_OC_NAME( oc ) );
avl_free( oc->bom_attrs, backsql_free_attr ); ldap_avl_free( oc->bom_attrs, backsql_free_attr );
ch_free( oc->bom_keytbl.bv_val ); ch_free( oc->bom_keytbl.bv_val );
ch_free( oc->bom_keycol.bv_val ); ch_free( oc->bom_keycol.bv_val );
if ( oc->bom_create_proc != NULL ) { if ( oc->bom_create_proc != NULL ) {
@ -1004,8 +1004,8 @@ int
backsql_destroy_schema_map( backsql_info *bi ) backsql_destroy_schema_map( backsql_info *bi )
{ {
Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n" ); Debug( LDAP_DEBUG_TRACE, "==>destroy_schema_map()\n" );
avl_free( bi->sql_oc_by_oc, 0 ); ldap_avl_free( bi->sql_oc_by_oc, 0 );
avl_free( bi->sql_oc_by_id, backsql_free_oc ); ldap_avl_free( bi->sql_oc_by_id, backsql_free_oc );
Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n" ); Debug( LDAP_DEBUG_TRACE, "<==destroy_schema_map()\n" );
return 0; return 0;
} }

2
servers/slapd/back-sql/search.c
View file

@ -2181,7 +2181,7 @@ backsql_search( Operation *op, SlapReply *rs )
* of entries matching LDAP query filter and scope (or at least * of entries matching LDAP query filter and scope (or at least
* candidates), and get the IDs. Do this in ID order for paging. * candidates), and get the IDs. Do this in ID order for paging.
*/ */
avl_apply( bi->sql_oc_by_id, backsql_oc_get_candidates, ldap_avl_apply( bi->sql_oc_by_id, backsql_oc_get_candidates,
&bsi, BACKSQL_AVL_STOP, AVL_INORDER ); &bsi, BACKSQL_AVL_STOP, AVL_INORDER );
/* check for abandon */ /* check for abandon */

12
servers/slapd/bconfig.c
View file

@ -4591,7 +4591,7 @@ config_register_schema(ConfigTable *ct, ConfigOCs *ocs) {
ocs[i].co_name = &ocs[i].co_oc->soc_cname; ocs[i].co_name = &ocs[i].co_oc->soc_cname;
if ( !ocs[i].co_table ) if ( !ocs[i].co_table )
ocs[i].co_table = ct; ocs[i].co_table = ct;
avl_insert( &CfOcTree, &ocs[i], CfOc_cmp, avl_dup_error ); ldap_avl_insert( &CfOcTree, &ocs[i], CfOc_cmp, ldap_avl_dup_error );
} }
} }
return 0; return 0;
@ -5181,7 +5181,7 @@ count_oc( ObjectClass *oc, ConfigOCs ***copp, int *nocs )
} }
co.co_name = &oc->soc_cname; co.co_name = &oc->soc_cname;
cop = avl_find( CfOcTree, &co, CfOc_cmp ); cop = ldap_avl_find( CfOcTree, &co, CfOc_cmp );
if ( cop ) { if ( cop ) {
int i; int i;
@ -5392,7 +5392,7 @@ config_add_oc( ConfigOCs **cop, CfEntryInfo *last, Entry *e, ConfigArgs *ca )
ConfigOCs co = { 0 }; ConfigOCs co = { 0 };
co.co_name = &(*ocp)->soc_cname; co.co_name = &(*ocp)->soc_cname;
*cop = avl_find( CfOcTree, &co, CfOc_cmp ); *cop = ldap_avl_find( CfOcTree, &co, CfOc_cmp );
if ( *cop == NULL ) { if ( *cop == NULL ) {
return rc; return rc;
} }
@ -5527,7 +5527,7 @@ config_add_internal( CfBackInfo *cfb, Entry *e, ConfigArgs *ca, SlapReply *rs,
ca->ca_op = op; ca->ca_op = op;
co.co_name = &soc_at->a_nvals[0]; co.co_name = &soc_at->a_nvals[0];
coptr = avl_find( CfOcTree, &co, CfOc_cmp ); coptr = ldap_avl_find( CfOcTree, &co, CfOc_cmp );
if ( coptr == NULL ) { if ( coptr == NULL ) {
Debug( LDAP_DEBUG_TRACE, "%s: config_add_internal: " Debug( LDAP_DEBUG_TRACE, "%s: config_add_internal: "
"DN=\"%s\" no structural objectClass in configuration table\n", "DN=\"%s\" no structural objectClass in configuration table\n",
@ -6666,7 +6666,7 @@ config_back_delete( Operation *op, SlapReply *rs )
} }
for ( i=0; !BER_BVISNULL(&oc_at->a_nvals[i]); i++ ) { for ( i=0; !BER_BVISNULL(&oc_at->a_nvals[i]); i++ ) {
co.co_name = &oc_at->a_nvals[i]; co.co_name = &oc_at->a_nvals[i];
coptr = avl_find( CfOcTree, &co, CfOc_cmp ); coptr = ldap_avl_find( CfOcTree, &co, CfOc_cmp );
if ( coptr == NULL || coptr->co_type != Cft_Misc ) { if ( coptr == NULL || coptr->co_type != Cft_Misc ) {
continue; continue;
} }
@ -7540,7 +7540,7 @@ config_back_db_destroy( BackendDB *be, ConfigReply *cr )
ch_free( cfdir.bv_val ); ch_free( cfdir.bv_val );
avl_free( CfOcTree, NULL ); ldap_avl_free( CfOcTree, NULL );
if ( cfb->cb_db.bd_info ) { if ( cfb->cb_db.bd_info ) {
cfb->cb_db.be_suffix = NULL; cfb->cb_db.be_suffix = NULL;

12
servers/slapd/cr.c
View file

@ -73,7 +73,7 @@ cr_bvfind( struct berval *crname )
{ {
struct cindexrec *cir; struct cindexrec *cir;
cir = avl_find( cr_index, crname, cr_index_name_cmp ); cir = ldap_avl_find( cr_index, crname, cr_index_name_cmp );
if ( cir != NULL ) { if ( cir != NULL ) {
return( cir->cir_cr ); return( cir->cir_cr );
@ -101,7 +101,7 @@ cr_destroy( void )
{ {
ContentRule *c; ContentRule *c;
avl_free(cr_index, ldap_memfree); ldap_avl_free(cr_index, ldap_memfree);
while( !LDAP_STAILQ_EMPTY(&cr_list) ) { while( !LDAP_STAILQ_EMPTY(&cr_list) ) {
c = LDAP_STAILQ_FIRST(&cr_list); c = LDAP_STAILQ_FIRST(&cr_list);
@ -129,8 +129,8 @@ cr_insert(
cir->cir_name.bv_len = strlen( scr->scr_oid ); cir->cir_name.bv_len = strlen( scr->scr_oid );
cir->cir_cr = scr; cir->cir_cr = scr;
if ( avl_insert( &cr_index, (caddr_t) cir, if ( ldap_avl_insert( &cr_index, (caddr_t) cir,
cr_index_cmp, avl_dup_error ) ) cr_index_cmp, ldap_avl_dup_error ) )
{ {
*err = scr->scr_oid; *err = scr->scr_oid;
ldap_memfree(cir); ldap_memfree(cir);
@ -149,8 +149,8 @@ cr_insert(
cir->cir_name.bv_len = strlen( *names ); cir->cir_name.bv_len = strlen( *names );
cir->cir_cr = scr; cir->cir_cr = scr;
if ( avl_insert( &cr_index, (caddr_t) cir, if ( ldap_avl_insert( &cr_index, (caddr_t) cir,
cr_index_cmp, avl_dup_error ) ) cr_index_cmp, ldap_avl_dup_error ) )
{ {
*err = *names; *err = *names;
ldap_memfree(cir); ldap_memfree(cir);

2
servers/slapd/main.c
View file

@ -1129,7 +1129,7 @@ stop:
ch_free( global_host ); ch_free( global_host );
/* kludge, get symbols referenced */ /* kludge, get symbols referenced */
tavl_free( NULL, NULL ); ldap_tavl_free( NULL, NULL );
#ifdef CSRIMALLOC #ifdef CSRIMALLOC
mal_dumpleaktrace( leakfile ); mal_dumpleaktrace( leakfile );

12
servers/slapd/mr.c
View file

@ -76,7 +76,7 @@ mr_bvfind( struct berval *mrname )
{ {
struct mindexrec *mir = NULL; struct mindexrec *mir = NULL;
if ( (mir = avl_find( mr_index, mrname, mr_index_name_cmp )) != NULL ) { if ( (mir = ldap_avl_find( mr_index, mrname, mr_index_name_cmp )) != NULL ) {
return( mir->mir_mr ); return( mir->mir_mr );
} }
return( NULL ); return( NULL );
@ -87,7 +87,7 @@ mr_destroy( void )
{ {
MatchingRule *m; MatchingRule *m;
avl_free(mr_index, ldap_memfree); ldap_avl_free(mr_index, ldap_memfree);
while( !LDAP_SLIST_EMPTY(&mr_list) ) { while( !LDAP_SLIST_EMPTY(&mr_list) ) {
m = LDAP_SLIST_FIRST(&mr_list); m = LDAP_SLIST_FIRST(&mr_list);
LDAP_SLIST_REMOVE_HEAD(&mr_list, smr_next); LDAP_SLIST_REMOVE_HEAD(&mr_list, smr_next);
@ -115,8 +115,8 @@ mr_insert(
mir->mir_name.bv_val = smr->smr_oid; mir->mir_name.bv_val = smr->smr_oid;
mir->mir_name.bv_len = strlen( smr->smr_oid ); mir->mir_name.bv_len = strlen( smr->smr_oid );
mir->mir_mr = smr; mir->mir_mr = smr;
if ( avl_insert( &mr_index, (caddr_t) mir, if ( ldap_avl_insert( &mr_index, (caddr_t) mir,
mr_index_cmp, avl_dup_error ) ) { mr_index_cmp, ldap_avl_dup_error ) ) {
*err = smr->smr_oid; *err = smr->smr_oid;
ldap_memfree(mir); ldap_memfree(mir);
return SLAP_SCHERR_MR_DUP; return SLAP_SCHERR_MR_DUP;
@ -131,8 +131,8 @@ mr_insert(
mir->mir_name.bv_val = *names; mir->mir_name.bv_val = *names;
mir->mir_name.bv_len = strlen( *names ); mir->mir_name.bv_len = strlen( *names );
mir->mir_mr = smr; mir->mir_mr = smr;
if ( avl_insert( &mr_index, (caddr_t) mir, if ( ldap_avl_insert( &mr_index, (caddr_t) mir,
mr_index_cmp, avl_dup_error ) ) { mr_index_cmp, ldap_avl_dup_error ) ) {
*err = *names; *err = *names;
ldap_memfree(mir); ldap_memfree(mir);
return SLAP_SCHERR_MR_DUP; return SLAP_SCHERR_MR_DUP;

22
servers/slapd/oc.c
View file

@ -180,15 +180,15 @@ oc_bvfind( struct berval *ocname )
struct oindexrec *oir; struct oindexrec *oir;
if ( oc_cache ) { if ( oc_cache ) {
oir = avl_find( oc_cache, ocname, oc_index_name_cmp ); oir = ldap_avl_find( oc_cache, ocname, oc_index_name_cmp );
if ( oir ) return oir->oir_oc; if ( oir ) return oir->oir_oc;
} }
oir = avl_find( oc_index, ocname, oc_index_name_cmp ); oir = ldap_avl_find( oc_index, ocname, oc_index_name_cmp );
if ( oir != NULL ) { if ( oir != NULL ) {
if ( at_oc_cache ) { if ( at_oc_cache ) {
avl_insert( &oc_cache, (caddr_t) oir, ldap_avl_insert( &oc_cache, (caddr_t) oir,
oc_index_cmp, avl_dup_error ); oc_index_cmp, ldap_avl_dup_error );
} }
return( oir->oir_oc ); return( oir->oir_oc );
} }
@ -407,7 +407,7 @@ oc_delete_names( ObjectClass *oc )
ber_str2bv( *names, 0, 0, &tmpoir.oir_name ); ber_str2bv( *names, 0, 0, &tmpoir.oir_name );
tmpoir.oir_oc = oc; tmpoir.oir_oc = oc;
oir = (struct oindexrec *)avl_delete( &oc_index, oir = (struct oindexrec *)ldap_avl_delete( &oc_index,
(caddr_t)&tmpoir, oc_index_cmp ); (caddr_t)&tmpoir, oc_index_cmp );
assert( oir != NULL ); assert( oir != NULL );
ldap_memfree( oir ); ldap_memfree( oir );
@ -472,7 +472,7 @@ oc_destroy( void )
oc_delete_names( o ); oc_delete_names( o );
} }
avl_free( oc_index, oc_destroy_one ); ldap_avl_free( oc_index, oc_destroy_one );
while( !LDAP_STAILQ_EMPTY(&oc_undef_list) ) { while( !LDAP_STAILQ_EMPTY(&oc_undef_list) ) {
o = LDAP_STAILQ_FIRST(&oc_undef_list); o = LDAP_STAILQ_FIRST(&oc_undef_list);
@ -597,7 +597,7 @@ oc_insert(
oir->oir_oc = soc; oir->oir_oc = soc;
oir_old = NULL; oir_old = NULL;
if ( avl_insert( &oc_index, (caddr_t) oir, if ( ldap_avl_insert( &oc_index, (caddr_t) oir,
oc_index_cmp, oc_dup_error ) ) oc_index_cmp, oc_dup_error ) )
{ {
ObjectClass *old_soc; ObjectClass *old_soc;
@ -649,8 +649,8 @@ oc_insert(
oir->oir_name.bv_len = strlen( *names ); oir->oir_name.bv_len = strlen( *names );
oir->oir_oc = soc; oir->oir_oc = soc;
if ( avl_insert( &oc_index, (caddr_t) oir, if ( ldap_avl_insert( &oc_index, (caddr_t) oir,
oc_index_cmp, avl_dup_error ) ) oc_index_cmp, ldap_avl_dup_error ) )
{ {
ObjectClass *old_soc; ObjectClass *old_soc;
int rc; int rc;
@ -669,7 +669,7 @@ oc_insert(
names--; names--;
ber_str2bv( *names, 0, 0, &tmpoir.oir_name ); ber_str2bv( *names, 0, 0, &tmpoir.oir_name );
tmpoir.oir_oc = soc; tmpoir.oir_oc = soc;
oir = (struct oindexrec *)avl_delete( &oc_index, oir = (struct oindexrec *)ldap_avl_delete( &oc_index,
(caddr_t)&tmpoir, oc_index_cmp ); (caddr_t)&tmpoir, oc_index_cmp );
assert( oir != NULL ); assert( oir != NULL );
ldap_memfree( oir ); ldap_memfree( oir );
@ -680,7 +680,7 @@ oc_insert(
ber_str2bv( soc->soc_oid, 0, 0, &tmpoir.oir_name ); ber_str2bv( soc->soc_oid, 0, 0, &tmpoir.oir_name );
tmpoir.oir_oc = soc; tmpoir.oir_oc = soc;
oir = (struct oindexrec *)avl_delete( &oc_index, oir = (struct oindexrec *)ldap_avl_delete( &oc_index,
(caddr_t)&tmpoir, oc_index_cmp ); (caddr_t)&tmpoir, oc_index_cmp );
assert( oir != NULL ); assert( oir != NULL );
ldap_memfree( oir ); ldap_memfree( oir );

56
servers/slapd/overlays/dynlist.c
View file

@ -382,8 +382,8 @@ dynlist_nested_memberOf( Entry *e, AttributeDescription *ad, TAvlnode *sups )
Attribute *a; Attribute *a;
a = attr_find( e->e_attrs, ad ); a = attr_find( e->e_attrs, ad );
for ( ptr = tavl_end( sups, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( sups, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
dyn = ptr->avl_data; dyn = ptr->avl_data;
if ( a ) { if ( a ) {
unsigned slot; unsigned slot;
@ -447,10 +447,10 @@ dynlist_nested_member( Operation *op, dynlist_member_t *dm, TAvlnode *subs )
if ( !a ) if ( !a )
return; return;
for ( ptr = tavl_end( subs, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( subs, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
dyn = ptr->avl_data; dyn = ptr->avl_data;
if ( tavl_insert( &dm->dm_groups, dyn, dynlist_ptr_cmp, avl_dup_error )) if ( ldap_tavl_insert( &dm->dm_groups, dyn, dynlist_ptr_cmp, ldap_avl_dup_error ))
continue; continue;
if ( overlay_entry_get_ov( op, &dyn->dy_name, NULL, NULL, 0, &ne, on ) != LDAP_SUCCESS || ne == NULL ) if ( overlay_entry_get_ov( op, &dyn->dy_name, NULL, NULL, 0, &ne, on ) != LDAP_SUCCESS || ne == NULL )
continue; continue;
@ -764,7 +764,7 @@ checkdyn:
dm.dm_ad = dlm->dlm_member_ad; dm.dm_ad = dlm->dlm_member_ad;
dynlist_nested_member( op, &dm, dyn->dy_subs ); dynlist_nested_member( op, &dm, dyn->dy_subs );
if ( dm.dm_groups ) if ( dm.dm_groups )
tavl_free( dm.dm_groups, NULL ); ldap_tavl_free( dm.dm_groups, NULL );
} }
} }
} }
@ -1089,7 +1089,7 @@ dynlist_search1resp( Operation *op, SlapReply *rs )
if ( b ) if ( b )
dyn->dy_staticmember = ds->ds_dlm->dlm_member_ad; dyn->dy_staticmember = ds->ds_dlm->dlm_member_ad;
if ( tavl_insert( &ds->ds_names, dyn, dynlist_avl_cmp, avl_dup_error )) { if ( ldap_tavl_insert( &ds->ds_names, dyn, dynlist_avl_cmp, ldap_avl_dup_error )) {
for (i=dyn->dy_numuris-1; i>=0; i--) { for (i=dyn->dy_numuris-1; i>=0; i--) {
ludp = dyn->dy_uris[i]; ludp = dyn->dy_uris[i];
if ( ludp->lud_filter ) { if ( ludp->lud_filter ) {
@ -1243,7 +1243,7 @@ dynlist_filter_group( Operation *op, dynlist_name_t *dyn, Filter *n, dynlist_sea
Attribute *a; Attribute *a;
int rc = -1; int rc = -1;
if ( tavl_insert( &ds->ds_fnodes, dyn, dynlist_ptr_cmp, avl_dup_error )) if ( ldap_tavl_insert( &ds->ds_fnodes, dyn, dynlist_ptr_cmp, ldap_avl_dup_error ))
return 0; return 0;
if ( overlay_entry_get_ov( op, &dyn->dy_name, NULL, NULL, 0, &e, on ) != if ( overlay_entry_get_ov( op, &dyn->dy_name, NULL, NULL, 0, &e, on ) !=
@ -1264,8 +1264,8 @@ dynlist_filter_group( Operation *op, dynlist_name_t *dyn, Filter *n, dynlist_sea
overlay_entry_release_ov( op, e, 0, on ); overlay_entry_release_ov( op, e, 0, on );
if ( dyn->dy_subs && !rc ) { if ( dyn->dy_subs && !rc ) {
TAvlnode *ptr; TAvlnode *ptr;
for ( ptr = tavl_end( dyn->dy_subs, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( dyn->dy_subs, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
dyn = ptr->avl_data; dyn = ptr->avl_data;
rc = dynlist_filter_group( op, dyn, n, ds ); rc = dynlist_filter_group( op, dyn, n, ds );
if ( rc ) if ( rc )
@ -1300,7 +1300,7 @@ dynlist_filter_dup( Operation *op, Filter *f, AttributeDescription *ad, dynlist_
case LDAP_FILTER_EQUALITY: case LDAP_FILTER_EQUALITY:
n->f_choice = SLAPD_FILTER_COMPUTED; n->f_choice = SLAPD_FILTER_COMPUTED;
if ( f->f_av_desc == ad ) { if ( f->f_av_desc == ad ) {
dynlist_name_t *dyn = tavl_find( ds->ds_names, &f->f_av_value, dynlist_avl_cmp ); dynlist_name_t *dyn = ldap_tavl_find( ds->ds_names, &f->f_av_value, dynlist_avl_cmp );
if ( dyn && !dynlist_filter_group( op, dyn, n, ds )) if ( dyn && !dynlist_filter_group( op, dyn, n, ds ))
break; break;
} }
@ -1380,9 +1380,9 @@ dynlist_search_free( void *ptr )
ldap_free_urldesc( ludp ); ldap_free_urldesc( ludp );
} }
if ( dyn->dy_subs ) if ( dyn->dy_subs )
tavl_free( dyn->dy_subs, NULL ); ldap_tavl_free( dyn->dy_subs, NULL );
if ( dyn->dy_sups ) if ( dyn->dy_sups )
tavl_free( dyn->dy_sups, NULL ); ldap_tavl_free( dyn->dy_sups, NULL );
ch_free( ptr ); ch_free( ptr );
} }
@ -1393,9 +1393,9 @@ dynlist_search_cleanup( Operation *op, SlapReply *rs )
rs->sr_err == SLAPD_ABANDON ) { rs->sr_err == SLAPD_ABANDON ) {
slap_callback *sc = op->o_callback; slap_callback *sc = op->o_callback;
dynlist_search_t *ds = op->o_callback->sc_private; dynlist_search_t *ds = op->o_callback->sc_private;
tavl_free( ds->ds_names, dynlist_search_free ); ldap_tavl_free( ds->ds_names, dynlist_search_free );
if ( ds->ds_fnodes ) if ( ds->ds_fnodes )
tavl_free( ds->ds_fnodes, NULL ); ldap_tavl_free( ds->ds_fnodes, NULL );
if ( ds->ds_origfilter ) { if ( ds->ds_origfilter ) {
op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx ); op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
dynlist_filter_free( op, op->ors_filter ); dynlist_filter_free( op, op->ors_filter );
@ -1472,8 +1472,8 @@ dynlist_add_memberOf(Operation *op, SlapReply *rs, dynlist_search_t *ds)
Attribute *a; Attribute *a;
/* See if there are any memberOf values to attach to this entry */ /* See if there are any memberOf values to attach to this entry */
for ( ptr = tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
dynlist_map_t *dlm; dynlist_map_t *dlm;
dyn = ptr->avl_data; dyn = ptr->avl_data;
for ( dlm = dyn->dy_dli->dli_dlm; dlm; dlm = dlm->dlm_next ) { for ( dlm = dyn->dy_dli->dli_dlm; dlm; dlm = dlm->dlm_next ) {
@ -1520,7 +1520,7 @@ dynlist_search2resp( Operation *op, SlapReply *rs )
if ( rs->sr_type == REP_SEARCH && rs->sr_entry != NULL ) { if ( rs->sr_type == REP_SEARCH && rs->sr_entry != NULL ) {
rc = SLAP_CB_CONTINUE; rc = SLAP_CB_CONTINUE;
/* See if this is one of our dynamic entries */ /* See if this is one of our dynamic entries */
dyn = tavl_find( ds->ds_names, &rs->sr_entry->e_nname, dynlist_avl_cmp ); dyn = ldap_tavl_find( ds->ds_names, &rs->sr_entry->e_nname, dynlist_avl_cmp );
if ( dyn ) { if ( dyn ) {
dyn->dy_seen = 1; dyn->dy_seen = 1;
rc = dynlist_prepare_entry( op, rs, dyn->dy_dli, dyn ); rc = dynlist_prepare_entry( op, rs, dyn->dy_dli, dyn );
@ -1542,8 +1542,8 @@ dynlist_search2resp( Operation *op, SlapReply *rs )
/* Check for any unexpanded dynamic group entries that weren't picked up /* Check for any unexpanded dynamic group entries that weren't picked up
* by the original search filter. * by the original search filter.
*/ */
for ( ptr = tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
dyn = ptr->avl_data; dyn = ptr->avl_data;
if ( dyn->dy_seen ) if ( dyn->dy_seen )
continue; continue;
@ -1599,13 +1599,13 @@ dynlist_nestlink_dg( Operation *op, SlapReply *rs )
if ( rs->sr_type != REP_SEARCH ) if ( rs->sr_type != REP_SEARCH )
return LDAP_SUCCESS; return LDAP_SUCCESS;
dj = tavl_find( dll->dl_ds->ds_names, &rs->sr_entry->e_nname, dynlist_avl_cmp ); dj = ldap_tavl_find( dll->dl_ds->ds_names, &rs->sr_entry->e_nname, dynlist_avl_cmp );
if ( dj ) { if ( dj ) {
if ( ds->ds_want & WANT_MEMBEROF ) { if ( ds->ds_want & WANT_MEMBEROF ) {
tavl_insert( &dj->dy_sups, di, dynlist_ptr_cmp, avl_dup_error ); ldap_tavl_insert( &dj->dy_sups, di, dynlist_ptr_cmp, ldap_avl_dup_error );
} }
if ( ds->ds_want & WANT_MEMBER ) { if ( ds->ds_want & WANT_MEMBER ) {
tavl_insert( &di->dy_subs, dj, dynlist_ptr_cmp, avl_dup_error ); ldap_tavl_insert( &di->dy_subs, dj, dynlist_ptr_cmp, ldap_avl_dup_error );
} }
} }
return LDAP_SUCCESS; return LDAP_SUCCESS;
@ -1622,8 +1622,8 @@ dynlist_nestlink( Operation *op, dynlist_search_t *ds )
Attribute *a; Attribute *a;
int i; int i;
for ( ptr = tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr; for ( ptr = ldap_tavl_end( ds->ds_names, TAVL_DIR_LEFT ); ptr;
ptr = tavl_next( ptr, TAVL_DIR_RIGHT )) { ptr = ldap_tavl_next( ptr, TAVL_DIR_RIGHT )) {
di = ptr->avl_data; di = ptr->avl_data;
if ( ds->ds_dlm ) { if ( ds->ds_dlm ) {
if ( overlay_entry_get_ov( op, &di->dy_name, NULL, NULL, 0, &e, on ) != LDAP_SUCCESS || e == NULL ) if ( overlay_entry_get_ov( op, &di->dy_name, NULL, NULL, 0, &e, on ) != LDAP_SUCCESS || e == NULL )
@ -1631,13 +1631,13 @@ dynlist_nestlink( Operation *op, dynlist_search_t *ds )
a = attr_find( e->e_attrs, ds->ds_dlm->dlm_member_ad ); a = attr_find( e->e_attrs, ds->ds_dlm->dlm_member_ad );
if ( a ) { if ( a ) {
for ( i=0; i < a->a_numvals; i++ ) { for ( i=0; i < a->a_numvals; i++ ) {
dj = tavl_find( ds->ds_names, &a->a_nvals[i], dynlist_avl_cmp ); dj = ldap_tavl_find( ds->ds_names, &a->a_nvals[i], dynlist_avl_cmp );
if ( dj ) { if ( dj ) {
if ( ds->ds_want & WANT_MEMBEROF ) { if ( ds->ds_want & WANT_MEMBEROF ) {
tavl_insert( &dj->dy_sups, di, dynlist_ptr_cmp, avl_dup_error ); ldap_tavl_insert( &dj->dy_sups, di, dynlist_ptr_cmp, ldap_avl_dup_error );
} }
if ( ds->ds_want & WANT_MEMBER ) { if ( ds->ds_want & WANT_MEMBER ) {
tavl_insert( &di->dy_subs, dj, dynlist_ptr_cmp, avl_dup_error ); ldap_tavl_insert( &di->dy_subs, dj, dynlist_ptr_cmp, ldap_avl_dup_error );
} }
} }
} }

28
servers/slapd/overlays/pcache.c
View file

@ -31,7 +31,7 @@
#include "slap.h" #include "slap.h"
#include "lutil.h" #include "lutil.h"
#include "ldap_rq.h" #include "ldap_rq.h"
#include "avl.h" #include "ldap_avl.h"
#include "../back-monitor/back-monitor.h" #include "../back-monitor/back-monitor.h"
@ -1290,10 +1290,10 @@ find_filter( Operation *op, TAvlnode *root, Filter *inputf, Filter *first )
* walk the entire list. * walk the entire list.
*/ */
if ( first->f_choice == LDAP_FILTER_SUBSTRINGS ) { if ( first->f_choice == LDAP_FILTER_SUBSTRINGS ) {
ptr = tavl_end( root, 1 ); ptr = ldap_tavl_end( root, 1 );
dir = TAVL_DIR_LEFT; dir = TAVL_DIR_LEFT;
} else { } else {
ptr = tavl_find3( root, &cq, pcache_query_cmp, &ret ); ptr = ldap_tavl_find3( root, &cq, pcache_query_cmp, &ret );
dir = (first->f_choice == LDAP_FILTER_GE) ? TAVL_DIR_LEFT : dir = (first->f_choice == LDAP_FILTER_GE) ? TAVL_DIR_LEFT :
TAVL_DIR_RIGHT; TAVL_DIR_RIGHT;
} }
@ -1317,7 +1317,7 @@ find_filter( Operation *op, TAvlnode *root, Filter *inputf, Filter *first )
if ( eqpass == 0 ) { if ( eqpass == 0 ) {
if ( qc->first->f_choice != LDAP_FILTER_EQUALITY ) { if ( qc->first->f_choice != LDAP_FILTER_EQUALITY ) {
nextpass: eqpass = 1; nextpass: eqpass = 1;
ptr = tavl_end( root, 1 ); ptr = ldap_tavl_end( root, 1 );
dir = TAVL_DIR_LEFT; dir = TAVL_DIR_LEFT;
continue; continue;
} }
@ -1426,7 +1426,7 @@ nextpass: eqpass = 1;
if ( res ) if ( res )
return qc; return qc;
ptr = tavl_next( ptr, dir ); ptr = ldap_tavl_next( ptr, dir );
} }
return NULL; return NULL;
} }
@ -1456,7 +1456,7 @@ query_containment(Operation *op, query_manager *qm,
ldap_pvt_thread_rdwr_rlock(&templa->t_rwlock); ldap_pvt_thread_rdwr_rlock(&templa->t_rwlock);
for( ;; ) { for( ;; ) {
/* Find the base */ /* Find the base */
qbptr = avl_find( templa->qbase, &qbase, pcache_dn_cmp ); qbptr = ldap_avl_find( templa->qbase, &qbase, pcache_dn_cmp );
if ( qbptr ) { if ( qbptr ) {
tscope = query->scope; tscope = query->scope;
/* Find a matching scope: /* Find a matching scope:
@ -1616,20 +1616,20 @@ add_query(
Debug( pcache_debug, "Lock AQ index = %p\n", Debug( pcache_debug, "Lock AQ index = %p\n",
(void *) templ ); (void *) templ );
ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock); ldap_pvt_thread_rdwr_wlock(&templ->t_rwlock);
qbase = avl_find( templ->qbase, &qb, pcache_dn_cmp ); qbase = ldap_avl_find( templ->qbase, &qb, pcache_dn_cmp );
if ( !qbase ) { if ( !qbase ) {
qbase = ch_calloc( 1, sizeof(Qbase) + qb.base.bv_len + 1 ); qbase = ch_calloc( 1, sizeof(Qbase) + qb.base.bv_len + 1 );
qbase->base.bv_len = qb.base.bv_len; qbase->base.bv_len = qb.base.bv_len;
qbase->base.bv_val = (char *)(qbase+1); qbase->base.bv_val = (char *)(qbase+1);
memcpy( qbase->base.bv_val, qb.base.bv_val, qb.base.bv_len ); memcpy( qbase->base.bv_val, qb.base.bv_val, qb.base.bv_len );
qbase->base.bv_val[qbase->base.bv_len] = '\0'; qbase->base.bv_val[qbase->base.bv_len] = '\0';
avl_insert( &templ->qbase, qbase, pcache_dn_cmp, avl_dup_error ); ldap_avl_insert( &templ->qbase, qbase, pcache_dn_cmp, ldap_avl_dup_error );
} }
new_cached_query->next = templ->query; new_cached_query->next = templ->query;
new_cached_query->prev = NULL; new_cached_query->prev = NULL;
new_cached_query->qbase = qbase; new_cached_query->qbase = qbase;
rc = tavl_insert( &qbase->scopes[query->scope], new_cached_query, rc = ldap_tavl_insert( &qbase->scopes[query->scope], new_cached_query,
pcache_query_cmp, avl_dup_error ); pcache_query_cmp, ldap_avl_dup_error );
if ( rc == 0 ) { if ( rc == 0 ) {
qbase->queries++; qbase->queries++;
if (templ->query == NULL) if (templ->query == NULL)
@ -1680,10 +1680,10 @@ remove_from_template (CachedQuery* qc, QueryTemplate* template)
qc->next->prev = qc->prev; qc->next->prev = qc->prev;
qc->prev->next = qc->next; qc->prev->next = qc->next;
} }
tavl_delete( &qc->qbase->scopes[qc->scope], qc, pcache_query_cmp ); ldap_tavl_delete( &qc->qbase->scopes[qc->scope], qc, pcache_query_cmp );
qc->qbase->queries--; qc->qbase->queries--;
if ( qc->qbase->queries == 0 ) { if ( qc->qbase->queries == 0 ) {
avl_delete( &template->qbase, qc->qbase, pcache_dn_cmp ); ldap_avl_delete( &template->qbase, qc->qbase, pcache_dn_cmp );
ch_free( qc->qbase ); ch_free( qc->qbase );
qc->qbase = NULL; qc->qbase = NULL;
} }
@ -4778,7 +4778,7 @@ pcache_free_qbase( void *v )
int i; int i;
for (i=0; i<3; i++) for (i=0; i<3; i++)
tavl_free( qb->scopes[i], NULL ); ldap_tavl_free( qb->scopes[i], NULL );
ch_free( qb ); ch_free( qb );
} }
@ -4910,7 +4910,7 @@ pcache_db_destroy(
qn = qc->next; qn = qc->next;
free_query( qc ); free_query( qc );
} }
avl_free( tm->qbase, pcache_free_qbase ); ldap_avl_free( tm->qbase, pcache_free_qbase );
free( tm->querystr.bv_val ); free( tm->querystr.bv_val );
free( tm->bindfattrs ); free( tm->bindfattrs );
free( tm->bindftemp.bv_val ); free( tm->bindftemp.bv_val );

48
servers/slapd/overlays/rwm.c
View file

@ -2229,10 +2229,10 @@ rwm_cf_gen( ConfigArgs *c )
/* in case of failure, restore /* in case of failure, restore
* the existing mapping */ * the existing mapping */
if ( rc ) { if ( rc ) {
avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_at.map, rwm_mapping_free );
rwmap->rwm_oc = rwm_oc; rwmap->rwm_oc = rwm_oc;
rwmap->rwm_at = rwm_at; rwmap->rwm_at = rwm_at;
break; break;
@ -2242,10 +2242,10 @@ rwm_cf_gen( ConfigArgs *c )
/* in case of success, destroy the old mapping /* in case of success, destroy the old mapping
* and eliminate the deleted one */ * and eliminate the deleted one */
if ( rc == 0 ) { if ( rc == 0 ) {
avl_free( rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwm_oc.map, rwm_mapping_free );
avl_free( rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwm_at.map, rwm_mapping_free );
ber_memfree( rwmap->rwm_bva_map[ c->valx ].bv_val ); ber_memfree( rwmap->rwm_bva_map[ c->valx ].bv_val );
for ( cnt = c->valx; !BER_BVISNULL( &rwmap->rwm_bva_map[ cnt ] ); cnt++ ) { for ( cnt = c->valx; !BER_BVISNULL( &rwmap->rwm_bva_map[ cnt ] ); cnt++ ) {
@ -2254,10 +2254,10 @@ rwm_cf_gen( ConfigArgs *c )
} }
} else { } else {
avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_at.map, rwm_mapping_free );
rwmap->rwm_oc.remap = NULL; rwmap->rwm_oc.remap = NULL;
rwmap->rwm_oc.map = NULL; rwmap->rwm_oc.map = NULL;
@ -2535,10 +2535,10 @@ rwm_cf_gen( ConfigArgs *c )
rwmap->rwm_bva_map = tmp; rwmap->rwm_bva_map = tmp;
BER_BVZERO( &rwmap->rwm_bva_map[ cnt + 1 ] ); BER_BVZERO( &rwmap->rwm_bva_map[ cnt + 1 ] );
avl_free( rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwm_oc.map, rwm_mapping_free );
avl_free( rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwm_at.map, rwm_mapping_free );
for ( ; cnt-- > c->valx; ) { for ( ; cnt-- > c->valx; ) {
rwmap->rwm_bva_map[ cnt + 1 ] = rwmap->rwm_bva_map[ cnt ]; rwmap->rwm_bva_map[ cnt + 1 ] = rwmap->rwm_bva_map[ cnt ];
@ -2547,10 +2547,10 @@ rwm_cf_gen( ConfigArgs *c )
} else { } else {
rwmmap_fail:; rwmmap_fail:;
avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_at.map, rwm_mapping_free );
rwmap->rwm_oc = rwm_oc; rwmap->rwm_oc = rwm_oc;
rwmap->rwm_at = rwm_at; rwmap->rwm_at = rwm_at;
} }
@ -2644,10 +2644,10 @@ rwm_db_destroy(
ber_bvarray_free( rwmap->rwm_bva_rewrite ); ber_bvarray_free( rwmap->rwm_bva_rewrite );
} }
avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_oc.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_oc.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_oc.map, rwm_mapping_free );
avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free ); ldap_avl_free( rwmap->rwm_at.remap, rwm_mapping_dst_free );
avl_free( rwmap->rwm_at.map, rwm_mapping_free ); ldap_avl_free( rwmap->rwm_at.map, rwm_mapping_free );
ber_bvarray_free( rwmap->rwm_bva_map ); ber_bvarray_free( rwmap->rwm_bva_map );
ch_free( rwmap ); ch_free( rwmap );

8
servers/slapd/overlays/rwmconf.c
View file

@ -216,8 +216,8 @@ rwm_map_config(
mapping[1].m_src_ad = mapping[0].m_dst_ad; mapping[1].m_src_ad = mapping[0].m_dst_ad;
} }
if ( ( src[0] != '\0' && avl_find( map->map, (caddr_t)mapping, rwm_mapping_cmp ) != NULL) if ( ( src[0] != '\0' && ldap_avl_find( map->map, (caddr_t)mapping, rwm_mapping_cmp ) != NULL)
|| avl_find( map->remap, (caddr_t)&mapping[1], rwm_mapping_cmp ) != NULL) || ldap_avl_find( map->remap, (caddr_t)&mapping[1], rwm_mapping_cmp ) != NULL)
{ {
Debug( LDAP_DEBUG_ANY, Debug( LDAP_DEBUG_ANY,
"%s: line %d: duplicate mapping found.\n", "%s: line %d: duplicate mapping found.\n",
@ -227,10 +227,10 @@ rwm_map_config(
} }
if ( src[0] != '\0' ) { if ( src[0] != '\0' ) {
avl_insert( &map->map, (caddr_t)&mapping[0], ldap_avl_insert( &map->map, (caddr_t)&mapping[0],
rwm_mapping_cmp, rwm_mapping_dup ); rwm_mapping_cmp, rwm_mapping_dup );
} }
avl_insert( &map->remap, (caddr_t)&mapping[1], ldap_avl_insert( &map->remap, (caddr_t)&mapping[1],
rwm_mapping_cmp, rwm_mapping_dup ); rwm_mapping_cmp, rwm_mapping_dup );
success_return:; success_return:;

6
servers/slapd/overlays/rwmmap.c
View file

@ -99,9 +99,9 @@ rwm_map_init( struct ldapmap *lm, struct ldapmapping **m )
mapping[1].m_src_ad = mapping[0].m_src_ad; mapping[1].m_src_ad = mapping[0].m_src_ad;
mapping[1].m_dst_ad = mapping[1].m_src_ad; mapping[1].m_dst_ad = mapping[1].m_src_ad;
avl_insert( &lm->map, (caddr_t)&mapping[0], ldap_avl_insert( &lm->map, (caddr_t)&mapping[0],
rwm_mapping_cmp, rwm_mapping_dup ); rwm_mapping_cmp, rwm_mapping_dup );
avl_insert( &lm->remap, (caddr_t)&mapping[1], ldap_avl_insert( &lm->remap, (caddr_t)&mapping[1],
rwm_mapping_cmp, rwm_mapping_dup ); rwm_mapping_cmp, rwm_mapping_dup );
*m = mapping; *m = mapping;
@ -138,7 +138,7 @@ rwm_mapping( struct ldapmap *map, struct berval *s, struct ldapmapping **m, int
} }
fmapping.m_src = *s; fmapping.m_src = *s;
*m = (struct ldapmapping *)avl_find( tree, (caddr_t)&fmapping, *m = (struct ldapmapping *)ldap_avl_find( tree, (caddr_t)&fmapping,
rwm_mapping_cmp ); rwm_mapping_cmp );
if ( *m == NULL ) { if ( *m == NULL ) {

8
servers/slapd/overlays/seqmod.c
View file

@ -61,7 +61,7 @@ seqmod_op_cleanup( Operation *op, SlapReply *rs )
mtdummy.mt_op = op; mtdummy.mt_op = op;
/* This op is done, remove it */ /* This op is done, remove it */
ldap_pvt_thread_mutex_lock( &sm->sm_mutex ); ldap_pvt_thread_mutex_lock( &sm->sm_mutex );
av = avl_find2( sm->sm_mods, &mtdummy, sm_avl_cmp ); av = ldap_avl_find2( sm->sm_mods, &mtdummy, sm_avl_cmp );
assert(av != NULL); assert(av != NULL);
mt = av->avl_data; mt = av->avl_data;
@ -71,7 +71,7 @@ seqmod_op_cleanup( Operation *op, SlapReply *rs )
av->avl_data = mt->mt_next; av->avl_data = mt->mt_next;
mt->mt_next->mt_tail = mt->mt_tail; mt->mt_next->mt_tail = mt->mt_tail;
} else { } else {
avl_delete( &sm->sm_mods, mt, sm_avl_cmp ); ldap_avl_delete( &sm->sm_mods, mt, sm_avl_cmp );
} }
ldap_pvt_thread_mutex_unlock( &sm->sm_mutex ); ldap_pvt_thread_mutex_unlock( &sm->sm_mutex );
op->o_callback = sc->sc_next; op->o_callback = sc->sc_next;
@ -100,7 +100,7 @@ seqmod_op_mod( Operation *op, SlapReply *rs )
* near-simultaneous mods of the same entry * near-simultaneous mods of the same entry
*/ */
ldap_pvt_thread_mutex_lock( &sm->sm_mutex ); ldap_pvt_thread_mutex_lock( &sm->sm_mutex );
av = avl_find2( sm->sm_mods, mt, sm_avl_cmp ); av = ldap_avl_find2( sm->sm_mods, mt, sm_avl_cmp );
if ( av ) { if ( av ) {
modtarget *mtp = av->avl_data; modtarget *mtp = av->avl_data;
mtp->mt_tail->mt_next = mt; mtp->mt_tail->mt_next = mt;
@ -116,7 +116,7 @@ seqmod_op_mod( Operation *op, SlapReply *rs )
} }
} else { } else {
/* Record that we're modifying this now */ /* Record that we're modifying this now */
avl_insert( &sm->sm_mods, mt, sm_avl_cmp, avl_dup_error ); ldap_avl_insert( &sm->sm_mods, mt, sm_avl_cmp, ldap_avl_dup_error );
} }
ldap_pvt_thread_mutex_unlock( &sm->sm_mutex ); ldap_pvt_thread_mutex_unlock( &sm->sm_mutex );

38
servers/slapd/overlays/sssvlv.c
View file

@ -29,7 +29,7 @@
#include <ac/string.h> #include <ac/string.h>
#include <ac/ctype.h> #include <ac/ctype.h>
#include <avl.h> #include <ldap_avl.h>
#include "slap.h" #include "slap.h"
#include "lutil.h" #include "lutil.h"
@ -411,14 +411,14 @@ static void free_sort_op( Connection *conn, sort_op *so )
TAvlnode *cur_node, *next_node; TAvlnode *cur_node, *next_node;
cur_node = so->so_tree; cur_node = so->so_tree;
while ( cur_node ) { while ( cur_node ) {
next_node = tavl_next( cur_node, TAVL_DIR_RIGHT ); next_node = ldap_tavl_next( cur_node, TAVL_DIR_RIGHT );
ch_free( cur_node->avl_data ); ch_free( cur_node->avl_data );
ber_memfree( cur_node ); ber_memfree( cur_node );
cur_node = next_node; cur_node = next_node;
} }
} else { } else {
tavl_free( so->so_tree, ch_free ); ldap_tavl_free( so->so_tree, ch_free );
} }
so->so_tree = NULL; so->so_tree = NULL;
} }
@ -463,11 +463,11 @@ static void send_list(
if ( BER_BVISNULL( &vc->vc_value )) { if ( BER_BVISNULL( &vc->vc_value )) {
if ( vc->vc_offset == vc->vc_count ) { if ( vc->vc_offset == vc->vc_count ) {
/* wants the last entry in the list */ /* wants the last entry in the list */
cur_node = tavl_end(so->so_tree, TAVL_DIR_RIGHT); cur_node = ldap_tavl_end(so->so_tree, TAVL_DIR_RIGHT);
so->so_vlv_target = so->so_nentries; so->so_vlv_target = so->so_nentries;
} else if ( vc->vc_offset == 1 ) { } else if ( vc->vc_offset == 1 ) {
/* wants the first entry in the list */ /* wants the first entry in the list */
cur_node = tavl_end(so->so_tree, TAVL_DIR_LEFT); cur_node = ldap_tavl_end(so->so_tree, TAVL_DIR_LEFT);
so->so_vlv_target = 1; so->so_vlv_target = 1;
} else { } else {
int target; int target;
@ -491,15 +491,15 @@ range_err:
so->so_vlv_target = target; so->so_vlv_target = target;
/* Start at left and go right, or start at right and go left? */ /* Start at left and go right, or start at right and go left? */
if ( target < so->so_nentries / 2 ) { if ( target < so->so_nentries / 2 ) {
cur_node = tavl_end(so->so_tree, TAVL_DIR_LEFT); cur_node = ldap_tavl_end(so->so_tree, TAVL_DIR_LEFT);
dir = TAVL_DIR_RIGHT; dir = TAVL_DIR_RIGHT;
} else { } else {
cur_node = tavl_end(so->so_tree, TAVL_DIR_RIGHT); cur_node = ldap_tavl_end(so->so_tree, TAVL_DIR_RIGHT);
dir = TAVL_DIR_LEFT; dir = TAVL_DIR_LEFT;
target = so->so_nentries - target + 1; target = so->so_nentries - target + 1;
} }
for ( i=1; i<target; i++ ) for ( i=1; i<target; i++ )
cur_node = tavl_next( cur_node, dir ); cur_node = ldap_tavl_next( cur_node, dir );
} }
} else { } else {
/* we're looking for a specific value */ /* we're looking for a specific value */
@ -532,11 +532,11 @@ range_err:
for (i=1; i<sc->sc_nkeys; i++) { for (i=1; i<sc->sc_nkeys; i++) {
BER_BVZERO( &sn->sn_vals[i] ); BER_BVZERO( &sn->sn_vals[i] );
} }
cur_node = tavl_find3( so->so_tree, sn, node_cmp, &j ); cur_node = ldap_tavl_find3( so->so_tree, sn, node_cmp, &j );
/* didn't find >= match */ /* didn't find >= match */
if ( j > 0 ) { if ( j > 0 ) {
if ( cur_node ) if ( cur_node )
cur_node = tavl_next( cur_node, TAVL_DIR_RIGHT ); cur_node = ldap_tavl_next( cur_node, TAVL_DIR_RIGHT );
} }
op->o_tmpfree( sn, op->o_tmpmemctx ); op->o_tmpfree( sn, op->o_tmpmemctx );
@ -547,14 +547,14 @@ range_err:
/* start from the left or the right side? */ /* start from the left or the right side? */
mr->smr_match( &i, 0, mr->smr_syntax, mr, &bv, &sn->sn_vals[0] ); mr->smr_match( &i, 0, mr->smr_syntax, mr, &bv, &sn->sn_vals[0] );
if ( i > 0 ) { if ( i > 0 ) {
tmp_node = tavl_end(so->so_tree, TAVL_DIR_RIGHT); tmp_node = ldap_tavl_end(so->so_tree, TAVL_DIR_RIGHT);
dir = TAVL_DIR_LEFT; dir = TAVL_DIR_LEFT;
} else { } else {
tmp_node = tavl_end(so->so_tree, TAVL_DIR_LEFT); tmp_node = ldap_tavl_end(so->so_tree, TAVL_DIR_LEFT);
dir = TAVL_DIR_RIGHT; dir = TAVL_DIR_RIGHT;
} }
for (i=0; tmp_node != cur_node; for (i=0; tmp_node != cur_node;
tmp_node = tavl_next( tmp_node, dir ), i++); tmp_node = ldap_tavl_next( tmp_node, dir ), i++);
so->so_vlv_target = (dir == TAVL_DIR_RIGHT) ? i+1 : so->so_nentries - i; so->so_vlv_target = (dir == TAVL_DIR_RIGHT) ? i+1 : so->so_nentries - i;
} }
if ( bv.bv_val != vc->vc_value.bv_val ) if ( bv.bv_val != vc->vc_value.bv_val )
@ -562,12 +562,12 @@ range_err:
} }
if ( !cur_node ) { if ( !cur_node ) {
i = 1; i = 1;
cur_node = tavl_end(so->so_tree, TAVL_DIR_RIGHT); cur_node = ldap_tavl_end(so->so_tree, TAVL_DIR_RIGHT);
} else { } else {
i = 0; i = 0;
} }
for ( ; i<vc->vc_before; i++ ) { for ( ; i<vc->vc_before; i++ ) {
tmp_node = tavl_next( cur_node, TAVL_DIR_LEFT ); tmp_node = ldap_tavl_next( cur_node, TAVL_DIR_LEFT );
if ( !tmp_node ) break; if ( !tmp_node ) break;
cur_node = tmp_node; cur_node = tmp_node;
} }
@ -589,7 +589,7 @@ range_err:
if ( rs->sr_err == LDAP_UNAVAILABLE ) if ( rs->sr_err == LDAP_UNAVAILABLE )
break; break;
} }
cur_node = tavl_next( cur_node, TAVL_DIR_RIGHT ); cur_node = ldap_tavl_next( cur_node, TAVL_DIR_RIGHT );
if ( !cur_node ) break; if ( !cur_node ) break;
} }
so->so_vlv_rc = LDAP_SUCCESS; so->so_vlv_rc = LDAP_SUCCESS;
@ -612,7 +612,7 @@ static void send_page( Operation *op, SlapReply *rs, sort_op *so )
if ( slapd_shutdown ) break; if ( slapd_shutdown ) break;
next_node = tavl_next( cur_node, TAVL_DIR_RIGHT ); next_node = ldap_tavl_next( cur_node, TAVL_DIR_RIGHT );
op->o_bd = select_backend( &sn->sn_dn, 0 ); op->o_bd = select_backend( &sn->sn_dn, 0 );
e = NULL; e = NULL;
@ -664,7 +664,7 @@ static void send_entry(
send_list( op, rs, so ); send_list( op, rs, so );
} else { } else {
/* Get the first node to send */ /* Get the first node to send */
TAvlnode *start_node = tavl_end(so->so_tree, TAVL_DIR_LEFT); TAvlnode *start_node = ldap_tavl_end(so->so_tree, TAVL_DIR_LEFT);
so->so_tree = start_node; so->so_tree = start_node;
if ( so->so_paged <= SLAP_CONTROL_IGNORED ) { if ( so->so_paged <= SLAP_CONTROL_IGNORED ) {
@ -777,7 +777,7 @@ static int sssvlv_op_response(
sn->sn_session = find_session_by_so( so->so_info->svi_max_percon, op->o_conn->c_conn_idx, so ); sn->sn_session = find_session_by_so( so->so_info->svi_max_percon, op->o_conn->c_conn_idx, so );
/* Insert into the AVL tree */ /* Insert into the AVL tree */
tavl_insert(&(so->so_tree), sn, node_insert, avl_dup_error); ldap_tavl_insert(&(so->so_tree), sn, node_insert, ldap_avl_dup_error);
so->so_nentries++; so->so_nentries++;

32
servers/slapd/overlays/syncprov.c
View file

@ -1532,7 +1532,7 @@ syncprov_op_cleanup( Operation *op, SlapReply *rs )
} else { } else {
ldap_pvt_thread_mutex_unlock( &mt->mt_mutex ); ldap_pvt_thread_mutex_unlock( &mt->mt_mutex );
ldap_pvt_thread_mutex_lock( &si->si_mods_mutex ); ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
avl_delete( &si->si_mods, mt, sp_avl_cmp ); ldap_avl_delete( &si->si_mods, mt, sp_avl_cmp );
ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex ); ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
ldap_pvt_thread_mutex_destroy( &mt->mt_mutex ); ldap_pvt_thread_mutex_destroy( &mt->mt_mutex );
ch_free( mt->mt_dn.bv_val ); ch_free( mt->mt_dn.bv_val );
@ -1649,7 +1649,7 @@ syncprov_add_slog( Operation *op )
ldap_pvt_thread_rdwr_wlock( &sl->sl_mutex ); ldap_pvt_thread_rdwr_wlock( &sl->sl_mutex );
/* can only do this if no one else is reading the log at the moment */ /* can only do this if no one else is reading the log at the moment */
if ( !sl->sl_playing ) { if ( !sl->sl_playing ) {
tavl_free( sl->sl_entries, (AVL_FREE)ch_free ); ldap_tavl_free( sl->sl_entries, (AVL_FREE)ch_free );
sl->sl_num = 0; sl->sl_num = 0;
sl->sl_entries = NULL; sl->sl_entries = NULL;
} }
@ -1693,7 +1693,7 @@ syncprov_add_slog( Operation *op )
BER_BVZERO( &sl->sl_mincsn[1] ); BER_BVZERO( &sl->sl_mincsn[1] );
} }
} }
rc = tavl_insert( &sl->sl_entries, se, syncprov_sessionlog_cmp, avl_dup_error ); rc = ldap_tavl_insert( &sl->sl_entries, se, syncprov_sessionlog_cmp, ldap_avl_dup_error );
if ( rc ) { if ( rc ) {
Debug( LDAP_DEBUG_SYNC, "%s syncprov_add_slog: " Debug( LDAP_DEBUG_SYNC, "%s syncprov_add_slog: "
"duplicate sessionlog entry ignored: csn=%s, uuid=%s\n", "duplicate sessionlog entry ignored: csn=%s, uuid=%s\n",
@ -1703,10 +1703,10 @@ syncprov_add_slog( Operation *op )
} }
sl->sl_num++; sl->sl_num++;
if ( !sl->sl_playing && sl->sl_num > sl->sl_size ) { if ( !sl->sl_playing && sl->sl_num > sl->sl_size ) {
TAvlnode *edge = tavl_end( sl->sl_entries, TAVL_DIR_LEFT ); TAvlnode *edge = ldap_tavl_end( sl->sl_entries, TAVL_DIR_LEFT );
while ( sl->sl_num > sl->sl_size ) { while ( sl->sl_num > sl->sl_size ) {
int i; int i;
TAvlnode *next = tavl_next( edge, TAVL_DIR_RIGHT ); TAvlnode *next = ldap_tavl_next( edge, TAVL_DIR_RIGHT );
se = edge->avl_data; se = edge->avl_data;
Debug( LDAP_DEBUG_SYNC, "%s syncprov_add_slog: " Debug( LDAP_DEBUG_SYNC, "%s syncprov_add_slog: "
"expiring csn=%s from sessionlog (sessionlog size=%d)\n", "expiring csn=%s from sessionlog (sessionlog size=%d)\n",
@ -1726,7 +1726,7 @@ syncprov_add_slog( Operation *op )
op->o_log_prefix, se->se_sid, sl->sl_mincsn[i].bv_val, se->se_csn.bv_val ); op->o_log_prefix, se->se_sid, sl->sl_mincsn[i].bv_val, se->se_csn.bv_val );
ber_bvreplace( &sl->sl_mincsn[i], &se->se_csn ); ber_bvreplace( &sl->sl_mincsn[i], &se->se_csn );
} }
tavl_delete( &sl->sl_entries, se, syncprov_sessionlog_cmp ); ldap_tavl_delete( &sl->sl_entries, se, syncprov_sessionlog_cmp );
ch_free( se ); ch_free( se );
edge = next; edge = next;
sl->sl_num--; sl->sl_num--;
@ -1904,7 +1904,7 @@ syncprov_accesslog_uuid_cb( Operation *op, SlapReply *rs )
} }
uuid[0] = a->a_nvals[0]; uuid[0] = a->a_nvals[0];
bv = avl_find( uuid_progress->uuids, uuid, sp_uuid_cmp ); bv = ldap_avl_find( uuid_progress->uuids, uuid, sp_uuid_cmp );
if ( bv ) { if ( bv ) {
/* Already checked or sent, no change */ /* Already checked or sent, no change */
Debug( LDAP_DEBUG_SYNC, "%s syncprov_accesslog_uuid_cb: " Debug( LDAP_DEBUG_SYNC, "%s syncprov_accesslog_uuid_cb: "
@ -1928,7 +1928,7 @@ syncprov_accesslog_uuid_cb( Operation *op, SlapReply *rs )
bv->bv_len = a->a_nvals[0].bv_len; bv->bv_len = a->a_nvals[0].bv_len;
AC_MEMCPY( bv->bv_val, a->a_nvals[0].bv_val, a->a_nvals[0].bv_len ); AC_MEMCPY( bv->bv_val, a->a_nvals[0].bv_val, a->a_nvals[0].bv_len );
rc = avl_insert( &uuid_progress->uuids, bv, sp_uuid_cmp, avl_dup_error ); rc = ldap_avl_insert( &uuid_progress->uuids, bv, sp_uuid_cmp, ldap_avl_dup_error );
assert( rc == LDAP_SUCCESS ); assert( rc == LDAP_SUCCESS );
if ( is_delete ) { if ( is_delete ) {
@ -1945,7 +1945,7 @@ syncprov_accesslog_uuid_cb( Operation *op, SlapReply *rs )
int ndel; int ndel;
assert( uuid_progress->ndel == uuid_progress->list_len ); assert( uuid_progress->ndel == uuid_progress->list_len );
ndel = avl_free( uuid_progress->uuids, NULL ); ndel = ldap_avl_free( uuid_progress->uuids, NULL );
assert( ndel == uuid_progress->ndel ); assert( ndel == uuid_progress->ndel );
uuid_progress->ndel = 0; uuid_progress->ndel = 0;
} }
@ -2026,13 +2026,13 @@ syncprov_play_sessionlog( Operation *op, SlapReply *rs, sync_control *srs,
{ {
slog_entry te = {0}; slog_entry te = {0};
te.se_csn = *mincsn; te.se_csn = *mincsn;
entry = tavl_find3( sl->sl_entries, &te, syncprov_sessionlog_cmp, &ndel ); entry = ldap_tavl_find3( sl->sl_entries, &te, syncprov_sessionlog_cmp, &ndel );
} }
if ( ndel > 0 && entry ) if ( ndel > 0 && entry )
entry = tavl_next( entry, TAVL_DIR_LEFT ); entry = ldap_tavl_next( entry, TAVL_DIR_LEFT );
/* if none, just start at beginning */ /* if none, just start at beginning */
if ( !entry ) if ( !entry )
entry = tavl_end( sl->sl_entries, TAVL_DIR_LEFT ); entry = ldap_tavl_end( sl->sl_entries, TAVL_DIR_LEFT );
do { do {
char uuidstr[40] = {}; char uuidstr[40] = {};
@ -2096,7 +2096,7 @@ syncprov_play_sessionlog( Operation *op, SlapReply *rs, sync_control *srs,
uuidstr, csns[j].bv_val ); uuidstr, csns[j].bv_val );
} }
ldap_pvt_thread_rdwr_rlock( &sl->sl_mutex ); ldap_pvt_thread_rdwr_rlock( &sl->sl_mutex );
} while ( (entry = tavl_next( entry, TAVL_DIR_RIGHT )) != NULL ); } while ( (entry = ldap_tavl_next( entry, TAVL_DIR_RIGHT )) != NULL );
ldap_pvt_thread_rdwr_runlock( &sl->sl_mutex ); ldap_pvt_thread_rdwr_runlock( &sl->sl_mutex );
ldap_pvt_thread_rdwr_wlock( &sl->sl_mutex ); ldap_pvt_thread_rdwr_wlock( &sl->sl_mutex );
sl->sl_playing--; sl->sl_playing--;
@ -2649,7 +2649,7 @@ syncprov_op_mod( Operation *op, SlapReply *rs )
mtdummy.mt_dn = op->o_req_ndn; mtdummy.mt_dn = op->o_req_ndn;
retry: retry:
ldap_pvt_thread_mutex_lock( &si->si_mods_mutex ); ldap_pvt_thread_mutex_lock( &si->si_mods_mutex );
mt = avl_find( si->si_mods, &mtdummy, sp_avl_cmp ); mt = ldap_avl_find( si->si_mods, &mtdummy, sp_avl_cmp );
if ( mt ) { if ( mt ) {
ldap_pvt_thread_mutex_lock( &mt->mt_mutex ); ldap_pvt_thread_mutex_lock( &mt->mt_mutex );
if ( mt->mt_mods == NULL ) { if ( mt->mt_mods == NULL ) {
@ -2723,7 +2723,7 @@ retry:
mt->mt_tail = mi; mt->mt_tail = mi;
ber_dupbv( &mt->mt_dn, &mi->mi_op->o_req_ndn ); ber_dupbv( &mt->mt_dn, &mi->mi_op->o_req_ndn );
ldap_pvt_thread_mutex_init( &mt->mt_mutex ); ldap_pvt_thread_mutex_init( &mt->mt_mutex );
avl_insert( &si->si_mods, mt, sp_avl_cmp, avl_dup_error ); ldap_avl_insert( &si->si_mods, mt, sp_avl_cmp, ldap_avl_dup_error );
ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex ); ldap_pvt_thread_mutex_unlock( &si->si_mods_mutex );
} }
opc->smt = mt; opc->smt = mt;
@ -4022,7 +4022,7 @@ syncprov_db_destroy(
if ( si->si_logs ) { if ( si->si_logs ) {
sessionlog *sl = si->si_logs; sessionlog *sl = si->si_logs;
tavl_free( sl->sl_entries, (AVL_FREE)ch_free ); ldap_tavl_free( sl->sl_entries, (AVL_FREE)ch_free );
if ( sl->sl_mincsn ) if ( sl->sl_mincsn )
ber_bvarray_free( sl->sl_mincsn ); ber_bvarray_free( sl->sl_mincsn );
if ( sl->sl_sids ) if ( sl->sl_sids )

10
servers/slapd/overlays/translucent.c
View file

@ -819,7 +819,7 @@ static int translucent_search_cb(Operation *op, SlapReply *rs) {
le = rs->sr_entry; le = rs->sr_entry;
/* If entry is already on list, use it */ /* If entry is already on list, use it */
if ( tc->step & USE_LIST ) { if ( tc->step & USE_LIST ) {
re = tavl_delete( &tc->list, le, entry_dn_cmp ); re = ldap_tavl_delete( &tc->list, le, entry_dn_cmp );
if ( re ) { if ( re ) {
rs_flush_entry( op, rs, on ); rs_flush_entry( op, rs, on );
rc = test_filter( op, re, tc->orig ); rc = test_filter( op, re, tc->orig );
@ -910,7 +910,7 @@ static int translucent_search_cb(Operation *op, SlapReply *rs) {
} }
/* If both filters, save entry for later */ /* If both filters, save entry for later */
if ( tc->step == (USE_LIST|RMT_SIDE) ) { if ( tc->step == (USE_LIST|RMT_SIDE) ) {
tavl_insert( &tc->list, re, entry_dn_cmp, avl_dup_error ); ldap_tavl_insert( &tc->list, re, entry_dn_cmp, ldap_avl_dup_error );
rs->sr_entry = NULL; rs->sr_entry = NULL;
rc = 0; rc = 0;
} else { } else {
@ -1180,7 +1180,7 @@ static int translucent_search(Operation *op, SlapReply *rs) {
if ( tc.list ) { if ( tc.list ) {
TAvlnode *av; TAvlnode *av;
av = tavl_end( tc.list, TAVL_DIR_LEFT ); av = ldap_tavl_end( tc.list, TAVL_DIR_LEFT );
while ( av ) { while ( av ) {
rs->sr_entry = av->avl_data; rs->sr_entry = av->avl_data;
if ( rc == LDAP_SUCCESS && LDAP_COMPARE_TRUE == if ( rc == LDAP_SUCCESS && LDAP_COMPARE_TRUE ==
@ -1191,9 +1191,9 @@ static int translucent_search(Operation *op, SlapReply *rs) {
} else { } else {
entry_free( rs->sr_entry ); entry_free( rs->sr_entry );
} }
av = tavl_next( av, TAVL_DIR_RIGHT ); av = ldap_tavl_next( av, TAVL_DIR_RIGHT );
} }
tavl_free( tc.list, NULL ); ldap_tavl_free( tc.list, NULL );
rs->sr_flags = 0; rs->sr_flags = 0;
rs->sr_entry = NULL; rs->sr_entry = NULL;
} }

2
servers/slapd/slap.h
View file

@ -40,7 +40,7 @@
#include <ac/time.h> #include <ac/time.h>
#include <ac/param.h> #include <ac/param.h>
#include "avl.h" #include "ldap_avl.h"
#ifndef ldap_debug #ifndef ldap_debug
#define ldap_debug slap_debug #define ldap_debug slap_debug

20
servers/slapd/syncrepl.c
View file

@ -3812,8 +3812,8 @@ presentlist_insert(
memcpy(&s, syncUUID->bv_val, 2); memcpy(&s, syncUUID->bv_val, 2);
memcpy(val, syncUUID->bv_val+2, UUIDLEN-2); memcpy(val, syncUUID->bv_val+2, UUIDLEN-2);
if ( avl_insert( &av[s], val, if ( ldap_avl_insert( &av[s], val,
syncuuid_cmp, avl_dup_error ) ) syncuuid_cmp, ldap_avl_dup_error ) )
{ {
ch_free( val ); ch_free( val );
return 0; return 0;
@ -3823,8 +3823,8 @@ presentlist_insert(
AC_MEMCPY( val, syncUUID->bv_val, UUIDLEN ); AC_MEMCPY( val, syncUUID->bv_val, UUIDLEN );
if ( avl_insert( &si->si_presentlist, val, if ( ldap_avl_insert( &si->si_presentlist, val,
syncuuid_cmp, avl_dup_error ) ) syncuuid_cmp, ldap_avl_dup_error ) )
{ {
ch_free( val ); ch_free( val );
return 0; return 0;
@ -3847,9 +3847,9 @@ presentlist_find(
return NULL; return NULL;
memcpy(&s, val->bv_val, 2); memcpy(&s, val->bv_val, 2);
return avl_find( a2[s], val->bv_val+2, syncuuid_cmp ); return ldap_avl_find( a2[s], val->bv_val+2, syncuuid_cmp );
#else #else
return avl_find( av, val->bv_val, syncuuid_cmp ); return ldap_avl_find( av, val->bv_val, syncuuid_cmp );
#endif #endif
} }
@ -3863,13 +3863,13 @@ presentlist_free( Avlnode *av )
if ( av ) { if ( av ) {
for (i=0; i<65536; i++) { for (i=0; i<65536; i++) {
if (a2[i]) if (a2[i])
count += avl_free( a2[i], ch_free ); count += ldap_avl_free( a2[i], ch_free );
} }
ch_free( av ); ch_free( av );
} }
return count; return count;
#else #else
return avl_free( av, ch_free ); return ldap_avl_free( av, ch_free );
#endif #endif
} }
@ -3883,9 +3883,9 @@ presentlist_delete(
unsigned short s; unsigned short s;
memcpy(&s, val->bv_val, 2); memcpy(&s, val->bv_val, 2);
avl_delete( &a2[s], val->bv_val+2, syncuuid_cmp ); ldap_avl_delete( &a2[s], val->bv_val+2, syncuuid_cmp );
#else #else
avl_delete( av, val->bv_val, syncuuid_cmp ); ldap_avl_delete( av, val->bv_val, syncuuid_cmp );
#endif #endif
} }

8
servers/slapd/syntax.c
View file

@ -60,7 +60,7 @@ syn_find( const char *synname )
{ {
struct sindexrec *sir = NULL; struct sindexrec *sir = NULL;
if ( (sir = avl_find( syn_index, synname, syn_index_name_cmp )) != NULL ) { if ( (sir = ldap_avl_find( syn_index, synname, syn_index_name_cmp )) != NULL ) {
return( sir->sir_syn ); return( sir->sir_syn );
} }
return( NULL ); return( NULL );
@ -113,7 +113,7 @@ syn_destroy( void )
{ {
Syntax *s; Syntax *s;
avl_free( syn_index, ldap_memfree ); ldap_avl_free( syn_index, ldap_memfree );
while( !LDAP_STAILQ_EMPTY( &syn_list ) ) { while( !LDAP_STAILQ_EMPTY( &syn_list ) ) {
s = LDAP_STAILQ_FIRST( &syn_list ); s = LDAP_STAILQ_FIRST( &syn_list );
LDAP_STAILQ_REMOVE_HEAD( &syn_list, ssyn_next ); LDAP_STAILQ_REMOVE_HEAD( &syn_list, ssyn_next );
@ -143,8 +143,8 @@ syn_insert(
} }
sir->sir_name = ssyn->ssyn_oid; sir->sir_name = ssyn->ssyn_oid;
sir->sir_syn = ssyn; sir->sir_syn = ssyn;
if ( avl_insert( &syn_index, (caddr_t) sir, if ( ldap_avl_insert( &syn_index, (caddr_t) sir,
syn_index_cmp, avl_dup_error ) ) { syn_index_cmp, ldap_avl_dup_error ) ) {
*err = ssyn->ssyn_oid; *err = ssyn->ssyn_oid;
ldap_memfree(sir); ldap_memfree(sir);
return SLAP_SCHERR_SYN_DUP; return SLAP_SCHERR_SYN_DUP;

22
servers/slapd/zn_malloc.c
View file

@ -87,7 +87,7 @@ slap_zn_mem_destroy(
ch_free(zh->zh_seqno); ch_free(zh->zh_seqno);
ch_free(zh->zh_znlock); ch_free(zh->zh_znlock);
avl_free(zh->zh_zonetree, slap_zo_release); ldap_avl_free(zh->zh_zonetree, slap_zo_release);
zo = LDAP_LIST_FIRST(&zh->zh_zopool); zo = LDAP_LIST_FIRST(&zh->zh_zopool);
while (zo) { while (zo) {
@ -217,7 +217,7 @@ slap_zn_mem_create(
zo->zo_ptr = zh->zh_zones[i]; zo->zo_ptr = zh->zh_zones[i];
zo->zo_siz = zh->zh_zonesize; zo->zo_siz = zh->zh_zonesize;
zo->zo_idx = i; zo->zo_idx = i;
avl_insert(&zh->zh_zonetree, zo, slap_zone_cmp, avl_dup_error); ldap_avl_insert(&zh->zh_zonetree, zo, slap_zone_cmp, ldap_avl_dup_error);
ldap_pvt_thread_rdwr_init(&zh->zh_znlock[i]); ldap_pvt_thread_rdwr_init(&zh->zh_znlock[i]);
} }
@ -371,7 +371,7 @@ retry:
zo->zo_ptr = zh->zh_zones[i]; zo->zo_ptr = zh->zh_zones[i];
zo->zo_siz = zh->zh_zonesize; zo->zo_siz = zh->zh_zonesize;
zo->zo_idx = i; zo->zo_idx = i;
avl_insert(&zh->zh_zonetree, zo, slap_zone_cmp, avl_dup_error); ldap_avl_insert(&zh->zh_zonetree, zo, slap_zone_cmp, ldap_avl_dup_error);
ldap_pvt_thread_rdwr_init(&zh->zh_znlock[i]); ldap_pvt_thread_rdwr_init(&zh->zh_znlock[i]);
} }
zh->zh_numzones += zh->zh_deltazones; zh->zh_numzones += zh->zh_deltazones;
@ -416,7 +416,7 @@ slap_zn_realloc(void *ptr, ber_len_t size, void *ctx)
if (zh) { if (zh) {
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
} }
@ -472,7 +472,7 @@ slap_zn_free(void *ptr, void *ctx)
if (zh) { if (zh) {
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
} }
@ -694,7 +694,7 @@ slap_zn_invalidate(
zoi.zo_idx = -1; zoi.zo_idx = -1;
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
if (zoo) { if (zoo) {
idx = zoo->zo_idx; idx = zoo->zo_idx;
@ -752,7 +752,7 @@ slap_zn_validate(
zoi.zo_ptr = ptr; zoi.zo_ptr = ptr;
zoi.zo_idx = -1; zoi.zo_idx = -1;
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
if (zoo) { if (zoo) {
idx = zoo->zo_idx; idx = zoo->zo_idx;
@ -810,7 +810,7 @@ int slap_zn_rlock(
zoi.zo_idx = -1; zoi.zo_idx = -1;
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
if (zoo) { if (zoo) {
@ -834,7 +834,7 @@ int slap_zn_runlock(
zoi.zo_idx = -1; zoi.zo_idx = -1;
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
if (zoo) { if (zoo) {
@ -858,7 +858,7 @@ int slap_zn_wlock(
zoi.zo_idx = -1; zoi.zo_idx = -1;
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
if (zoo) { if (zoo) {
@ -882,7 +882,7 @@ int slap_zn_wunlock(
zoi.zo_idx = -1; zoi.zo_idx = -1;
ldap_pvt_thread_mutex_lock( &zh->zh_mutex ); ldap_pvt_thread_mutex_lock( &zh->zh_mutex );
zoo = avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp); zoo = ldap_avl_find(zh->zh_zonetree, &zoi, slap_zone_cmp);
ldap_pvt_thread_mutex_unlock( &zh->zh_mutex ); ldap_pvt_thread_mutex_unlock( &zh->zh_mutex );
if (zoo) { if (zoo) {