Attribute * slap_operational_entryDN( Entry *e ) { Attribute *a; assert( e != NULL ); assert( !BER_BVISNULL( &e->e_name ) ); assert( !BER_BVISNULL( &e->e_nname ) ); a = attr_alloc( slap_schema.si_ad_entryDN ); a->a_numvals = 1; a->a_vals = ch_malloc( 2 * sizeof( struct berval ) ); ber_dupbv( &a->a_vals[ 0 ], &e->e_name ); BER_BVZERO( &a->a_vals[ 1 ] ); a->a_nvals = ch_malloc( 2 * sizeof( struct berval ) ); ber_dupbv( &a->a_nvals[ 0 ], &e->e_nname ); BER_BVZERO( &a->a_nvals[ 1 ] ); return a; }
static int sssvlv_db_init( BackendDB *be, ConfigReply *cr) { slap_overinst *on = (slap_overinst *)be->bd_info; sssvlv_info *si; if ( ov_count == 0 ) { int rc; rc = register_supported_control2( LDAP_CONTROL_SORTREQUEST, SLAP_CTRL_SEARCH, NULL, sss_parseCtrl, 1 /* replace */, &sss_cid ); if ( rc != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_ANY, "Failed to register Sort Request control '%s' (%d)\n", LDAP_CONTROL_SORTREQUEST, rc ); return rc; } rc = register_supported_control2( LDAP_CONTROL_VLVREQUEST, SLAP_CTRL_SEARCH, NULL, vlv_parseCtrl, 1 /* replace */, &vlv_cid ); if ( rc != LDAP_SUCCESS ) { Debug( LDAP_DEBUG_ANY, "Failed to register VLV Request control '%s' (%d)\n", LDAP_CONTROL_VLVREQUEST, rc ); #ifdef SLAP_CONFIG_DELETE overlay_unregister_control( be, LDAP_CONTROL_SORTREQUEST ); unregister_supported_control( LDAP_CONTROL_SORTREQUEST ); #endif /* SLAP_CONFIG_DELETE */ return rc; } } si = (sssvlv_info *)ch_malloc(sizeof(sssvlv_info)); on->on_bi.bi_private = si; si->svi_max = 0; si->svi_num = 0; si->svi_max_keys = SSSVLV_DEFAULT_MAX_KEYS; si->svi_max_percon = SSSVLV_DEFAULT_MAX_REQUEST_PER_CONN; ov_count++; return LDAP_SUCCESS; }
static int denyop_over_init( BackendDB *be ) { slap_overinst *on = (slap_overinst *) be->bd_info; denyop_info *oi; oi = (denyop_info *)ch_malloc(sizeof(denyop_info)); memset(oi, 0, sizeof(denyop_info)); on->on_bi.bi_private = oi; return 0; }
Attribute * slap_operational_subschemaSubentry( Backend *be ) { Attribute *a; /* The backend wants to take care of it */ if ( be && !SLAP_FRONTEND(be) && be->be_schemadn.bv_val ) return NULL; a = attr_alloc( slap_schema.si_ad_subschemaSubentry ); a->a_numvals = 1; a->a_vals = ch_malloc( 2 * sizeof( struct berval ) ); ber_dupbv( a->a_vals, &frontendDB->be_schemadn ); a->a_vals[1].bv_len = 0; a->a_vals[1].bv_val = NULL; a->a_nvals = ch_malloc( 2 * sizeof( struct berval ) ); ber_dupbv( a->a_nvals, &frontendDB->be_schemandn ); a->a_nvals[1].bv_len = 0; a->a_nvals[1].bv_val = NULL; return a; }
int backsql_api_config( backsql_info *bi, const char *name, int argc, char *argv[] ) { backsql_api *ba; assert( bi != NULL ); assert( name != NULL ); for ( ba = backsqlapi; ba; ba = ba->ba_next ) { if ( strcasecmp( name, ba->ba_name ) == 0 ) { backsql_api *ba2; ba2 = ch_malloc( sizeof( backsql_api ) ); *ba2 = *ba; if ( ba2->ba_config ) { if ( ( *ba2->ba_config )( ba2, argc, argv ) ) { ch_free( ba2 ); return 1; } ba2->ba_argc = argc; if ( argc ) { int i; ba2->ba_argv = ch_malloc( argc * sizeof(char *)); for ( i=0; i<argc; i++ ) ba2->ba_argv[i] = ch_strdup( argv[i] ); } } ba2->ba_next = bi->sql_api; bi->sql_api = ba2; return 0; } } return 1; }
/* Perform replacement on regexp matches */ static void slap_sasl_rx_exp( const char *rep, const int *off, regmatch_t *str, const char *saslname, struct berval *out ) { int i, n, len, insert; /* Get the total length of the final URI */ n=1; len = 0; while( off[n] >= 0 ) { /* Len of next section from replacement string (x,y,z above) */ len += off[n] - off[n-1] - 2; if( off[n+1] < 0) break; /* Len of string from saslname that matched next $i (b,d above) */ i = rep[ off[n] + 1 ] - '0'; len += str[i].rm_eo - str[i].rm_so; n++; } out->bv_val = ch_malloc( len + 1 ); out->bv_len = len; /* Fill in URI with replace string, replacing $i as we go */ n=1; insert = 0; while( off[n] >= 0) { /* Paste in next section from replacement string (x,y,z above) */ len = off[n] - off[n-1] - 2; strncpy( out->bv_val+insert, rep + off[n-1] + 2, len); insert += len; if( off[n+1] < 0) break; /* Paste in string from saslname that matched next $i (b,d above) */ i = rep[ off[n] + 1 ] - '0'; len = str[i].rm_eo - str[i].rm_so; strncpy( out->bv_val+insert, saslname + str[i].rm_so, len ); insert += len; n++; } out->bv_val[insert] = '\0'; }
static int ndb_oc_create( struct ndb_info *ni, NdbOcInfo *oci, int create ) { char buf[4096], *ptr; int i, rc = 0, col; if ( create ) { ptr = buf + sprintf( buf, "CREATE TABLE `%s` (eid bigint unsigned NOT NULL, vid int unsigned NOT NULL", oci->no_table.bv_val ); } col = 0; if ( oci->no_oc->soc_required ) { for ( i=0; oci->no_oc->soc_required[i]; i++ ); col += i; } if ( oci->no_oc->soc_allowed ) { for ( i=0; oci->no_oc->soc_allowed[i]; i++ ); col += i; } /* assume all are present */ oci->no_attrs = (struct ndb_attrinfo **)ch_malloc( col * sizeof(struct ndb_attrinfo *)); col = 2; ldap_pvt_thread_rdwr_wlock( &ni->ni_ai_rwlock ); if ( oci->no_oc->soc_required ) { rc = ndb_ai_check( ni, oci, oci->no_oc->soc_required, &ptr, &col, create ); } if ( !rc && oci->no_oc->soc_allowed ) { rc = ndb_ai_check( ni, oci, oci->no_oc->soc_allowed, &ptr, &col, create ); } ldap_pvt_thread_rdwr_wunlock( &ni->ni_ai_rwlock ); /* shrink down to just the needed size */ oci->no_attrs = (struct ndb_attrinfo **)ch_realloc( oci->no_attrs, oci->no_nattrs * sizeof(struct ndb_attrinfo *)); if ( create ) { ptr = lutil_strcopy( ptr, ", PRIMARY KEY(eid, vid) ) ENGINE=ndb PARTITION BY KEY(eid)" ); rc = mysql_real_query( &ni->ni_sql, buf, ptr - buf ); if ( rc ) { Debug( LDAP_DEBUG_ANY, "ndb_oc_create: CREATE TABLE %s failed, %s (%d)\n", oci->no_table.bv_val, mysql_error(&ni->ni_sql), mysql_errno(&ni->ni_sql) ); } } return rc; }
static int dynacl_aci_unparse( void *priv, struct berval *bv ) { AttributeDescription *ad = ( AttributeDescription * )priv; char *ptr; assert( ad != NULL ); bv->bv_val = ch_malloc( STRLENOF(" aci=") + ad->ad_cname.bv_len + 1 ); ptr = lutil_strcopy( bv->bv_val, " aci=" ); ptr = lutil_strcopy( ptr, ad->ad_cname.bv_val ); bv->bv_len = ptr - bv->bv_val; return 0; }
static void attr_dup2( Attribute *tmp, Attribute *a ) { tmp->a_flags = a->a_flags & SLAP_ATTR_PERSISTENT_FLAGS; if ( a->a_vals != NULL ) { unsigned i, j; tmp->a_numvals = a->a_numvals; tmp->a_vals = ch_malloc( (tmp->a_numvals + 1) * sizeof(struct berval) ); for ( i = 0; i < tmp->a_numvals; i++ ) { ber_dupbv( &tmp->a_vals[i], &a->a_vals[i] ); if ( BER_BVISNULL( &tmp->a_vals[i] ) ) break; /* FIXME: error? */ } BER_BVZERO( &tmp->a_vals[i] ); /* a_nvals must be non null; it may be equal to a_vals */ assert( a->a_nvals != NULL ); if ( a->a_nvals != a->a_vals ) { tmp->a_nvals = ch_malloc( (tmp->a_numvals + 1) * sizeof(struct berval) ); for ( j = 0; !BER_BVISNULL( &a->a_nvals[j] ); j++ ) { assert( j < i ); ber_dupbv( &tmp->a_nvals[j], &a->a_nvals[j] ); if ( BER_BVISNULL( &tmp->a_nvals[j] ) ) break; /* FIXME: error? */ } assert( j == i ); BER_BVZERO( &tmp->a_nvals[j] ); } else { tmp->a_nvals = tmp->a_vals; } } }
static ID2 *scope_chunk_get( Operation *op ) { ID2 *ret = NULL; ldap_pvt_thread_pool_getkey( op->o_threadctx, (void *)scope_chunk_get, (void *)&ret, NULL ); if ( !ret ) { ret = ch_malloc( MDB_IDL_UM_SIZE * sizeof( ID2 )); } else { void *r2 = ret[0].mval.mv_data; ldap_pvt_thread_pool_setkey( op->o_threadctx, (void *)scope_chunk_get, r2, scope_chunk_free, NULL, NULL ); } return ret; }
static int retcode_db_init( BackendDB *be, ConfigReply *cr ) { slap_overinst *on = (slap_overinst *)be->bd_info; retcode_t *rd; srand( getpid() ); rd = (retcode_t *)ch_malloc( sizeof( retcode_t ) ); memset( rd, 0, sizeof( retcode_t ) ); on->on_bi.bi_private = (void *)rd; return 0; }
static int adremap_cf_case(ConfigArgs *c) { BackendDB *be = (BackendDB *)c->be; slap_overinst *on = (slap_overinst *)c->bi; adremap_info *ai = on->on_bi.bi_private; adremap_case *ac, **a2; int rc = ARG_BAD_CONF; switch(c->op) { case SLAP_CONFIG_EMIT: for (ac = ai->ai_case; ac; ac=ac->ac_next) { rc = value_add_one(&c->rvalue_vals, &ac->ac_attr->ad_cname); if (rc) break; } break; case LDAP_MOD_DELETE: if (c->valx < 0) { for (ac = ai->ai_case; ac; ac=ai->ai_case) { ai->ai_case = ac->ac_next; ch_free(ac); } } else { int i; for (i=0, a2 = &ai->ai_case; i<c->valx; i++, a2 = &(*a2)->ac_next); ac = *a2; *a2 = ac->ac_next; ch_free(ac); } rc = 0; break; default: { const char *text; adremap_case ad; ad.ac_attr = NULL; rc = slap_str2ad(c->argv[1], &ad.ac_attr, &text); if (rc) break; for (a2 = &ai->ai_case; *a2; a2 = &(*a2)->ac_next); ac = ch_malloc(sizeof(adremap_case)); ac->ac_next = NULL; ac->ac_attr = ad.ac_attr; *a2 = ac; break; } } return rc; }
int perl_back_db_init( BackendDB *be, ConfigReply *cr ) { be->be_private = (PerlBackend *) ch_malloc( sizeof(PerlBackend) ); memset( be->be_private, '\0', sizeof(PerlBackend)); ((PerlBackend *)be->be_private)->pb_filter_search_results = 0; Debug( LDAP_DEBUG_TRACE, "perl backend db init\n", 0, 0, 0 ); be->be_cf_ocs = be->bd_info->bi_cf_ocs; return 0; }
int txn_start_extop( Operation *op, SlapReply *rs ) { int rc; struct berval *bv; Statslog( LDAP_DEBUG_STATS, "%s TXN START\n", op->o_log_prefix, 0, 0, 0, 0 ); if( op->ore_reqdata != NULL ) { rs->sr_text = "no request data expected"; return LDAP_PROTOCOL_ERROR; } op->o_bd = op->o_conn->c_authz_backend; if( backend_check_restrictions( op, rs, (struct berval *)&slap_EXOP_TXN_START ) != LDAP_SUCCESS ) { return rs->sr_err; } /* acquire connection lock */ ldap_pvt_thread_mutex_lock( &op->o_conn->c_mutex ); if( op->o_conn->c_txn != CONN_TXN_INACTIVE ) { rs->sr_text = "Too many transactions"; rc = LDAP_BUSY; goto done; } assert( op->o_conn->c_txn_backend == NULL ); op->o_conn->c_txn = CONN_TXN_SPECIFY; bv = (struct berval *) ch_malloc( sizeof (struct berval) ); bv->bv_len = 0; bv->bv_val = NULL; rs->sr_rspdata = bv; rc = LDAP_SUCCESS; done: /* release connection lock */ ldap_pvt_thread_mutex_unlock( &op->o_conn->c_mutex ); return rc; }
static char *v2ref( BerVarray ref, const char *text ) { size_t len = 0, i = 0; char *v2; if(ref == NULL) { if (text) { return ch_strdup(text); } else { return NULL; } } if ( text != NULL ) { len = strlen( text ); if (text[len-1] != '\n') { i = 1; } } v2 = ch_malloc( len+i+sizeof("Referral:") ); if( text != NULL ) { strcpy(v2, text); if( i ) { v2[len++] = '\n'; } } strcpy( v2+len, "Referral:" ); len += sizeof("Referral:"); for( i=0; ref[i].bv_val != NULL; i++ ) { v2 = ch_realloc( v2, len + ref[i].bv_len + 1 ); v2[len-1] = '\n'; memcpy(&v2[len], ref[i].bv_val, ref[i].bv_len ); len += ref[i].bv_len; if (ref[i].bv_val[ref[i].bv_len-1] != '/') { ++len; } } v2[len-1] = '\0'; return v2; }
/* * dn "pretty"ing routine */ int dnPretty( Syntax *syntax, struct berval *val, struct berval **pretty) { struct berval *out; int rc; assert( pretty && *pretty == NULL ); out = ch_malloc( sizeof( struct berval ) ); rc = dnPretty2( syntax, val, out ); if ( rc != LDAP_SUCCESS ) free( out ); else *pretty = out; return rc; }
void build_new_dn( struct berval * new_dn, struct berval * parent_dn, struct berval * newrdn ) { char *ptr; if ( parent_dn == NULL ) { ber_dupbv( new_dn, newrdn ); return; } new_dn->bv_len = parent_dn->bv_len + newrdn->bv_len + 1; new_dn->bv_val = (char *) ch_malloc( new_dn->bv_len + 1 ); ptr = lutil_strcopy( new_dn->bv_val, newrdn->bv_val ); *ptr++ = ','; strcpy( ptr, parent_dn->bv_val ); }
/* * dn normalize routine */ int dnNormalize( Syntax *syntax, struct berval *val, struct berval **normalized ) { struct berval *out; int rc; assert( normalized && *normalized == NULL ); out = ch_malloc( sizeof( struct berval ) ); rc = dnNormalize2( syntax, val, out ); if ( rc != LDAP_SUCCESS ) free( out ); else *normalized = out; return rc; }
Attribute * slap_operational_hasSubordinate( int hs ) { Attribute *a; struct berval val; val = hs ? slap_true_bv : slap_false_bv; a = attr_alloc( slap_schema.si_ad_hasSubordinates ); a->a_numvals = 1; a->a_vals = ch_malloc( 2 * sizeof( struct berval ) ); ber_dupbv( &a->a_vals[0], &val ); a->a_vals[1].bv_val = NULL; a->a_nvals = a->a_vals; return a; }
static int bdb_attr_index_unparser( void *v1, void *v2 ) { AttrInfo *ai = v1; BerVarray *bva = v2; struct berval bv; char *ptr; slap_index2bvlen( ai->ai_indexmask, &bv ); if ( bv.bv_len ) { bv.bv_len += ai->ai_desc->ad_cname.bv_len + 1; ptr = ch_malloc( bv.bv_len+1 ); bv.bv_val = lutil_strcopy( ptr, ai->ai_desc->ad_cname.bv_val ); *bv.bv_val++ = ' '; slap_index2bv( ai->ai_indexmask, &bv ); bv.bv_val = ptr; ber_bvarray_add( bva, &bv ); } return 0; }
void slapi_int_plugin_unparse( Backend *be, BerVarray *out ) { Slapi_PBlock *pp; int i, j; char **argv, ibuf[32], *ptr; struct berval idx, bv; *out = NULL; idx.bv_val = ibuf; i = 0; for ( pp = SLAPI_BACKEND_PBLOCK( be ); pp != NULL; slapi_pblock_get( pp, SLAPI_IBM_PBLOCK, &pp ) ) { slapi_pblock_get( pp, SLAPI_X_CONFIG_ARGV, &argv ); if ( argv == NULL ) /* could be dynamic plugin */ continue; idx.bv_len = snprintf( idx.bv_val, sizeof( ibuf ), "{%d}", i ); if ( idx.bv_len >= sizeof( ibuf ) ) { /* FIXME: just truncating by now */ idx.bv_len = sizeof( ibuf ) - 1; } bv.bv_len = idx.bv_len; for (j=1; argv[j]; j++) { bv.bv_len += strlen(argv[j]); if ( j ) bv.bv_len++; } bv.bv_val = ch_malloc( bv.bv_len + 1 ); ptr = lutil_strcopy( bv.bv_val, ibuf ); for (j=1; argv[j]; j++) { if ( j ) *ptr++ = ' '; ptr = lutil_strcopy( ptr, argv[j] ); } ber_bvarray_add( out, &bv ); } }
/* This function adds a node into the main AVL tree */ idNode *bdb_add_node( ID id, char *d, struct bdb_info *bdb ) { idNode *node; node = (idNode *)ch_malloc(sizeof(idNode)); node->i_id = id; node->i_parent = NULL; node->i_kids = NULL; node->i_rdn = (diskNode *)d; node->i_rdn->rdn.bv_val += (long)d; node->i_rdn->nrdn.bv_val += (long)d; ldap_pvt_thread_rdwr_init(&node->i_kids_rdwr); avl_insert( &bdb->bi_tree, (caddr_t) node, node_add_cmp, avl_dup_error ); if (id == 1) bdb->bi_troot = node; return node; }
static int gssattr_dynacl_unparse( void *priv, struct berval *bv ) { gssattr_t *gssattr = (gssattr_t *)priv; char *ptr; bv->bv_len = STRLENOF( " dynacl/gss/.expand=" ) + gssattr->gssattr_name.bv_len + gssattr->gssattr_value.bv_len; bv->bv_val = ch_malloc( bv->bv_len + 1 ); ptr = lutil_strcopy( bv->bv_val, " dynacl/gss/" ); ptr = lutil_strncopy( ptr, gssattr->gssattr_name.bv_val, gssattr->gssattr_name.bv_len ); switch ( gssattr->gssattr_style ) { case ACL_STYLE_BASE: ptr = lutil_strcopy( ptr, ".exact=" ); break; case ACL_STYLE_REGEX: ptr = lutil_strcopy( ptr, ".regex=" ); break; case ACL_STYLE_EXPAND: ptr = lutil_strcopy( ptr, ".expand=" ); break; default: assert( 0 ); break; } ptr = lutil_strncopy( ptr, gssattr->gssattr_value.bv_val, gssattr->gssattr_value.bv_len ); ptr[ 0 ] = '\0'; bv->bv_len = ptr - bv->bv_val; return 0; }
int mdb_tool_entry_open( BackendDB *be, int mode ) { /* In Quick mode, commit once per 500 entries */ mdb_writes = 0; if ( slapMode & SLAP_TOOL_QUICK ) mdb_writes_per_commit = MDB_WRITES_PER_COMMIT; else mdb_writes_per_commit = 1; /* Set up for threaded slapindex */ if (( slapMode & (SLAP_TOOL_QUICK|SLAP_TOOL_READONLY)) == SLAP_TOOL_QUICK ) { if ( !mdb_tool_info ) { struct mdb_info *mdb = (struct mdb_info *) be->be_private; ldap_pvt_thread_mutex_init( &mdb_tool_index_mutex ); ldap_pvt_thread_cond_init( &mdb_tool_index_cond_main ); ldap_pvt_thread_cond_init( &mdb_tool_index_cond_work ); if ( mdb->mi_nattrs ) { int i; #if 0 /* threaded indexing has no performance advantage */ mdb_tool_threads = slap_tool_thread_max - 1; #endif if ( mdb_tool_threads > 1 ) { mdb_tool_index_rec = ch_calloc( mdb->mi_nattrs, sizeof( IndexRec )); mdb_tool_index_tcount = mdb_tool_threads - 1; for (i=1; i<mdb_tool_threads; i++) { int *ptr = ch_malloc( sizeof( int )); *ptr = i; ldap_pvt_thread_pool_submit( &connection_pool, mdb_tool_index_task, ptr ); } mdb_tool_info = mdb; } } } } return 0; }
static int dynlist_build_def_filter( dynlist_info_t *dli ) { char *ptr; dli->dli_default_filter.bv_len = STRLENOF( "(!(objectClass=" "))" ) + dli->dli_oc->soc_cname.bv_len; dli->dli_default_filter.bv_val = ch_malloc( dli->dli_default_filter.bv_len + 1 ); if ( dli->dli_default_filter.bv_val == NULL ) { Debug( LDAP_DEBUG_ANY, "dynlist_db_open: malloc failed.\n", 0, 0, 0 ); return -1; } ptr = lutil_strcopy( dli->dli_default_filter.bv_val, "(!(objectClass=" ); ptr = lutil_strcopy( ptr, dli->dli_oc->soc_cname.bv_val ); ptr = lutil_strcopy( ptr, "))" ); assert( ptr == &dli->dli_default_filter.bv_val[dli->dli_default_filter.bv_len] ); return 0; }
/* This function constructs a full DN for a given id. We really should * be passing idNodes directly, to save some effort... */ int bdb_fix_dn( BackendDB *be, ID id, Entry *e ) { struct bdb_info *bdb = (struct bdb_info *) be->be_private; idNode *n, *o; int rlen, nrlen; char *ptr, *nptr; ldap_pvt_thread_rdwr_rlock(&bdb->bi_tree_rdwr); o = bdb_find_id_node(id, bdb->bi_tree); rlen = be->be_suffix[0].bv_len + 1; nrlen = be->be_nsuffix[0].bv_len + 1; for (n = o; n && n->i_parent; n=n->i_parent) { rlen += n->i_rdn->rdn.bv_len + 1; nrlen += n->i_rdn->nrdn.bv_len + 1; } e->e_name.bv_len = rlen - 1; e->e_nname.bv_len = nrlen - 1; e->e_name.bv_val = ch_malloc(rlen + nrlen); e->e_nname.bv_val = e->e_name.bv_val + rlen; ptr = e->e_name.bv_val; nptr = e->e_nname.bv_val; for (n = o; n && n->i_parent; n=n->i_parent) { ptr = lutil_strcopy(ptr, n->i_rdn->rdn.bv_val); *ptr++ = ','; nptr = lutil_strcopy(nptr, n->i_rdn->nrdn.bv_val); *nptr++ = ','; } ldap_pvt_thread_rdwr_runlock(&bdb->bi_tree_rdwr); strcpy(ptr, be->be_suffix[0].bv_val); strcpy(nptr, be->be_nsuffix[0].bv_val); return 0; }
/* * Add information about replica host specified by Ri to list * of hosts. */ static Stel * St_add( St *st, Ri *ri ) { int ind; if ( st == NULL || ri == NULL ) { return NULL; } /* Serialize access to the St struct */ ldap_pvt_thread_mutex_lock( &(st->st_mutex )); st->st_nreplicas++; ind = st->st_nreplicas - 1; st->st_data = ( Stel ** ) ch_realloc( st->st_data, ( st->st_nreplicas * sizeof( Stel * ))); if ( st->st_data == NULL ) { ldap_pvt_thread_mutex_unlock( &(st->st_mutex )); return NULL; } st->st_data[ ind ] = ( Stel * ) ch_malloc( sizeof( Stel ) ); if ( st->st_data[ ind ] == NULL ) { ldap_pvt_thread_mutex_unlock( &(st->st_mutex )); return NULL; } st->st_data[ ind ]->hostname = strdup( ri->ri_hostname ); st->st_data[ ind ]->port = ri->ri_port; st->st_data[ ind ]->last = 0; st->st_data[ ind ]->seq = 0; ldap_pvt_thread_mutex_unlock( &(st->st_mutex )); return st->st_data[ ind ]; }
/* * adds an entry to the cache and inits the mutex */ int monitor_cache_add( monitor_info_t *mi, Entry *e ) { monitor_cache_t *mc; monitor_entry_t *mp; int rc; assert( mi != NULL ); assert( e != NULL ); mp = ( monitor_entry_t *)e->e_private; mc = ( monitor_cache_t * )ch_malloc( sizeof( monitor_cache_t ) ); mc->mc_ndn = e->e_nname; mc->mc_e = e; ldap_pvt_thread_mutex_lock( &mi->mi_cache_mutex ); rc = avl_insert( &mi->mi_cache, ( caddr_t )mc, monitor_cache_cmp, monitor_cache_dup ); ldap_pvt_thread_mutex_unlock( &mi->mi_cache_mutex ); return rc; }
static void *search_stack( Operation *op ) { struct mdb_info *mdb = (struct mdb_info *) op->o_bd->be_private; void *ret = NULL; if ( op->o_threadctx ) { ldap_pvt_thread_pool_getkey( op->o_threadctx, (void *)search_stack, &ret, NULL ); } else { ret = mdb->mi_search_stack; } if ( !ret ) { ret = ch_malloc( mdb->mi_search_stack_depth * MDB_IDL_UM_SIZE * sizeof( ID ) ); if ( op->o_threadctx ) { ldap_pvt_thread_pool_setkey( op->o_threadctx, (void *)search_stack, ret, search_stack_free, NULL, NULL ); } else { mdb->mi_search_stack = ret; } } return ret; }
/* Find or create an NdbAttrInfo */ extern "C" NdbAttrInfo * ndb_ai_get( struct ndb_info *ni, struct berval *aname ) { NdbAttrInfo atmp, *ai; atmp.na_name = *aname; ai = (NdbAttrInfo *)avl_find( ni->ni_ai_tree, &atmp, ndb_name_cmp ); if ( !ai ) { const char *text; AttributeDescription *ad = NULL; if ( slap_bv2ad( aname, &ad, &text )) return NULL; ai = (NdbAttrInfo *)ch_malloc( sizeof( NdbAttrInfo )); ai->na_desc = ad; ai->na_attr = ai->na_desc->ad_type; ai->na_name = ai->na_attr->sat_cname; ai->na_oi = NULL; ai->na_flag = 0; ai->na_ixcol = 0; ai->na_len = ai->na_attr->sat_atype.at_syntax_len; /* Reasonable default */ if ( !ai->na_len ) { if ( ai->na_attr->sat_syntax == slap_schema.si_syn_distinguishedName ) ai->na_len = 1024; else ai->na_len = 128; } /* Arbitrary limit */ if ( ai->na_len > 1024 ) ai->na_len = 1024; avl_insert( &ni->ni_ai_tree, ai, ndb_name_cmp, avl_dup_error ); } return ai; }