static int
bdb_cache_entryinfo_destroy( EntryInfo *e )
{
ldap_pvt_thread_mutex_destroy( &e->bei_kids_mutex );
free( e->bei_nrdn.bv_val );
#ifdef BDB_HIER
free( e->bei_rdn.bv_val );
#endif
free( e );
return 0;
}
static void
target_free(
metatarget_t *mt )
{
if ( mt->mt_uri ) {
free( mt->mt_uri );
ldap_pvt_thread_mutex_destroy( &mt->mt_uri_mutex );
}
if ( mt->mt_subtree_exclude ) {
ber_bvarray_free( mt->mt_subtree_exclude );
}
if ( !BER_BVISNULL( &mt->mt_psuffix ) ) {
free( mt->mt_psuffix.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_nsuffix ) ) {
free( mt->mt_nsuffix.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_binddn ) ) {
free( mt->mt_binddn.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_bindpw ) ) {
free( mt->mt_bindpw.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_authcID ) ) {
ch_free( mt->mt_idassert_authcID.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_authcDN ) ) {
ch_free( mt->mt_idassert_authcDN.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_passwd ) ) {
ch_free( mt->mt_idassert_passwd.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_authzID ) ) {
ch_free( mt->mt_idassert_authzID.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_sasl_mech ) ) {
ch_free( mt->mt_idassert_sasl_mech.bv_val );
}
if ( !BER_BVISNULL( &mt->mt_idassert_sasl_realm ) ) {
ch_free( mt->mt_idassert_sasl_realm.bv_val );
}
if ( mt->mt_idassert_authz != NULL ) {
ber_bvarray_free( mt->mt_idassert_authz );
}
if ( mt->mt_rwmap.rwm_rw ) {
rewrite_info_delete( &mt->mt_rwmap.rwm_rw );
}
avl_free( mt->mt_rwmap.rwm_oc.remap, mapping_dst_free );
avl_free( mt->mt_rwmap.rwm_oc.map, mapping_free );
avl_free( mt->mt_rwmap.rwm_at.remap, mapping_dst_free );
avl_free( mt->mt_rwmap.rwm_at.map, mapping_free );
free( mt );
}
int
perl_back_destroy(
BackendInfo *bd
)
{
perl_free(PERL_INTERPRETER);
PERL_INTERPRETER = NULL;
ldap_pvt_thread_mutex_destroy( &perl_interpreter_mutex );
return 0;
}
static int
auditlog_db_destroy(
BackendDB *be,
ConfigReply *cr
)
{
slap_overinst *on = (slap_overinst *)be->bd_info;
auditlog_data *ad = on->on_bi.bi_private;
ldap_pvt_thread_mutex_destroy( &ad->ad_mutex );
free( ad );
return 0;
}
/*
* call from within bdb_db_destroy()
*/
int
bdb_monitor_db_destroy( BackendDB *be )
{
#ifdef BDB_MONITOR_IDX
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
/* TODO: free tree */
ldap_pvt_thread_mutex_destroy( &bdb->bi_idx_mutex );
avl_free( bdb->bi_idx, ch_free );
#endif /* BDB_MONITOR_IDX */
return 0;
}
int
backsql_db_destroy(
BackendDB *bd )
{
backsql_info *si = (backsql_info*)bd->be_private;
Debug( LDAP_DEBUG_TRACE, "==>backsql_db_destroy()\n", 0, 0, 0 );
ldap_pvt_thread_mutex_lock( &si->dbconn_mutex );
backsql_free_db_env( si );
ldap_pvt_thread_mutex_unlock( &si->dbconn_mutex );
ldap_pvt_thread_mutex_destroy( &si->dbconn_mutex );
ldap_pvt_thread_mutex_lock( &si->schema_mutex );
backsql_destroy_schema_map( si );
ldap_pvt_thread_mutex_unlock( &si->schema_mutex );
ldap_pvt_thread_mutex_destroy( &si->schema_mutex );
free( si->dbname );
free( si->dbuser );
if ( si->dbpasswd ) {
free( si->dbpasswd );
}
if ( si->dbhost ) {
free( si->dbhost );
}
if ( si->upper_func.bv_val ) {
free( si->upper_func.bv_val );
free( si->upper_func_open.bv_val );
free( si->upper_func_close.bv_val );
}
free( si->subtree_cond.bv_val );
free( si->oc_query );
free( si->at_query );
free( si->insentry_query );
free( si->delentry_query );
free( si );
Debug( LDAP_DEBUG_TRACE, "<==backsql_db_destroy()\n", 0, 0, 0 );
return 0;
}
/*
** 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;
}
static int
usn_db_destroy(
BackendDB *be,
ConfigReply *cr
)
{
slap_overinst *on = (slap_overinst *)be->bd_info;
usn_info_t *ui = on->on_bi.bi_private;
ldap_pvt_thread_mutex_destroy( &ui->ui_mutex );
ch_free( ui );
on->on_bi.bi_private = NULL;
return 0;
}
void quorum_global_destroy() {
if (quorum_list != QR_POISON) {
lock();
while (quorum_list) {
slap_quorum_t *next = quorum_list;
ch_free(quorum_list->qr_present);
ch_free(quorum_list->qr_requirements);
ch_free(quorum_list);
quorum_list = next;
}
quorum_list = QR_POISON;
unlock();
ldap_pvt_thread_mutex_destroy(&quorum_mutex);
}
}
static int
dds_db_destroy(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *)be->bd_info;
dds_info_t *di = on->on_bi.bi_private;
if ( di != NULL ) {
ldap_pvt_thread_mutex_destroy( &di->di_mutex );
free( di );
}
return 0;
}
int
perl_back_close(
BackendInfo *bd
)
{
perl_destruct(PERL_INTERPRETER);
perl_free(PERL_INTERPRETER);
PERL_INTERPRETER = NULL;
#ifdef PERL_SYS_TERM
PERL_SYS_TERM();
#endif
ldap_pvt_thread_mutex_destroy( &perl_interpreter_mutex );
return 0;
}
static int
seqmod_db_close(
BackendDB *be,
ConfigReply *cr
)
{
slap_overinst *on = (slap_overinst *)be->bd_info;
seqmod_info *sm = (seqmod_info *)on->on_bi.bi_private;
if ( sm ) {
ldap_pvt_thread_mutex_destroy( &sm->sm_mutex );
ch_free( sm );
}
return 0;
}
int
ldap_pvt_thread_rdwr_destroy( ldap_pvt_thread_rdwr_t *rwlock )
{
struct ldap_int_thread_rdwr_s *rw;
assert( rwlock != NULL );
rw = *rwlock;
assert( rw != NULL );
assert( rw->ltrw_valid == LDAP_PVT_THREAD_RDWR_VALID );
if( rw->ltrw_valid != LDAP_PVT_THREAD_RDWR_VALID )
return LDAP_PVT_THREAD_EINVAL;
ldap_pvt_thread_mutex_lock( &rw->ltrw_mutex );
assert( rw->ltrw_w_active >= 0 );
assert( rw->ltrw_w_wait >= 0 );
assert( rw->ltrw_r_active >= 0 );
assert( rw->ltrw_r_wait >= 0 );
/* active threads? */
if( rw->ltrw_r_active > 0 || rw->ltrw_w_active > 0) {
ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
return LDAP_PVT_THREAD_EBUSY;
}
/* waiting threads? */
if( rw->ltrw_r_wait > 0 || rw->ltrw_w_wait > 0) {
ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
return LDAP_PVT_THREAD_EBUSY;
}
rw->ltrw_valid = 0;
ldap_pvt_thread_mutex_unlock( &rw->ltrw_mutex );
ldap_pvt_thread_mutex_destroy( &rw->ltrw_mutex );
ldap_pvt_thread_cond_destroy( &rw->ltrw_read );
ldap_pvt_thread_cond_destroy( &rw->ltrw_write );
LDAP_FREE(rw);
*rwlock = NULL;
return 0;
}
static void
rewrite_session_clean( void *v_session )
{
struct rewrite_session *session = (struct rewrite_session *)v_session;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rewrite_var_delete( session->ls_vars );
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
ldap_pvt_thread_rdwr_destroy( &session->ls_vars_mutex );
ldap_pvt_thread_mutex_unlock( &session->ls_mutex );
ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
}
static int
bdb_db_destroy( BackendDB *be, ConfigReply *cr )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
/* stop and remove checkpoint task */
if ( bdb->bi_txn_cp_task ) {
struct re_s *re = bdb->bi_txn_cp_task;
bdb->bi_txn_cp_task = NULL;
ldap_pvt_thread_mutex_lock( &slapd_rq.rq_mutex );
if ( ldap_pvt_runqueue_isrunning( &slapd_rq, re ) )
ldap_pvt_runqueue_stoptask( &slapd_rq, re );
ldap_pvt_runqueue_remove( &slapd_rq, re );
ldap_pvt_thread_mutex_unlock( &slapd_rq.rq_mutex );
}
/* monitor handling */
(void)bdb_monitor_db_destroy( be );
if( bdb->bi_dbenv_home ) ch_free( bdb->bi_dbenv_home );
if( bdb->bi_db_config_path ) ch_free( bdb->bi_db_config_path );
bdb_attr_index_destroy( bdb );
ldap_pvt_thread_rdwr_destroy ( &bdb->bi_cache.c_rwlock );
ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_lru_mutex );
ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_count_mutex );
ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_eifree_mutex );
ldap_pvt_thread_mutex_destroy( &bdb->bi_cache.c_dntree.bei_kids_mutex );
#ifdef BDB_HIER
ldap_pvt_thread_mutex_destroy( &bdb->bi_modrdns_mutex );
#endif
ldap_pvt_thread_mutex_destroy( &bdb->bi_lastid_mutex );
ldap_pvt_thread_mutex_destroy( &bdb->bi_database_mutex );
ldap_pvt_thread_rdwr_destroy( &bdb->bi_idl_tree_rwlock );
ldap_pvt_thread_mutex_destroy( &bdb->bi_idl_tree_lrulock );
ch_free( bdb );
be->be_private = NULL;
return 0;
}
/*
* call from within bdb_db_destroy()
*/
int
bdb_monitor_db_destroy( BackendDB *be )
{
if ( SLAP_GLUE_SUBORDINATE( be ) ) {
return 0;
}
#ifdef BDB_MONITOR_IDX
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
/* TODO: free tree */
ldap_pvt_thread_mutex_destroy( &bdb->bi_idx_mutex );
avl_free( bdb->bi_idx, ch_free );
}
#endif /* BDB_MONITOR_IDX */
return 0;
}
static int
ndb_db_destroy( BackendDB *be, ConfigReply *cr )
{
struct ndb_info *ni = (struct ndb_info *) be->be_private;
#ifdef DO_MONITORING
/* monitor handling */
(void)ndb_monitor_db_destroy( be );
#endif
ldap_pvt_thread_mutex_destroy( &ni->ni_conn_mutex );
ldap_pvt_thread_rdwr_destroy( &ni->ni_ai_rwlock );
ldap_pvt_thread_rdwr_destroy( &ni->ni_oc_rwlock );
ch_free( ni );
be->be_private = NULL;
return 0;
}
static int
ldap_distproc_db_destroy(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *) be->bd_info;
ldap_distproc_t *lc = (ldap_distproc_t *)on->on_bi.bi_private;
int rc;
rc = ldap_distproc_db_func( be, db_destroy );
if ( lc ) {
avl_free( lc->lc_lai.lai_tree, NULL );
ldap_pvt_thread_mutex_destroy( &lc->lc_lai.lai_mutex );
ch_free( lc );
}
return rc;
}
void slap_counters_destroy( slap_counters_t *sc )
{
int i;
ldap_pvt_thread_mutex_destroy( &sc->sc_mutex );
ldap_pvt_mp_clear( sc->sc_bytes );
ldap_pvt_mp_clear( sc->sc_pdu );
ldap_pvt_mp_clear( sc->sc_entries );
ldap_pvt_mp_clear( sc->sc_refs );
ldap_pvt_mp_clear( sc->sc_ops_initiated );
ldap_pvt_mp_clear( sc->sc_ops_completed );
#ifdef SLAPD_MONITOR
for ( i = 0; i < SLAP_OP_LAST; i++ ) {
ldap_pvt_mp_clear( sc->sc_ops_initiated_[ i ] );
ldap_pvt_mp_clear( sc->sc_ops_completed_[ i ] );
}
#endif /* SLAPD_MONITOR */
}
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;
}
/*
* releases the lock of the entry; if it is marked as volatile, it is
* destroyed.
*/
int
monitor_cache_release(
monitor_info_t *mi,
Entry *e )
{
monitor_entry_t *mp;
assert( mi != NULL );
assert( e != NULL );
assert( e->e_private != NULL );
mp = ( monitor_entry_t * )e->e_private;
if ( mp->mp_flags & MONITOR_F_VOLATILE ) {
monitor_cache_t *mc, tmp_mc;
/* volatile entries do not return to cache */
ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex );
tmp_mc.mc_ndn = e->e_nname;
mc = avl_delete( &mi->mi_cache,
( caddr_t )&tmp_mc, monitor_cache_cmp );
ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex );
if ( mc != NULL ) {
ch_free( mc );
}
ldap_pvt_thread_mutex_unlock( &mp->mp_mutex );
ldap_pvt_thread_mutex_destroy( &mp->mp_mutex );
ch_free( mp );
e->e_private = NULL;
entry_free( e );
return( 0 );
}
ldap_pvt_thread_mutex_unlock( &mp->mp_mutex );
return( 0 );
}
int
ldap_pvt_thread_rmutex_destroy( ldap_pvt_thread_rmutex_t *rmutex )
{
struct ldap_int_thread_rmutex_s *rm;
assert( rmutex != NULL );
rm = *rmutex;
assert( rm != NULL );
assert( rm->ltrm_valid == LDAP_PVT_THREAD_RMUTEX_VALID );
if( rm->ltrm_valid != LDAP_PVT_THREAD_RMUTEX_VALID )
return LDAP_PVT_THREAD_EINVAL;
ldap_pvt_thread_mutex_lock( &rm->ltrm_mutex );
assert( rm->ltrm_depth >= 0 );
assert( rm->ltrm_waits >= 0 );
/* in use? */
if( rm->ltrm_depth > 0 || rm->ltrm_waits > 0 ) {
ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );
return LDAP_PVT_THREAD_EBUSY;
}
rm->ltrm_valid = 0;
ldap_pvt_thread_mutex_unlock( &rm->ltrm_mutex );
ldap_pvt_thread_mutex_destroy( &rm->ltrm_mutex );
ldap_pvt_thread_cond_destroy( &rm->ltrm_cond );
LDAP_FREE(rm);
*rmutex = NULL;
return 0;
}
static void
monitor_entry_destroy( void *v_mc )
{
monitor_cache_t *mc = (monitor_cache_t *)v_mc;
if ( mc->mc_e != NULL ) {
monitor_entry_t *mp;
assert( mc->mc_e->e_private != NULL );
mp = ( monitor_entry_t * )mc->mc_e->e_private;
if ( mp->mp_cb ) {
monitor_callback_t *cb;
for ( cb = mp->mp_cb; cb != NULL; ) {
monitor_callback_t *next = cb->mc_next;
if ( cb->mc_free ) {
(void)cb->mc_free( mc->mc_e, &cb->mc_private );
}
ch_free( mp->mp_cb );
cb = next;
}
}
ldap_pvt_thread_mutex_destroy( &mp->mp_mutex );
ch_free( mp );
mc->mc_e->e_private = NULL;
entry_free( mc->mc_e );
}
ch_free( mc );
}
int
ldap_ld_free(
LDAP *ld,
int close,
LDAPControl **sctrls,
LDAPControl **cctrls )
{
LDAPMessage *lm, *next;
int err = LDAP_SUCCESS;
LDAP_MUTEX_LOCK( &ld->ld_ldcmutex );
/* Someone else is still using this ld. */
if (ld->ld_ldcrefcnt > 1) { /* but not last thread */
/* clean up self only */
ld->ld_ldcrefcnt--;
if ( ld->ld_error != NULL ) {
LDAP_FREE( ld->ld_error );
ld->ld_error = NULL;
}
if ( ld->ld_matched != NULL ) {
LDAP_FREE( ld->ld_matched );
ld->ld_matched = NULL;
}
if ( ld->ld_referrals != NULL) {
LDAP_VFREE(ld->ld_referrals);
ld->ld_referrals = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_ldcmutex );
LDAP_FREE( (char *) ld );
return( err );
}
/* This ld is the last thread. */
/* free LDAP structure and outstanding requests/responses */
LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
while ( ld->ld_requests != NULL ) {
ldap_free_request( ld, ld->ld_requests );
}
LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
/* free and unbind from all open connections */
while ( ld->ld_conns != NULL ) {
ldap_free_connection( ld, ld->ld_conns, 1, close );
}
LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
for ( lm = ld->ld_responses; lm != NULL; lm = next ) {
next = lm->lm_next;
ldap_msgfree( lm );
}
if ( ld->ld_abandoned != NULL ) {
LDAP_FREE( ld->ld_abandoned );
ld->ld_abandoned = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
LDAP_MUTEX_LOCK( &ld->ld_ldopts_mutex );
/* final close callbacks */
{
ldaplist *ll, *next;
for ( ll = ld->ld_options.ldo_conn_cbs; ll; ll = next ) {
ldap_conncb *cb = ll->ll_data;
next = ll->ll_next;
cb->lc_del( ld, NULL, cb );
LDAP_FREE( ll );
}
}
if ( ld->ld_error != NULL ) {
LDAP_FREE( ld->ld_error );
ld->ld_error = NULL;
}
if ( ld->ld_matched != NULL ) {
LDAP_FREE( ld->ld_matched );
ld->ld_matched = NULL;
}
if ( ld->ld_referrals != NULL) {
LDAP_VFREE(ld->ld_referrals);
ld->ld_referrals = NULL;
}
if ( ld->ld_selectinfo != NULL ) {
ldap_free_select_info( ld->ld_selectinfo );
ld->ld_selectinfo = NULL;
}
if ( ld->ld_options.ldo_defludp != NULL ) {
ldap_free_urllist( ld->ld_options.ldo_defludp );
ld->ld_options.ldo_defludp = NULL;
}
#ifdef LDAP_CONNECTIONLESS
if ( ld->ld_options.ldo_peer != NULL ) {
LDAP_FREE( ld->ld_options.ldo_peer );
ld->ld_options.ldo_peer = NULL;
}
if ( ld->ld_options.ldo_cldapdn != NULL ) {
LDAP_FREE( ld->ld_options.ldo_cldapdn );
ld->ld_options.ldo_cldapdn = NULL;
}
#endif
#ifdef HAVE_CYRUS_SASL
if ( ld->ld_options.ldo_def_sasl_mech != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_mech );
ld->ld_options.ldo_def_sasl_mech = NULL;
}
if ( ld->ld_options.ldo_def_sasl_realm != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_realm );
ld->ld_options.ldo_def_sasl_realm = NULL;
}
if ( ld->ld_options.ldo_def_sasl_authcid != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_authcid );
ld->ld_options.ldo_def_sasl_authcid = NULL;
}
if ( ld->ld_options.ldo_def_sasl_authzid != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_authzid );
ld->ld_options.ldo_def_sasl_authzid = NULL;
}
#endif
#ifdef HAVE_TLS
ldap_int_tls_destroy( &ld->ld_options );
#endif
if ( ld->ld_options.ldo_sctrls != NULL ) {
ldap_controls_free( ld->ld_options.ldo_sctrls );
ld->ld_options.ldo_sctrls = NULL;
}
if ( ld->ld_options.ldo_cctrls != NULL ) {
ldap_controls_free( ld->ld_options.ldo_cctrls );
ld->ld_options.ldo_cctrls = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_ldopts_mutex );
ber_sockbuf_free( ld->ld_sb );
#ifdef LDAP_R_COMPILE
ldap_pvt_thread_mutex_destroy( &ld->ld_msgid_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_conn_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_req_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_res_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_abandon_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_ldopts_mutex );
ldap_pvt_thread_mutex_unlock( &ld->ld_ldcmutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_ldcmutex );
#endif
#ifndef NDEBUG
LDAP_TRASH(ld);
#endif
LDAP_FREE( (char *) ld->ldc );
LDAP_FREE( (char *) ld );
return( err );
}
int
ldap_ld_free(
LDAP *ld,
int close,
LDAPControl **sctrls,
LDAPControl **cctrls )
{
LDAPMessage *lm, *next;
int err = LDAP_SUCCESS;
LDAP_MUTEX_LOCK( &ld->ld_ldcmutex );
/* Someone else is still using this ld. */
if (ld->ld_ldcrefcnt > 1) { /* but not last thread */
/* clean up self only */
ld->ld_ldcrefcnt--;
if ( ld->ld_error != NULL ) {
LDAP_FREE( ld->ld_error );
ld->ld_error = NULL;
}
if ( ld->ld_matched != NULL ) {
LDAP_FREE( ld->ld_matched );
ld->ld_matched = NULL;
}
if ( ld->ld_referrals != NULL) {
LDAP_VFREE(ld->ld_referrals);
ld->ld_referrals = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_ldcmutex );
LDAP_FREE( (char *) ld );
return( err );
}
/* This ld is the last thread. */
/* free LDAP structure and outstanding requests/responses */
#ifdef LDAP_R_COMPILE
#ifdef __APPLE__
/* If the ld is in async mode, this will stop the thread that's handling
* the results messages. This *must* be done before anything is torn
* down to prevent the thread from using deallocated structs. This is a
* blocking call; it won't exit until the thread exits. If not in
* async mode, this call does nothing.
*/
ldap_pvt_clear_search_results_callback( ld );
#endif
#endif
LDAP_MUTEX_LOCK( &ld->ld_req_mutex );
while ( ld->ld_requests != NULL ) {
ldap_free_request( ld, ld->ld_requests );
}
LDAP_MUTEX_UNLOCK( &ld->ld_req_mutex );
LDAP_MUTEX_LOCK( &ld->ld_conn_mutex );
/* free and unbind from all open connections */
while ( ld->ld_conns != NULL ) {
ldap_free_connection( ld, ld->ld_conns, 1, close );
}
LDAP_MUTEX_UNLOCK( &ld->ld_conn_mutex );
LDAP_MUTEX_LOCK( &ld->ld_res_mutex );
#ifdef LDAP_RESPONSE_RB_TREE
ldap_resp_rbt_free( ld );
#else
for ( lm = ld->ld_responses; lm != NULL; lm = next ) {
next = lm->lm_next;
ldap_msgfree( lm );
}
#endif
if ( ld->ld_abandoned != NULL ) {
LDAP_FREE( ld->ld_abandoned );
ld->ld_abandoned = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_res_mutex );
LDAP_MUTEX_LOCK( &ld->ld_ldopts_mutex );
/* final close callbacks */
{
ldaplist *ll, *next;
for ( ll = ld->ld_options.ldo_conn_cbs; ll; ll = next ) {
ldap_conncb *cb = ll->ll_data;
next = ll->ll_next;
cb->lc_del( ld, NULL, cb );
LDAP_FREE( ll );
}
}
if ( ld->ld_error != NULL ) {
LDAP_FREE( ld->ld_error );
ld->ld_error = NULL;
}
if ( ld->ld_matched != NULL ) {
LDAP_FREE( ld->ld_matched );
ld->ld_matched = NULL;
}
if ( ld->ld_referrals != NULL) {
LDAP_VFREE(ld->ld_referrals);
ld->ld_referrals = NULL;
}
if ( ld->ld_selectinfo != NULL ) {
ldap_free_select_info( ld->ld_selectinfo );
ld->ld_selectinfo = NULL;
}
if ( ld->ld_options.ldo_defludp != NULL ) {
ldap_free_urllist( ld->ld_options.ldo_defludp );
ld->ld_options.ldo_defludp = NULL;
}
#ifdef LDAP_CONNECTIONLESS
if ( ld->ld_options.ldo_peer != NULL ) {
LDAP_FREE( ld->ld_options.ldo_peer );
ld->ld_options.ldo_peer = NULL;
}
if ( ld->ld_options.ldo_cldapdn != NULL ) {
LDAP_FREE( ld->ld_options.ldo_cldapdn );
ld->ld_options.ldo_cldapdn = NULL;
}
#endif
#ifdef HAVE_CYRUS_SASL
if ( ld->ld_options.ldo_def_sasl_mech != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_mech );
ld->ld_options.ldo_def_sasl_mech = NULL;
}
if ( ld->ld_options.ldo_def_sasl_realm != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_realm );
ld->ld_options.ldo_def_sasl_realm = NULL;
}
if ( ld->ld_options.ldo_def_sasl_authcid != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_authcid );
ld->ld_options.ldo_def_sasl_authcid = NULL;
}
if ( ld->ld_options.ldo_def_sasl_authzid != NULL ) {
LDAP_FREE( ld->ld_options.ldo_def_sasl_authzid );
ld->ld_options.ldo_def_sasl_authzid = NULL;
}
#endif
#ifdef HAVE_TLS
ldap_int_tls_destroy( &ld->ld_options );
#endif
if ( ld->ld_options.ldo_sctrls != NULL ) {
ldap_controls_free( ld->ld_options.ldo_sctrls );
ld->ld_options.ldo_sctrls = NULL;
}
if ( ld->ld_options.ldo_cctrls != NULL ) {
ldap_controls_free( ld->ld_options.ldo_cctrls );
ld->ld_options.ldo_cctrls = NULL;
}
if ( ld->ld_options.ldo_sasl_secprops.property_names != NULL ) {
LDAP_FREE( ld->ld_options.ldo_sasl_secprops.property_names );
ld->ld_options.ldo_sasl_secprops.property_names = NULL;
}
if ( ld->ld_options.ldo_sasl_secprops.property_values != NULL ) {
LDAP_FREE( ld->ld_options.ldo_sasl_secprops.property_values );
ld->ld_options.ldo_sasl_secprops.property_values = NULL;
}
if ( ld->ld_options.ldo_sasl_fqdn != NULL ) {
LDAP_FREE( ld->ld_options.ldo_sasl_fqdn );
ld->ld_options.ldo_sasl_fqdn = NULL;
}
LDAP_MUTEX_UNLOCK( &ld->ld_ldopts_mutex );
ber_sockbuf_free( ld->ld_sb );
#ifdef LDAP_R_COMPILE
ldap_pvt_thread_mutex_destroy( &ld->ld_msgid_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_conn_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_req_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_res_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_abandon_mutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_ldopts_mutex );
ldap_pvt_thread_mutex_unlock( &ld->ld_ldcmutex );
ldap_pvt_thread_mutex_destroy( &ld->ld_ldcmutex );
#endif
#ifndef NDEBUG
LDAP_TRASH(ld);
#endif
LDAP_FREE( (char *) ld->ldc );
LDAP_FREE( (char *) ld );
return( err );
}
static int
ag_cfgen( ConfigArgs *c )
{
slap_overinst *on = (slap_overinst *)c->bi;
autogroup_info_t *agi = (autogroup_info_t *)on->on_bi.bi_private;
autogroup_def_t *agd;
autogroup_entry_t *age;
int rc = 0, i;
Debug( LDAP_DEBUG_TRACE, "==> autogroup_cfgen\n", 0, 0, 0);
if( agi == NULL ) {
agi = (autogroup_info_t*)ch_calloc( 1, sizeof(autogroup_info_t) );
ldap_pvt_thread_mutex_init( &agi->agi_mutex );
agi->agi_def = NULL;
agi->agi_entry = NULL;
on->on_bi.bi_private = (void *)agi;
}
agd = agi->agi_def;
age = agi->agi_entry;
if ( c->op == SLAP_CONFIG_EMIT ) {
ldap_pvt_thread_mutex_lock( &agi->agi_mutex );
for ( i = 0 ; agd ; i++, agd = agd->agd_next ) {
struct berval bv;
char *ptr = c->cr_msg;
assert(agd->agd_oc != NULL);
assert(agd->agd_member_url_ad != NULL);
assert(agd->agd_member_ad != NULL);
ptr += snprintf( c->cr_msg, sizeof( c->cr_msg ),
SLAP_X_ORDERED_FMT "%s %s %s", i,
agd->agd_oc->soc_cname.bv_val,
agd->agd_member_url_ad->ad_cname.bv_val,
agd->agd_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 );
}
ldap_pvt_thread_mutex_unlock( &agi->agi_mutex );
return rc;
}else if ( c->op == LDAP_MOD_DELETE ) {
if ( c->valx < 0) {
autogroup_def_t *agd_next;
autogroup_entry_t *age_next;
autogroup_filter_t *agf = age->age_filter,
*agf_next;
ldap_pvt_thread_mutex_lock( &agi->agi_mutex );
for ( agd_next = agd; agd_next; agd = agd_next ) {
agd_next = agd->agd_next;
ch_free( agd );
}
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 );
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_init( &age->age_mutex );
ch_free( age );
}
ldap_pvt_thread_mutex_unlock( &agi->agi_mutex );
ldap_pvt_thread_mutex_destroy( &agi->agi_mutex );
ch_free( agi );
on->on_bi.bi_private = NULL;
} else {
autogroup_def_t **agdp;
autogroup_entry_t *age_next, *age_prev;
autogroup_filter_t *agf,
*agf_next;
ldap_pvt_thread_mutex_lock( &agi->agi_mutex );
for ( i = 0, agdp = &agi->agi_def;
i < c->valx; i++ )
{
if ( *agdp == NULL) {
return 1;
}
agdp = &(*agdp)->agd_next;
}
agd = *agdp;
*agdp = agd->agd_next;
for ( age_next = age , age_prev = NULL ; age_next ; age_prev = age, age = age_next ) {
age_next = age->age_next;
if( age->age_def == agd ) {
agf = age->age_filter;
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_destroy( &age->age_mutex );
ch_free( age );
age = age_prev;
if( age_prev != NULL ) {
age_prev->age_next = age_next;
}
}
}
ch_free( agd );
agd = agi->agi_def;
ldap_pvt_thread_mutex_unlock( &agi->agi_mutex );
}
return rc;
}
switch(c->type){
case AG_ATTRSET: {
autogroup_def_t **agdp,
*agd_next = NULL;
ObjectClass *oc = NULL;
AttributeDescription *member_url_ad = NULL,
*member_ad = NULL;
const char *text;
oc = oc_find( c->argv[ 1 ] );
if( oc == NULL ){
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"unable to find ObjectClass \"%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 ], &member_url_ad, &text );
if( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"unable to find AttributeDescription \"%s\"",
c->argv[ 2 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
if( !is_at_subtype( member_url_ad->ad_type, slap_schema.si_ad_labeledURI->ad_type ) ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"AttributeDescription \"%s\" ",
"must be of a subtype \"labeledURI\"",
c->argv[ 2 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
rc = slap_str2ad( c->argv[3], &member_ad, &text );
if( rc != LDAP_SUCCESS ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"unable to find AttributeDescription \"%s\"",
c->argv[ 3 ] );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
return 1;
}
ldap_pvt_thread_mutex_lock( &agi->agi_mutex );
for ( agdp = &agi->agi_def ; *agdp ; agdp = &(*agdp)->agd_next ) {
/* The same URL attribute / member attribute pair
* cannot be repeated */
if ( (*agdp)->agd_member_url_ad == member_url_ad && (*agdp)->agd_member_ad == member_ad ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"URL attributeDescription \"%s\" already mapped",
member_ad->ad_cname.bv_val );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
/* return 1; //warning*/
}
}
if ( c->valx > 0 ) {
int i;
for ( i = 0, agdp = &agi->agi_def ;
i < c->valx; i++ )
{
if ( *agdp == NULL ) {
snprintf( c->cr_msg, sizeof( c->cr_msg ),
"\"autogroup-attrset <oc> <URL-ad> <member-ad>\": "
"invalid index {%d}",
c->valx );
Debug( LDAP_DEBUG_ANY, "%s: %s.\n",
c->log, c->cr_msg, 0 );
ldap_pvt_thread_mutex_unlock( &agi->agi_mutex );
return 1;
}
agdp = &(*agdp)->agd_next;
}
agd_next = *agdp;
} else {
for ( agdp = &agi->agi_def; *agdp;
agdp = &(*agdp)->agd_next )
/* goto last */;
}
*agdp = (autogroup_def_t *)ch_calloc( 1, sizeof(autogroup_info_t));
(*agdp)->agd_oc = oc;
(*agdp)->agd_member_url_ad = member_url_ad;
(*agdp)->agd_member_ad = member_ad;
(*agdp)->agd_next = agd_next;
ldap_pvt_thread_mutex_unlock( &agi->agi_mutex );
} break;
default:
rc = 1;
break;
}
return rc;
}
int
rewrite_xmap_destroy(
struct rewrite_map **pmap
)
{
struct rewrite_map *map;
assert( pmap != NULL );
assert( *pmap != NULL );
map = *pmap;
switch ( map->lm_type ) {
case REWRITE_MAP_XPWDMAP:
#ifdef USE_REWRITE_LDAP_PVT_THREADS
--xpasswd_mutex_init;
if ( !xpasswd_mutex_init ) {
ldap_pvt_thread_mutex_destroy( &xpasswd_mutex );
}
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
break;
case REWRITE_MAP_XFILEMAP:
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_mutex_lock( &map->lm_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
if ( map->lm_args ) {
fclose( ( FILE * )map->lm_args );
map->lm_args = NULL;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_mutex_unlock( &map->lm_mutex );
ldap_pvt_thread_mutex_destroy( &map->lm_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
break;
case REWRITE_MAP_XLDAPMAP:
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_mutex_lock( &map->lm_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
if ( map->lm_args ) {
ldap_free_urldesc( ( LDAPURLDesc * )map->lm_args );
map->lm_args = NULL;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_mutex_unlock( &map->lm_mutex );
ldap_pvt_thread_mutex_destroy( &map->lm_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
break;
default:
break;
}
free( map->lm_name );
free( map );
*pmap = NULL;
return 0;
}
int
meta_back_db_destroy(
Backend *be,
ConfigReply *cr )
{
metainfo_t *mi;
if ( be->be_private ) {
int i;
mi = ( metainfo_t * )be->be_private;
/*
* Destroy the connection tree
*/
ldap_pvt_thread_mutex_lock( &mi->mi_conninfo.lai_mutex );
if ( mi->mi_conninfo.lai_tree ) {
avl_free( mi->mi_conninfo.lai_tree, meta_back_conn_free );
}
for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
while ( !LDAP_TAILQ_EMPTY( &mi->mi_conn_priv[ i ].mic_priv ) ) {
metaconn_t *mc = LDAP_TAILQ_FIRST( &mi->mi_conn_priv[ i ].mic_priv );
LDAP_TAILQ_REMOVE( &mi->mi_conn_priv[ i ].mic_priv, mc, mc_q );
meta_back_conn_free( mc );
}
}
/*
* Destroy the per-target stuff (assuming there's at
* least one ...)
*/
if ( mi->mi_targets != NULL ) {
for ( i = 0; i < mi->mi_ntargets; i++ ) {
metatarget_t *mt = mi->mi_targets[ i ];
if ( META_BACK_TGT_QUARANTINE( mt ) ) {
if ( mt->mt_quarantine.ri_num != mi->mi_quarantine.ri_num )
{
mi->mi_ldap_extra->retry_info_destroy( &mt->mt_quarantine );
}
ldap_pvt_thread_mutex_destroy( &mt->mt_quarantine_mutex );
}
target_free( mt );
}
free( mi->mi_targets );
}
ldap_pvt_thread_mutex_lock( &mi->mi_cache.mutex );
if ( mi->mi_cache.tree ) {
avl_free( mi->mi_cache.tree, meta_dncache_free );
}
ldap_pvt_thread_mutex_unlock( &mi->mi_cache.mutex );
ldap_pvt_thread_mutex_destroy( &mi->mi_cache.mutex );
ldap_pvt_thread_mutex_unlock( &mi->mi_conninfo.lai_mutex );
ldap_pvt_thread_mutex_destroy( &mi->mi_conninfo.lai_mutex );
if ( mi->mi_candidates != NULL ) {
ber_memfree_x( mi->mi_candidates, NULL );
}
if ( META_BACK_QUARANTINE( mi ) ) {
mi->mi_ldap_extra->retry_info_destroy( &mi->mi_quarantine );
}
}
free( be->be_private );
return 0;
}
/*
* Inits a session
*/
struct rewrite_session *
rewrite_session_init(
struct rewrite_info *info,
const void *cookie
)
{
struct rewrite_session *session, tmp;
int rc;
assert( info != NULL );
assert( cookie != NULL );
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
tmp.ls_cookie = ( void * )cookie;
session = ( struct rewrite_session * )avl_find( info->li_cookies,
( caddr_t )&tmp, rewrite_cookie_cmp );
if ( session ) {
session->ls_count++;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return session;
}
session = calloc( sizeof( struct rewrite_session ), 1 );
if ( session == NULL ) {
return NULL;
}
session->ls_cookie = ( void * )cookie;
session->ls_count = 1;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( ldap_pvt_thread_mutex_init( &session->ls_mutex ) ) {
free( session );
return NULL;
}
if ( ldap_pvt_thread_rdwr_init( &session->ls_vars_mutex ) ) {
ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
free( session );
return NULL;
}
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rc = avl_insert( &info->li_cookies, ( caddr_t )session,
rewrite_cookie_cmp, rewrite_cookie_dup );
info->li_num_cookies++;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
if ( rc != 0 ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_destroy( &session->ls_vars_mutex );
ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
free( session );
return NULL;
}
return session;
}
struct rewrite_map *
rewrite_map_parse(
struct rewrite_info *info,
const char *string,
const char **currpos
)
{
struct rewrite_map *map = NULL;
struct rewrite_subst *subst = NULL;
char *s, *begin = NULL, *end;
const char *p;
int l, cnt, mtx = 0, rc = 0;
assert( info != NULL );
assert( string != NULL );
assert( currpos != NULL );
*currpos = NULL;
/*
* Go to the end of the map invocation (the right closing brace)
*/
for ( p = string, cnt = 1; p[ 0 ] != '\0' && cnt > 0; p++ ) {
if ( IS_REWRITE_SUBMATCH_ESCAPE( p[ 0 ] ) ) {
/*
* '%' marks the beginning of a new map
*/
if ( p[ 1 ] == '{' ) {
cnt++;
/*
* '%' followed by a digit may mark the beginning
* of an old map
*/
} else if ( isdigit( (unsigned char) p[ 1 ] ) && p[ 2 ] == '{' ) {
cnt++;
p++;
}
if ( p[ 1 ] != '\0' ) {
p++;
}
} else if ( p[ 0 ] == '}' ) {
cnt--;
}
}
if ( cnt != 0 ) {
return NULL;
}
*currpos = p;
/*
* Copy the map invocation
*/
l = p - string - 1;
s = calloc( sizeof( char ), l + 1 );
if ( s == NULL ) {
return NULL;
}
AC_MEMCPY( s, string, l );
s[ l ] = 0;
/*
* Isolate the map name (except for variable deref)
*/
switch ( s[ 0 ] ) {
case REWRITE_OPERATOR_VARIABLE_GET:
case REWRITE_OPERATOR_PARAM_GET:
break;
default:
begin = strchr( s, '(' );
if ( begin == NULL ) {
rc = -1;
goto cleanup;
}
begin[ 0 ] = '\0';
begin++;
break;
}
/*
* Check for special map types
*/
p = s;
switch ( p[ 0 ] ) {
case REWRITE_OPERATOR_SUBCONTEXT:
case REWRITE_OPERATOR_COMMAND:
case REWRITE_OPERATOR_VARIABLE_SET:
case REWRITE_OPERATOR_VARIABLE_GET:
case REWRITE_OPERATOR_PARAM_GET:
p++;
break;
}
/*
* Variable set and get may be repeated to indicate session-wide
* instead of operation-wide variables
*/
switch ( p[ 0 ] ) {
case REWRITE_OPERATOR_VARIABLE_SET:
case REWRITE_OPERATOR_VARIABLE_GET:
p++;
break;
}
/*
* Variable get token can be appended to variable set to mean store
* AND rewrite
*/
if ( p[ 0 ] == REWRITE_OPERATOR_VARIABLE_GET ) {
p++;
}
/*
* Check the syntax of the variable name
*/
if ( !isalpha( (unsigned char) p[ 0 ] ) ) {
rc = -1;
goto cleanup;
}
for ( p++; p[ 0 ] != '\0'; p++ ) {
if ( !isalnum( (unsigned char) p[ 0 ] ) ) {
rc = -1;
goto cleanup;
}
}
/*
* Isolate the argument of the map (except for variable deref)
*/
switch ( s[ 0 ] ) {
case REWRITE_OPERATOR_VARIABLE_GET:
case REWRITE_OPERATOR_PARAM_GET:
break;
default:
end = strrchr( begin, ')' );
if ( end == NULL ) {
rc = -1;
goto cleanup;
}
end[ 0 ] = '\0';
/*
* Compile the substitution pattern of the map argument
*/
subst = rewrite_subst_compile( info, begin );
if ( subst == NULL ) {
rc = -1;
goto cleanup;
}
break;
}
/*
* Create the map
*/
map = calloc( sizeof( struct rewrite_map ), 1 );
if ( map == NULL ) {
rc = -1;
goto cleanup;
}
memset( map, 0, sizeof( struct rewrite_map ) );
#ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( ldap_pvt_thread_mutex_init( &map->lm_mutex ) ) {
rc = -1;
goto cleanup;
}
++mtx;
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
/*
* No subst for variable deref
*/
switch ( s[ 0 ] ) {
case REWRITE_OPERATOR_VARIABLE_GET:
case REWRITE_OPERATOR_PARAM_GET:
break;
default:
map->lm_subst = subst;
break;
}
/*
* Parses special map types
*/
switch ( s[ 0 ] ) {
/*
* Subcontext
*/
case REWRITE_OPERATOR_SUBCONTEXT: /* '>' */
/*
* Fetch the rewrite context
* it MUST have been defined previously
*/
map->lm_type = REWRITE_MAP_SUBCONTEXT;
map->lm_name = strdup( s + 1 );
if ( map->lm_name == NULL ) {
rc = -1;
goto cleanup;
}
map->lm_data = rewrite_context_find( info, s + 1 );
if ( map->lm_data == NULL ) {
rc = -1;
goto cleanup;
}
break;
/*
* External command (not implemented yet)
*/
case REWRITE_OPERATOR_COMMAND: /* '|' */
rc = -1;
goto cleanup;
/*
* Variable set
*/
case REWRITE_OPERATOR_VARIABLE_SET: /* '&' */
if ( s[ 1 ] == REWRITE_OPERATOR_VARIABLE_SET ) {
if ( s[ 2 ] == REWRITE_OPERATOR_VARIABLE_GET ) {
map->lm_type = REWRITE_MAP_SETW_SESN_VAR;
map->lm_name = strdup( s + 3 );
} else {
map->lm_type = REWRITE_MAP_SET_SESN_VAR;
map->lm_name = strdup( s + 2 );
}
} else {
if ( s[ 1 ] == REWRITE_OPERATOR_VARIABLE_GET ) {
map->lm_type = REWRITE_MAP_SETW_OP_VAR;
map->lm_name = strdup( s + 2 );
} else {
map->lm_type = REWRITE_MAP_SET_OP_VAR;
map->lm_name = strdup( s + 1 );
}
}
if ( map->lm_name == NULL ) {
rc = -1;
goto cleanup;
}
break;
/*
* Variable dereference
*/
case REWRITE_OPERATOR_VARIABLE_GET: /* '*' */
if ( s[ 1 ] == REWRITE_OPERATOR_VARIABLE_GET ) {
map->lm_type = REWRITE_MAP_GET_SESN_VAR;
map->lm_name = strdup( s + 2 );
} else {
map->lm_type = REWRITE_MAP_GET_OP_VAR;
map->lm_name = strdup( s + 1 );
}
if ( map->lm_name == NULL ) {
rc = -1;
goto cleanup;
}
break;
/*
* Parameter
*/
case REWRITE_OPERATOR_PARAM_GET: /* '$' */
map->lm_type = REWRITE_MAP_GET_PARAM;
map->lm_name = strdup( s + 1 );
if ( map->lm_name == NULL ) {
rc = -1;
goto cleanup;
}
break;
/*
* Built-in map
*/
default:
map->lm_type = REWRITE_MAP_BUILTIN;
map->lm_name = strdup( s );
if ( map->lm_name == NULL ) {
rc = -1;
goto cleanup;
}
map->lm_data = rewrite_builtin_map_find( info, s );
if ( map->lm_data == NULL ) {
rc = -1;
goto cleanup;
}
break;
}
cleanup:
free( s );
if ( rc ) {
if ( subst != NULL ) {
free( subst );
}
if ( map ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( mtx ) {
ldap_pvt_thread_mutex_destroy( &map->lm_mutex );
}
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
if ( map->lm_name ) {
free( map->lm_name );
map->lm_name = NULL;
}
free( map );
map = NULL;
}
}
return map;
}