void ldap_int_utils_init( void )
{
static int done=0;
if (done)
return;
done=1;
#ifdef LDAP_R_COMPILE
#if !defined( USE_CTIME_R ) && !defined( HAVE_REENTRANT_FUNCTIONS )
ldap_pvt_thread_mutex_init( &ldap_int_ctime_mutex );
#endif
#if !defined( USE_GMTIME_R ) && !defined( USE_LOCALTIME_R )
ldap_pvt_thread_mutex_init( &ldap_int_gmtime_mutex );
#endif
ldap_pvt_thread_mutex_init( &ldap_int_resolv_mutex );
#ifdef HAVE_CYRUS_SASL
ldap_pvt_thread_mutex_init( &ldap_int_sasl_mutex );
#endif
#ifdef HAVE_GSSAPI
ldap_pvt_thread_mutex_init( &ldap_int_gssapi_mutex );
#endif
#endif
/* call other module init functions here... */
}
int
entry_init(void)
{
ldap_pvt_thread_mutex_init( &entry2str_mutex );
ldap_pvt_thread_mutex_init( &entry_mutex );
return attr_init();
}
int slapi_over_config( BackendDB *be, ConfigReply *cr )
{
if ( slapi_over_initialized == 0 ) {
int rc;
/* do global initializaiton */
ldap_pvt_thread_mutex_init( &slapi_hn_mutex );
ldap_pvt_thread_mutex_init( &slapi_time_mutex );
ldap_pvt_thread_mutex_init( &slapi_printmessage_mutex );
if ( slapi_log_file == NULL )
slapi_log_file = slapi_ch_strdup( LDAP_RUNDIR LDAP_DIRSEP "errors" );
rc = slapi_int_init_object_extensions();
if ( rc != 0 )
return rc;
rc = slapi_over_init();
if ( rc != 0 )
return rc;
slapi_over_initialized = 1;
}
return overlay_config( be, SLAPI_OVERLAY_NAME, -1, NULL, cr );
}
int
meta_back_db_init(
Backend *be,
ConfigReply *cr)
{
metainfo_t *mi;
int i;
BackendInfo *bi;
bi = backend_info( "ldap" );
if ( !bi || !bi->bi_extra ) {
Debug( LDAP_DEBUG_ANY,
"meta_back_db_init: needs back-ldap\n" );
return 1;
}
mi = ch_calloc( 1, sizeof( metainfo_t ) );
if ( mi == NULL ) {
return -1;
}
/* set default flags */
mi->mi_flags =
META_BACK_F_DEFER_ROOTDN_BIND
| META_BACK_F_PROXYAUTHZ_ALWAYS
| META_BACK_F_PROXYAUTHZ_ANON
| META_BACK_F_PROXYAUTHZ_NOANON;
/*
* At present the default is no default target;
* this may change
*/
mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
mi->mi_bind_timeout.tv_sec = 0;
mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;
mi->mi_rebind_f = meta_back_default_rebind;
mi->mi_urllist_f = meta_back_default_urllist;
ldap_pvt_thread_mutex_init( &mi->mi_conninfo.lai_mutex );
ldap_pvt_thread_mutex_init( &mi->mi_cache.mutex );
/* safe default */
mi->mi_nretries = META_RETRY_DEFAULT;
mi->mi_version = LDAP_VERSION3;
for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
mi->mi_conn_priv[ i ].mic_num = 0;
LDAP_TAILQ_INIT( &mi->mi_conn_priv[ i ].mic_priv );
}
mi->mi_conn_priv_max = LDAP_BACK_CONN_PRIV_DEFAULT;
mi->mi_ldap_extra = (ldap_extra_t *)bi->bi_extra;
be->be_private = mi;
be->be_cf_ocs = be->bd_info->bi_cf_ocs;
return 0;
}
int bdb_tool_entry_open(
BackendDB *be, int mode )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
/* initialize key and data thangs */
DBTzero( &key );
DBTzero( &data );
key.flags = DB_DBT_USERMEM;
key.data = &nid;
key.size = key.ulen = sizeof( nid );
data.flags = DB_DBT_USERMEM;
if (cursor == NULL) {
int rc = bdb->bi_id2entry->bdi_db->cursor(
bdb->bi_id2entry->bdi_db, bdb->bi_cache.c_txn, &cursor,
bdb->bi_db_opflags );
if( rc != 0 ) {
return -1;
}
}
/* Set up for threaded slapindex */
if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) {
if ( !bdb_tool_info ) {
#ifdef USE_TRICKLE
ldap_pvt_thread_mutex_init( &bdb_tool_trickle_mutex );
ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond );
ldap_pvt_thread_cond_init( &bdb_tool_trickle_cond_end );
ldap_pvt_thread_pool_submit( &connection_pool, bdb_tool_trickle_task, bdb->bi_dbenv );
#endif
ldap_pvt_thread_mutex_init( &bdb_tool_index_mutex );
ldap_pvt_thread_cond_init( &bdb_tool_index_cond_main );
ldap_pvt_thread_cond_init( &bdb_tool_index_cond_work );
if ( bdb->bi_nattrs ) {
int i;
bdb_tool_threads = slap_tool_thread_max - 1;
if ( bdb_tool_threads > 1 ) {
bdb_tool_index_threads = ch_malloc( bdb_tool_threads * sizeof( int ));
bdb_tool_index_rec = ch_malloc( bdb->bi_nattrs * sizeof( IndexRec ));
bdb_tool_index_tcount = bdb_tool_threads - 1;
for (i=1; i<bdb_tool_threads; i++) {
int *ptr = ch_malloc( sizeof( int ));
*ptr = i;
ldap_pvt_thread_pool_submit( &connection_pool,
bdb_tool_index_task, ptr );
}
}
}
bdb_tool_info = bdb;
}
}
return 0;
}
static void tlso_thr_init( void )
{
int i;
for( i=0; i< CRYPTO_NUM_LOCKS ; i++ ) {
ldap_pvt_thread_mutex_init( &tlso_mutexes[i] );
}
ldap_pvt_thread_mutex_init( &tlso_dh_mutex );
CRYPTO_set_locking_callback( tlso_locking_cb );
CRYPTO_set_id_callback( tlso_thread_self );
}
/*
* Allocate and initialize an St struct.
*/
int
St_init(
St **st
)
{
if ( st == NULL ) {
return -1;
}
(*st) = (St *) malloc( sizeof( St ));
if ( *st == NULL ) {
return -1;
}
ldap_pvt_thread_mutex_init( &((*st)->st_mutex) );
(*st)->st_data = NULL;
(*st)->st_fp = NULL;
(*st)->st_lfp = NULL;
(*st)->st_nreplicas = 0;
(*st)->st_err_logged = 0;
(*st)->st_update = St_update;
(*st)->st_add = St_add;
(*st)->st_write = St_write;
(*st)->st_read = St_read;
(*st)->st_lock = St_lock;
(*st)->st_unlock = St_unlock;
return 0;
}
/*
* Parses a plugin map
*/
static int
rewrite_parse_builtin_map(
struct rewrite_info *info,
const char *fname,
int lineno,
int argc,
char **argv
)
{
struct rewrite_builtin_map *map;
#define MAP_TYPE 1
#define MAP_NAME 2
assert( info != NULL );
assert( fname != NULL );
assert( argc > 2 );
assert( argv != NULL );
assert( strcasecmp( argv[ 0 ], "rewriteMap" ) == 0 );
map = calloc( sizeof( struct rewrite_builtin_map ), 1 );
if ( map == NULL ) {
return REWRITE_ERR;
}
map->lb_name = strdup( argv[ MAP_NAME ] );
if ( map->lb_name == NULL ) {
free( map );
return REWRITE_ERR;
}
/*
* Built-in ldap map
*/
if (( map->lb_mapper = rewrite_mapper_find( argv[ MAP_TYPE ] ))) {
map->lb_type = REWRITE_BUILTIN_MAP;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
if ( ldap_pvt_thread_mutex_init( & map->lb_mutex ) ) {
free( map->lb_name );
free( map );
return REWRITE_ERR;
}
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
map->lb_private = map->lb_mapper->rm_config( fname, lineno,
argc - 3, argv + 3 );
/*
* Error
*/
} else {
free( map );
Debug( LDAP_DEBUG_ANY, "[%s:%d] unknown map type\n%s",
fname, lineno, "" );
return -1;
}
return rewrite_builtin_map_insert( info, map );
}
static int
ldap_distproc_db_init(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *)be->bd_info;
ldap_distproc_t *lc = NULL;
if ( lback == NULL ) {
lback = backend_info( "ldap" );
if ( lback == NULL ) {
return 1;
}
}
lc = ch_malloc( sizeof( ldap_distproc_t ) );
if ( lc == NULL ) {
return 1;
}
memset( lc, 0, sizeof( ldap_distproc_t ) );
ldap_pvt_thread_mutex_init( &lc->lc_lai.lai_mutex );
on->on_bi.bi_private = (void *)lc;
return 0;
}
static int
ndb_db_init( BackendDB *be, ConfigReply *cr )
{
struct ndb_info *ni;
int rc = 0;
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(ndb_db_init) ": Initializing ndb database\n",
0, 0, 0 );
/* allocate backend-database-specific stuff */
ni = (struct ndb_info *) ch_calloc( 1, sizeof(struct ndb_info) );
be->be_private = ni;
be->be_cf_ocs = be->bd_info->bi_cf_ocs;
ni->ni_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
ldap_pvt_thread_rdwr_init( &ni->ni_ai_rwlock );
ldap_pvt_thread_rdwr_init( &ni->ni_oc_rwlock );
ldap_pvt_thread_mutex_init( &ni->ni_conn_mutex );
#ifdef DO_MONITORING
rc = ndb_monitor_db_init( be );
#endif
return rc;
}
static int sssvlv_db_open(
BackendDB *be,
ConfigReply *cr )
{
slap_overinst *on = (slap_overinst *)be->bd_info;
sssvlv_info *si = on->on_bi.bi_private;
int rc;
int conn_index;
/* If not set, default to 1/2 of available threads */
if ( !si->svi_max )
si->svi_max = connection_pool_max / 2;
if ( dtblsize && !sort_conns ) {
ldap_pvt_thread_mutex_init( &sort_conns_mutex );
/* accommodate for c_conn_idx == -1 */
sort_conns = ch_calloc( dtblsize + 1, sizeof(sort_op **) );
for ( conn_index = 0 ; conn_index < dtblsize + 1 ; conn_index++ ) {
sort_conns[conn_index] = ch_calloc( si->svi_max_percon, sizeof(sort_op *) );
}
sort_conns++;
}
rc = overlay_register_control( be, LDAP_CONTROL_SORTREQUEST );
if ( rc == LDAP_SUCCESS )
rc = overlay_register_control( be, LDAP_CONTROL_VLVREQUEST );
return rc;
}
int
perl_back_initialize(
BackendInfo *bi
)
{
char *embedding[] = { "", "-e", "0" };
int argc = 3;
bi->bi_open = NULL;
bi->bi_config = 0;
bi->bi_close = perl_back_close;
bi->bi_destroy = 0;
bi->bi_db_init = perl_back_db_init;
bi->bi_db_config = perl_back_db_config;
bi->bi_db_open = perl_back_db_open;
bi->bi_db_close = 0;
bi->bi_db_destroy = perl_back_db_destroy;
bi->bi_op_bind = perl_back_bind;
bi->bi_op_unbind = 0;
bi->bi_op_search = perl_back_search;
bi->bi_op_compare = perl_back_compare;
bi->bi_op_modify = perl_back_modify;
bi->bi_op_modrdn = perl_back_modrdn;
bi->bi_op_add = perl_back_add;
bi->bi_op_delete = perl_back_delete;
bi->bi_op_abandon = 0;
bi->bi_extended = 0;
bi->bi_chk_referrals = 0;
bi->bi_connection_init = 0;
bi->bi_connection_destroy = 0;
/* injecting code from perl_back_open, because using fonction reference (bi->bi_open) is not functional */
Debug( LDAP_DEBUG_TRACE, "perl backend open\n", 0, 0, 0 );
if( PERL_INTERPRETER != NULL ) {
Debug( LDAP_DEBUG_ANY, "perl backend open: already opened\n",
0, 0, 0 );
return 1;
}
ldap_pvt_thread_mutex_init( &perl_interpreter_mutex );
#ifdef PERL_SYS_INIT3
PERL_SYS_INIT3(&argc, &embedding, (char ***)NULL);
#endif
PERL_INTERPRETER = perl_alloc();
perl_construct(PERL_INTERPRETER);
#ifdef PERL_EXIT_DESTRUCT_END
PL_exit_flags |= PERL_EXIT_DESTRUCT_END;
#endif
perl_parse(PERL_INTERPRETER, perl_back_xs_init, argc, embedding, (char **)NULL);
perl_run(PERL_INTERPRETER);
return perl_back_init_cf( bi );
}
int
backsql_db_init(
BackendDB *bd )
{
backsql_info *si;
Debug( LDAP_DEBUG_TRACE, "==>backsql_db_init()\n", 0, 0, 0 );
si = (backsql_info *)ch_calloc( 1, sizeof( backsql_info ) );
memset( si, '\0', sizeof( backsql_info ) );
ldap_pvt_thread_mutex_init( &si->dbconn_mutex );
ldap_pvt_thread_mutex_init( &si->schema_mutex );
backsql_init_db_env( si );
bd->be_private = si;
Debug( LDAP_DEBUG_TRACE, "<==backsql_db_init()\n", 0, 0, 0 );
return 0;
}
int
meta_back_db_init(
Backend *be,
ConfigReply *cr)
{
metainfo_t *mi;
int i;
mi = ch_calloc( 1, sizeof( metainfo_t ) );
if ( mi == NULL ) {
return -1;
}
/* set default flags */
mi->mi_flags =
META_BACK_F_DEFER_ROOTDN_BIND;
/*
* At present the default is no default target;
* this may change
*/
mi->mi_defaulttarget = META_DEFAULT_TARGET_NONE;
mi->mi_bind_timeout.tv_sec = 0;
mi->mi_bind_timeout.tv_usec = META_BIND_TIMEOUT;
mi->mi_rebind_f = meta_back_default_rebind;
mi->mi_urllist_f = meta_back_default_urllist;
ldap_pvt_thread_mutex_init( &mi->mi_conninfo.lai_mutex );
ldap_pvt_thread_mutex_init( &mi->mi_cache.mutex );
/* safe default */
mi->mi_nretries = META_RETRY_DEFAULT;
mi->mi_version = LDAP_VERSION3;
for ( i = LDAP_BACK_PCONN_FIRST; i < LDAP_BACK_PCONN_LAST; i++ ) {
mi->mi_conn_priv[ i ].mic_num = 0;
LDAP_TAILQ_INIT( &mi->mi_conn_priv[ i ].mic_priv );
}
mi->mi_conn_priv_max = LDAP_BACK_CONN_PRIV_DEFAULT;
be->be_private = mi;
return 0;
}
int slapi_int_init_object_extensions(void)
{
memset( ®istered_extensions, 0, sizeof( registered_extensions ) );
if ( ldap_pvt_thread_mutex_init( ®istered_extensions.mutex ) != 0 ) {
return -1;
}
return 0;
}
static int autoPosixIds_db_init( BackendDB *be, ConfigReply *cr ) {
slap_overinst *on = (slap_overinst *)be->bd_info;
autoPosixIds_data *ad = ch_calloc(1, sizeof(autoPosixIds_data));
on->on_bi.bi_private = ad;
ldap_pvt_thread_mutex_init( &ad->mutex );
ad->max_uid_number = 0;
return 0;
}
/*
* initializes log subentry
*/
int
monitor_subsys_log_init(
BackendDB *be,
monitor_subsys_t *ms )
{
ms->mss_open = monitor_subsys_log_open;
ms->mss_modify = monitor_subsys_log_modify;
ldap_pvt_thread_mutex_init( &monitor_log_mutex );
return( 0 );
}
void quorum_global_init() {
int rc;
assert(quorum_list == QR_POISON);
rc = ldap_pvt_thread_mutex_init(&quorum_mutex);
if (rc) {
Debug( LDAP_DEBUG_ANY, "mutex_init failed for quorum_mutex, rc = %d\n", rc );
LDAP_BUG();
exit( EXIT_FAILURE );
}
quorum_list = NULL;
}
static int
mdb_db_init( BackendDB *be, ConfigReply *cr )
{
struct mdb_info *mdb;
int rc;
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(mdb_db_init) ": Initializing mdb database\n" );
#if MDBX_MODE_ENABLED
unsigned flags = mdbx_setup_debug(MDBX_DBG_DNT, mdbx_debug, MDBX_DBG_DNT);
flags &= ~(MDBX_DBG_TRACE | MDBX_DBG_EXTRA | MDBX_DBG_ASSERT);
if (reopenldap_mode_check())
flags |= MDBX_DBG_ASSERT;
# if LDAP_DEBUG > 1
flags |= MDBX_DBG_PRINT | MDBX_DBG_TRACE;
# endif /* LDAP_DEBUG > 1 */
# if LDAP_DEBUG > 2
flags |= MDBX_DBG_EXTRA;
# endif /* LDAP_DEBUG > 2 */
mdbx_setup_debug(flags, (MDBX_debug_func*) MDBX_DBG_DNT, MDBX_DBG_DNT);
#endif /* MDBX_MODE_ENABLED */
/* allocate backend-database-specific stuff */
mdb = (struct mdb_info *) ch_calloc( 1, sizeof(struct mdb_info) );
/* DBEnv parameters */
mdb->mi_dbenv_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
mdb->mi_dbenv_flags = 0;
mdb->mi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;
mdb->mi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
mdb->mi_search_stack = NULL;
mdb->mi_mapsize = DEFAULT_MAPSIZE;
mdb->mi_rtxn_size = DEFAULT_RTXN_SIZE;
be->be_private = mdb;
be->be_cf_ocs = be->bd_info->bi_cf_ocs;
#ifndef MDB_MULTIPLE_SUFFIXES
SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_ONE_SUFFIX;
#endif
slap_backtrace_set_dir( mdb->mi_dbenv_home );
ldap_pvt_thread_mutex_init( &mdb->mi_ads_mutex );
rc = mdb_monitor_db_init( be );
return rc;
}
static int
bdb_db_init( BackendDB *be, ConfigReply *cr )
{
struct bdb_info *bdb;
int rc;
Debug( LDAP_DEBUG_TRACE,
LDAP_XSTRING(bdb_db_init) ": Initializing " BDB_UCTYPE " database\n",
0, 0, 0 );
/* allocate backend-database-specific stuff */
bdb = (struct bdb_info *) ch_calloc( 1, sizeof(struct bdb_info) );
/* DBEnv parameters */
bdb->bi_dbenv_home = ch_strdup( SLAPD_DEFAULT_DB_DIR );
bdb->bi_dbenv_xflags = DB_TIME_NOTGRANTED;
bdb->bi_dbenv_mode = SLAPD_DEFAULT_DB_MODE;
bdb->bi_cache.c_maxsize = DEFAULT_CACHE_SIZE;
bdb->bi_cache.c_minfree = 1;
bdb->bi_lock_detect = DB_LOCK_DEFAULT;
bdb->bi_search_stack_depth = DEFAULT_SEARCH_STACK_DEPTH;
bdb->bi_search_stack = NULL;
ldap_pvt_thread_mutex_init( &bdb->bi_database_mutex );
ldap_pvt_thread_mutex_init( &bdb->bi_lastid_mutex );
#ifdef BDB_HIER
ldap_pvt_thread_mutex_init( &bdb->bi_modrdns_mutex );
#endif
ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_lru_mutex );
ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_count_mutex );
ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_eifree_mutex );
ldap_pvt_thread_mutex_init( &bdb->bi_cache.c_dntree.bei_kids_mutex );
ldap_pvt_thread_rdwr_init ( &bdb->bi_cache.c_rwlock );
ldap_pvt_thread_rdwr_init( &bdb->bi_idl_tree_rwlock );
ldap_pvt_thread_mutex_init( &bdb->bi_idl_tree_lrulock );
be->be_private = bdb;
be->be_cf_ocs = be->bd_info->bi_cf_ocs;
#ifndef BDB_MULTIPLE_SUFFIXES
SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_ONE_SUFFIX;
#endif
rc = bdb_monitor_db_init( be );
return rc;
}
static int
authzid_initialize( void )
{
ldap_pvt_thread_mutex_init( &authzid_mutex );
authzid.on_bi.bi_type = "authzid";
authzid.on_bi.bi_db_init = authzid_db_init;
authzid.on_bi.bi_db_destroy = authzid_db_destroy;
authzid.on_bi.bi_op_bind = authzid_op_bind;
return overlay_register( &authzid );
}
static int
auditlog_db_init(
BackendDB *be,
ConfigReply *cr
)
{
slap_overinst *on = (slap_overinst *)be->bd_info;
auditlog_data *ad = ch_calloc(1, sizeof(auditlog_data));
on->on_bi.bi_private = ad;
ldap_pvt_thread_mutex_init( &ad->ad_mutex );
return 0;
}
/*
* Initialize connection management infrastructure.
*/
int connections_init(void)
{
int i;
assert( connections == NULL );
if( connections != NULL) {
Debug( LDAP_DEBUG_ANY, "connections_init: already initialized.\n",
0, 0, 0 );
return -1;
}
/* should check return of every call */
ldap_pvt_thread_mutex_init( &connections_mutex );
ldap_pvt_thread_mutex_init( &conn_nextid_mutex );
connections = (Connection *) ch_calloc( dtblsize, sizeof(Connection) );
if( connections == NULL ) {
Debug( LDAP_DEBUG_ANY, "connections_init: "
"allocation (%d*%ld) of connection array failed\n",
dtblsize, (long) sizeof(Connection), 0 );
return -1;
}
assert( connections[0].c_struct_state == SLAP_C_UNINITIALIZED );
assert( connections[dtblsize-1].c_struct_state == SLAP_C_UNINITIALIZED );
for (i=0; i<dtblsize; i++) connections[i].c_conn_idx = i;
/*
* per entry initialization of the Connection array initialization
* will be done by connection_init()
*/
return 0;
}
int
meta_back_db_init(
Backend *be
)
{
struct metainfo *li;
li = ch_calloc( 1, sizeof( struct metainfo ) );
if ( li == NULL ) {
return -1;
}
/*
* At present the default is no default target;
* this may change
*/
li->defaulttarget = META_DEFAULT_TARGET_NONE;
ldap_pvt_thread_mutex_init( &li->conn_mutex );
ldap_pvt_thread_mutex_init( &li->cache.mutex );
be->be_private = li;
return 0;
}
static int example_open(BackendDB *be, ConfigReply *cr) {
slap_overinst *on = (slap_overinst *)be->bd_info;
example_data *ex = on->on_bi.bi_private;
ObjectClass *oc_kerberos;
ldap_pvt_thread_mutex_init(&ex->examplemutex);
// if (krb5_init_context(&ex->context)) return -1;
oc_kerberos = oc_find("krbPrincipal");
if (!oc_kerberos) return -1;
if (!ex->keytabpath) ex->keytabpath = DEFAULT_KEYTAB_PATH;
return 0;
}
int
backsql_db_init(
BackendDB *bd,
ConfigReply *cr )
{
backsql_info *bi;
int rc = 0;
Debug( LDAP_DEBUG_TRACE, "==>backsql_db_init()\n", 0, 0, 0 );
bi = (backsql_info *)ch_calloc( 1, sizeof( backsql_info ) );
ldap_pvt_thread_mutex_init( &bi->sql_dbconn_mutex );
ldap_pvt_thread_mutex_init( &bi->sql_schema_mutex );
if ( backsql_init_db_env( bi ) != SQL_SUCCESS ) {
rc = -1;
}
bd->be_private = bi;
Debug( LDAP_DEBUG_TRACE, "<==backsql_db_init()\n", 0, 0, 0 );
return rc;
}
static int
seqmod_db_open(
BackendDB *be,
ConfigReply *cr
)
{
slap_overinst *on = (slap_overinst *)be->bd_info;
seqmod_info *sm;
sm = ch_calloc(1, sizeof(seqmod_info));
on->on_bi.bi_private = sm;
ldap_pvt_thread_mutex_init( &sm->sm_mutex );
return 0;
}
static int
vc_initialize( void )
{
int rc;
rc = load_extop2( (struct berval *)&vc_exop_oid_bv,
SLAP_EXOP_HIDE, vc_exop, 0 );
if ( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"vc_initialize: unable to register VerifyCredentials exop: %d.\n",
rc, 0, 0 );
}
ldap_pvt_thread_mutex_init( &vc_mutex );
return rc;
}
monitor_entry_t *
monitor_back_entrypriv_create( void )
{
monitor_entry_t *mp;
mp = ( monitor_entry_t * )ch_calloc( sizeof( monitor_entry_t ), 1 );
mp->mp_next = NULL;
mp->mp_children = NULL;
mp->mp_info = NULL;
mp->mp_flags = MONITOR_F_NONE;
mp->mp_cb = NULL;
ldap_pvt_thread_mutex_init( &mp->mp_mutex );
return mp;
}
/*
* call from within bdb_db_init()
*/
int
bdb_monitor_db_init( BackendDB *be )
{
struct bdb_info *bdb = (struct bdb_info *) be->be_private;
if ( bdb_monitor_initialize() == LDAP_SUCCESS ) {
/* monitoring in back-bdb is on by default */
SLAP_DBFLAGS( be ) |= SLAP_DBFLAG_MONITORING;
}
#ifdef BDB_MONITOR_IDX
bdb->bi_idx = NULL;
ldap_pvt_thread_mutex_init( &bdb->bi_idx_mutex );
#endif /* BDB_MONITOR_IDX */
return 0;
}
