int
turbo_sibling_search (Entry e, struct search_kid_arg *ska)
{
EntryInfo *list;
Entry *tmp;
DN dn;
Index *pindex;
*ska->ska_einfo = NULLENTRYINFO;
if ( e->e_leaf )
return;
if ( e->e_children == NULLAVL ) {
search_refer( ska->ska_arg, e, ska->ska_local, ska->ska_refer,
ska->ska_ismanager );
return;
}
dn = get_copy_dn( e );
if ( (pindex = get_sibling_index( dn )) == NULLINDEX ) {
LLOG( log_dsap, LLOG_EXCEPTIONS, ("Cannot find sibling index") );
dn_free( dn );
return;
}
dn_free( dn );
g_size_normalizer = 1;
list = turbo_filterkids( e, ska->ska_arg->sra_filter, ska, pindex, 1 );
apply_sacl( &list, e, ska );
/* security error coming back */
if ( ska->ska_saclerror < 0 ) {
entryinfo_free( list, 0 );
return;
}
if ( *ska->ska_einfo == NULLENTRYINFO )
*ska->ska_einfo = list;
else if ( list != NULLENTRYINFO )
entryinfo_append( *ska->ska_einfo, list );
/* sizelimit already exceeded */
if ( ska->ska_saclerror > 0 )
return;
if ( ska->ska_arg->sra_searchaliases && pindex->i_nonlocalaliases
!= (Entry *) 0 ) {
for ( tmp = pindex->i_nonlocalaliases; *tmp; tmp++ )
do_alias( ska->ska_arg, *tmp, ska->ska_local );
}
}
int
makeListOrganisations (struct namelist **olistp)
{
entrystruct * x;
int retval;
if (rebind() != OK)
return NOTOK;
retval = ds_search(&sarg, &serror, &sresult);
if ((retval == DSE_INTR_ABANDONED) &&
(serror.dse_type == DSE_ABANDONED))
abandoned = TRUE;
if (retval != OK)
return NOTOK;
correlate_search_results (&sresult);
setProblemFlags(sresult);
highNumber = 0;
for (x = sresult.CSR_entries; x != NULLENTRYINFO; x = x->ent_next) {
*olistp = list_alloc();
(*olistp)->name = dn2pstr(x->ent_dn);
(*olistp)->ats = as_cpy(x->ent_attr);
olistp = &(*olistp)->next;
highNumber++;
}
*olistp = NULLLIST;
entryinfo_free(sresult.CSR_entries, 0);
dn_free (sresult.CSR_object);
crefs_free (sresult.CSR_cr);
filter_free(sarg.sra_filter);
return OK;
}
int
Usage (char *rtn)
{
extern DN dn,
savename;
int i;
dn_free (dn);
dn = savename;
savename = NULLDN;
if (print_arg_error (OPT) == OK)
return;
for (i = 0; help_info[i].command != 0; i++)
if (strcmp (help_info[i].command, rtn) == 0) {
if (help_info[i].serv) {
ps_printf (OPT, "Usage %s [-help] [<object>] %s \n", rtn, help_info[i].args);
print_other(OPT, help_info[i].other);
ps_printf (OPT, "\n[<service controls>]\n");
} else
ps_printf (OPT, "Usage %s [-help] %s\n", rtn, help_info[i].args);
return;
}
ps_print (OPT, "Usage...\n");
}
int
consolidate_move (void) {
if (move_flag) {
move_flag = FALSE;
dn_free (fixed_pos);
fixed_pos = dn_cpy (dn);
}
}
rstatus_t
rack_deinit(struct rack *rack)
{
if (rack->continuum != NULL) {
dn_free(rack->continuum);
}
return DN_OK;
}
static void
dict_node_destructor(void *privdata, void *val)
{
DICT_NOTUSED(privdata);
struct gossip_node *node = val;
node_deinit(node);
dn_free(node);
}
void
dmsg_free(struct dmsg *dmsg)
{
#ifdef DN_DEBUG_LOG
log_debug(LOG_VVERB, "free dmsg %p id %"PRIu64"", dmsg, dmsg->id);
#endif
dn_free(dmsg);
}
void
dict_string_destructor(void *privdata, void *val)
{
DICT_NOTUSED(privdata);
struct string *s = val;
string_deinit(s);
dn_free(s);
}
static void
stats_destroy_buf(struct stats *st)
{
if (st->buf.size != 0) {
ASSERT(st->buf.data != NULL);
dn_free(st->buf.data);
st->buf.size = 0;
}
}
void
stats_destroy(struct stats *st)
{
stats_stop_aggregator(st);
stats_pool_unmap(&st->sum);
stats_pool_unmap(&st->shadow);
stats_pool_unmap(&st->current);
stats_destroy_buf(st);
dn_free(st);
}
void
event_base_destroy(struct event_base *evb)
{
int status;
if (evb == NULL) {
return;
}
ASSERT(evb->ep > 0);
dn_free(evb->event);
status = close(evb->ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", evb->ep, strerror(errno));
}
evb->ep = -1;
dn_free(evb);
}
static void
core_ctx_destroy(struct context *ctx)
{
log_debug(LOG_VVERB, "destroy ctx %p id %"PRIu32"", ctx, ctx->id);
proxy_deinit(ctx);
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
}
static void
mbuf_free(struct mbuf *mbuf)
{
uint8_t *buf;
log_debug(LOG_VVERB, "put mbuf %p len %d", mbuf, mbuf->last - mbuf->pos);
ASSERT(STAILQ_NEXT(mbuf, next) == NULL);
ASSERT(mbuf->magic == MBUF_MAGIC);
buf = (uint8_t *)mbuf - mbuf_offset;
dn_free(buf);
}
int
aps_free (struct access_point *app)
{
if(app == NULLACCESSPOINT)
return;
aps_free(app->ap_next);
dn_free(app->ap_name);
if (app->ap_address)
psap_free (app->ap_address);
free((char *)app);
}
int
dn_seq_free (struct dn_seq *dnseq)
{
struct dn_seq * ptr;
struct dn_seq * next;
for (ptr=dnseq ; ptr!=NULLDNSEQ; ptr=next ) {
next = ptr->dns_next;
dn_free (ptr->dns_dn);
free ((char *) ptr);
}
}
void
mbuf_dealloc(struct mbuf *mbuf)
{
uint8_t *buf;
log_debug(LOG_VVERB, "free mbuf %p len %d", mbuf, mbuf->last - mbuf->pos);
ASSERT(STAILQ_NEXT(mbuf, next) == NULL);
ASSERT(mbuf->magic == MBUF_MAGIC);
size_t mbuf_offset = mbuf->chunk_size - MBUF_HSIZE;
buf = (uint8_t *)mbuf - mbuf_offset;
dn_free(buf);
}
struct event_base *
event_base_create(int nevent, event_cb_t cb)
{
struct event_base *evb;
int status, ep;
struct epoll_event *event;
ASSERT(nevent > 0);
ep = epoll_create(nevent);
if (ep < 0) {
log_error("epoll create of size %d failed: %s", nevent, strerror(errno));
return NULL;
}
event = dn_calloc(nevent, sizeof(*event));
if (event == NULL) {
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb = dn_alloc(sizeof(*evb));
if (evb == NULL) {
dn_free(event);
status = close(ep);
if (status < 0) {
log_error("close e %d failed, ignored: %s", ep, strerror(errno));
}
return NULL;
}
evb->ep = ep;
evb->event = event;
evb->nevent = nevent;
evb->cb = cb;
log_debug(LOG_INFO, "e %d with nevent %d", evb->ep, evb->nevent);
return evb;
}
int
conn_free (struct connection *conn)
{
DLOG(log_dsap, LLOG_TRACE, ("conn_free()"));
if(conn->cn_dn != NULLDN) {
dn_free(conn->cn_dn);
conn->cn_dn = NULLDN ;
}
if (conn->cn_initiator) {
conn_connect_free (&(conn->cn_connect));
} else {
conn_start_free (&(conn->cn_start));
}
check_getedb_ops(conn->cn_ad);
free((char *)conn);
}
static struct dyn_token *
dnode_peer_pool_hash(struct server_pool *pool, uint8_t *key, uint32_t keylen)
{
ASSERT(array_n(&pool->peers) != 0);
ASSERT(key != NULL && keylen != 0);
struct dyn_token *token = dn_alloc(sizeof(struct dyn_token));
if (token == NULL) {
return NULL;
}
init_dyn_token(token);
rstatus_t status = pool->key_hash((char *)key, keylen, token);
if (status != DN_OK) {
dn_free(token);
return NULL;
}
return token;
}
void
dmsg_free(struct dmsg *dmsg)
{
log_debug(LOG_VVVERB, "free dmsg %p id %"PRIu64"", dmsg, dmsg->id);
dn_free(dmsg);
}
static struct context *
core_ctx_create(struct instance *nci)
{
rstatus_t status;
struct context *ctx;
srand((unsigned) time(NULL));
ctx = dn_alloc(sizeof(*ctx));
if (ctx == NULL) {
return NULL;
}
ctx->id = ++ctx_id;
ctx->cf = NULL;
ctx->stats = NULL;
ctx->evb = NULL;
array_null(&ctx->pool);
ctx->max_timeout = nci->stats_interval;
ctx->timeout = ctx->max_timeout;
ctx->dyn_state = INIT;
/* parse and create configuration */
ctx->cf = conf_create(nci->conf_filename);
if (ctx->cf == NULL) {
loga("Failed to create context!!!");
dn_free(ctx);
return NULL;
}
/* initialize server pool from configuration */
status = server_pool_init(&ctx->pool, &ctx->cf->pool, ctx);
if (status != DN_OK) {
loga("Failed to initialize server pool!!!");
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* crypto init */
status = crypto_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize crypto!!!");
dn_free(ctx);
return NULL;
}
/* create stats per server pool */
ctx->stats = stats_create(nci->stats_port, nci->stats_addr, nci->stats_interval,
nci->hostname, &ctx->pool, ctx);
if (ctx->stats == NULL) {
loga("Failed to create stats!!!");
crypto_deinit();
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize event handling for client, proxy and server */
ctx->evb = event_base_create(EVENT_SIZE, &core_core);
if (ctx->evb == NULL) {
loga("Failed to create socket event handling!!!");
crypto_deinit();
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* preconnect? servers in server pool */
status = server_pool_preconnect(ctx);
if (status != DN_OK) {
loga("Failed to preconnect for server pool!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize proxy per server pool */
status = proxy_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize proxy!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
/* initialize dnode listener per server pool */
status = dnode_init(ctx);
if (status != DN_OK) {
loga("Failed to initialize dnode!!!");
crypto_deinit();
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
ctx->dyn_state = JOINING; //TODOS: change this to JOINING
/* initialize peers */
status = dnode_peer_init(&ctx->pool, ctx);
if (status != DN_OK) {
loga("Failed to initialize dnode peers!!!");
crypto_deinit();
dnode_deinit(ctx);
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
core_debug(ctx);
/* preconntect peers - probably start gossip here */
status = dnode_peer_pool_preconnect(ctx);
if (status != DN_OK) {
loga("Failed to preconnect dnode peers!!!");
crypto_deinit();
dnode_peer_deinit(&ctx->pool);
dnode_deinit(ctx);
server_pool_disconnect(ctx);
event_base_destroy(ctx->evb);
stats_destroy(ctx->stats);
server_pool_deinit(&ctx->pool);
conf_destroy(ctx->cf);
dn_free(ctx);
return NULL;
}
//init ring msg queue
CBUF_Init(C2G_InQ);
CBUF_Init(C2G_OutQ);
//init stats msg queue
CBUF_Init(C2S_InQ);
CBUF_Init(C2S_OutQ);
gossip_pool_init(ctx);
log_debug(LOG_VVERB, "created ctx %p id %"PRIu32"", ctx, ctx->id);
return ctx;
}
dsEnqError list_start()
{
struct ds_search_arg search_arg;
struct ds_search_result result;
struct DSError error;
dsEnqError return_error;
return_error = Okay;
if (get_default_service (&search_arg.sra_common) != 0) {
return localdsaerror;
}
search_arg.sra_common.ca_servicecontrol.svc_options = SVC_OPT_PREFERCHAIN;
search_arg.sra_baseobject = (*base_path != 'T'?
str2dn (base_path):
NULLDN);
search_arg.sra_eis.eis_allattributes = FALSE;
search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTETYPESONLY;
search_arg.sra_eis.eis_select = 0;
search_arg.sra_searchaliases = TRUE;
search_arg.sra_subset = SRA_ONELEVEL;
search_arg.sra_filter = filter_alloc();
search_arg.sra_filter->flt_type = FILTER_NOT;
search_arg.sra_filter->flt_next = NULLFILTER;
search_arg.sra_filter->flt_un.flt_un_filter = filter_alloc();
search_arg.sra_filter->flt_un.flt_un_filter->flt_type = FILTER_ITEM;
search_arg.sra_filter->flt_un.flt_un_filter->flt_next = NULLFILTER;
search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_type
= FILTERITEM_EQUALITY;
search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
fi_un_ava.ava_type = AttrT_new("2.5.4.0");
search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.fi_un.
fi_un_ava.ava_value =
str2AttrV("dsa", search_arg.sra_filter->flt_un.flt_un_filter->
flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->
oa_syntax);
#ifndef NO_STATS
LLOG (log_stat,LLOG_NOTICE,("search +%s,extent %d, val objectClass != dsa",
base_path,search_arg.sra_subset));
#endif
if (search_arg.sra_filter->flt_un.flt_un_filter->flt_un.flt_un_item.
fi_un.fi_un_ava.ava_value == NULLAttrV) {
return_error = localdsaerror;
} else if (ds_search (&search_arg, &error, &result) != DS_OK) {
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
log_ds_error(&error);
ds_error_free(&error);
switch (error.dse_type) {
case DSE_LOCALERROR:
return_error = duaerror;
break;
case DSE_REMOTEERROR:
return_error = localdsaerror;
break;
case DSE_ATTRIBUTEERROR:
return_error = attributerror;
break;
case DSE_REFERRAL:
case DSE_DSAREFERRAL:
return_error = remotedsaerror;
break;
case DSE_SECURITYERROR:
return_error = security;
break;
case DSE_NAMEERROR:
return_error = namerror;
break;
case DSE_SERVICEERROR:
return_error = serviceerror;
break;
default:
return_error = localdsaerror;
break;
}
} else {
dn_number = 0;
if (result.CSR_entries != NULLENTRYINFO) {
register EntryInfo *ptr;
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
for (ptr = result.CSR_entries; ptr != NULLENTRYINFO;
ptr = ptr->ent_next) {
dn_number++;
dn2buf ((caddr_t)ptr->ent_dn, goto_path);
add_seq (&dnseq, goto_path);
}
if (dn_number) dnseq = SortList(dnseq);
} else if (result.CSR_limitproblem == LSR_NOLIMITPROBLEM) {
free_seq(dnseq);
dnseq = NULLDS;
dn_number = 0;
return_error = nothingfound;
}
if (result.CSR_limitproblem != LSR_NOLIMITPROBLEM) {
switch (result.CSR_limitproblem) {
case LSR_TIMELIMITEXCEEDED:
if (dn_number > 0) return_error = timelimit_w_partial;
else {
free_seq(dnseq);
dnseq = NULLDS;
return_error = timelimit;
}
break;
case LSR_SIZELIMITEXCEEDED:
return_error = listsizelimit;
break;
case LSR_ADMINSIZEEXCEEDED:
if (dn_number > 0) return_error = adminlimit_w_partial;
else {
free_seq(dnseq);
dnseq = NULLDS;
return_error = adminlimit;
}
break;
}
}
if (result.CSR_entries) entryinfo_free(result.CSR_entries, 0);
}
entry_number = dn_number;
filter_free(search_arg.sra_filter);
dn_free(search_arg.sra_baseobject);
ds_error_free(&error);
return return_error;
}
int
find_child_entry (DN object, common_args *ca, DN acl_who, struct dn_seq *dn_stack, int master, Entry *ent_p, struct DSError *err, struct di_block **di_p)
{
/* this is very similar to find_entry(), except a top level */
/* constructor is allowed */
int deref = FALSE;
int res;
DN dn_found;
Entry akid;
DLOG (log_dsap,LLOG_DEBUG,("find_child_entry"));
err->dse_type = DSE_NOERROR;
if ((ca->ca_servicecontrol.svc_options & SVC_OPT_DONTDEREFERENCEALIAS) == 0)
deref = TRUE;
if ((ca->ca_servicecontrol.svc_options & SVC_OPT_DONTUSECOPY) != 0)
master = TRUE;
switch(really_find_entry(object,deref,dn_stack,master,ent_p,err,di_p)) {
case DS_OK:
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - rfe: OK"));
/* Have set up ent_p continue processing */
break;
case DS_CONTINUE:
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - rfe: CONTINUE"));
#ifdef DEBUG
di_list_log((*di_p));
#endif
/* Have set up di_blocks of DSAs to be questioned */
return(DS_CONTINUE);
case DS_X500_ERROR:
/* Have set up an error */
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - rfe: X500_ERROR"));
return(DS_X500_ERROR);
default:
/* Scream */
LLOG(log_dsap, LLOG_EXCEPTIONS, ("really_find_entry failed in find_entry 1"));
return(DS_ERROR_LOCAL);
}
/* check to see if children OK */
if ((*ent_p)->e_children != NULLAVL && (*ent_p)->e_allchildrenpresent
!= FALSE) {
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - children OK"));
akid = (Entry) avl_getone((*ent_p)->e_children);
switch (akid->e_data) {
case E_DATA_MASTER:
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - children masters"));
break;
case E_TYPE_SLAVE:
/* see if we can use a copy ... */
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - children slaves"));
if (master) {
dn_found = get_copy_dn (*ent_p);
res = constructor_dsa_info_aux(dn_found,dn_stack,master,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
}
break;
default:
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - default"));
dn_found = get_copy_dn (*ent_p);
res = constructor_dsa_info_aux(dn_found,dn_stack,master,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
}
} else if ( (! isleaf(*ent_p)) || (*ent_p)->e_external) {
DLOG(log_dsap, LLOG_DEBUG, ("find_child_entry - children NOTOK"));
dn_found = get_copy_dn (*ent_p);
res = constructor_dsa_info_aux(dn_found,dn_stack,master,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
}
if (check_acl (acl_who,ACL_DETECT, (*ent_p)->e_acl->ac_child, object) == NOTOK) {
err->dse_type = DSE_SECURITYERROR;
err->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
return (DS_X500_ERROR);
}
return (DS_OK);
}
int
move (char *arg)
{
extern int print_parse_errors;
DN user_down ();
DN str2dn_aux ();
DN sequence_dn();
DN tmpdn;
char * ptr;
char alias = FALSE;
int len;
print_parse_errors = FALSE;
if (*arg == '-') {
print_parse_errors = TRUE;
return (NOTOK); /* can't be a move if it starts with a minus */
}
if (*arg == '+')
arg++; /* old style call */
ptr = arg;
while (*ptr != 0) {
if (! isdigit (*ptr))
break;
ptr++;
}
if (*ptr == 0) {
/* sequence move */
dn_free (dn);
dn = dn_cpy (sequence_dn(atoi(arg)));
print_parse_errors = TRUE;
if (dn == NULLDN) {
ps_printf (OPT,"Invalid sequence number %s\n",arg);
return (NOTOK);
} else
return (OK);
}
len = strlen(arg);
if ((arg[0] == '<') && ( arg[len-1] == '>')) {
dn_free(dn);
dn = str2dn(arg);
return (OK);
}
if ((ptr = index (arg,'@')) != NULLCP) {
*ptr = 0;
if (*arg == 0) {
/* from root */
dn_free (dn);
dn = NULLDN;
*ptr ='@';
arg = ++ptr;
if (*arg == 0) {
print_parse_errors = TRUE;
return (OK); /* @ -> move to root */
}
if ((ptr = index (arg,'@')) != NULLCP)
*ptr = 0;
}
} else {
dn_free (dn);
dn = dn_cpy (fixed_pos);
}
if (strcmp (arg,"..") == 0) {
do {
DN dnptr;
DN trail;
if (dn == NULLDN) {
print_parse_errors = TRUE;
ps_print (OPT, "Can't go back past root\n");
return (NOTOK);
}
if (dn->dn_parent == NULLDN) {
dn_free (dn);
dn = NULLDN;
} else {
for (dnptr = dn; dnptr->dn_parent != NULLDN; dnptr = dnptr->dn_parent)
trail = dnptr;
dn_comp_free (dnptr);
trail->dn_parent = NULLDN;
}
if (ptr == NULLCP) {
print_parse_errors = TRUE;
return (OK);
}
arg = ++ptr;
if ((ptr = index (arg,'@')) != NULLCP)
*ptr = 0;
} while (strcmp (arg,"..") == 0);
}
if (ptr != NULL)
*ptr = '@';
if ((tmpdn = str2dn_aux (arg,&alias)) != NULLDN) {
if (dn == NULLDN)
dn = tmpdn;
else {
if (alias) {
dn_free (dn);
dn = tmpdn;
} else
dn_append (dn,tmpdn);
}
print_parse_errors = TRUE;
return (OK);
} else {
print_parse_errors = TRUE;
return (NOTOK);
}
}
int
set_current_pos (void) {
move_flag = FALSE;
dn_free (dn);
dn = dn_cpy (fixed_pos);
}
int
find_entry (DN object, common_args *ca, DN acl_who, struct dn_seq *dn_stack, int master, Entry *ent_p, struct DSError *err, struct di_block **di_p, int optype)
{
int deref = FALSE;
extern time_t cache_timeout;
DN dn_found;
int res;
DLOG (log_dsap,LLOG_TRACE,("find_entry"));
err->dse_type = DSE_NOERROR;
if ((ca->ca_servicecontrol.svc_options & SVC_OPT_DONTDEREFERENCEALIAS) == 0)
deref = TRUE;
if ((ca->ca_servicecontrol.svc_options & SVC_OPT_DONTUSECOPY) != 0)
master = TRUE;
switch(really_find_entry(object,deref,dn_stack,master,ent_p,err,di_p)) {
case DS_OK:
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - rfe: OK"));
/* Have set up ent_p continue processing */
break;
case DS_CONTINUE:
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - rfe: CONT"));
#ifdef DEBUG
di_list_log((*di_p));
#endif
/* Have set up di_blocks of DSAs to be questioned */
return(DS_CONTINUE);
case DS_X500_ERROR:
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - rfe: X500_ERROR"));
/* Have set up an error */
return(DS_X500_ERROR);
default:
/* Scream */
LLOG(log_dsap, LLOG_EXCEPTIONS, ("really_find_entry failed in find_entry 1"));
return(DS_ERROR_LOCAL);
}
dn_found = get_copy_dn (*ent_p);
/* if the returned entry is a CONSTRUCTOR, return a referral */
if ((*ent_p)->e_data == E_TYPE_CONSTRUCTOR) {
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - constructor"));
res = constructor_dsa_info(dn_found,dn_stack,FALSE,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
}
/* if the returned entry is a COPY, - check service controls */
if (((*ent_p)->e_data != E_DATA_MASTER) && (master)) {
/* DSAs are special for read/modify */
if ((optype == OP_READ) ||
(optype == OP_MODIFYRDN) ||
(optype == OP_MODIFYENTRY)) {
if ((quipu_ctx_supported (*ent_p) > 2) && (quipu_version_7 (*ent_p))) {
if (dn_cmp (dn_found, mydsadn) == 0)
goto out;
mk_ref:
;
(*di_p) = di_alloc();
(*di_p)->di_type = DI_TASK;
(*di_p)->di_dn = dn_found;
(*di_p)->di_target = dn_cpy(dn_found);
(*di_p)->di_reftype = RT_UNDEFINED;
(*di_p)->di_rdn_resolved = CR_RDNRESOLVED_NOTDEFINED;
(*di_p)->di_aliasedRDNs = CR_NOALIASEDRDNS;
(*di_p)->di_entry = *ent_p;
(*ent_p)->e_refcount++;
(*di_p)->di_state = DI_COMPLETE;
return DS_CONTINUE;
}
}
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - slave master needed"));
res = constructor_dsa_info(dn_found,dn_stack,TRUE,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
} else if ( ((optype == OP_MODIFYRDN) || (optype == OP_MODIFYENTRY)) &&
(quipu_ctx_supported (*ent_p) > 2) &&
quipu_version_7 (*ent_p) &&
(dn_cmp (dn_found, mydsadn) != 0))
goto mk_ref;
#ifdef WRONG_BEHAVIOUR
/* if this is right, we need to make sure that dsa_info */
/* pick ups the correct external reference */
if ((*ent_p)->e_external &&
((*ent_p)->e_reftype != RT_NONSPECIFICSUBORDINATE)) {
res = constructor_dsa_info(dn_found,dn_stack,TRUE,(*ent_p),err,di_p);
dn_free (dn_found);
return (res);
}
#endif
if (((*ent_p)->e_data == E_TYPE_CACHE_FROM_MASTER) &&
(timenow - (*ent_p)->e_age > cache_timeout)) {
DLOG(log_dsap, LLOG_DEBUG, ("find_entry - cache timed out"));
res = constructor_dsa_info(dn_found,dn_stack,TRUE,(*ent_p),err,di_p);
delete_cache (dn_found);
dn_free (dn_found);
return (res);
}
out:
;
dn_free (dn_found);
if ((*ent_p)->e_parent == NULLENTRY) {
DLOG(log_dsap, LLOG_DEBUG, ("find_entry: (*ent_p)->e_parent is NULLENTRY"));
return (DS_OK); /* no acl for root entry */
}
if (check_acl (acl_who,ACL_DETECT, (*ent_p)->e_parent->e_acl->ac_child, object) == NOTOK) {
err->dse_type = DSE_SECURITYERROR;
err->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
return (DS_X500_ERROR);
}
if (check_acl (acl_who,ACL_DETECT, (*ent_p)->e_acl->ac_entry, object) == NOTOK) {
err->dse_type = DSE_SECURITYERROR;
err->ERR_SECURITY.DSE_sc_problem = DSE_SC_ACCESSRIGHTS;
return (DS_X500_ERROR);
}
return (DS_OK);
}
static struct server *
dnode_peer_pool_server(struct server_pool *pool, struct rack *rack, uint8_t *key, uint32_t keylen)
{
struct server *server;
uint32_t hash, idx;
struct dyn_token *token = NULL;
ASSERT(array_n(&pool->peers) != 0);
//ASSERT(rack != NULL);
switch (pool->dist_type) {
case DIST_KETAMA:
token = dnode_peer_pool_hash(pool, key, keylen);
hash = token->mag[0];
idx = ketama_dispatch(rack->continuum, rack->ncontinuum, hash);
break;
case DIST_VNODE:
if (keylen == 0) {
idx = 0; //for no argument command
break;
}
token = dnode_peer_pool_hash(pool, key, keylen);
//print_dyn_token(token, 1);
idx = vnode_dispatch(rack->continuum, rack->ncontinuum, token);
//loga("found idx %d for rack '%.*s' ", idx, rack->name->len, rack->name->data);
break;
case DIST_MODULA:
token = dnode_peer_pool_hash(pool, key, keylen);
hash = token->mag[0];
idx = modula_dispatch(rack->continuum, rack->ncontinuum, hash);
break;
case DIST_RANDOM:
idx = random_dispatch(rack->continuum, rack->ncontinuum, 0);
break;
case DIST_SINGLE:
idx = 0;
break;
default:
NOT_REACHED();
return NULL;
}
//TODOs: should reuse the token
if (token != NULL) {
deinit_dyn_token(token);
dn_free(token);
}
ASSERT(idx < array_n(&pool->peers));
server = array_get(&pool->peers, idx);
log_debug(LOG_VERB, "dyn: key '%.*s' on dist %d maps to server '%.*s'", keylen,
key, pool->dist_type, server->pname.len, server->pname.data);
return server;
}
/* ---------------------------------------------------------------------------
.CSD: dget
.NAM:
.SHD:
.DSC: Realisierung suchen und Parameter lesen
- der Inhalt der Parameterstruktur wird bis auf die Komponenten
xt und lxt grundsaetzlich geloescht,
- alle fuer die gesuchte Realisierung nicht spezifizierten
Felder (Zeiger darauf) enthalten den NULL-Poiter!
- wurde die gesuchte Realisierung nicht gefunden, sind in parms
bis auf xt/lxt ebenfalls alle anderen Komponenten geloescht!
.RES:
.REM:
.SAL:
.EXF:
.END.
---------------------------------------------------------------------------
*/
short dget( DNORM_DCB * stream, short knr, short rnr, DPARA * parms )
{
RVB rvb;
VRVB vrvb;
char * buffer; /* Puffer fuer Daten des var.Rea.vorblocks */
char * pt;
KR_NODE * node;
char * m_xt, * m_vdt;
short m_lxt, m_lvdt;
char m_dtype[2];
double m_dres1, m_dres2, m_dres3, m_dres4, m_dres5;
long read_bytes;
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
union
{
struct
{
char l;
char h;
} b;
short s;
} val;
#endif
/* ---------- Pruefung des Argumentstreams ----------
*/
if ( stream == NULL || stream->fp == NULL ) /* garnicht offen! */
{
derrno = DNERR_CLSTREAM;
return( EOF );
}
if ( stream->fopen_mode == 'w' ||
stream->fopen_mode == 'a' ) /* nicht fuer mich! */
{
derrno = stream->err = DNERR_NOREADSTREAM;
return( EOF );
}
/* ---------- sind ueberhaupt Realisierungen im Baum? ----------
*/
if ( !stream->tree || !stream->objects )
{
derrno = stream->err = DNERR_NOREADOBJS;
return( EOF );
}
/* ---------- aktuell in parms gesetzte Parameter merken
(nur die dateiglobalen) ----------
*/
m_xt = parms->xt;
m_lxt = parms->lxt;
m_vdt = parms->vdt;
m_lvdt = parms->lvdt;
m_dtype[0] = parms->dtype[0];
m_dtype[1] = parms->dtype[1];
m_dres1 = parms->dres1;
m_dres2 = parms->dres2;
m_dres3 = parms->dres3;
m_dres4 = parms->dres4;
m_dres5 = parms->dres5;
/* ---------- aktuell in parms gesetzte realis.spezif. Parameter
loeschen ----------
*/
if ( parms->rb && parms->lrb )
dn_free( parms->rb ); /* geloescht! und der Speich*/
if ( parms->rt && parms->lrt )
dn_free( parms->rt ); /* fuer alte rb/rt/dt... */
if ( parms->dt && parms->ldt )
dn_free( parms->dt ); /* geloescht */
if ( parms->ht && parms->lht )
dn_free( parms->ht );
if ( parms->vrt && parms->lvrt )
dn_free( parms->vrt );
memset( parms, '\0', sizeof( DPARA ) ); /* */
/* ---------- gemerkte dateiglob.Parms zuruecksetzen ----------
*/
parms->xt = m_xt; /* und nun wieder xt-Angaben*/
parms->lxt = m_lxt; /* zurueckspeichern */
parms->vdt = m_vdt; /* auch property desrciption*/
parms->lvdt = m_lvdt; /* zurueckspeichern */
parms->dtype[0] = m_dtype[0];
parms->dtype[1] = m_dtype[1];
parms->dres1 = m_dres1;
parms->dres2 = m_dres2;
parms->dres3 = m_dres3;
parms->dres4 = m_dres4;
parms->dres5 = m_dres5;
/* ---------- Suche der spez. Realisierung im Realis.baum
folgende Suchvarianten werden unterstuetzt:
Fall 1: 1.knr/1.rnr der Datei (FIRST/FIRST)
Fall 2.1: naechste knr/rnr der Datei (NEXT/NEXT)
bei erstem Zugriff auf Datei (identisch
mit (FIRST/FIRST)
Fall 2.2: naechste knr/rnr der Datei (NEXT/NEXT)
bei Folgezugriff auf Datei.
Fall 3: erste rnr bei konstanter knr (knr/FIRST)
(nicht implementiert)
Fall 4: naechste rnr bei erster knr (FIRST/NEXT)
(nicht implementiert)
Fall 5: naechste rnr bei konstanter knr (knr/NEXT)
(nicht implementiert)
Fall 6: erste knr bei konstanter rnr (FIRST/rnr)
(nicht implementiert)
Fall 7: naechste knr bei erster rnr (NEXT/FIRST)
(nicht implementiert)
Fall 8: naechste knr bei konstanter rnr (NEXT/rnr)
(nicht implementiert)
Fall 9: bestimmte knr und bestimmte rnr (knr/rnr)
*/
/* ---------- Fall 1: ----------
*/
if ( knr == FIRST && rnr == FIRST ) /* erste Kl/Real. */
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_FIRST ), /* erste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
else if ( knr == NEXT && rnr == NEXT ) /* naechste Kl/Real.*/
{
/* ---------- Fall 2.1: ----------
*/
if ( stream->knr == 0 && stream->rnr == 0 ) /* erster Zugriff */
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_FIRST ), /* erste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
/* ---------- Fall 2.2: ----------
*/
else
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_NEXT ), /* naechste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
}
/* ---------- Fall 9: ----------
*/
else /* normal spezifiz. */
{
if ( node = search_tree( stream->tree, knr, /* suchen nach knr/ */
rnr, SEARCH_KRN ), /* rnr */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
/* ---------- tatsaechliche knr/rnr fuer stream merken ----------
*/
stream->knr = node->knr;
stream->rnr = node->rnr;
/* ---------- konstanten Realisierungsvorblock lesen ----------
*/
stream->rvb_rba = node->rba; /* Beginn des Vorbl. merken */
fseek( stream->fp, node->rba, SEEK_SET ); /* auf RVB positionieren */
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
read_bytes = read_rvb( &rvb, stream->fp );
#else
fread( &rvb, (size_t)sizeof( RVB ),
(size_t)1, stream->fp ); /* ... und RVB einlesen */
read_bytes = sizeof( RVB );
#endif
/* ---------- Rest des Realisierungsvorblocks (variablen
Teil) lesen und in vrvb aufbereiten ----------
*/
pt = buffer = dn_malloc( ((size_t)rvb.vblocks * BL_SIZE) - read_bytes );
if(fread( pt, ((size_t)rvb.vblocks * BL_SIZE) - read_bytes, /* var.Parameter einlesen */
(size_t)1, stream->fp ) != 1) {
derrno = stream->err = DNERR_NOREADSTREAM;
return( EOF );
}
memset( &vrvb, '\0', sizeof( vrvb ) ); /* keine Parameter spezifiz.*/
pt += sizeof( vrvb.rb_sign );
vrvb.lrb = *(short *)pt;
#if defined _SUNGC_
myswab( &vrvb.lrb, sizeof( vrvb.lrb ), 1 );
#endif
pt += sizeof( vrvb.lrb );
if ( vrvb.lrb == 0 ) /* Das keine RB spezifiz.ist*/
{
derrno = stream->err = DNERR_BADRB;
return( EOF ); /* ist nicht zulaessig! */
}
vrvb.rb = (RB *)pt;
pt += vrvb.lrb;
pt += sizeof( vrvb.rt_sign );
vrvb.lrt = *(short *)pt;
#if defined _SUNGC_
myswab( &vrvb.lrt, sizeof( vrvb.lrt ), 1 );
#endif
pt += sizeof( vrvb.lrt );
if ( vrvb.lrt != 0 ) /* nur, wenn rt spezifiziert*/
vrvb.rt = pt; /* sonst bleibt vrvb.rt NULL*/
pt += vrvb.lrt;
pt += sizeof( vrvb.dt_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.ldt = val.s;
#else
vrvb.ldt = *(short *)pt;
pt += sizeof( vrvb.ldt );
#endif
#if defined _SUNGC_
myswab( &vrvb.ldt, sizeof( vrvb.ldt ), 1 );
#endif
if ( vrvb.ldt != 0 ) /* nur, wenn dt spezifiziert*/
vrvb.dt = pt;
pt += vrvb.ldt;
pt += sizeof( vrvb.ht_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.lht = val.s;
#else
vrvb.lht = *(short *)pt;
pt += sizeof( vrvb.lht );
#endif
#if defined _SUNGC_
myswab( &vrvb.lht, sizeof( vrvb.lht ), 1 );
#endif
if ( vrvb.lht != 0 ) /* nur, wenn ht spezifiziert*/
vrvb.ht = pt;
pt += vrvb.lht;
pt += sizeof( vrvb.vrt_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.lvrt = val.s;
#else
vrvb.lvrt = *(short *)pt;
pt += sizeof( vrvb.lvrt );
#endif
#if defined _SUNGC_
myswab( &vrvb.lvrt, sizeof( vrvb.lvrt ), 1 );
#endif
if ( vrvb.lvrt != 0 ) /* nur,wenn vrt spezifiziert*/
vrvb.vrt = pt;
pt += vrvb.lvrt;
/* ---------- alle gelesenen Realisierungsparameter in
die Parameterstruktur parms eintragen
(wenn spezifiziert) ----------
*/
/* ---------- 1. Parameter des konstanter Parameterteils ----------
*/
parms->knr = stream->knr; /* tatsaechliche Klassennnummer */
parms->rnr = stream->rnr; /* tatsaechliche Realisierungsnr. */
parms->vanz = rvb.vanz; /* Vektoranzahl */
parms->vdim = rvb.vdim; /* Vektordimension */
parms->vsize = rvb.vsize; /* Vektorgroesse in byte */
parms->zf = rvb.zf; /* Zeitfensterfaktor */
parms->fsr = rvb.fsr; /* Fortsetzrate */
parms->ofs = rvb.ofs; /* Offset */
parms->rres1 = rvb.rres1; /* Nutzerspezif. Zellen */
parms->rres2 = rvb.rres2; /* Nutzerspezif. Zellen */
parms->rres3 = rvb.rres3; /* Nutzerspezif. Zellen */
parms->rres4 = rvb.rres4; /* Nutzerspezif. Zellen */
parms->rres5 = rvb.rres5; /* Nutzerspezif. Zellen */
parms->rb = dn_malloc( vrvb.lrb +1 );
/* ---------- lesbare Daten vorhanden? ----------
*/
if ( !parms->vanz || !parms->vdim || !parms->vsize )
{
derrno = stream->err = DNERR_NOREADOBJS;
return( EOF );
}
/* ---------- 2. Parameter variabler Laenge ----------
*/
memmove( parms->rb, vrvb.rb, (size_t)vrvb.lrb );
((char *)parms->rb)[vrvb.lrb] = '\0';
parms->lrb = vrvb.lrb;
if ( vrvb.rt )
{
parms->rt = dn_malloc( vrvb.lrt +1 );
memmove( parms->rt, vrvb.rt, (size_t)vrvb.lrt );
((char *)parms->rt)[vrvb.lrt] = '\0';
parms->lrt = vrvb.lrt;
}
if ( vrvb.dt )
{
parms->dt = dn_malloc( vrvb.ldt +1 );
memmove( parms->dt, vrvb.dt, (size_t)vrvb.ldt );
((char *)parms->dt)[vrvb.ldt] = '\0';
parms->ldt = vrvb.ldt;
}
if ( vrvb.ht )
{
parms->ht = dn_malloc( vrvb.lht +1 );
memmove( parms->ht, vrvb.ht, (size_t)vrvb.lht );
((char *)parms->ht)[vrvb.lht] = '\0';
parms->lht = vrvb.lht;
}
if ( vrvb.vrt )
{
parms->vrt = dn_malloc( vrvb.lvrt +1 );
memmove( parms->vrt, vrvb.vrt, (size_t)vrvb.lvrt );
((char *)parms->vrt)[vrvb.lvrt] = '\0';
parms->lvrt = vrvb.lvrt;
}
/* ---------- aktuelle Realisierungsdatenblockgroessen fuer
stream merken ----------
*/
stream->dat_rba = ftell( stream->fp ); /* Beginn der Daten-blocks */
stream->r_rest = rvb.vsize * rvb.vanz; /* noch zu lesende Datenbyte*/
/* ---------- Speicherfreigaben ----------
*/
dn_free( buffer );
/* ----- Systemfehler bei File-E/A pruefen -----
*/
if ( ferror( stream->fp ) )
{
perror( "dnorm sys error" );
exit( 1 );
}
derrno = stream->err = DNERR_OK;
return( 0 );
} /* end of dget() */
int
really_find_entry (
DN object,
int deref,
struct dn_seq *dn_stack,
int master, /* Generate only master references - NB
does not imply returned entry is master */
Entry *ent_p,
struct DSError *err,
struct di_block **di_p
)
{
Entry parent;
Avlnode *kids;
int entryrdn_cmp ();
RDN b_rdn;
DN tdn, dn, dn_trail = NULLDN;
DN aliasdn = NULLDN;
int rdns, aliases;
DLOG (log_dsap,LLOG_TRACE,("really find entry"));
if (deref == -2) {
/* alias loop */
err->dse_type = DSE_NAMEERROR;
err->ERR_NAME.DSE_na_problem = DSE_NA_ALIASDEREFERENCE;
err->ERR_NAME.DSE_na_matched = NULLDN;
return (DS_X500_ERROR);
}
if (database_root == NULLENTRY) {
LLOG (log_dsap,LLOG_NOTICE,("null root !!!"));
return(dsa_info_parent(object, err, di_p, master));
}
if ((dn = object) == NULLDN) {
DLOG(log_dsap,LLOG_DEBUG,("really_fe - DS_OK: database_root"));
(*ent_p) = database_root;
return (DS_OK);
}
b_rdn = dn->dn_rdn;
if ((kids = database_root->e_children) == NULLAVL) {
DLOG(log_dsap, LLOG_DEBUG, ("database->e_child == NULLENTRY"));
return (no_reply_child (object,dn,dn_stack,master,database_root,err,di_p));
}
parent = database_root;
for(rdns = 1, aliases = 0 ; ; rdns++ ) { /* break or return out */
*ent_p = (Entry) avl_find(kids, (caddr_t) b_rdn, entryrdn_cmp);
if ( *ent_p == NULLENTRY ) {
int res = no_reply_edb(object, dn_trail, dn_stack,
master, parent, err, di_p);
if (res == DS_CONTINUE)
di_rdns (*di_p,rdns,aliases,NULLDN);
if (aliasdn)
dn_free (aliasdn);
return res;
}
if ( (*ent_p)->e_alias != NULLDN )
/* got an alias entry */
if (deref != FALSE) {
Entry new_entry;
int new_deref;
DN t_aliasdn;
err->dse_type = DSE_NAMEERROR;
new_deref = (deref == -1) ? -2 : -1;
switch(really_find_entry ((*ent_p)->e_alias,new_deref,dn_stack,master,&(new_entry),err,di_p)) {
case DS_OK:
DLOG(log_dsap, LLOG_DEBUG, ("rfe:rfe:OK"));
(*ent_p) = new_entry;
t_aliasdn = aliasdn;
aliasdn = get_copy_dn(new_entry);
aliases = 0;
for (tdn=aliasdn; tdn != NULLDN; tdn=tdn->dn_parent)
aliases++;
tdn = dn->dn_parent;
if (aliasdn == NULLDN)
dn = aliasdn = dn_cpy(tdn);
else {
for (dn = aliasdn;
dn->dn_parent != NULLDN;
dn = dn->dn_parent)
;
dn->dn_parent = dn_cpy(tdn);
}
if (t_aliasdn)
dn_free (t_aliasdn);
object = aliasdn;
break;
case DS_CONTINUE:
DLOG(log_dsap, LLOG_DEBUG, ("rfe:rfe:CONT"));
#ifdef DEBUG
di_list_log((*di_p));
#endif
t_aliasdn = aliasdn;
aliasdn = dn_cpy ((*ent_p)->e_alias);
aliases = 0;
for (tdn=aliasdn; tdn != NULLDN; tdn=tdn->dn_parent)
aliases++;
tdn = dn->dn_parent;
if (aliasdn == NULLDN)
dn = aliasdn = dn_cpy(tdn);
else {
for (dn = aliasdn;
dn->dn_parent != NULLDN;
dn = dn->dn_parent)
;
dn->dn_parent = dn_cpy(tdn);
}
if (t_aliasdn)
dn_free (t_aliasdn);
di_rdns (*di_p,rdns,aliases,aliasdn);
if (aliasdn)
dn_free (aliasdn);
return(DS_CONTINUE);
case DS_X500_ERROR:
DLOG(log_dsap, LLOG_DEBUG, ("rfe:rfe:X500ERR"));
if ((err->dse_type == DSE_NAMEERROR) &&
( err->ERR_NAME.DSE_na_problem == DSE_NA_ALIASDEREFERENCE)) {
if (err->ERR_NAME.DSE_na_matched == NULLDN) {
DN tmp_dn;
tmp_dn = dn->dn_parent;
dn->dn_parent = NULLDN;
err->ERR_NAME.DSE_na_matched = dn_cpy(object);
dn->dn_parent = tmp_dn;
pslog (log_dsap,LLOG_EXCEPTIONS,"Alias deref Problem",(IFP)dn_print,(caddr_t)err->ERR_NAME.DSE_na_matched);
}
if (aliasdn)
dn_free (aliasdn);
return (DS_X500_ERROR);
} else {
ds_error_free (err);
err->dse_type = DSE_NAMEERROR;
err->ERR_NAME.DSE_na_problem = DSE_NA_ALIASPROBLEM;
err->ERR_NAME.DSE_na_matched = dn_cpy((*ent_p)->e_alias);
pslog (log_dsap,LLOG_EXCEPTIONS,"Alias Problem",(IFP)dn_print,(caddr_t)err->ERR_NAME.DSE_na_matched);
if (aliasdn)
dn_free (aliasdn);
return (DS_X500_ERROR);
}
default:
if (aliasdn)
dn_free (aliasdn);
DLOG(log_dsap, LLOG_DEBUG, ("rfe:rfe:localerror"));
return(DS_ERROR_LOCAL);
}
} else if ( dn->dn_parent == NULLDN) {
DLOG(log_dsap,LLOG_DEBUG,("really_fe - DS_OK: ?1"));
if (aliasdn)
dn_free (aliasdn);
return(DS_OK);
} else {
/* alias on route - error in this case */
DN tmp_dn;
err->dse_type = DSE_NAMEERROR;
err->ERR_NAME.DSE_na_problem = DSE_NA_ALIASDEREFERENCE;
tmp_dn = dn->dn_parent;
dn->dn_parent = NULLDN;
err->ERR_NAME.DSE_na_matched = dn_cpy(object);
dn->dn_parent = tmp_dn;
pslog (log_dsap,LLOG_EXCEPTIONS,"Alias deref(2) Problem",(IFP)dn_print,(caddr_t)err->ERR_NAME.DSE_na_matched);
if (aliasdn)
dn_free (aliasdn);
return (DS_X500_ERROR);
}
if (dn->dn_parent == NULLDN) {
DLOG(log_dsap,LLOG_DEBUG,("really_fe - DS_OK: ?2"));
if (aliasdn)
dn_free (aliasdn);
return (DS_OK);
}
if ((*ent_p)->e_children == NULLAVL) {
int res = no_reply_child (object,dn,dn_stack,master,(*ent_p),err,di_p);
if (res == DS_CONTINUE)
di_rdns (*di_p,rdns,aliases,NULLDN);
if (aliasdn)
dn_free (aliasdn);
return res;
}
dn_trail = dn;
dn = dn->dn_parent;
b_rdn = dn->dn_rdn;
kids = (*ent_p)->e_children;
parent = *ent_p;
}
/* NOTREACHED */
}
int
turbo_subtree_search (Entry e, struct search_kid_arg *ska)
{
EntryInfo *list;
Entry *tmp;
DN dn;
Index *pindex;
dn = get_copy_dn( e );
if ( (pindex = get_subtree_index( dn )) == NULLINDEX ) {
LLOG( log_dsap, LLOG_EXCEPTIONS, ("Cannot find subtree index") );
dn_free( dn );
return;
}
dn_free( dn );
g_size_normalizer = 1;
list = turbo_filterkids( e, ska->ska_arg->sra_filter, ska, pindex, 1 );
apply_sacl( &list, e, ska );
/* security error coming back */
if ( ska->ska_saclerror < 0 ) {
entryinfo_free( list, 0 );
return;
}
if ( *ska->ska_einfo == NULLENTRYINFO )
*ska->ska_einfo = list;
else if ( list != NULLENTRYINFO )
entryinfo_append( *ska->ska_einfo, list );
/* sizelimit already exceeded */
if ( ska->ska_saclerror > 0 )
return;
/*
* at this point, anything held locally below this point has been
* searched. we now search through the nonleaf children recursively
* for one whose children are not held locally, referring any that
* we find. next, we search through the list of nonlocal aliases
* searching for one that matches (if dereferencing is allowed).
*/
if ( pindex->i_nonleafkids != (Entry *) 0 )
subtree_refer( pindex, ska );
if ( ska->ska_arg->sra_searchaliases && pindex->i_nonlocalaliases
!= (Entry *) 0 ) {
for ( tmp = pindex->i_nonlocalaliases; *tmp; tmp++ ) {
int i;
i = th_prefix( (*ska->ska_local)->st_originalbase,
(*tmp)->e_alias );
if ( i > 0 ) {
do_alias( ska->ska_arg, *tmp,
ska->ska_local );
}
}
}
}
