/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 1998-2008 The OpenLDAP Foundation.
+ * Copyright 1998-2009 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
(void)backend_set_controls( be );
} else {
+ char *type = be->bd_info->bi_type;
+ char *suffix = "(null)";
+
+ if ( overlay_is_over( be ) ) {
+ slap_overinfo *oi = (slap_overinfo *)be->bd_info->bi_private;
+ type = oi->oi_orig->bi_type;
+ }
+
+ if ( be->be_suffix != NULL && !BER_BVISNULL( &be->be_suffix[0] ) ) {
+ suffix = be->be_suffix[0].bv_val;
+ }
+
Debug( LDAP_DEBUG_ANY,
- "backend_startup_one: bi_db_open failed! (%d)\n",
- rc, 0, 0 );
+ "backend_startup_one (type=%s, suffix=\"%s\"): "
+ "bi_db_open failed! (%d)\n",
+ type, suffix, rc );
}
}
return rc;
}
}
- /* append global access controls */
- acl_append( &be->be_acl, frontendDB->be_acl, -1 );
return backend_startup_one( be, &cr );
}
"has no suffix\n",
i, be->bd_info->bi_type, 0 );
}
- /* append global access controls */
- acl_append( &be->be_acl, frontendDB->be_acl, -1 );
rc = backend_startup_one( be, &cr );
}
if ( be->bd_info->bi_db_close ) {
- be->bd_info->bi_db_close( be, NULL );
+ rc = be->bd_info->bi_db_close( be, NULL );
+ if ( rc ) return rc;
}
if( be->bd_info->bi_close ) {
- be->bd_info->bi_close( be->bd_info );
+ rc = be->bd_info->bi_close( be->bd_info );
+ if ( rc ) return rc;
}
return 0;
if ( !BER_BVISNULL( &bd->be_rootpw ) ) {
free( bd->be_rootpw.bv_val );
}
- acl_destroy( bd->be_acl, frontendDB->be_acl );
+ acl_destroy( bd->be_acl );
limits_destroy( bd->be_limits );
if ( !BER_BVISNULL( &bd->be_update_ndn ) ) {
ch_free( bd->be_update_ndn.bv_val );
if ( !BER_BVISNULL( &bd->be_rootpw ) ) {
free( bd->be_rootpw.bv_val );
}
- acl_destroy( bd->be_acl, frontendDB->be_acl );
+ acl_destroy( bd->be_acl );
+ frontendDB = NULL;
}
return 0;
}
be->bd_info = bi;
+ be->bd_self = be;
be->be_def_limit = frontendDB->be_def_limit;
be->be_dfltaccess = frontendDB->be_dfltaccess;
be->be_requires = frontendDB->be_requires;
be->be_ssf_set = frontendDB->be_ssf_set;
- be->be_pcl_mutexp = &be->be_pcl_mutex;
- ldap_pvt_thread_mutex_init( be->be_pcl_mutexp );
+ ldap_pvt_thread_mutex_init( &be->be_pcl_mutex );
/* assign a default depth limit for alias deref */
be->be_max_deref_depth = SLAPD_DEFAULT_MAXDEREFDEPTH;
nbackends--;
}
} else {
+ if ( !bi->bi_nDB ) {
+ backend_init_controls( bi );
+ }
bi->bi_nDB++;
}
return( be );
int
be_shadow_update( Operation *op )
{
- /* This assumes that all internal ops (connid == -1) on a syncrepl
+ /* This assumes that all internal ops (connid <= -1000) on a syncrepl
* database are syncrepl operations.
*/
- return (( SLAP_SYNC_SHADOW( op->o_bd ) && op->o_connid == -1 ) ||
+ return ( ( SLAP_SYNC_SHADOW( op->o_bd ) && SLAPD_SYNC_IS_SYNCCONN( op->o_connid ) ) ||
( SLAP_SHADOW( op->o_bd ) && be_isupdate_dn( op->o_bd, &op->o_ndn ) ) );
}
case LDAP_COMPARE_FALSE:
if ( !op->o_bd->be_ctrls[cid] && (*ctrls)->ldctl_iscritical ) {
+#ifdef SLAP_CONTROL_X_WHATFAILED
+ if ( get_whatFailed( op ) ) {
+ char *oids[ 2 ];
+ oids[ 0 ] = (*ctrls)->ldctl_oid;
+ oids[ 1 ] = NULL;
+ slap_ctrl_whatFailed_add( op, rs, oids );
+ }
+#endif
/* RFC 4511 allows unavailableCriticalExtension to be
* returned when the server is unwilling to perform
* an operation extended by a recognized critical
slap_mask_t requires;
slap_mask_t opflag;
slap_mask_t exopflag = 0;
- slap_ssf_set_t *ssf;
+ slap_ssf_set_t ssfs, *ssf;
int updateop = 0;
int starttls = 0;
int session = 0;
+ restrictops = frontendDB->be_restrictops;
+ requires = frontendDB->be_requires;
+ ssfs = frontendDB->be_ssf_set;
+ ssf = &ssfs;
+
if ( op->o_bd ) {
- int rc = SLAP_CB_CONTINUE;
+ slap_ssf_t *fssf, *bssf;
+ int rc = SLAP_CB_CONTINUE, i;
if ( op->o_bd->be_chk_controls ) {
rc = ( *op->o_bd->be_chk_controls )( op, rs );
return rs->sr_err;
}
- restrictops = op->o_bd->be_restrictops;
- requires = op->o_bd->be_requires;
- ssf = &op->o_bd->be_ssf_set;
-
- } else {
- restrictops = frontendDB->be_restrictops;
- requires = frontendDB->be_requires;
- ssf = &frontendDB->be_ssf_set;
+ restrictops |= op->o_bd->be_restrictops;
+ requires |= op->o_bd->be_requires;
+ bssf = &op->o_bd->be_ssf_set.sss_ssf;
+ fssf = &ssfs.sss_ssf;
+ for ( i=0; i<sizeof(ssfs)/sizeof(slap_ssf_t); i++ ) {
+ if ( bssf[i] ) fssf[i] = bssf[i];
+ }
}
switch( op->o_tag ) {
}
if( ( restrictops & opflag )
- || ( exopflag && ( restrictops & exopflag ) ) ) {
+ || ( exopflag && ( restrictops & exopflag ) )
+ || (( restrictops & SLAP_RESTRICT_READONLY ) && updateop )) {
if( ( restrictops & SLAP_RESTRICT_OP_MASK) == SLAP_RESTRICT_OP_READS ) {
rs->sr_text = "read operations restricted";
} else if ( restrictops & exopflag ) {
{
rc = 0;
}
- filter_free_x( op, filter );
+ filter_free_x( op, filter, 1 );
}
loopit:
ldap_free_urldesc( ludp );
BerVarray *vals,
slap_access_t access )
{
- Entry *e = NULL;
void *o_priv = op->o_private, *e_priv = NULL;
Attribute *a = NULL;
int freeattr = 0, i, j, rc = LDAP_SUCCESS;
AccessControlState acl_state = ACL_STATE_INIT;
+ AclCheck ak;
Backend *be = op->o_bd;
OpExtra *oex;
op->o_bd = select_backend( edn, 0 );
if ( target && dn_match( &target->e_nname, edn ) ) {
- e = target;
+ ak.ak_e = target;
} else {
op->o_private = NULL;
- rc = be_entry_get_rw( op, edn, NULL, entry_at, 0, &e );
+ ak.ak_e = NULL;
+ rc = be_entry_get_rw( op, edn, NULL, entry_at, 0, &ak.ak_e );
e_priv = op->o_private;
op->o_private = o_priv;
}
- if ( e ) {
+ if ( ak.ak_e ) {
+ ak.ak_state = &acl_state;
+ ak.ak_desc = entry_at;
+ ak.ak_access = access;
if ( entry_at == slap_schema.si_ad_entry || entry_at == slap_schema.si_ad_children ) {
assert( vals == NULL );
+ ak.ak_val = NULL;
rc = LDAP_SUCCESS;
if ( op->o_conn && access > ACL_NONE &&
- access_allowed( op, e, entry_at, NULL,
- access, &acl_state ) == 0 )
+ access_allowed( op, &ak ) == 0 )
{
rc = LDAP_INSUFFICIENT_ACCESS;
}
goto freeit;
}
- a = attr_find( e->e_attrs, entry_at );
+ a = attr_find( ak.ak_e->e_attrs, entry_at );
if ( a == NULL ) {
SlapReply rs = { 0 };
AttributeName anlist[ 2 ];
/* NOTE: backend_operational() is also called
* when returning results, so it's supposed
* to do no harm to entries */
- rs.sr_entry = e;
+ rs.sr_entry = ak.ak_e;
rc = backend_operational( op, &rs );
rs.sr_entry = NULL;
BerVarray v;
if ( op->o_conn && access > ACL_NONE &&
- access_allowed( op, e, entry_at, NULL,
- access, &acl_state ) == 0 )
+ access_allowed( op, &ak ) == 0 )
{
rc = LDAP_INSUFFICIENT_ACCESS;
goto freeit;
op->o_tmpmemctx );
for ( i = 0, j = 0; !BER_BVISNULL( &a->a_vals[i] ); i++ )
{
+ ak.ak_val = &a->a_nvals[i];
if ( op->o_conn && access > ACL_NONE &&
- access_allowed( op, e, entry_at,
- &a->a_nvals[i],
- access,
- &acl_state ) == 0 )
+ access_allowed( op, &ak ) == 0 )
{
continue;
}
rc = LDAP_SUCCESS;
}
}
-freeit: if ( e != target ) {
+freeit: if ( ak.ak_e != target ) {
op->o_private = e_priv;
- be_entry_release_r( op, e );
+ be_entry_release_r( op, ak.ak_e );
op->o_private = o_priv;
}
if ( freeattr ) {
int
backend_access(
Operation *op,
- Entry *target,
- struct berval *edn,
- AttributeDescription *entry_at,
- struct berval *nval,
- slap_access_t access,
- slap_mask_t *mask )
+ AclCheck *ak,
+ struct berval *edn )
{
- Entry *e = NULL;
void *o_priv = op->o_private, *e_priv = NULL;
int rc = LDAP_INSUFFICIENT_ACCESS;
Backend *be = op->o_bd;
+ int freeent = 0;
/* pedantic */
assert( op != NULL );
assert( op->o_conn != NULL );
assert( edn != NULL );
- assert( access > ACL_NONE );
+ assert( ak->ak_access > ACL_NONE );
if ( !op->o_bd ) {
op->o_bd = select_backend( edn, 0 );
}
- if ( target && dn_match( &target->e_nname, edn ) ) {
- e = target;
-
- } else {
+ if ( !ak->ak_e || !dn_match( &ak->ak_e->e_nname, edn ) ) {
op->o_private = NULL;
- rc = be_entry_get_rw( op, edn, NULL, entry_at, 0, &e );
+ rc = be_entry_get_rw( op, edn, NULL, ak->ak_desc, 0, &ak->ak_e );
+ freeent = 1;
e_priv = op->o_private;
op->o_private = o_priv;
}
- if ( e ) {
+ if ( ak->ak_e ) {
Attribute *a = NULL;
int freeattr = 0;
- if ( entry_at == NULL ) {
- entry_at = slap_schema.si_ad_entry;
+ if ( ak->ak_desc == NULL ) {
+ ak->ak_desc = slap_schema.si_ad_entry;
}
- if ( entry_at == slap_schema.si_ad_entry || entry_at == slap_schema.si_ad_children )
+ if ( ak->ak_desc == slap_schema.si_ad_entry || ak->ak_desc == slap_schema.si_ad_children )
{
- if ( access_allowed_mask( op, e, entry_at,
- NULL, access, NULL, mask ) == 0 )
+ if ( access_allowed( op, ak ) == 0 )
{
rc = LDAP_INSUFFICIENT_ACCESS;
}
} else {
- a = attr_find( e->e_attrs, entry_at );
+ a = attr_find( ak->ak_e->e_attrs, ak->ak_desc );
if ( a == NULL ) {
SlapReply rs = { 0 };
AttributeName anlist[ 2 ];
- anlist[ 0 ].an_name = entry_at->ad_cname;
- anlist[ 0 ].an_desc = entry_at;
+ anlist[ 0 ].an_name = ak->ak_desc->ad_cname;
+ anlist[ 0 ].an_desc = ak->ak_desc;
BER_BVZERO( &anlist[ 1 ].an_name );
rs.sr_attrs = anlist;
/* NOTE: backend_operational() is also called
* when returning results, so it's supposed
* to do no harm to entries */
- rs.sr_entry = e;
+ rs.sr_entry = ak->ak_e;
rc = backend_operational( op, &rs );
rs.sr_entry = NULL;
}
if ( a ) {
- if ( access_allowed_mask( op, e, entry_at,
- nval, access, NULL, mask ) == 0 )
+ if ( access_allowed( op, ak ) == 0 )
{
rc = LDAP_INSUFFICIENT_ACCESS;
goto freeit;
rc = LDAP_SUCCESS;
}
}
-freeit: if ( e != target ) {
+freeit: if ( freeent ) {
op->o_private = e_priv;
- be_entry_release_r( op, e );
+ be_entry_release_r( op, ak->ak_e );
op->o_private = o_priv;
}
if ( freeattr ) {
projects / openldap / blobdiff