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; }