p = slapi_value_get_string( &attr->a_vals[0] );
if ( p != NULL ) {
- return slapi_ch_strdup( (char *)p );
+ return slapi_ch_strdup( p );
}
}
}
char *
-slapi_ch_strdup( char *s )
+slapi_ch_strdup( const char *s )
{
- return ch_strdup( (const char *)s );
+ return ch_strdup( s );
}
size_t
-slapi_ch_stlen( char *s )
+slapi_ch_stlen( const char *s )
{
- return strlen( (const char *)s );
+ return strlen( s );
}
int
Slapi_Value *slapi_value_init_string(Slapi_Value *v, const char *s)
{
- v->bv_val = slapi_ch_strdup( (char *)s );
+ v->bv_val = slapi_ch_strdup( s );
v->bv_len = strlen( s );
return v;
if ( pb == NULL || pb->pb_op == NULL )
return LDAP_PARAM_ERROR;
- ml = slapi_int_ldapmods2modifications( mods, NULL );
+ ml = slapi_int_ldapmods2modifications( mods );
if ( ml == NULL ) {
return LDAP_OTHER;
}
*
* This function must also be called before slap_mods_check().
*/
-LDAPMod **slapi_int_modifications2ldapmods(
- Modifications **pmodlist,
- void *memctx
-)
+LDAPMod **slapi_int_modifications2ldapmods( Modifications **pmodlist )
{
Modifications *ml, *modlist;
LDAPMod **mods, *modp;
for( i = 0, ml = modlist; ml != NULL; i++, ml = ml->sml_next )
;
- mods = (LDAPMod **)slap_sl_malloc( (i + 1) * sizeof(LDAPMod *), memctx );
+ mods = (LDAPMod **)slapi_ch_malloc( (i + 1) * sizeof(LDAPMod *) );
for( i = 0, ml = modlist; ml != NULL; ml = ml->sml_next ) {
- mods[i] = (LDAPMod *)slap_sl_malloc( sizeof(LDAPMod), memctx );
+ mods[i] = (LDAPMod *)slapi_ch_malloc( sizeof(LDAPMod) );
modp = mods[i];
modp->mod_op = ml->sml_op | LDAP_MOD_BVALUES;
- modp->mod_type = slapi_ch_strdup( ml->sml_type.bv_val );
- ml->sml_type.bv_val = NULL;
+ if ( BER_BVISNULL( &ml->sml_type ) ) {
+ /* may happen for internally generated mods */
+ assert( ml->sml_desc != NULL );
+ modp->mod_type = slapi_ch_strdup( ml->sml_desc->ad_cname.bv_val );
+ } else {
+ modp->mod_type = slapi_ch_strdup( ml->sml_type.bv_val );
+ BER_BVZERO( &ml->sml_type );
+ }
if ( ml->sml_values != NULL ) {
for( j = 0; ml->sml_values[j].bv_val != NULL; j++ )
;
- modp->mod_bvalues = (struct berval **)slap_sl_malloc( (j + 1) *
- sizeof(struct berval *), memctx );
+ modp->mod_bvalues = (struct berval **)slapi_ch_malloc( (j + 1) *
+ sizeof(struct berval *) );
for( j = 0; ml->sml_values[j].bv_val != NULL; j++ ) {
+ modp->mod_bvalues[j] = (struct berval *)slapi_ch_malloc(
+ sizeof(struct berval) );
/* Take ownership of original values. */
- modp->mod_bvalues[j] = (struct berval *)slap_sl_malloc(
- sizeof(struct berval), memctx );
modp->mod_bvalues[j]->bv_len = ml->sml_values[j].bv_len;
modp->mod_bvalues[j]->bv_val = ml->sml_values[j].bv_val;
ml->sml_values[j].bv_len = 0;
* before prettying (and we can't easily get out of calling
* slap_mods_check() because we need normalized values).
*/
-Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods, void *memctx )
+Modifications *slapi_int_ldapmods2modifications ( LDAPMod **mods )
{
Modifications *modlist = NULL, **modtail;
LDAPMod **modp;
continue;
}
- mod = (Modifications *) slap_sl_malloc( sizeof(Modifications), memctx );
+ mod = (Modifications *) slapi_ch_malloc( sizeof(Modifications) );
mod->sml_op = lmod->mod_op & ~(LDAP_MOD_BVALUES);
mod->sml_flags = 0;
mod->sml_type = ad->ad_cname;
if ( i == 0 ) {
mod->sml_values = NULL;
} else {
- mod->sml_values = (BerVarray) slap_sl_malloc( (i + 1) * sizeof(struct berval), memctx );
+ mod->sml_values = (BerVarray) slapi_ch_malloc( (i + 1) * sizeof(struct berval) );
/* NB: This implicitly trusts a plugin to return valid modifications. */
if ( lmod->mod_op & LDAP_MOD_BVALUES ) {
}
} else {
for ( i = 0; lmod->mod_values[i] != NULL; i++ ) {
- mod->sml_values[i].bv_val = dup ? slapi_ch_strdup( lmod->mod_values[i] ) :
- lmod->mod_values[i];
+ mod->sml_values[i].bv_val = slapi_ch_strdup( lmod->mod_values[i] );
mod->sml_values[i].bv_len = strlen( lmod->mod_values[i] );
}
}
modtail = &mod->sml_next;
}
- if ( slap_mods_check( modlist, &text, textbuf, sizeof( textbuf ), memctx ) != LDAP_SUCCESS ) {
+ if ( slap_mods_check( modlist, &text, textbuf, sizeof( textbuf ), NULL ) != LDAP_SUCCESS ) {
slap_mods_free( modlist, 1 );
modlist = NULL;
}
return modlist;
}
-/*
- * This function only frees the parts of the mods array that
- * are not shared with the Modification list that was created
- * by slapi_int_ldapmods2modifications() (if dup == 0).
- */
-void
-slapi_int_free_ldapmods ( LDAPMod **mods )
-{
- int i, j;
-
- if ( mods == NULL )
- return;
-
- for ( i = 0; mods[i] != NULL; i++ ) {
- /*
- * Don't free values themselves; they're owned by the
- * Modification list. Do free the containing array.
- */
- if ( mods[i]->mod_op & LDAP_MOD_BVALUES ) {
- if ( mods[i]->mod_bvalues != NULL ) {
- for ( j = 0; mods[i]->mod_bvalues[j] != NULL; j++ )
- slapi_ch_free( (void **)&mods[i]->mod_bvalues[j] );
- slapi_ch_free( (void **)&mods[i]->mod_bvalues );
- }
- } else {
- slapi_ch_free( (void **)&mods[i]->mod_values );
- }
- slapi_ch_free_string( &mods[i]->mod_type );
- slapi_ch_free( (void **)&mods[i] );
- }
- slapi_ch_free( (void **)&mods );
-}
-
/*
* Sun ONE DS 5.x computed attribute support. Computed attributes
* allow for dynamically generated operational attributes, a very
return type;
}
+void slapi_be_set_readonly( Slapi_Backend *be, int readonly )
+{
+ if ( be == NULL )
+ return;
+
+ if ( readonly )
+ be->be_restrictops |= SLAP_RESTRICT_OP_WRITES;
+ else
+ be->be_restrictops &= ~(SLAP_RESTRICT_OP_WRITES);
+}
+
+int slapi_be_get_readonly( Slapi_Backend *be )
+{
+ if ( be == NULL )
+ return 0;
+
+ return ( (be->be_restrictops & SLAP_RESTRICT_OP_WRITES) == SLAP_RESTRICT_OP_WRITES );
+}
+
+const char *slapi_x_be_get_updatedn( Slapi_Backend *be )
+{
+ if ( be == NULL )
+ return NULL;
+
+ return be->be_update_ndn.bv_val;
+}
+
+Slapi_Backend *slapi_be_select( const Slapi_DN *sdn )
+{
+ Slapi_Backend *be;
+
+ slapi_sdn_get_ndn( sdn );
+
+ be = select_backend( (struct berval *)&sdn->ndn, 0, 0 );
+
+ return be;
+}
+
#if 0
void
slapi_operation_set_flag(Slapi_Operation *op, unsigned long flag)
projects / openldap / blobdiff