int
main( int argc, char **argv )
{
Avlnode *tree = NULL, *n;
char command[ 10 ];
char name[ 80 ];
char *p;
printf( "> " );
while ( fgets( command, sizeof( command ), stdin ) != NULL ) {
switch( *command ) {
case 'n': /* new tree */
( void ) tavl_free( tree, free );
tree = NULL;
break;
case 'p': /* print */
( void ) myprint( tree );
break;
case 't': /* traverse with first, next */
printf( "***\n" );
for ( n = tavl_end( tree, TAVL_DIR_LEFT );
n != NULL;
n = tavl_next( n, TAVL_DIR_RIGHT ))
printf( "%s\n", n->avl_data );
printf( "***\n" );
break;
case 'f': /* find */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( (p = (char *) tavl_find( tree, name, avl_strcmp ))
== NULL )
printf( "Not found.\n\n" );
else
printf( "%s\n\n", p );
break;
case 'i': /* insert */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( tavl_insert( &tree, strdup( name ), avl_strcmp,
avl_dup_error ) != 0 )
printf( "\nNot inserted!\n" );
break;
case 'd': /* delete */
printf( "data? " );
if ( fgets( name, sizeof( name ), stdin ) == NULL )
exit( EXIT_SUCCESS );
name[ strlen( name ) - 1 ] = '\0';
if ( tavl_delete( &tree, name, avl_strcmp ) == NULL )
printf( "\nNot found!\n" );
break;
case 'q': /* quit */
exit( EXIT_SUCCESS );
break;
case '\n':
break;
default:
printf("Commands: insert, delete, print, new, quit\n");
}
printf( "> " );
}
return( 0 );
}
static int sssvlv_op_response(
Operation *op,
SlapReply *rs )
{
sort_ctrl *sc = op->o_controls[sss_cid];
sort_op *so = op->o_callback->sc_private;
if ( rs->sr_type == REP_SEARCH ) {
int i;
size_t len;
sort_node *sn, *sn2;
struct berval *bv;
char *ptr;
len = sizeof(sort_node) + sc->sc_nkeys * sizeof(struct berval) +
rs->sr_entry->e_nname.bv_len + 1;
sn = op->o_tmpalloc( len, op->o_tmpmemctx );
sn->sn_vals = (struct berval *)(sn+1);
/* Build tmp list of key values */
for ( i=0; i<sc->sc_nkeys; i++ ) {
Attribute *a = attr_find( rs->sr_entry->e_attrs,
sc->sc_keys[i].sk_ad );
if ( a ) {
if ( a->a_numvals > 1 ) {
bv = select_value( a, &sc->sc_keys[i] );
} else {
bv = a->a_nvals;
}
sn->sn_vals[i] = *bv;
len += bv->bv_len + 1;
} else {
BER_BVZERO( &sn->sn_vals[i] );
}
}
/* Now dup into regular memory */
sn2 = ch_malloc( len );
sn2->sn_vals = (struct berval *)(sn2+1);
memcpy( sn2->sn_vals, sn->sn_vals,
sc->sc_nkeys * sizeof(struct berval));
ptr = (char *)(sn2->sn_vals + sc->sc_nkeys);
sn2->sn_dn.bv_val = ptr;
sn2->sn_dn.bv_len = rs->sr_entry->e_nname.bv_len;
memcpy( ptr, rs->sr_entry->e_nname.bv_val,
rs->sr_entry->e_nname.bv_len );
ptr += rs->sr_entry->e_nname.bv_len;
*ptr++ = '\0';
for ( i=0; i<sc->sc_nkeys; i++ ) {
if ( !BER_BVISNULL( &sn2->sn_vals[i] )) {
memcpy(ptr, sn2->sn_vals[i].bv_val, sn2->sn_vals[i].bv_len);
sn2->sn_vals[i].bv_val = ptr;
ptr += sn2->sn_vals[i].bv_len;
*ptr++ = '\0';
}
}
op->o_tmpfree( sn, op->o_tmpmemctx );
sn = sn2;
sn->sn_conn = op->o_conn->c_conn_idx;
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 */
tavl_insert(&(so->so_tree), sn, node_insert, avl_dup_error);
so->so_nentries++;
/* Collected the keys so that they can be sorted. Thus, stop
* the entry from propagating.
*/
rs->sr_err = LDAP_SUCCESS;
}
else if ( rs->sr_type == REP_RESULT ) {
/* Remove serversort response callback.
* We don't want the entries that we are about to send to be
* processed by serversort response again. */
slap_callback **scp = &op->o_callback;
while ( *scp ) {
if ( (*scp)->sc_response == sssvlv_op_response ) {
*scp = (*scp)->sc_next;
break;
}
scp = &(*scp)->sc_next;
}
send_entry( op, rs, so );
send_result( op, rs, so );
}
return rs->sr_err;
}
static int translucent_search_cb(Operation *op, SlapReply *rs) {
trans_ctx *tc;
BackendDB *db;
slap_overinst *on;
translucent_info *ov;
Entry *le, *re;
Attribute *a, *ax, *an, *as = NULL;
int rc;
int test_f = 0;
tc = op->o_callback->sc_private;
/* Don't let the op complete while we're gathering data */
if ( rs->sr_type == REP_RESULT && ( tc->step & USE_LIST ))
return 0;
if(rs->sr_type != REP_SEARCH || !rs->sr_entry)
return(SLAP_CB_CONTINUE);
Debug(LDAP_DEBUG_TRACE, "==> translucent_search_cb: %s\n",
rs->sr_entry->e_name.bv_val, 0, 0);
op->ors_slimit = tc->slimit + ( tc->slimit > 0 ? 1 : 0 );
if ( op->ors_attrs == slap_anlist_all_attributes ) {
op->ors_attrs = tc->attrs;
rs->sr_attrs = tc->attrs;
rs->sr_attr_flags = slap_attr_flags( rs->sr_attrs );
}
on = tc->on;
ov = on->on_bi.bi_private;
db = op->o_bd;
re = NULL;
/* If we have local, get remote */
if ( tc->step & LCL_SIDE ) {
le = rs->sr_entry;
/* If entry is already on list, use it */
if ( tc->step & USE_LIST ) {
re = tavl_delete( &tc->list, le, entry_dn_cmp );
if ( re ) {
rs_flush_entry( op, rs, on );
rc = test_filter( op, re, tc->orig );
if ( rc == LDAP_COMPARE_TRUE ) {
rs->sr_flags |= REP_ENTRY_MUSTBEFREED;
rs->sr_entry = re;
if ( tc->slimit >= 0 && rs->sr_nentries >= tc->slimit ) {
return LDAP_SIZELIMIT_EXCEEDED;
}
return SLAP_CB_CONTINUE;
} else {
entry_free( re );
rs->sr_entry = NULL;
return 0;
}
}
}
op->o_bd = &ov->db;
rc = be_entry_get_rw( op, &rs->sr_entry->e_nname, NULL, NULL, 0, &re );
if ( rc == LDAP_SUCCESS && re ) {
Entry *tmp = entry_dup( re );
be_entry_release_r( op, re );
re = tmp;
test_f = 1;
}
} else {
/* Else we have remote, get local */
op->o_bd = tc->db;
le = NULL;
rc = overlay_entry_get_ov(op, &rs->sr_entry->e_nname, NULL, NULL, 0, &le, on);
if ( rc == LDAP_SUCCESS && le ) {
re = entry_dup( rs->sr_entry );
rs_flush_entry( op, rs, on );
} else {
le = NULL;
}
}
/*
** if we got remote and local entry:
** foreach local attr:
** foreach remote attr:
** if match, remote attr with local attr;
** if new local, add to list;
** append new local attrs to remote;
**
*/
if ( re && le ) {
for(ax = le->e_attrs; ax; ax = ax->a_next) {
for(a = re->e_attrs; a; a = a->a_next) {
if(a->a_desc == ax->a_desc) {
test_f = 1;
if(a->a_vals != a->a_nvals)
ber_bvarray_free(a->a_nvals);
ber_bvarray_free(a->a_vals);
ber_bvarray_dup_x( &a->a_vals, ax->a_vals, NULL );
if ( ax->a_vals == ax->a_nvals ) {
a->a_nvals = a->a_vals;
} else {
ber_bvarray_dup_x( &a->a_nvals, ax->a_nvals, NULL );
}
break;
}
}
if(a) continue;
an = attr_dup(ax);
an->a_next = as;
as = an;
}
/* Dispose of local entry */
if ( tc->step & LCL_SIDE ) {
rs_flush_entry(op, rs, on);
} else {
overlay_entry_release_ov(op, le, 0, on);
}
/* literally append, so locals are always last */
if(as) {
if(re->e_attrs) {
for(ax = re->e_attrs; ax->a_next; ax = ax->a_next);
ax->a_next = as;
} else {
re->e_attrs = as;
}
}
/* If both filters, save entry for later */
if ( tc->step == (USE_LIST|RMT_SIDE) ) {
tavl_insert( &tc->list, re, entry_dn_cmp, avl_dup_error );
rs->sr_entry = NULL;
rc = 0;
} else {
/* send it now */
rs->sr_entry = re;
rs->sr_flags |= REP_ENTRY_MUSTBEFREED;
if ( test_f ) {
rc = test_filter( op, rs->sr_entry, tc->orig );
if ( rc == LDAP_COMPARE_TRUE ) {
rc = SLAP_CB_CONTINUE;
} else {
rc = 0;
}
} else {
rc = SLAP_CB_CONTINUE;
}
}
} else if ( le ) {
/* Only a local entry: remote was deleted
* Ought to delete the local too...
*/
rc = 0;
} else if ( tc->step & USE_LIST ) {
/* Only a remote entry, but both filters:
* Test the complete filter
*/
rc = test_filter( op, rs->sr_entry, tc->orig );
if ( rc == LDAP_COMPARE_TRUE ) {
rc = SLAP_CB_CONTINUE;
} else {
rc = 0;
}
} else {
/* Only a remote entry, only remote filter:
* just pass thru
*/
rc = SLAP_CB_CONTINUE;
}
op->o_bd = db;
if ( rc == SLAP_CB_CONTINUE && tc->slimit >= 0 && rs->sr_nentries >= tc->slimit ) {
return LDAP_SIZELIMIT_EXCEEDED;
}
return rc;
}
int mdb_tool_idl_add(
MDB_cursor *mc,
struct berval *keys,
ID id )
{
MDB_dbi dbi;
mdb_tool_idl_cache *ic, itmp;
mdb_tool_idl_cache_entry *ice;
int i, rc, lcount;
AttrInfo *ai = (AttrInfo *)mc;
mc = ai->ai_cursor;
dbi = ai->ai_dbi;
for (i=0; keys[i].bv_val; i++) {
itmp.kstr = keys[i];
ic = tavl_find( (Avlnode *)ai->ai_root, &itmp, mdb_tool_idl_cmp );
/* No entry yet, create one */
if ( !ic ) {
MDB_val key, data;
ID nid;
int rc;
if ( ai->ai_clist ) {
ic = ai->ai_clist;
ai->ai_clist = ic->head;
} else {
ic = ch_malloc( sizeof( mdb_tool_idl_cache ) + itmp.kstr.bv_len + 4 );
}
ic->kstr.bv_len = itmp.kstr.bv_len;
ic->kstr.bv_val = (char *)(ic+1);
memcpy( ic->kstr.bv_val, itmp.kstr.bv_val, ic->kstr.bv_len );
ic->head = ic->tail = NULL;
ic->last = 0;
ic->count = 0;
ic->offset = 0;
ic->flags = 0;
tavl_insert( (Avlnode **)&ai->ai_root, ic, mdb_tool_idl_cmp,
avl_dup_error );
/* load existing key count here */
key.mv_size = keys[i].bv_len;
key.mv_data = keys[i].bv_val;
rc = mdb_cursor_get( mc, &key, &data, MDB_SET );
if ( rc == 0 ) {
ic->flags |= WAS_FOUND;
nid = *(ID *)data.mv_data;
if ( nid == 0 ) {
ic->count = MDB_IDL_DB_SIZE+1;
ic->flags |= WAS_RANGE;
} else {
size_t count;
mdb_cursor_count( mc, &count );
ic->count = count;
ic->first = nid;
ic->offset = count & (IDBLOCK-1);
}
}
}
/* are we a range already? */
if ( ic->count > MDB_IDL_DB_SIZE ) {
ic->last = id;
continue;
/* Are we at the limit, and converting to a range? */
} else if ( ic->count == MDB_IDL_DB_SIZE ) {
if ( ic->head ) {
ic->tail->next = ai->ai_flist;
ai->ai_flist = ic->head;
}
ic->head = ic->tail = NULL;
ic->last = id;
ic->count++;
continue;
}
/* No free block, create that too */
lcount = ic->count & (IDBLOCK-1);
if ( !ic->tail || lcount == 0) {
if ( ai->ai_flist ) {
ice = ai->ai_flist;
ai->ai_flist = ice->next;
} else {
ice = ch_malloc( sizeof( mdb_tool_idl_cache_entry ));
}
ice->next = NULL;
if ( !ic->head ) {
ic->head = ice;
} else {
ic->tail->next = ice;
}
ic->tail = ice;
if ( lcount )
ice->ids[lcount-1] = 0;
if ( !ic->count )
ic->first = id;
}
ice = ic->tail;
if (!lcount || ice->ids[lcount-1] != id)
ice->ids[lcount] = id;
ic->count++;
}
return 0;
}