void audio_output_finish(struct audio_output *ao)
{
audio_output_close(ao);
assert(ao->fail_timer == NULL);
if (ao->thread != NULL) {
g_mutex_lock(ao->mutex);
ao_command(ao, AO_COMMAND_KILL);
g_mutex_unlock(ao->mutex);
g_thread_join(ao->thread);
}
if (ao->mixer != NULL)
mixer_free(ao->mixer);
ao_plugin_finish(ao->plugin, ao->data);
g_cond_free(ao->cond);
g_mutex_free(ao->mutex);
if (ao->replay_gain_filter != NULL)
filter_free(ao->replay_gain_filter);
if (ao->other_replay_gain_filter != NULL)
filter_free(ao->other_replay_gain_filter);
filter_free(ao->filter);
pcm_buffer_deinit(&ao->cross_fade_buffer);
}
void
systrace_cleanpolicy(struct policy *policy)
{
struct filter *filter;
struct policy_syscall *pflq;
int i;
/* Set the default policy to ask */
for (i = 0; i < INTERCEPT_MAXSYSCALLNR; i++)
policy->kerneltable[i] = ICPOLICY_ASK;
while ((filter = TAILQ_FIRST(&policy->prefilters)) != NULL) {
TAILQ_REMOVE(&policy->prefilters, filter, policy_next);
filter_free(filter);
}
while ((filter = TAILQ_FIRST(&policy->filters)) != NULL) {
TAILQ_REMOVE(&policy->filters, filter, policy_next);
filter_free(filter);
}
while ((pflq = SPLAY_ROOT(&policy->pflqs)) != NULL) {
SPLAY_REMOVE(syscalltree, &policy->pflqs, pflq);
while ((filter = TAILQ_FIRST(&pflq->flq)) != NULL) {
TAILQ_REMOVE(&pflq->flq, filter, next);
filter_free(filter);
}
free(pflq);
}
}
static void dominoex_free(struct dominoex *s)
{
if (s) {
fft_free(s->fft);
sfft_free(s->sfft);
filter_free(s->hilbert);
g_free(s->pipe);
filter_free(s->filt);
g_free(s);
}
}
static void
constraint_free( constraint *cp, int freeme )
{
if (cp->restrict_lud)
ldap_free_urldesc(cp->restrict_lud);
if (!BER_BVISNULL(&cp->restrict_ndn))
ch_free(cp->restrict_ndn.bv_val);
if (cp->restrict_filter != NULL && cp->restrict_filter != slap_filter_objectClass_pres)
filter_free(cp->restrict_filter);
if (!BER_BVISNULL(&cp->restrict_val))
ch_free(cp->restrict_val.bv_val);
if (cp->re) {
regfree(cp->re);
ch_free(cp->re);
}
if (!BER_BVISNULL(&cp->val))
ch_free(cp->val.bv_val);
if (cp->lud)
ldap_free_urldesc(cp->lud);
if (cp->attrs)
ch_free(cp->attrs);
if (cp->ap)
ch_free(cp->ap);
if (freeme)
ch_free(cp);
}
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;
}
static int
replace_filter(DnfSack *sack, struct _Filter **fp, int keyname, int cmp_type,
const char *match)
{
if (*fp == NULL)
*fp = filter_create(1);
else
filter_reinit(*fp, 1);
struct _Filter *f = *fp;
f->keyname = keyname;
f->cmp_type = cmp_type;
if (keyname == HY_PKG_PROVIDES && cmp_type != HY_GLOB) {
f->match_type = _HY_RELDEP;
DnfReldep *reldep = reldep_from_str (sack, match);
if (reldep == NULL) {
filter_free(*fp);
*fp = NULL;
return DNF_ERROR_BAD_SELECTOR;
}
f->matches[0].reldep = reldep;
return 0;
}
f->match_type = _HY_STR;
f->matches[0].str = g_strdup(match);
return 0;
}
static void
chain_free_child(gpointer data, G_GNUC_UNUSED gpointer user_data)
{
struct filter *filter = data;
filter_free(filter);
}
void free_receiver(struct receiver *rx)
{
if (rx) {
filter_free(rx->filter);
hfree(rx);
}
}
/**
* Free the memory associated with the session
*
* @param instance The filter instance
* @param session The filter session
*/
static void
freeSession(FILTER *instance, void *session)
{
TEE_SESSION *my_session = (TEE_SESSION *)session;
SESSION* ses = my_session->branch_session;
session_state_t state;
#ifdef SS_DEBUG
skygw_log_write(LOGFILE_TRACE,"Tee free: %d", atomic_add(&debug_seq,1));
#endif
if (ses != NULL)
{
state = ses->state;
if (state == SESSION_STATE_ROUTER_READY)
{
session_free(ses);
}
else if (state == SESSION_STATE_TO_BE_FREED)
{
/** Free branch router session */
ses->service->router->freeSession(
ses->service->router_instance,
ses->router_session);
/** Free memory of branch client session */
ses->state = SESSION_STATE_FREE;
free(ses);
/** This indicates that branch session is not available anymore */
my_session->branch_session = NULL;
}
else if(state == SESSION_STATE_STOPPING)
{
orphan_session_t* orphan;
if((orphan = malloc(sizeof(orphan_session_t))) == NULL)
{
skygw_log_write(LOGFILE_ERROR,"Error : Failed to "
"allocate memory for orphan session struct, "
"child session might leak memory.");
}else{
orphan->session = ses;
spinlock_acquire(&orphanLock);
orphan->next = allOrphans;
allOrphans = orphan;
spinlock_release(&orphanLock);
}
}
}
if (my_session->dummy_filterdef)
{
filter_free(my_session->dummy_filterdef);
}
if(my_session->tee_replybuf)
gwbuf_free(my_session->tee_replybuf);
free(session);
orphan_free(NULL);
return;
}
static void
autoconvert_filter_finish(struct filter *_filter)
{
struct autoconvert_filter *filter =
(struct autoconvert_filter *)_filter;
filter_free(filter->filter);
g_free(filter);
}
static unsigned long autoPosixIds_next_available( Operation *op ) {
slap_overinst* on = (slap_overinst *)op->o_bd->bd_info;
autoPosixIds_data* ad = on->on_bi.bi_private;
Operation nop = *op;
SlapReply nrs = { REP_RESULT };
Filter* filter = NULL;
slap_callback cb = { NULL, autoPosixIds_search_cb, NULL, ad };
struct berval fstr = BER_BVNULL;
struct berval rootstr = BER_BVNULL;
int rc;
// if max uid is known don't bother searching the tree
if( ad->max_uid_number == 0 ) {
nop.o_callback = &cb;
op->o_bd->bd_info = (BackendInfo *) on->on_info;
nop.o_tag = LDAP_REQ_SEARCH;
nop.o_ctrls = NULL;
filter = str2filter( "(uidNumber=*)" );
filter2bv( filter, &fstr );
nop.ors_scope = LDAP_SCOPE_SUBTREE;
nop.ors_deref = LDAP_DEREF_NEVER;
nop.ors_slimit = -1;//SLAP_NO_LIMIT;
nop.ors_tlimit = -1;//SLAP_NO_LIMIT;
nop.ors_attrsonly = 1;
nop.ors_attrs = slap_anlist_no_attrs;
nop.ors_filter = filter;
nop.ors_filterstr = fstr;
memset( &nrs, 0, sizeof(nrs) );
nrs.sr_type = REP_RESULT;
nrs.sr_err = LDAP_SUCCESS;
nrs.sr_entry = NULL;
nrs.sr_flags |= REP_ENTRY_MUSTBEFREED;
nrs.sr_text = NULL;
nop.o_req_dn = rootstr;
nop.o_req_ndn = rootstr;
if( nop.o_bd->be_search ) {
rc = nop.o_bd->be_search( &nop, &nrs );
Debug( LDAP_DEBUG_TRACE, "%s: finished searching for entries with uidNumber\n", autoPosixIds.on_bi.bi_type, 0, 0 );
}
else {
Debug( LDAP_DEBUG_ANY, "%s: backend missing search function\n", autoPosixIds.on_bi.bi_type, 0, 0 );
}
if( filter ) filter_free( filter );
if( fstr.bv_val ) ch_free( fstr.bv_val );
}
return ++(ad->max_uid_number);
}
void hf_options_dialog_free (gpointer hf_opt_ptr) {
gint i;
hf_options_struct *hf_opt = (hf_options_struct *) hf_opt_ptr;
if (!hf_opt) return;
// printf("HF_OPTIONS_DIALOG_FREE-1\n");
if (hf_opt->creation_widgets)
x_free(hf_opt->creation_widgets);
if (hf_opt->uniform_value)
x_free(hf_opt->uniform_value);
if (hf_opt->subdiv1_options)
x_free(hf_opt->subdiv1_options);
if (hf_opt->subdiv2_options)
x_free(hf_opt->subdiv2_options);
if (hf_opt->surfadd_options)
x_free(hf_opt->surfadd_options);
if (hf_opt->waves_options)
x_free(hf_opt->waves_options);
if (hf_opt->wide_filter)
filter_free(hf_opt->wide_filter);
if (hf_opt->medium_filter1)
filter_free(hf_opt->medium_filter1);
if (hf_opt->medium_filter2)
filter_free(hf_opt->medium_filter2);
if (hf_opt->sharp_filter)
filter_free(hf_opt->sharp_filter);
if (hf_opt->gauss_filter)
filter_free(hf_opt->gauss_filter);
for (i=0; i<GAUSS_LIST_LENGTH; i++)
if (hf_opt->gauss_list[i])
x_free(hf_opt->gauss_list[i]);
if (hf_opt->img)
img_dialog_free(hf_opt->img);
if (hf_opt->draw)
draw_tools_free(hf_opt->draw);
if (hf_opt->fourier)
fourier_dialog_free(hf_opt->fourier);
if (hf_opt->render_str)
x_free(hf_opt->render_str);
x_free(hf_opt);
// printf("HF_OPTIONS_DIALOG_FREE-4\n");
}
/*
* NAME: player_finish()
* DESCRIPTION: destroy a player structure
*/
void player_finish(struct player *player)
{
if (player->output.filters)
filter_free(player->output.filters);
if (player->output.resampled) {
resample_finish(&player->output.resample[0]);
resample_finish(&player->output.resample[1]);
free(player->output.resampled);
player->output.resampled = 0;
}
}
static void
autoconvert_filter_close(struct filter *_filter)
{
struct autoconvert_filter *filter =
(struct autoconvert_filter *)_filter;
if (filter->convert != NULL) {
filter_close(filter->convert);
filter_free(filter->convert);
}
filter_close(filter->filter);
}
PRIVATE int parseFilter(am_filters *filters, const char* filter_str) {
am_filter filter = NULL;
int32_t result = SUCCESS; /* be optimistic */
simple_list option_list = NULL;
NODE * current = NULL;
suboption_t *opt_item = NULL;
char *tmpStr = NULL;
option_list = parseMultiOption(filter_str);
current = option_list;
while (current != NULL) {
opt_item = (suboption_t*)current->data;
if(opt_item != NULL) {
if(!filter) {
filter = filter_new();
assert(filter && "filter_new() failed!");
}
if(!strncmp(opt_item->option, "pattern", 7)) {
filter->pattern = trim(opt_item->value);
} else if(!strncmp(opt_item->option, "folder", 6)) {
tmpStr = trim(opt_item->value);
set_path(tmpStr, &filter->folder);
am_free(tmpStr);
} else if(!strncmp(opt_item->option, "feedid", 6)) {
filter->feedID = trim(opt_item->value);
} else {
dbg_printf(P_ERROR, "Unknown suboption '%s'!", opt_item->option);
}
} else {
assert(0 && "opt_item == NULL");
}
current = current->next;
}
if(filter && filter->pattern) {
filter_add(filter, filters);
} else {
dbg_printf(P_ERROR, "Invalid filter: '%s'", filter_str);
filter_free(filter);
result = FAILURE;
}
if(option_list != NULL) {
freeList(&option_list, freeOptionItem);
}
return result;
}
static const struct audio_format *
autoconvert_filter_open(struct filter *_filter,
struct audio_format *in_audio_format,
GError **error_r)
{
struct autoconvert_filter *filter =
(struct autoconvert_filter *)_filter;
const struct audio_format *out_audio_format;
assert(audio_format_valid(in_audio_format));
/* open the "real" filter */
filter->in_audio_format = *in_audio_format;
out_audio_format = filter_open(filter->filter,
&filter->in_audio_format, error_r);
if (out_audio_format == NULL)
return NULL;
/* need to convert? */
if (!audio_format_equals(&filter->in_audio_format, in_audio_format)) {
/* yes - create a convert_filter */
struct audio_format audio_format2 = *in_audio_format;
const struct audio_format *audio_format3;
filter->convert = filter_new(&convert_filter_plugin, NULL,
error_r);
if (filter->convert == NULL) {
filter_close(filter->filter);
return NULL;
}
audio_format3 = filter_open(filter->convert, &audio_format2,
error_r);
if (audio_format3 == NULL) {
filter_free(filter->convert);
filter_close(filter->filter);
return NULL;
}
assert(audio_format_equals(&audio_format2, in_audio_format));
convert_filter_set(filter->convert, &filter->in_audio_format);
} else
/* no */
filter->convert = NULL;
return out_audio_format;
}
/*
** agi - internal group and attribute definitions list
** e - the group to remove from the internal list
*/
static int
autogroup_delete_group( autogroup_info_t *agi, autogroup_entry_t *e )
{
autogroup_entry_t *age = agi->agi_entry,
*age_prev = NULL,
*age_next;
int rc = 1;
Debug( LDAP_DEBUG_TRACE, "==> autogroup_delete_group <%s>\n",
age->age_dn.bv_val, 0, 0);
for ( age_next = age ; age_next ; age_prev = age, age = age_next ) {
age_next = age->age_next;
if ( age == e ) {
autogroup_filter_t *agf = age->age_filter,
*agf_next;
if ( age_prev != NULL ) {
age_prev->age_next = age_next;
} else {
agi->agi_entry = NULL;
}
ch_free( age->age_dn.bv_val );
ch_free( age->age_ndn.bv_val );
for( agf_next = agf ; agf_next ; agf = agf_next ){
agf_next = agf->agf_next;
filter_free( agf->agf_filter );
ch_free( agf->agf_filterstr.bv_val );
ch_free( agf->agf_dn.bv_val );
ch_free( agf->agf_ndn.bv_val );
}
ldap_pvt_thread_mutex_unlock( &age->age_mutex );
ldap_pvt_thread_mutex_destroy( &age->age_mutex );
ch_free( age );
rc = 0;
return rc;
}
}
Debug( LDAP_DEBUG_TRACE, "autogroup_delete_group: group <%s> not found, should not happen\n", age->age_dn.bv_val, 0, 0);
return rc;
}
void
hy_selector_free(HySelector sltr)
{
filter_free(sltr->f_arch);
filter_free(sltr->f_evr);
filter_free(sltr->f_file);
filter_free(sltr->f_name);
filter_free(sltr->f_provides);
filter_free(sltr->f_reponame);
filter_free(sltr->f_pkg);
g_free(sltr);
}
void
ao_base_finish(struct audio_output *ao)
{
assert(!ao->open);
assert(ao->fail_timer == NULL);
assert(ao->thread == NULL);
if (ao->mixer != NULL)
mixer_free(ao->mixer);
g_cond_free(ao->cond);
g_mutex_free(ao->mutex);
if (ao->replay_gain_filter != NULL)
filter_free(ao->replay_gain_filter);
if (ao->other_replay_gain_filter != NULL)
filter_free(ao->other_replay_gain_filter);
filter_free(ao->filter);
pcm_buffer_deinit(&ao->cross_fade_buffer);
}
/**
* Free the memory associated with the session
*
* @param instance The filter instance
* @param session The filter session
*/
static void
freeSession(FILTER *instance, void *session)
{
TEE_SESSION *my_session = (TEE_SESSION *) session;
SESSION* ses = my_session->branch_session;
session_state_t state;
#ifdef SS_DEBUG
MXS_INFO("Tee free: %d", atomic_add(&debug_seq, 1));
#endif
if (ses != NULL)
{
state = ses->state;
if (state == SESSION_STATE_ROUTER_READY)
{
session_free(ses);
}
else if (state == SESSION_STATE_TO_BE_FREED)
{
/** Free branch router session */
ses->service->router->freeSession(
ses->service->router_instance,
ses->router_session);
/** Free memory of branch client session */
ses->state = SESSION_STATE_FREE;
free(ses);
/** This indicates that branch session is not available anymore */
my_session->branch_session = NULL;
}
else if (state == SESSION_STATE_STOPPING)
{
create_orphan(ses);
}
}
if (my_session->dummy_filterdef)
{
filter_free(my_session->dummy_filterdef);
}
if (my_session->tee_replybuf)
{
gwbuf_free(my_session->tee_replybuf);
}
free(session);
orphan_free(NULL);
return;
}
static int
dynlist_db_destroy(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *) be->bd_info;
if ( on->on_bi.bi_private ) {
dynlist_info_t *dli = (dynlist_info_t *)on->on_bi.bi_private,
*dli_next;
for ( dli_next = dli; dli_next; dli = dli_next ) {
dynlist_map_t *dlm;
dynlist_map_t *dlm_next;
dli_next = dli->dli_next;
if ( !BER_BVISNULL( &dli->dli_uri ) ) {
ch_free( dli->dli_uri.bv_val );
}
if ( dli->dli_lud != NULL ) {
ldap_free_urldesc( dli->dli_lud );
}
if ( !BER_BVISNULL( &dli->dli_uri_nbase ) ) {
ber_memfree( dli->dli_uri_nbase.bv_val );
}
if ( dli->dli_uri_filter != NULL ) {
filter_free( dli->dli_uri_filter );
}
ch_free( dli->dli_default_filter.bv_val );
dlm = dli->dli_dlm;
while ( dlm != NULL ) {
dlm_next = dlm->dlm_next;
ch_free( dlm );
dlm = dlm_next;
}
ch_free( dli );
}
}
return 0;
}
static int example_search(Operation *op, char *attrcontent) {
slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
example_data *ex = on->on_bi.bi_private;
Operation nop = *op;
slap_callback cb = { NULL, example_callback, NULL, NULL, ex};
SlapReply nrs = { REP_RESULT };
int rc;
Filter *filter = NULL;
struct berval fstr = BER_BVNULL;
char *buffer;
size_t len;
len = strlen(ex->principalattr) + 5;
buffer = (char *)malloc(sizeof(char) * len);
if (!buffer) {
nop.o_bd->bd_info = (BackendInfo *)(on->on_info);
send_ldap_error(&nop, &nrs, LDAP_OTHER,
"Cannot allocate memory in example_search()");
return nrs.sr_err;
}
snprintf(buffer, len, "(krbPrincipalName=%s@%s)", attrcontent, ex->exampledomain) ;
filter = str2filter(buffer);
filter2bv(filter, &fstr);
nop.o_callback = &cb;
op->o_bd->bd_info = (BackendInfo *) on->on_info;
nop.o_tag = LDAP_REQ_SEARCH;
nop.o_ctrls = NULL;
nop.ors_scope = LDAP_SCOPE_SUBTREE;
nop.ors_deref = LDAP_DEREF_NEVER;
nop.ors_slimit = SLAP_NO_LIMIT;
nop.ors_tlimit = SLAP_NO_LIMIT;
nop.ors_attrsonly = 1;
nop.ors_attrs = slap_anlist_no_attrs;
nop.ors_filter = filter;
nop.ors_filterstr = fstr;
if (nop.o_bd->be_search) rc = nop.o_bd->be_search(&nop, &nrs);
free(buffer);
if (filter) filter_free(filter);
if (fstr.bv_val) ch_free(fstr.bv_val);
return SLAP_CB_CONTINUE;
}
static int
autogroup_db_close(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *) be->bd_info;
Debug( LDAP_DEBUG_TRACE, "==> autogroup_db_close\n", 0, 0, 0);
if ( on->on_bi.bi_private ) {
autogroup_info_t *agi = on->on_bi.bi_private;
autogroup_entry_t *age = agi->agi_entry,
*age_next;
autogroup_filter_t *agf, *agf_next;
for ( age_next = age; age_next; age = age_next ) {
age_next = age->age_next;
ch_free( age->age_dn.bv_val );
ch_free( age->age_ndn.bv_val );
agf = age->age_filter;
for ( agf_next = agf; agf_next; agf = agf_next ) {
agf_next = agf->agf_next;
filter_free( agf->agf_filter );
ch_free( agf->agf_filterstr.bv_val );
ch_free( agf->agf_dn.bv_val );
ch_free( agf->agf_ndn.bv_val );
ch_free( agf );
}
ldap_pvt_thread_mutex_destroy( &age->age_mutex );
ch_free( age );
}
}
return 0;
}
/* deinitialization */
VOID
OnUnload(IN PDRIVER_OBJECT DriverObject)
{
#ifndef USE_TDI_HOOKING
d_n_d_device(DriverObject, g_tcpoldobj, g_tcpfltobj);
d_n_d_device(DriverObject, g_udpoldobj, g_udpfltobj);
d_n_d_device(DriverObject, g_ipoldobj, g_ipfltobj);
#else
if (g_hooked)
hook_tcpip(&g_old_DriverObject, FALSE);
#endif
// delete control device and symbolic link
if (g_devcontrol != NULL) {
UNICODE_STRING linkname;
RtlInitUnicodeString(&linkname, L"\\??\\tdifw");
IoDeleteSymbolicLink(&linkname);
IoDeleteDevice(g_devcontrol);
}
// delete info device and symbolic link
if (g_devnfo != NULL) {
UNICODE_STRING linkname;
RtlInitUnicodeString(&linkname, L"\\??\\tdifw_nfo");
IoDeleteSymbolicLink(&linkname);
IoDeleteDevice(g_devnfo);
}
filter_free();
ot_free();
conn_state_free(); // call after ot_free()
memtrack_free();
}
static
int slap_sasl_match(Connection *conn, struct berval *rule, struct berval *assertDN, struct berval *authc )
{
struct berval searchbase = {0, NULL};
int rc, scope;
Backend *be;
Filter *filter=NULL;
regex_t reg;
smatch_info sm;
slap_callback cb = {
slap_cb_null_response,
slap_cb_null_sresult,
sasl_sc_smatch,
NULL
};
Operation op = {0};
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, ENTRY,
"slap_sasl_match: comparing DN %s to rule %s\n",
assertDN->bv_val, rule->bv_val,0 );
#else
Debug( LDAP_DEBUG_TRACE,
"===>slap_sasl_match: comparing DN %s to rule %s\n",
assertDN->bv_val, rule->bv_val, 0 );
#endif
rc = slap_parseURI( rule, &searchbase, &scope, &filter );
if( rc != LDAP_SUCCESS ) goto CONCLUDED;
/* Massive shortcut: search scope == base */
if( scope == LDAP_SCOPE_BASE ) {
rc = regcomp(®, searchbase.bv_val,
REG_EXTENDED|REG_ICASE|REG_NOSUB);
if ( rc == 0 ) {
rc = regexec(®, assertDN->bv_val, 0, NULL, 0);
regfree( ® );
}
if ( rc == 0 ) {
rc = LDAP_SUCCESS;
} else {
rc = LDAP_INAPPROPRIATE_AUTH;
}
goto CONCLUDED;
}
/* Must run an internal search. */
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, DETAIL1,
"slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
searchbase.bv_val, scope,0 );
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl_match: performing internal search (base=%s, scope=%d)\n",
searchbase.bv_val, scope, 0 );
#endif
be = select_backend( &searchbase, 0, 1 );
if(( be == NULL ) || ( be->be_search == NULL)) {
rc = LDAP_INAPPROPRIATE_AUTH;
goto CONCLUDED;
}
sm.dn = assertDN;
sm.match = 0;
cb.sc_private = &sm;
op.o_tag = LDAP_REQ_SEARCH;
op.o_protocol = LDAP_VERSION3;
op.o_ndn = *authc;
op.o_callback = &cb;
op.o_time = slap_get_time();
op.o_do_not_cache = 1;
op.o_is_auth_check = 1;
op.o_threadctx = conn->c_sasl_bindop->o_threadctx;
(*be->be_search)( be, conn, &op, /*base=*/NULL, &searchbase,
scope, /*deref=*/1, /*sizelimit=*/0, /*time=*/0, filter, /*fstr=*/NULL,
/*attrs=*/NULL, /*attrsonly=*/0 );
if (sm.match) {
rc = LDAP_SUCCESS;
} else {
rc = LDAP_INAPPROPRIATE_AUTH;
}
CONCLUDED:
if( searchbase.bv_len ) ch_free( searchbase.bv_val );
if( filter ) filter_free( filter );
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, ENTRY,
"slap_sasl_match: comparison returned %d\n", rc, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE,
"<===slap_sasl_match: comparison returned %d\n", rc, 0, 0);
#endif
return( rc );
}
static int slap_parseURI( struct berval *uri,
struct berval *searchbase, int *scope, Filter **filter )
{
struct berval bv;
int rc;
LDAPURLDesc *ludp;
assert( uri != NULL && uri->bv_val != NULL );
searchbase->bv_val = NULL;
searchbase->bv_len = 0;
*scope = -1;
*filter = NULL;
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, ENTRY,
"slap_parseURI: parsing %s\n", uri->bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE, "slap_parseURI: parsing %s\n", uri->bv_val, 0, 0 );
#endif
/* If it does not look like a URI, assume it is a DN */
if( !strncasecmp( uri->bv_val, "dn:", sizeof("dn:")-1 ) ) {
bv.bv_val = uri->bv_val + sizeof("dn:")-1;
bv.bv_val += strspn( bv.bv_val, " " );
is_dn: bv.bv_len = uri->bv_len - (bv.bv_val - uri->bv_val);
rc = dnNormalize2( NULL, &bv, searchbase );
if( rc == LDAP_SUCCESS ) {
*scope = LDAP_SCOPE_BASE;
}
return( rc );
}
rc = ldap_url_parse( uri->bv_val, &ludp );
if ( rc == LDAP_URL_ERR_BADSCHEME ) {
bv.bv_val = uri->bv_val;
goto is_dn;
}
if ( rc != LDAP_URL_SUCCESS ) {
return LDAP_PROTOCOL_ERROR;
}
if (( ludp->lud_host && *ludp->lud_host )
|| ludp->lud_attrs || ludp->lud_exts )
{
/* host part should be empty */
/* attrs and extensions parts should be empty */
return LDAP_PROTOCOL_ERROR;
}
/* Grab the scope */
*scope = ludp->lud_scope;
/* Grab the filter */
if ( ludp->lud_filter ) {
*filter = str2filter( ludp->lud_filter );
if ( *filter == NULL ) {
rc = LDAP_PROTOCOL_ERROR;
goto done;
}
}
/* Grab the searchbase */
bv.bv_val = ludp->lud_dn;
bv.bv_len = strlen( bv.bv_val );
rc = dnNormalize2( NULL, &bv, searchbase );
done:
if( rc != LDAP_SUCCESS ) {
if( *filter ) filter_free( *filter );
}
ldap_free_urldesc( ludp );
return( rc );
}
/* Setup the resample information
from_frequency - input frequency
lowpass_frequency - lowpass frequency, use 0 to automatically compute it from the resample operation
restart - restart the resample state
*/
static void mixer_channel_resample_set(struct mixer_channel_data *channel, unsigned from_frequency, unsigned lowpass_frequency, int restart)
{
unsigned to_frequency;
to_frequency = Machine->sample_rate;
mixerlogerror(("Mixer:mixer_channel_resample_set(%s,%d,%d)\n",channel->name,from_frequency,lowpass_frequency,restart));
if (restart)
{
mixerlogerror(("\tpivot=0\n"));
channel->pivot = 0;
channel->frac = 0;
}
/* only if the filter change */
if (from_frequency != channel->from_frequency
|| to_frequency != channel->to_frequency
|| lowpass_frequency != channel->lowpass_frequency)
{
/* delete the previous filter */
if (channel->filter)
{
filter_free(channel->filter);
channel->filter = 0;
}
/* make a new filter */
#ifdef MIXER_USE_OPTION_FILTER
if (options.use_filter)
#endif
if ((from_frequency != 0 && to_frequency != 0 && (from_frequency != to_frequency || lowpass_frequency != 0)))
{
double cut;
unsigned cut_frequency;
if (from_frequency < to_frequency) {
/* upsampling */
cut_frequency = from_frequency / 2;
if (lowpass_frequency != 0 && cut_frequency > lowpass_frequency)
cut_frequency = lowpass_frequency;
cut = (double)cut_frequency / to_frequency;
} else {
/* downsampling */
cut_frequency = to_frequency / 2;
if (lowpass_frequency != 0 && cut_frequency > lowpass_frequency)
cut_frequency = lowpass_frequency;
cut = (double)cut_frequency / from_frequency;
}
channel->filter = filter_lp_fir_alloc(cut, FILTER_WIDTH);
mixerlogerror(("\tfilter from %d Hz, to %d Hz, cut %f, cut %d Hz\n",from_frequency,to_frequency,cut,cut_frequency));
}
}
channel->lowpass_frequency = lowpass_frequency;
channel->from_frequency = from_frequency;
channel->to_frequency = to_frequency;
channel->step = (double)from_frequency * (1 << FRACTION_BITS) / to_frequency;
/* reset the filter state */
if (channel->filter && channel->is_reset_requested)
{
mixerlogerror(("\tstate clear\n"));
channel->is_reset_requested = 0;
filter_state_reset(channel->filter,channel->left);
filter_state_reset(channel->filter,channel->right);
}
}
static int
dl_cfgen( ConfigArgs *c )
{
slap_overinst *on = (slap_overinst *)c->bi;
dynlist_info_t *dli = (dynlist_info_t *)on->on_bi.bi_private;
int rc = 0, i;
if ( c->op == SLAP_CONFIG_EMIT ) {
switch( c->type ) {
case DL_ATTRSET:
for ( i = 0; dli; i++, dli = dli->dli_next ) {
struct berval bv;
char *ptr = c->cr_msg;
dynlist_map_t *dlm;
assert( dli->dli_oc != NULL );
assert( dli->dli_ad != NULL );
/* FIXME: check buffer overflow! */
ptr += snprintf( c->cr_msg, sizeof( c->cr_msg ),
SLAP_X_ORDERED_FMT "%s", i,
dli->dli_oc->soc_cname.bv_val );
if ( !BER_BVISNULL( &dli->dli_uri ) ) {
*ptr++ = ' ';
*ptr++ = '"';
ptr = lutil_strncopy( ptr, dli->dli_uri.bv_val,
dli->dli_uri.bv_len );
*ptr++ = '"';
}
*ptr++ = ' ';
ptr = lutil_strncopy( ptr, dli->dli_ad->ad_cname.bv_val,
dli->dli_ad->ad_cname.bv_len );
for ( dlm = dli->dli_dlm; dlm; dlm = dlm->dlm_next ) {
ptr[ 0 ] = ' ';
ptr++;
if ( dlm->dlm_mapped_ad ) {
ptr = lutil_strcopy( ptr, dlm->dlm_mapped_ad->ad_cname.bv_val );
ptr[ 0 ] = ':';
ptr++;
}
ptr = lutil_strcopy( ptr, dlm->dlm_member_ad->ad_cname.bv_val );
}
bv.bv_val = c->cr_msg;
bv.bv_len = ptr - bv.bv_val;
value_add_one( &c->rvalue_vals, &bv );
}
break;
case DL_ATTRPAIR_COMPAT:
case DL_ATTRPAIR:
rc = 1;
break;
default:
rc = 1;
break;
}
return rc;
} else if ( c->op == LDAP_MOD_DELETE ) {
switch( c->type ) {
case DL_ATTRSET:
if ( c->valx < 0 ) {
dynlist_info_t *dli_next;
for ( dli_next = dli; dli_next; dli = dli_next ) {
dynlist_map_t *dlm = dli->dli_dlm;
dynlist_map_t *dlm_next;
dli_next = dli->dli_next;
if ( !BER_BVISNULL( &dli->dli_uri ) ) {
ch_free( dli->dli_uri.bv_val );
}
if ( dli->dli_lud != NULL ) {
ldap_free_urldesc( dli->dli_lud );
}
if ( !BER_BVISNULL( &dli->dli_uri_nbase ) ) {
ber_memfree( dli->dli_uri_nbase.bv_val );
}
if ( dli->dli_uri_filter != NULL ) {
filter_free( dli->dli_uri_filter );
}
ch_free( dli->dli_default_filter.bv_val );
while ( dlm != NULL ) {
dlm_next = dlm->dlm_next;
ch_free( dlm );
dlm = dlm_next;
}
ch_free( dli );
}
on->on_bi.bi_private = NULL;
} else {
dynlist_info_t **dlip;
dynlist_map_t *dlm;
dynlist_map_t *dlm_next;
for ( i = 0, dlip = (dynlist_info_t **)&on->on_bi.bi_private;
i < c->valx; i++ )
{
if ( *dlip == NULL ) {
return 1;
}
dlip = &(*dlip)->dli_next;
}
dli = *dlip;
*dlip = dli->dli_next;
if ( !BER_BVISNULL( &dli->dli_uri ) ) {
ch_free( dli->dli_uri.bv_val );
}
if ( dli->dli_lud != NULL ) {
ldap_free_urldesc( dli->dli_lud );
}
if ( !BER_BVISNULL( &dli->dli_uri_nbase ) ) {
ber_memfree( dli->dli_uri_nbase.bv_val );
}
if ( dli->dli_uri_filter != NULL ) {
filter_free( dli->dli_uri_filter );
}
ch_free( dli->dli_default_filter.bv_val );
dlm = dli->dli_dlm;
while ( dlm != NULL ) {
dlm_next = dlm->dlm_next;
ch_free( dlm );
dlm = dlm_next;
}
ch_free( dli );
dli = (dynlist_info_t *)on->on_bi.bi_private;
}
break;
case DL_ATTRPAIR_COMPAT:
case DL_ATTRPAIR:
rc = 1;
break;
default:
rc = 1;
break;
}
return rc;
}
switch( c->type ) {
case DL_ATTRSET: {
dynlist_info_t **dlip,
*dli_next = NULL;
ObjectClass *oc = NULL;
AttributeDescription *ad = NULL;
int attridx = 2;
LDAPURLDesc *lud = NULL;
struct berval nbase = BER_BVNULL;
Filter *filter = NULL;
struct berval uri = BER_BVNULL;
dynlist_map_t *dlm = NULL, *dlml = NULL;
const char *text;
oc = oc_find( c->argv[ 1 ] );
if ( oc == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"unable to find ObjectClass \"%s\"",
c->argv[ 1 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
if ( strncasecmp( c->argv[ attridx ], "ldap://", STRLENOF("ldap://") ) == 0 ) {
if ( ldap_url_parse( c->argv[ attridx ], &lud ) != LDAP_URL_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"unable to parse URI \"%s\"",
c->argv[ attridx ] );
rc = 1;
goto done_uri;
}
if ( lud->lud_host != NULL ) {
if ( lud->lud_host[0] == '\0' ) {
ch_free( lud->lud_host );
lud->lud_host = NULL;
} else {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"host not allowed in URI \"%s\"",
c->argv[ attridx ] );
rc = 1;
goto done_uri;
}
}
if ( lud->lud_attrs != NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"attrs not allowed in URI \"%s\"",
c->argv[ attridx ] );
rc = 1;
goto done_uri;
}
if ( lud->lud_exts != NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"extensions not allowed in URI \"%s\"",
c->argv[ attridx ] );
rc = 1;
goto done_uri;
}
if ( lud->lud_dn != NULL && lud->lud_dn[ 0 ] != '\0' ) {
struct berval dn;
ber_str2bv( lud->lud_dn, 0, 0, &dn );
rc = dnNormalize( 0, NULL, NULL, &dn, &nbase, NULL );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"DN normalization failed in URI \"%s\"",
c->argv[ attridx ] );
goto done_uri;
}
}
if ( lud->lud_filter != NULL && lud->lud_filter[ 0 ] != '\0' ) {
filter = str2filter( lud->lud_filter );
if ( filter == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"filter parsing failed in URI \"%s\"",
c->argv[ attridx ] );
rc = 1;
goto done_uri;
}
}
ber_str2bv( c->argv[ attridx ], 0, 1, &uri );
done_uri:;
if ( rc ) {
if ( lud ) {
ldap_free_urldesc( lud );
}
if ( !BER_BVISNULL( &nbase ) ) {
ber_memfree( nbase.bv_val );
}
if ( filter != NULL ) {
filter_free( filter );
}
while ( dlm != NULL ) {
dlml = dlm;
dlm = dlm->dlm_next;
ch_free( dlml );
}
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return rc;
}
attridx++;
}
rc = slap_str2ad( c->argv[ attridx ], &ad, &text );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"unable to find AttributeDescription \"%s\"",
c->argv[ attridx ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
rc = 1;
goto done_uri;
}
if ( !is_at_subtype( ad->ad_type, slap_schema.si_ad_labeledURI->ad_type ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ), DYNLIST_USAGE
"AttributeDescription \"%s\" "
"must be a subtype of \"labeledURI\"",
c->argv[ attridx ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
rc = 1;
goto done_uri;
}
attridx++;
for ( i = attridx; i < c->argc; i++ ) {
char *arg;
char *cp;
AttributeDescription *member_ad = NULL;
AttributeDescription *mapped_ad = NULL;
dynlist_map_t *dlmp;
/*
* If no mapped attribute is given, dn is used
* for backward compatibility.
*/
arg = c->argv[i];
if ( ( cp = strchr( arg, ':' ) ) != NULL ) {
struct berval bv;
ber_str2bv( arg, cp - arg, 0, &bv );
rc = slap_bv2ad( &bv, &mapped_ad, &text );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
DYNLIST_USAGE
"unable to find mapped AttributeDescription #%d \"%s\"\n",
i - 3, c->argv[ i ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
rc = 1;
goto done_uri;
}
arg = cp + 1;
}
rc = slap_str2ad( arg, &member_ad, &text );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
DYNLIST_USAGE
"unable to find AttributeDescription #%d \"%s\"\n",
i - 3, c->argv[ i ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
rc = 1;
goto done_uri;
}
dlmp = (dynlist_map_t *)ch_calloc( 1, sizeof( dynlist_map_t ) );
if ( dlm == NULL ) {
dlm = dlmp;
}
dlmp->dlm_member_ad = member_ad;
dlmp->dlm_mapped_ad = mapped_ad;
dlmp->dlm_next = NULL;
if ( dlml != NULL )
dlml->dlm_next = dlmp;
dlml = dlmp;
}
if ( c->valx > 0 ) {
int i;
for ( i = 0, dlip = (dynlist_info_t **)&on->on_bi.bi_private;
i < c->valx; i++ )
{
if ( *dlip == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
DYNLIST_USAGE
"invalid index {%d}\n",
c->valx );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
rc = 1;
goto done_uri;
}
dlip = &(*dlip)->dli_next;
}
dli_next = *dlip;
} else {
for ( dlip = (dynlist_info_t **)&on->on_bi.bi_private;
*dlip; dlip = &(*dlip)->dli_next )
/* goto last */;
}
*dlip = (dynlist_info_t *)ch_calloc( 1, sizeof( dynlist_info_t ) );
(*dlip)->dli_oc = oc;
(*dlip)->dli_ad = ad;
(*dlip)->dli_dlm = dlm;
(*dlip)->dli_next = dli_next;
(*dlip)->dli_lud = lud;
(*dlip)->dli_uri_nbase = nbase;
(*dlip)->dli_uri_filter = filter;
(*dlip)->dli_uri = uri;
rc = dynlist_build_def_filter( *dlip );
} break;
case DL_ATTRPAIR_COMPAT:
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"warning: \"attrpair\" only supported for limited "
"backward compatibility with overlay \"dyngroup\"" );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n", c->log, c->cr_msg, 0 );
/* fallthru */
case DL_ATTRPAIR: {
dynlist_info_t **dlip;
ObjectClass *oc = NULL;
AttributeDescription *ad = NULL,
*member_ad = NULL;
const char *text;
oc = oc_find( "groupOfURLs" );
if ( oc == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"dynlist-attrpair <member-ad> <URL-ad>\": "
"unable to find default ObjectClass \"groupOfURLs\"" );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
rc = slap_str2ad( c->argv[ 1 ], &member_ad, &text );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"dynlist-attrpair <member-ad> <URL-ad>\": "
"unable to find AttributeDescription \"%s\"",
c->argv[ 1 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
rc = slap_str2ad( c->argv[ 2 ], &ad, &text );
if ( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"dynlist-attrpair <member-ad> <URL-ad>\": "
"unable to find AttributeDescription \"%s\"\n",
c->argv[ 2 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
if ( !is_at_subtype( ad->ad_type, slap_schema.si_ad_labeledURI->ad_type ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
DYNLIST_USAGE
"AttributeDescription \"%s\" "
"must be a subtype of \"labeledURI\"",
c->argv[ 2 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
for ( dlip = (dynlist_info_t **)&on->on_bi.bi_private;
*dlip; dlip = &(*dlip)->dli_next )
{
/*
* The same URL attribute / member attribute pair
* cannot be repeated, but we enforce this only
* when the member attribute is unique. Performing
* the check for multiple values would require
* sorting and comparing the lists, which is left
* as a future improvement
*/
if ( (*dlip)->dli_ad == ad &&
(*dlip)->dli_dlm->dlm_next == NULL &&
member_ad == (*dlip)->dli_dlm->dlm_member_ad ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"dynlist-attrpair <member-ad> <URL-ad>\": "
"URL attributeDescription \"%s\" already mapped.\n",
ad->ad_cname.bv_val );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
#if 0
/* make it a warning... */
return 1;
#endif
}
}
*dlip = (dynlist_info_t *)ch_calloc( 1, sizeof( dynlist_info_t ) );
(*dlip)->dli_oc = oc;
(*dlip)->dli_ad = ad;
(*dlip)->dli_dlm = (dynlist_map_t *)ch_calloc( 1, sizeof( dynlist_map_t ) );
(*dlip)->dli_dlm->dlm_member_ad = member_ad;
(*dlip)->dli_dlm->dlm_mapped_ad = NULL;
rc = dynlist_build_def_filter( *dlip );
} break;
default:
rc = 1;
break;
}
return rc;
}
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;
}
/*
* Given a SASL name (e.g. "UID=name,cn=REALM,cn=MECH,cn=AUTH")
* return the LDAP DN to which it matches. The SASL regexp rules in the config
* file turn the SASL name into an LDAP URI. If the URI is just a DN (or a
* search with scope=base), just return the URI (or its searchbase). Otherwise
* an internal search must be done, and if that search returns exactly one
* entry, return the DN of that one entry.
*/
void slap_sasl2dn( Connection *conn,
struct berval *saslname, struct berval *sasldn )
{
int rc;
Backend *be = NULL;
struct berval dn = { 0, NULL };
int scope = LDAP_SCOPE_BASE;
Filter *filter = NULL;
slap_callback cb = { slap_cb_null_response,
slap_cb_null_sresult, sasl_sc_sasl2dn, slap_cb_null_sreference, NULL};
Operation op = {0};
struct berval regout = { 0, NULL };
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, ENTRY,
"slap_sasl2dn: converting SASL name %s to DN.\n",
saslname->bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE, "==>slap_sasl2dn: "
"converting SASL name %s to a DN\n",
saslname->bv_val, 0,0 );
#endif
sasldn->bv_val = NULL;
sasldn->bv_len = 0;
cb.sc_private = sasldn;
/* Convert the SASL name into a minimal URI */
if( !slap_sasl_regexp( saslname, ®out ) ) {
goto FINISHED;
}
rc = slap_parseURI( ®out, &dn, &scope, &filter );
if( regout.bv_val ) ch_free( regout.bv_val );
if( rc != LDAP_SUCCESS ) {
goto FINISHED;
}
/* Must do an internal search */
be = select_backend( &dn, 0, 1 );
/* Massive shortcut: search scope == base */
if( scope == LDAP_SCOPE_BASE ) {
*sasldn = dn;
dn.bv_len = 0;
dn.bv_val = NULL;
goto FINISHED;
}
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, DETAIL1,
"slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
dn.bv_val, scope, 0 );
#else
Debug( LDAP_DEBUG_TRACE,
"slap_sasl2dn: performing internal search (base=%s, scope=%d)\n",
dn.bv_val, scope, 0 );
#endif
if(( be == NULL ) || ( be->be_search == NULL)) {
goto FINISHED;
}
op.o_tag = LDAP_REQ_SEARCH;
op.o_protocol = LDAP_VERSION3;
op.o_ndn = conn->c_ndn;
op.o_callback = &cb;
op.o_time = slap_get_time();
op.o_do_not_cache = 1;
op.o_is_auth_check = 1;
op.o_threadctx = conn->c_sasl_bindop->o_threadctx;
(*be->be_search)( be, conn, &op, NULL, &dn,
scope, LDAP_DEREF_NEVER, 1, 0,
filter, NULL, NULL, 1 );
FINISHED:
if( sasldn->bv_len ) {
conn->c_authz_backend = be;
}
if( dn.bv_len ) ch_free( dn.bv_val );
if( filter ) filter_free( filter );
#ifdef NEW_LOGGING
LDAP_LOG( TRANSPORT, ENTRY,
"slap_sasl2dn: Converted SASL name to %s\n",
sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
#else
Debug( LDAP_DEBUG_TRACE, "<==slap_sasl2dn: Converted SASL name to %s\n",
sasldn->bv_len ? sasldn->bv_val : "<nothing>", 0, 0 );
#endif
return;
}
