X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Facl.c;h=39857052f8244932f2286658f8f3640c1cfc8031;hb=298d439d596b198a3e96e4885dc80a9aba5e64be;hp=2c5551cc3f460e2a12a2e3699af1f29e25145dd0;hpb=0076b40c329936cf8fc788ca109d1d39e5422c5e;p=openldap diff --git a/servers/slapd/acl.c b/servers/slapd/acl.c index 2c5551cc3f..39857052f8 100644 --- a/servers/slapd/acl.c +++ b/servers/slapd/acl.c @@ -2,7 +2,7 @@ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * - * Copyright 1998-2005 The OpenLDAP Foundation. + * Copyright 1998-2006 The OpenLDAP Foundation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without @@ -35,55 +35,19 @@ #include "slap.h" #include "sets.h" #include "lber_pvt.h" - -#ifdef LDAP_SLAPI -#include "slapi/slapi.h" -#endif /* LDAPI_SLAPI */ +#include "lutil.h" #define ACL_BUF_SIZE 1024 /* use most appropriate size */ -/* - * speed up compares - */ -static struct berval - aci_bv_entry = BER_BVC("entry"), - aci_bv_children = BER_BVC("children"), - aci_bv_onelevel = BER_BVC("onelevel"), - aci_bv_subtree = BER_BVC("subtree"), - aci_bv_br_entry = BER_BVC("[entry]"), - aci_bv_br_all = BER_BVC("[all]"), - aci_bv_access_id = BER_BVC("access-id"), - aci_bv_anonymous = BER_BVC("anonymous"), - aci_bv_public = BER_BVC("public"), - aci_bv_users = BER_BVC("users"), - aci_bv_self = BER_BVC("self"), - aci_bv_dnattr = BER_BVC("dnattr"), - aci_bv_group = BER_BVC("group"), - aci_bv_role = BER_BVC("role"), - aci_bv_set = BER_BVC("set"), - aci_bv_set_ref = BER_BVC("set-ref"), - aci_bv_grant = BER_BVC("grant"), - aci_bv_deny = BER_BVC("deny"), - - aci_bv_ip_eq = BER_BVC("IP="), +static const struct berval acl_bv_ip_eq = BER_BVC( "IP=" ); +#ifdef LDAP_PF_INET6 +static const struct berval acl_bv_ipv6_eq = BER_BVC( "IP=[" ); +#endif /* LDAP_PF_INET6 */ #ifdef LDAP_PF_LOCAL - aci_bv_path_eq = BER_BVC("PATH="), - aci_bv_dirsep = BER_BVC(LDAP_DIRSEP), +static const struct berval acl_bv_path_eq = BER_BVC("PATH="); #endif /* LDAP_PF_LOCAL */ - - aci_bv_group_class = BER_BVC(SLAPD_GROUP_CLASS), - aci_bv_group_attr = BER_BVC(SLAPD_GROUP_ATTR), - aci_bv_role_class = BER_BVC(SLAPD_ROLE_CLASS), - aci_bv_role_attr = BER_BVC(SLAPD_ROLE_ATTR), - aci_bv_set_attr = BER_BVC(SLAPD_ACI_SET_ATTR); - -typedef enum slap_aci_scope_t { - SLAP_ACI_SCOPE_ENTRY = 0x1, - SLAP_ACI_SCOPE_CHILDREN = 0x2, - SLAP_ACI_SCOPE_SUBTREE = ( SLAP_ACI_SCOPE_ENTRY | SLAP_ACI_SCOPE_CHILDREN ) -} slap_aci_scope_t; - -static AccessControl * acl_get( + +static AccessControl * slap_acl_get( AccessControl *ac, int *count, Operation *op, Entry *e, AttributeDescription *desc, @@ -91,7 +55,7 @@ static AccessControl * acl_get( int nmatch, regmatch_t *matches, AccessControlState *state ); -static slap_control_t acl_mask( +static slap_control_t slap_acl_mask( AccessControl *ac, slap_mask_t *mask, Operation *op, Entry *e, AttributeDescription *desc, @@ -101,35 +65,18 @@ static slap_control_t acl_mask( int count, AccessControlState *state ); -#ifdef SLAPD_ACI_ENABLED -static int aci_mask( - Operation *op, Entry *e, - AttributeDescription *desc, - struct berval *val, - struct berval *aci, - int nmatch, - regmatch_t *matches, - slap_access_t *grant, - slap_access_t *deny, - slap_aci_scope_t scope); -#endif - static int regex_matches( struct berval *pat, char *str, char *buf, int nmatch, regmatch_t *matches); -static int string_expand( - struct berval *newbuf, struct berval *pattern, - char *match, int nmatch, regmatch_t *matches); -typedef struct AciSetCookie { - Operation *op; - Entry *e; -} AciSetCookie; +typedef struct AclSetCookie { + SetCookie asc_cookie; +#define asc_op asc_cookie.set_op + Entry *asc_e; +} AclSetCookie; -SLAP_SET_GATHER aci_set_gather; -SLAP_SET_GATHER aci_set_gather2; -static int aci_match_set ( struct berval *subj, Operation *op, - Entry *e, int setref ); +SLAP_SET_GATHER acl_set_gather; +SLAP_SET_GATHER acl_set_gather2; /* * access_allowed - check whether op->o_ndn is allowed the requested access @@ -137,7 +84,7 @@ static int aci_match_set ( struct berval *subj, Operation *op, * the whole attribute is assumed (all values). * * This routine loops through all access controls and calls - * acl_mask() on each applicable access control. + * slap_acl_mask() on each applicable access control. * The loop exits when a definitive answer is reached or * or no more controls remain. * @@ -151,7 +98,25 @@ static int aci_match_set ( struct berval *subj, Operation *op, */ int -access_allowed_mask( +slap_access_always_allowed( + Operation *op, + Entry *e, + AttributeDescription *desc, + struct berval *val, + slap_access_t access, + AccessControlState *state, + slap_mask_t *maskp ) +{ + assert( maskp != NULL ); + + /* assign all */ + ACL_LVL_ASSIGN_MANAGE( *maskp ); + + return 1; +} + +int +slap_access_allowed( Operation *op, Entry *e, AttributeDescription *desc, @@ -163,99 +128,32 @@ access_allowed_mask( int ret = 1; int count; AccessControl *a = NULL; - Backend *be; - int be_null = 0; #ifdef LDAP_DEBUG - char accessmaskbuf[ACCESSMASK_MAXLEN]; + char accessmaskbuf[ACCESSMASK_MAXLEN]; #endif - slap_mask_t mask; - slap_control_t control; - const char *attr; - regmatch_t matches[MAXREMATCHES]; - int st_same_attr = 0; - static AccessControlState state_init = ACL_STATE_INIT; + slap_mask_t mask; + slap_control_t control; + slap_access_t access_level; + const char *attr; + regmatch_t matches[MAXREMATCHES]; + assert( op != NULL ); assert( e != NULL ); assert( desc != NULL ); - assert( access > ACL_NONE ); - if ( maskp ) ACL_INVALIDATE( *maskp ); + assert( maskp != NULL ); + access_level = ACL_LEVEL( access ); attr = desc->ad_cname.bv_val; assert( attr != NULL ); - if( op && op->o_is_auth_check && - ( access == ACL_SEARCH || access == ACL_READ )) - { - access = ACL_AUTH; - } - - if( state ) { - if ( state->as_vd_ad==desc) { - if ( state->as_recorded ) { - if( state->as_recorded & ACL_STATE_RECORDED_NV && - val == NULL ) - { - return state->as_result; - } else if ( state->as_recorded & ACL_STATE_RECORDED_VD && - val != NULL && state->as_vd_acl == NULL ) - { - return state->as_result; - } - } - st_same_attr = 1; - } else { - *state = state_init; - } - - state->as_vd_ad=desc; - } - - Debug( LDAP_DEBUG_ACL, - "=> access_allowed: %s access to \"%s\" \"%s\" requested\n", - access2str( access ), e->e_dn, attr ); - - if ( op == NULL ) { - /* no-op call */ - goto done; - } - - be = op->o_bd; - if ( be == NULL ) { - be = LDAP_STAILQ_FIRST(&backendDB); - be_null = 1; -#ifdef LDAP_DEVEL - /* - * FIXME: experimental; use first backend rules - * iff there is no global_acl (ITS#3100) */ - if ( frontendDB->be_acl == NULL ) -#endif - { - op->o_bd = be; - } - } - assert( be != NULL ); - -#ifdef LDAP_SLAPI - if ( op->o_pb != NULL ) { - ret = slapi_int_access_allowed( op, e, desc, val, access, state ); - if ( ret == 0 ) { - /* ACL plugin denied access */ - goto done; - } - } -#endif /* LDAP_SLAPI */ + ACL_INIT( mask ); /* grant database root access */ - if ( be != NULL && be_isroot( op ) ) { - Debug( LDAP_DEBUG_ACL, - "<= root access granted\n", - 0, 0, 0 ); - if ( maskp ) { - mask = ACL_LVL_MANAGE; - } - + if ( be_isroot( op ) ) { + Debug( LDAP_DEBUG_ACL, "<= root access granted\n", 0, 0, 0 ); + mask = ACL_LVL_MANAGE; goto done; } @@ -263,8 +161,13 @@ access_allowed_mask( * no-user-modification operational attributes are ignored * by ACL_WRITE checking as any found here are not provided * by the user + * + * NOTE: but they are not ignored for ACL_MANAGE, because + * if we get here it means a non-root user is trying to + * manage data, so we need to check its privileges. */ - if ( access >= ACL_WRITE && is_at_no_user_mod( desc->ad_type ) + if ( access_level == ACL_WRITE + && is_at_no_user_mod( desc->ad_type ) && desc != slap_schema.si_ad_entry && desc != slap_schema.si_ad_children ) { @@ -275,152 +178,283 @@ access_allowed_mask( } /* use backend default access if no backend acls */ - if( be != NULL && be->be_acl == NULL ) { - Debug( LDAP_DEBUG_ACL, - "=> access_allowed: backend default %s access %s to \"%s\"\n", - access2str( access ), - be->be_dfltaccess >= access ? "granted" : "denied", - op->o_dn.bv_val ? op->o_dn.bv_val : "(anonymous)" ); - ret = be->be_dfltaccess >= access; + if ( op->o_bd->be_acl == NULL ) { + int i; - if ( maskp ) { - int i; - - mask = ACL_PRIV_LEVEL; - for ( i = ACL_NONE; i <= be->be_dfltaccess; i++ ) { - mask |= ACL_ACCESS2PRIV( i ); - } - } - - goto done; - -#ifdef notdef - /* be is always non-NULL */ - /* use global default access if no global acls */ - } else if ( be == NULL && frontendDB->be_acl == NULL ) { Debug( LDAP_DEBUG_ACL, - "=> access_allowed: global default %s access %s to \"%s\"\n", + "=> slap_access_allowed: backend default %s " + "access %s to \"%s\"\n", access2str( access ), - frontendDB->be_dfltaccess >= access ? "granted" : "denied", op->o_dn.bv_val ); - ret = frontendDB->be_dfltaccess >= access; - - if ( maskp ) { - int i; + op->o_bd->be_dfltaccess >= access_level ? "granted" : "denied", + op->o_dn.bv_val ? op->o_dn.bv_val : "(anonymous)" ); + ret = op->o_bd->be_dfltaccess >= access_level; - mask = ACL_PRIV_LEVEL; - for ( i = ACL_NONE; i <= global_default_access; i++ ) { - mask |= ACL_ACCESS2PRIV( i ); - } + mask = ACL_PRIV_LEVEL; + for ( i = ACL_NONE; i <= op->o_bd->be_dfltaccess; i++ ) { + ACL_PRIV_SET( mask, ACL_ACCESS2PRIV( i ) ); } goto done; -#endif } ret = 0; control = ACL_BREAK; - if( st_same_attr ) { - assert( state->as_vd_acl != NULL ); - + if ( state && state->as_vd_ad == desc ) { a = state->as_vd_acl; count = state->as_vd_acl_count; - if ( !ACL_IS_INVALID( state->as_vd_acl_mask )) { - mask = state->as_vd_acl_mask; - AC_MEMCPY( matches, state->as_vd_acl_matches, sizeof(matches) ); - goto vd_access; - } } else { if ( state ) state->as_vi_acl = NULL; a = NULL; - ACL_INIT(mask); count = 0; - memset(matches, '\0', sizeof(matches)); } + ACL_PRIV_ASSIGN( mask, *maskp ); + memset( matches, '\0', sizeof( matches ) ); - while((a = acl_get( a, &count, op, e, desc, val, - MAXREMATCHES, matches, state )) != NULL) + while ( ( a = slap_acl_get( a, &count, op, e, desc, val, + MAXREMATCHES, matches, state ) ) != NULL ) { int i; - for (i = 0; i < MAXREMATCHES && matches[i].rm_so > 0; i++) { + for ( i = 0; i < MAXREMATCHES && matches[i].rm_so > 0; i++ ) { Debug( LDAP_DEBUG_ACL, "=> match[%d]: %d %d ", i, - (int)matches[i].rm_so, (int)matches[i].rm_eo ); - if( matches[i].rm_so <= matches[0].rm_eo ) { + (int)matches[i].rm_so, (int)matches[i].rm_eo ); + if ( matches[i].rm_so <= matches[0].rm_eo ) { int n; - for ( n = matches[i].rm_so; n < matches[i].rm_eo; n++) { + for ( n = matches[i].rm_so; n < matches[i].rm_eo; n++ ) { Debug( LDAP_DEBUG_ACL, "%c", e->e_ndn[n], 0, 0 ); } } Debug( LDAP_DEBUG_ARGS, "\n", 0, 0, 0 ); } - if (state) { - if (state->as_vi_acl == a && (state->as_recorded & ACL_STATE_RECORDED_NV)) { - Debug( LDAP_DEBUG_ACL, "access_allowed: result from state (%s)\n", attr, 0, 0 ); + if ( state ) { + if ( state->as_vi_acl == a && + ( state->as_recorded & ACL_STATE_RECORDED_NV ) ) + { + Debug( LDAP_DEBUG_ACL, + "=> slap_access_allowed: result from state (%s)\n", + attr, 0, 0 ); ret = state->as_result; goto done; } else { - Debug( LDAP_DEBUG_ACL, "access_allowed: no res from state (%s)\n", attr, 0, 0); + Debug( LDAP_DEBUG_ACL, + "=> slap_access_allowed: no res from state (%s)\n", + attr, 0, 0 ); } } -vd_access: - control = acl_mask( a, &mask, op, + control = slap_acl_mask( a, &mask, op, e, desc, val, MAXREMATCHES, matches, count, state ); if ( control != ACL_BREAK ) { break; } - memset(matches, '\0', sizeof(matches)); + memset( matches, '\0', sizeof( matches ) ); } if ( ACL_IS_INVALID( mask ) ) { Debug( LDAP_DEBUG_ACL, - "=> access_allowed: \"%s\" (%s) invalid!\n", + "=> slap_access_allowed: \"%s\" (%s) invalid!\n", e->e_dn, attr, 0 ); - ACL_INIT(mask); + ACL_PRIV_ASSIGN( mask, *maskp ); } else if ( control == ACL_BREAK ) { Debug( LDAP_DEBUG_ACL, - "=> access_allowed: no more rules\n", 0, 0, 0); + "=> slap_access_allowed: no more rules\n", 0, 0, 0 ); goto done; } + ret = ACL_GRANT( mask, access ); + Debug( LDAP_DEBUG_ACL, - "=> access_allowed: %s access %s by %s\n", - access2str( access ), - ACL_GRANT(mask, access) ? "granted" : "denied", + "=> slap_access_allowed: %s access %s by %s\n", + access2str( access ), ret ? "granted" : "denied", accessmask2str( mask, accessmaskbuf, 1 ) ); - ret = ACL_GRANT(mask, access); +done: + ACL_PRIV_ASSIGN( *maskp, mask ); + return ret; +} + +int +fe_access_allowed( + Operation *op, + Entry *e, + AttributeDescription *desc, + struct berval *val, + slap_access_t access, + AccessControlState *state, + slap_mask_t *maskp ) +{ + BackendDB *be_orig; + int rc; + + /* + * NOTE: control gets here if FIXME + * if an appropriate backend cannot be selected for the operation, + * we assume that the frontend should handle this + * FIXME: should select_backend() take care of this, + * and return frontendDB instead of NULL? maybe for some value + * of the flags? + */ + be_orig = op->o_bd; + + if ( op->o_bd == NULL ) { + op->o_bd = select_backend( &op->o_req_ndn, 0, 0 ); + if ( op->o_bd == NULL ) + op->o_bd = frontendDB; + } + rc = slap_access_allowed( op, e, desc, val, access, state, maskp ); + op->o_bd = be_orig; + + return rc; +} + +int +access_allowed_mask( + Operation *op, + Entry *e, + AttributeDescription *desc, + struct berval *val, + slap_access_t access, + AccessControlState *state, + slap_mask_t *maskp ) +{ + int ret = 1; + AccessControl *a = NULL; + int be_null = 0; + +#ifdef LDAP_DEBUG + char accessmaskbuf[ACCESSMASK_MAXLEN]; +#endif + slap_mask_t mask; + slap_access_t access_level; + const char *attr; + static AccessControlState state_init = ACL_STATE_INIT; + + assert( e != NULL ); + assert( desc != NULL ); + + access_level = ACL_LEVEL( access ); + + assert( access_level > ACL_NONE ); + + ACL_INIT( mask ); + if ( maskp ) ACL_INVALIDATE( *maskp ); + + attr = desc->ad_cname.bv_val; + + assert( attr != NULL ); + + if ( op ) { + if ( op->o_is_auth_check && + ( access_level == ACL_SEARCH || access_level == ACL_READ ) ) + { + access = ACL_AUTH; + + } else if ( get_relax( op ) && access_level == ACL_WRITE && + desc == slap_schema.si_ad_entry ) + { + access = ACL_MANAGE; + } + } + + if ( state ) { + if ( state->as_vd_ad == desc ) { + if ( ( state->as_recorded & ACL_STATE_RECORDED_NV ) && + val == NULL ) + { + return state->as_result; + + } + } else { + *state = state_init; + } + } + + Debug( LDAP_DEBUG_ACL, + "=> access_allowed: %s access to \"%s\" \"%s\" requested\n", + access2str( access ), e->e_dn, attr ); + + if ( op == NULL ) { + /* no-op call */ + goto done; + } + + if ( op->o_bd == NULL ) { + op->o_bd = LDAP_STAILQ_FIRST( &backendDB ); + be_null = 1; + + /* FIXME: experimental; use first backend rules + * iff there is no global_acl (ITS#3100) + */ + if ( frontendDB->be_acl != NULL ) { + op->o_bd = frontendDB; + } + } + assert( op->o_bd != NULL ); + + /* this is enforced in backend_add() */ + if ( op->o_bd->bd_info->bi_access_allowed ) { + /* delegate to backend */ + ret = op->o_bd->bd_info->bi_access_allowed( op, e, + desc, val, access, state, &mask ); + + } else { + /* use default (but pass through frontend + * for global ACL overlays) */ + ret = frontendDB->bd_info->bi_access_allowed( op, e, + desc, val, access, state, &mask ); + } + + if ( !ret ) { + if ( ACL_IS_INVALID( mask ) ) { + Debug( LDAP_DEBUG_ACL, + "=> access_allowed: \"%s\" (%s) invalid!\n", + e->e_dn, attr, 0 ); + ACL_INIT( mask ); + + } else { + Debug( LDAP_DEBUG_ACL, + "=> access_allowed: no more rules\n", 0, 0, 0 ); + + goto done; + } + } + + Debug( LDAP_DEBUG_ACL, + "=> access_allowed: %s access %s by %s\n", + access2str( access ), ret ? "granted" : "denied", + accessmask2str( mask, accessmaskbuf, 1 ) ); done: - if( state != NULL ) { + if ( state != NULL ) { /* If not value-dependent, save ACL in case of more attrs */ - if ( !(state->as_recorded & ACL_STATE_RECORDED_VD) ) { + if ( !( state->as_recorded & ACL_STATE_RECORDED_VD ) ) { state->as_vi_acl = a; state->as_result = ret; } state->as_recorded |= ACL_STATE_RECORDED; + state->as_vd_ad = desc; } - if (be_null) op->o_bd = NULL; - if ( maskp ) *maskp = mask; + if ( be_null ) op->o_bd = NULL; + if ( maskp ) ACL_PRIV_ASSIGN( *maskp, mask ); return ret; } /* - * acl_get - return the acl applicable to entry e, attribute + * slap_acl_get - return the acl applicable to entry e, attribute * attr. the acl returned is suitable for use in subsequent calls to * acl_access_allowed(). */ static AccessControl * -acl_get( +slap_acl_get( AccessControl *a, int *count, Operation *op, @@ -460,7 +494,7 @@ acl_get( dnlen = e->e_nname.bv_len; - for ( ; a != NULL; a = a->acl_next ) { + for ( ; a != NULL; prev = a, a = a->acl_next ) { (*count) ++; if ( a->acl_dn_pat.bv_len || ( a->acl_dn_style != ACL_STYLE_REGEX )) { @@ -483,7 +517,8 @@ acl_get( continue; } else if ( a->acl_dn_style == ACL_STYLE_ONE ) { - int rdnlen = -1, sep = 0; + ber_len_t rdnlen = 0; + int sep = 0; if ( dnlen <= patlen ) continue; @@ -531,10 +566,7 @@ acl_get( if( state && !( state->as_recorded & ACL_STATE_RECORDED_VD )) { state->as_recorded |= ACL_STATE_RECORDED_VD; state->as_vd_acl = prev; - state->as_vd_acl_count = *count; - state->as_vd_access = a->acl_access; - state->as_vd_access_count = 1; - ACL_INVALIDATE( state->as_vd_acl_mask ); + state->as_vd_acl_count = *count - 1; } if ( a->acl_attrval_style == ACL_STYLE_REGEX ) { @@ -555,7 +587,7 @@ acl_get( if ( a->acl_attrs[0].an_desc->ad_type->sat_syntax != slap_schema.si_syn_distinguishedName ) { if (value_match( &match, desc, - desc->ad_type->sat_equality, 0, + a->acl_attrval_mr, 0, val, &a->acl_attrval, &text ) != LDAP_SUCCESS || match ) continue; @@ -569,12 +601,12 @@ acl_get( if ( vdnlen < patlen ) continue; - if ( a->acl_dn_style == ACL_STYLE_BASE ) { + if ( a->acl_attrval_style == ACL_STYLE_BASE ) { if ( vdnlen > patlen ) continue; - } else if ( a->acl_dn_style == ACL_STYLE_ONE ) { - int rdnlen = -1; + } else if ( a->acl_attrval_style == ACL_STYLE_ONE ) { + ber_len_t rdnlen = 0; if ( !DN_SEPARATOR( val->bv_val[vdnlen - patlen - 1] ) ) continue; @@ -583,11 +615,11 @@ acl_get( if ( rdnlen != vdnlen - patlen - 1 ) continue; - } else if ( a->acl_dn_style == ACL_STYLE_SUBTREE ) { + } else if ( a->acl_attrval_style == ACL_STYLE_SUBTREE ) { if ( vdnlen > patlen && !DN_SEPARATOR( val->bv_val[vdnlen - patlen - 1] ) ) continue; - } else if ( a->acl_dn_style == ACL_STYLE_CHILDREN ) { + } else if ( a->acl_attrval_style == ACL_STYLE_CHILDREN ) { if ( vdnlen <= patlen ) continue; @@ -595,7 +627,7 @@ acl_get( continue; } - if ( strcmp( a->acl_attrval.bv_val, val->bv_val + vdnlen - patlen )) + if ( strcmp( a->acl_attrval.bv_val, val->bv_val + vdnlen - patlen ) ) continue; } } @@ -624,292 +656,489 @@ acl_get( if( state && !( state->as_recorded & ACL_STATE_RECORDED_VD )) { \ state->as_recorded |= ACL_STATE_RECORDED_VD; \ state->as_vd_acl = a; \ - AC_MEMCPY( state->as_vd_acl_matches, matches, \ - sizeof( state->as_vd_acl_matches )) ; \ state->as_vd_acl_count = count; \ - state->as_vd_access = b; \ - state->as_vd_access_count = i; \ } \ } while( 0 ) -/* - * acl_mask - modifies mask based upon the given acl and the - * requested access to entry e, attribute attr, value val. if val - * is null, access to the whole attribute is assumed (all values). - * - * returns 0 access NOT allowed - * 1 access allowed - */ - -static slap_control_t -acl_mask( - AccessControl *a, - slap_mask_t *mask, +static int +acl_mask_dn( Operation *op, Entry *e, AttributeDescription *desc, struct berval *val, + AccessControl *a, int nmatch, regmatch_t *matches, - int count, - AccessControlState *state ) + slap_dn_access *bdn, + struct berval *opndn ) { - int i, odnlen, patlen; - Access *b; -#ifdef LDAP_DEBUG - char accessmaskbuf[ACCESSMASK_MAXLEN]; - char accessmaskbuf1[ACCESSMASK_MAXLEN]; -#endif - const char *attr; - - assert( a != NULL ); - assert( mask != NULL ); - assert( desc != NULL ); + /* + * if access applies to the entry itself, and the + * user is bound as somebody in the same namespace as + * the entry, OR the given dn matches the dn pattern + */ + /* + * NOTE: styles "anonymous", "users" and "self" + * have been moved to enum slap_style_t, whose + * value is set in a_dn_style; however, the string + * is maintained in a_dn_pat. + */ - attr = desc->ad_cname.bv_val; + if ( bdn->a_style == ACL_STYLE_ANONYMOUS ) { + if ( !BER_BVISEMPTY( opndn ) ) { + return 1; + } - assert( attr != NULL ); + } else if ( bdn->a_style == ACL_STYLE_USERS ) { + if ( BER_BVISEMPTY( opndn ) ) { + return 1; + } - Debug( LDAP_DEBUG_ACL, - "=> acl_mask: access to entry \"%s\", attr \"%s\" requested\n", - e->e_dn, attr, 0 ); + } else if ( bdn->a_style == ACL_STYLE_SELF ) { + struct berval ndn, selfndn; + int level; - Debug( LDAP_DEBUG_ACL, - "=> acl_mask: to %s by \"%s\", (%s) \n", - val ? "value" : "all values", - op->o_ndn.bv_val ? op->o_ndn.bv_val : "", - accessmask2str( *mask, accessmaskbuf, 1) ); + if ( BER_BVISEMPTY( opndn ) || BER_BVISNULL( &e->e_nname ) ) { + return 1; + } + level = bdn->a_self_level; + if ( level < 0 ) { + selfndn = *opndn; + ndn = e->e_nname; + level = -level; - if( state && ( state->as_recorded & ACL_STATE_RECORDED_VD ) - && state->as_vd_acl == a ) - { - b = state->as_vd_access; - i = state->as_vd_access_count; + } else { + ndn = *opndn; + selfndn = e->e_nname; + } - } else { - b = a->acl_access; - i = 1; - } + for ( ; level > 0; level-- ) { + if ( BER_BVISEMPTY( &ndn ) ) { + break; + } + dnParent( &ndn, &ndn ); + } + + if ( BER_BVISEMPTY( &ndn ) || !dn_match( &ndn, &selfndn ) ) + { + return 1; + } - for ( ; b != NULL; b = b->a_next, i++ ) { - slap_mask_t oldmask, modmask; + } else if ( bdn->a_style == ACL_STYLE_REGEX ) { + if ( !ber_bvccmp( &bdn->a_pat, '*' ) ) { + int tmp_nmatch; + regmatch_t tmp_matches[2], + *tmp_matchesp = tmp_matches; - ACL_INVALIDATE( modmask ); + int rc = 0; - /* AND clauses */ - if ( !BER_BVISEMPTY( &b->a_dn_pat ) ) { - Debug( LDAP_DEBUG_ACL, "<= check a_dn_pat: %s\n", - b->a_dn_pat.bv_val, 0, 0); - /* - * if access applies to the entry itself, and the - * user is bound as somebody in the same namespace as - * the entry, OR the given dn matches the dn pattern - */ - /* - * NOTE: styles "anonymous", "users" and "self" - * have been moved to enum slap_style_t, whose - * value is set in a_dn_style; however, the string - * is maintaned in a_dn_pat. - */ - if ( b->a_dn_style == ACL_STYLE_ANONYMOUS ) { - if ( op->o_ndn.bv_len != 0 ) { - continue; + switch ( a->acl_dn_style ) { + case ACL_STYLE_REGEX: + if ( !BER_BVISNULL( &a->acl_dn_pat ) ) { + tmp_matchesp = matches; + tmp_nmatch = nmatch; + break; } + /* FALLTHRU: applies also to ACL_STYLE_REGEX when pattern is "*" */ - } else if ( b->a_dn_style == ACL_STYLE_USERS ) { - if ( op->o_ndn.bv_len == 0 ) { - continue; + case ACL_STYLE_BASE: + tmp_matches[0].rm_so = 0; + tmp_matches[0].rm_eo = e->e_nname.bv_len; + tmp_nmatch = 1; + break; + + case ACL_STYLE_ONE: + case ACL_STYLE_SUBTREE: + case ACL_STYLE_CHILDREN: + tmp_matches[0].rm_so = 0; + tmp_matches[0].rm_eo = e->e_nname.bv_len; + tmp_matches[1].rm_so = e->e_nname.bv_len - a->acl_dn_pat.bv_len; + tmp_matches[1].rm_eo = e->e_nname.bv_len; + tmp_nmatch = 2; + break; + + default: + /* error */ + rc = 1; + break; + } + + if ( rc ) { + return 1; + } + + if ( !regex_matches( &bdn->a_pat, opndn->bv_val, + e->e_ndn, tmp_nmatch, tmp_matchesp ) ) + { + return 1; + } + } + + } else { + struct berval pat; + ber_len_t patlen, odnlen; + int got_match = 0; + + if ( e->e_dn == NULL ) + return 1; + + if ( bdn->a_expand ) { + struct berval bv; + char buf[ACL_BUF_SIZE]; + + int tmp_nmatch; + regmatch_t tmp_matches[2], + *tmp_matchesp = tmp_matches; + + int rc = 0; + + bv.bv_len = sizeof( buf ) - 1; + bv.bv_val = buf; + + switch ( a->acl_dn_style ) { + case ACL_STYLE_REGEX: + if ( !BER_BVISNULL( &a->acl_dn_pat ) ) { + tmp_matchesp = matches; + tmp_nmatch = nmatch; + break; } + /* FALLTHRU: applies also to ACL_STYLE_REGEX when pattern is "*" */ - } else if ( b->a_dn_style == ACL_STYLE_SELF ) { - if ( op->o_ndn.bv_len == 0 ) { - continue; + case ACL_STYLE_BASE: + tmp_matches[0].rm_so = 0; + tmp_matches[0].rm_eo = e->e_nname.bv_len; + tmp_nmatch = 1; + break; + + case ACL_STYLE_ONE: + case ACL_STYLE_SUBTREE: + case ACL_STYLE_CHILDREN: + tmp_matches[0].rm_so = 0; + tmp_matches[0].rm_eo = e->e_nname.bv_len; + tmp_matches[1].rm_so = e->e_nname.bv_len - a->acl_dn_pat.bv_len; + tmp_matches[1].rm_eo = e->e_nname.bv_len; + tmp_nmatch = 2; + break; + + default: + /* error */ + rc = 1; + break; + } + + if ( rc ) { + return 1; + } + + if ( acl_string_expand( &bv, &bdn->a_pat, + e->e_nname.bv_val, + tmp_nmatch, tmp_matchesp ) ) + { + return 1; + } + + if ( dnNormalize(0, NULL, NULL, &bv, + &pat, op->o_tmpmemctx ) + != LDAP_SUCCESS ) + { + /* did not expand to a valid dn */ + return 1; + } + + } else { + pat = bdn->a_pat; + } + + patlen = pat.bv_len; + odnlen = opndn->bv_len; + if ( odnlen < patlen ) { + goto dn_match_cleanup; + + } + + if ( bdn->a_style == ACL_STYLE_BASE ) { + /* base dn -- entire object DN must match */ + if ( odnlen != patlen ) { + goto dn_match_cleanup; + } + + } else if ( bdn->a_style == ACL_STYLE_ONE ) { + ber_len_t rdnlen = 0; + + if ( odnlen <= patlen ) { + goto dn_match_cleanup; + } + + if ( !DN_SEPARATOR( opndn->bv_val[odnlen - patlen - 1] ) ) { + goto dn_match_cleanup; + } + + rdnlen = dn_rdnlen( NULL, opndn ); + if ( rdnlen - ( odnlen - patlen - 1 ) != 0 ) { + goto dn_match_cleanup; + } + + } else if ( bdn->a_style == ACL_STYLE_SUBTREE ) { + if ( odnlen > patlen && !DN_SEPARATOR( opndn->bv_val[odnlen - patlen - 1] ) ) { + goto dn_match_cleanup; + } + + } else if ( bdn->a_style == ACL_STYLE_CHILDREN ) { + if ( odnlen <= patlen ) { + goto dn_match_cleanup; + } + + if ( !DN_SEPARATOR( opndn->bv_val[odnlen - patlen - 1] ) ) { + goto dn_match_cleanup; + } + + } else if ( bdn->a_style == ACL_STYLE_LEVEL ) { + int level = bdn->a_level; + struct berval ndn; + + if ( odnlen <= patlen ) { + goto dn_match_cleanup; + } + + if ( level > 0 && !DN_SEPARATOR( opndn->bv_val[odnlen - patlen - 1] ) ) + { + goto dn_match_cleanup; + } + + ndn = *opndn; + for ( ; level > 0; level-- ) { + if ( BER_BVISEMPTY( &ndn ) ) { + goto dn_match_cleanup; } - - if ( e->e_dn == NULL || !dn_match( &e->e_nname, &op->o_ndn ) ) { - continue; + dnParent( &ndn, &ndn ); + if ( ndn.bv_len < patlen ) { + goto dn_match_cleanup; } + } + + if ( ndn.bv_len != patlen ) { + goto dn_match_cleanup; + } + } - } else if ( b->a_dn_style == ACL_STYLE_REGEX ) { - if ( !ber_bvccmp( &b->a_dn_pat, '*' ) ) { - int tmp_nmatch; - regmatch_t tmp_matches[2], - *tmp_matchesp = tmp_matches; + got_match = !strcmp( pat.bv_val, &opndn->bv_val[ odnlen - patlen ] ); - int rc = 0; +dn_match_cleanup:; + if ( pat.bv_val != bdn->a_pat.bv_val ) { + slap_sl_free( pat.bv_val, op->o_tmpmemctx ); + } - switch ( a->acl_dn_style ) { - case ACL_STYLE_REGEX: - if ( !BER_BVISNULL( &a->acl_dn_pat ) ) { - tmp_matchesp = matches; - tmp_nmatch = nmatch; - break; - } - /* FALLTHRU: applies also to ACL_STYLE_REGEX when pattern is "*" */ + if ( !got_match ) { + return 1; + } + } - case ACL_STYLE_BASE: - tmp_matches[0].rm_so = 0; - tmp_matches[0].rm_eo = e->e_nname.bv_len; - tmp_nmatch = 1; - break; + return 0; +} - case ACL_STYLE_ONE: - case ACL_STYLE_SUBTREE: - case ACL_STYLE_CHILDREN: - tmp_matches[0].rm_so = 0; - tmp_matches[0].rm_eo = e->e_nname.bv_len; - tmp_matches[1].rm_so = e->e_nname.bv_len - a->acl_dn_pat.bv_len; - tmp_matches[1].rm_eo = e->e_nname.bv_len; - tmp_nmatch = 2; - break; +static int +acl_mask_dnattr( + Operation *op, + Entry *e, + struct berval *val, + AccessControl *a, + Access *b, + int i, + regmatch_t *matches, + int count, + AccessControlState *state, + slap_dn_access *bdn, + struct berval *opndn ) +{ + Attribute *at; + struct berval bv; + int rc, match = 0; + const char *text; + const char *attr = bdn->a_at->ad_cname.bv_val; - default: - /* error */ - rc = 1; - break; - } + assert( attr != NULL ); - if ( rc ) { - continue; - } + if ( BER_BVISEMPTY( opndn ) ) { + return 1; + } - if ( !regex_matches( &b->a_dn_pat, - op->o_ndn.bv_val, e->e_ndn, - tmp_nmatch, tmp_matchesp ) ) - { - continue; - } - } + Debug( LDAP_DEBUG_ACL, "<= check a_dn_at: %s\n", attr, 0, 0 ); + bv = *opndn; - } else { - struct berval pat; - int got_match = 0; + /* see if asker is listed in dnattr */ + for ( at = attrs_find( e->e_attrs, bdn->a_at ); + at != NULL; + at = attrs_find( at->a_next, bdn->a_at ) ) + { + if ( value_find_ex( bdn->a_at, + SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH | + SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH, + at->a_nvals, + &bv, op->o_tmpmemctx ) == 0 ) + { + /* found it */ + match = 1; + break; + } + } - if ( e->e_dn == NULL ) - continue; + if ( match ) { + /* have a dnattr match. if this is a self clause then + * the target must also match the op dn. + */ + if ( bdn->a_self ) { + /* check if the target is an attribute. */ + if ( val == NULL ) return 1; - if ( b->a_dn_expand ) { - struct berval bv; - char buf[ACL_BUF_SIZE]; - - int tmp_nmatch; - regmatch_t tmp_matches[2], - *tmp_matchesp = tmp_matches; + /* target is attribute, check if the attribute value + * is the op dn. + */ + rc = value_match( &match, bdn->a_at, + bdn->a_at->ad_type->sat_equality, 0, + val, &bv, &text ); + /* on match error or no match, fail the ACL clause */ + if ( rc != LDAP_SUCCESS || match != 0 ) + return 1; + } - int rc = 0; + } else { + /* no dnattr match, check if this is a self clause */ + if ( ! bdn->a_self ) + return 1; - bv.bv_len = sizeof( buf ) - 1; - bv.bv_val = buf; + ACL_RECORD_VALUE_STATE; - switch ( a->acl_dn_style ) { - case ACL_STYLE_REGEX: - if ( !BER_BVISNULL( &a->acl_dn_pat ) ) { - tmp_matchesp = matches; - tmp_nmatch = nmatch; - break; - } - /* FALLTHRU: applies also to ACL_STYLE_REGEX when pattern is "*" */ + /* this is a self clause, check if the target is an + * attribute. + */ + if ( val == NULL ) + return 1; - case ACL_STYLE_BASE: - tmp_matches[0].rm_so = 0; - tmp_matches[0].rm_eo = e->e_nname.bv_len; - tmp_nmatch = 1; - break; + /* target is attribute, check if the attribute value + * is the op dn. + */ + rc = value_match( &match, bdn->a_at, + bdn->a_at->ad_type->sat_equality, 0, + val, &bv, &text ); - case ACL_STYLE_ONE: - case ACL_STYLE_SUBTREE: - case ACL_STYLE_CHILDREN: - tmp_matches[0].rm_so = 0; - tmp_matches[0].rm_eo = e->e_nname.bv_len; - tmp_matches[1].rm_so = e->e_nname.bv_len - a->acl_dn_pat.bv_len; - tmp_matches[1].rm_eo = e->e_nname.bv_len; - tmp_nmatch = 2; - break; + /* on match error or no match, fail the ACL clause */ + if ( rc != LDAP_SUCCESS || match != 0 ) + return 1; + } - default: - /* error */ - rc = 1; - break; - } + return 0; +} - if ( rc ) { - continue; - } - if ( string_expand( &bv, &b->a_dn_pat, - e->e_nname.bv_val, - tmp_nmatch, tmp_matchesp ) ) - { - continue; - } - - if ( dnNormalize(0, NULL, NULL, &bv, - &pat, op->o_tmpmemctx ) - != LDAP_SUCCESS ) - { - /* did not expand to a valid dn */ - continue; - } +/* + * slap_acl_mask - modifies mask based upon the given acl and the + * requested access to entry e, attribute attr, value val. if val + * is null, access to the whole attribute is assumed (all values). + * + * returns 0 access NOT allowed + * 1 access allowed + */ - } else { - pat = b->a_dn_pat; - } +static slap_control_t +slap_acl_mask( + AccessControl *a, + slap_mask_t *mask, + Operation *op, + Entry *e, + AttributeDescription *desc, + struct berval *val, + int nmatch, + regmatch_t *matches, + int count, + AccessControlState *state ) +{ + int i; + Access *b; +#ifdef LDAP_DEBUG + char accessmaskbuf[ACCESSMASK_MAXLEN]; +#endif /* DEBUG */ + const char *attr; + slap_mask_t a2pmask = ACL_ACCESS2PRIV( *mask ); - patlen = pat.bv_len; - odnlen = op->o_ndn.bv_len; - if ( odnlen < patlen ) { - goto dn_match_cleanup; + assert( a != NULL ); + assert( mask != NULL ); + assert( desc != NULL ); - } + attr = desc->ad_cname.bv_val; - if ( b->a_dn_style == ACL_STYLE_BASE ) { - /* base dn -- entire object DN must match */ - if ( odnlen != patlen ) { - goto dn_match_cleanup; - } + assert( attr != NULL ); - } else if ( b->a_dn_style == ACL_STYLE_ONE ) { - int rdnlen = -1; + Debug( LDAP_DEBUG_ACL, + "=> acl_mask: access to entry \"%s\", attr \"%s\" requested\n", + e->e_dn, attr, 0 ); - if ( odnlen <= patlen ) { - goto dn_match_cleanup; - } + Debug( LDAP_DEBUG_ACL, + "=> acl_mask: to %s by \"%s\", (%s) \n", + val ? "value" : "all values", + op->o_ndn.bv_val ? op->o_ndn.bv_val : "", + accessmask2str( *mask, accessmaskbuf, 1 ) ); - if ( !DN_SEPARATOR( op->o_ndn.bv_val[odnlen - patlen - 1] ) ) { - goto dn_match_cleanup; - } - rdnlen = dn_rdnlen( NULL, &op->o_ndn ); - if ( rdnlen != odnlen - patlen - 1 ) { - goto dn_match_cleanup; - } + b = a->acl_access; + i = 1; - } else if ( b->a_dn_style == ACL_STYLE_SUBTREE ) { - if ( odnlen > patlen && !DN_SEPARATOR( op->o_ndn.bv_val[odnlen - patlen - 1] ) ) { - goto dn_match_cleanup; - } + for ( ; b != NULL; b = b->a_next, i++ ) { + slap_mask_t oldmask, modmask; - } else if ( b->a_dn_style == ACL_STYLE_CHILDREN ) { - if ( odnlen <= patlen ) { - goto dn_match_cleanup; - } + ACL_INVALIDATE( modmask ); - if ( !DN_SEPARATOR( op->o_ndn.bv_val[odnlen - patlen - 1] ) ) { - goto dn_match_cleanup; - } - } + /* AND clauses */ + if ( !BER_BVISEMPTY( &b->a_dn_pat ) ) { + Debug( LDAP_DEBUG_ACL, "<= check a_dn_pat: %s\n", + b->a_dn_pat.bv_val, 0, 0); + /* + * if access applies to the entry itself, and the + * user is bound as somebody in the same namespace as + * the entry, OR the given dn matches the dn pattern + */ + /* + * NOTE: styles "anonymous", "users" and "self" + * have been moved to enum slap_style_t, whose + * value is set in a_dn_style; however, the string + * is maintained in a_dn_pat. + */ - got_match = !strcmp( pat.bv_val, op->o_ndn.bv_val + odnlen - patlen ); + if ( acl_mask_dn( op, e, desc, val, a, nmatch, matches, + &b->a_dn, &op->o_ndn ) ) + { + continue; + } + } -dn_match_cleanup:; - if ( pat.bv_val != b->a_dn_pat.bv_val ) { - slap_sl_free( pat.bv_val, op->o_tmpmemctx ); - } + if ( !BER_BVISEMPTY( &b->a_realdn_pat ) ) { + struct berval ndn; - if ( !got_match ) { - continue; - } + Debug( LDAP_DEBUG_ACL, "<= check a_realdn_pat: %s\n", + b->a_realdn_pat.bv_val, 0, 0); + /* + * if access applies to the entry itself, and the + * user is bound as somebody in the same namespace as + * the entry, OR the given dn matches the dn pattern + */ + /* + * NOTE: styles "anonymous", "users" and "self" + * have been moved to enum slap_style_t, whose + * value is set in a_dn_style; however, the string + * is maintained in a_dn_pat. + */ + + if ( op->o_conn && !BER_BVISNULL( &op->o_conn->c_ndn ) ) + { + ndn = op->o_conn->c_ndn; + } else { + ndn = op->o_ndn; + } + + if ( acl_mask_dn( op, e, desc, val, a, nmatch, matches, + &b->a_realdn, &ndn ) ) + { + continue; } } @@ -934,7 +1163,7 @@ dn_match_cleanup:; bv.bv_len = sizeof( buf ) - 1; bv.bv_val = buf; - if ( string_expand( &bv, &b->a_sockurl_pat, + if ( acl_string_expand( &bv, &b->a_sockurl_pat, e->e_ndn, nmatch, matches ) ) { continue; @@ -979,7 +1208,7 @@ dn_match_cleanup:; bv.bv_len = sizeof(buf) - 1; bv.bv_val = buf; - if ( string_expand(&bv, &b->a_domain_pat, + if ( acl_string_expand(&bv, &b->a_domain_pat, e->e_ndn, nmatch, matches) ) { continue; @@ -1036,7 +1265,7 @@ dn_match_cleanup:; bv.bv_len = sizeof( buf ) - 1; bv.bv_val = buf; - if ( string_expand( &bv, &b->a_peername_pat, + if ( acl_string_expand( &bv, &b->a_peername_pat, e->e_ndn, nmatch, matches ) ) { continue; @@ -1055,20 +1284,18 @@ dn_match_cleanup:; int port_number = -1; if ( strncasecmp( op->o_conn->c_peer_name.bv_val, - aci_bv_ip_eq.bv_val, aci_bv_ip_eq.bv_len ) != 0 ) + acl_bv_ip_eq.bv_val, + acl_bv_ip_eq.bv_len ) != 0 ) continue; - ip.bv_val = op->o_conn->c_peer_name.bv_val + aci_bv_ip_eq.bv_len; - ip.bv_len = op->o_conn->c_peer_name.bv_len - aci_bv_ip_eq.bv_len; + ip.bv_val = op->o_conn->c_peer_name.bv_val + acl_bv_ip_eq.bv_len; + ip.bv_len = op->o_conn->c_peer_name.bv_len - acl_bv_ip_eq.bv_len; port = strrchr( ip.bv_val, ':' ); if ( port ) { - char *next; - ip.bv_len = port - ip.bv_val; ++port; - port_number = strtol( port, &next, 10 ); - if ( next[0] != '\0' ) + if ( lutil_atoi( &port_number, port ) != 0 ) continue; } @@ -1092,22 +1319,77 @@ dn_match_cleanup:; if ( (addr & b->a_peername_mask) != b->a_peername_addr ) continue; -#ifdef LDAP_PF_LOCAL - /* extract path and try exact match */ - } else if ( b->a_peername_style == ACL_STYLE_PATH ) { - struct berval path; +#ifdef LDAP_PF_INET6 + /* extract IPv6 and try exact match */ + } else if ( b->a_peername_style == ACL_STYLE_IPV6 ) { + char *port; + char buf[] = "FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF:FFFF"; + struct berval ip; + struct in6_addr addr; + int port_number = -1, i; - if ( strncmp( op->o_conn->c_peer_name.bv_val, - aci_bv_path_eq.bv_val, aci_bv_path_eq.bv_len ) != 0 ) + if ( strncasecmp( op->o_conn->c_peer_name.bv_val, + acl_bv_ipv6_eq.bv_val, + acl_bv_ipv6_eq.bv_len ) != 0 ) continue; - path.bv_val = op->o_conn->c_peer_name.bv_val + aci_bv_path_eq.bv_len; - path.bv_len = op->o_conn->c_peer_name.bv_len - aci_bv_path_eq.bv_len; + ip.bv_val = op->o_conn->c_peer_name.bv_val + acl_bv_ipv6_eq.bv_len; + ip.bv_len = op->o_conn->c_peer_name.bv_len - acl_bv_ipv6_eq.bv_len; - if ( ber_bvcmp( &b->a_peername_pat, &path ) != 0 ) + port = strrchr( ip.bv_val, ']' ); + if ( port ) { + ip.bv_len = port - ip.bv_val; + ++port; + if ( port[0] == ':' && lutil_atoi( &port_number, ++port ) != 0 ) + continue; + } + + /* the port check can be anticipated here */ + if ( b->a_peername_port != -1 && port_number != b->a_peername_port ) + continue; + + /* address longer than expected? */ + if ( ip.bv_len >= sizeof(buf) ) continue; -#endif /* LDAP_PF_LOCAL */ + AC_MEMCPY( buf, ip.bv_val, ip.bv_len ); + buf[ ip.bv_len ] = '\0'; + + if ( inet_pton( AF_INET6, buf, &addr ) != 1 ) + continue; + + /* check mask */ + for ( i = 0; i < 4; i++ ) { + if ( ( addr.s6_addr32[i] & b->a_peername_mask6.s6_addr32[i] ) + != b->a_peername_addr6.s6_addr32[i] ) + { + break; + } + } + + if ( i != 4 ) + continue; +#endif /* LDAP_PF_INET6 */ + +#ifdef LDAP_PF_LOCAL + /* extract path and try exact match */ + } else if ( b->a_peername_style == ACL_STYLE_PATH ) { + struct berval path; + + if ( strncmp( op->o_conn->c_peer_name.bv_val, + acl_bv_path_eq.bv_val, + acl_bv_path_eq.bv_len ) != 0 ) + continue; + + path.bv_val = op->o_conn->c_peer_name.bv_val + + acl_bv_path_eq.bv_len; + path.bv_len = op->o_conn->c_peer_name.bv_len + - acl_bv_path_eq.bv_len; + + if ( ber_bvcmp( &b->a_peername_pat, &path ) != 0 ) + continue; + +#endif /* LDAP_PF_LOCAL */ /* exact match (very unlikely...) */ } else if ( ber_bvcmp( &op->o_conn->c_peer_name, &b->a_peername_pat ) != 0 ) { @@ -1137,7 +1419,7 @@ dn_match_cleanup:; bv.bv_len = sizeof( buf ) - 1; bv.bv_val = buf; - if ( string_expand( &bv, &b->a_sockname_pat, + if ( acl_string_expand( &bv, &b->a_sockname_pat, e->e_ndn, nmatch, matches ) ) { continue; @@ -1156,80 +1438,29 @@ dn_match_cleanup:; } if ( b->a_dn_at != NULL ) { - Attribute *at; - struct berval bv; - int rc, match = 0; - const char *text; - const char *attr = b->a_dn_at->ad_cname.bv_val; - - assert( attr != NULL ); - - if ( op->o_ndn.bv_len == 0 ) { + if ( acl_mask_dnattr( op, e, val, a, b, i, + matches, count, state, + &b->a_dn, &op->o_ndn ) ) + { continue; } + } - Debug( LDAP_DEBUG_ACL, "<= check a_dn_at: %s\n", - attr, 0, 0); - bv = op->o_ndn; + if ( b->a_realdn_at != NULL ) { + struct berval ndn; - /* see if asker is listed in dnattr */ - for( at = attrs_find( e->e_attrs, b->a_dn_at ); - at != NULL; - at = attrs_find( at->a_next, b->a_dn_at ) ) + if ( op->o_conn && !BER_BVISNULL( &op->o_conn->c_ndn ) ) { - if( value_find_ex( b->a_dn_at, - SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH | - SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH, - at->a_nvals, - &bv, op->o_tmpmemctx ) == 0 ) - { - /* found it */ - match = 1; - break; - } - } - - if( match ) { - /* have a dnattr match. if this is a self clause then - * the target must also match the op dn. - */ - if ( b->a_dn_self ) { - /* check if the target is an attribute. */ - if ( val == NULL ) continue; - - /* target is attribute, check if the attribute value - * is the op dn. - */ - rc = value_match( &match, b->a_dn_at, - b->a_dn_at->ad_type->sat_equality, 0, - val, &bv, &text ); - /* on match error or no match, fail the ACL clause */ - if (rc != LDAP_SUCCESS || match != 0 ) - continue; - } + ndn = op->o_conn->c_ndn; } else { - /* no dnattr match, check if this is a self clause */ - if ( ! b->a_dn_self ) - continue; - - ACL_RECORD_VALUE_STATE; - - /* this is a self clause, check if the target is an - * attribute. - */ - if ( val == NULL ) - continue; - - /* target is attribute, check if the attribute value - * is the op dn. - */ - rc = value_match( &match, b->a_dn_at, - b->a_dn_at->ad_type->sat_equality, 0, - val, &bv, &text ); + ndn = op->o_ndn; + } - /* on match error or no match, fail the ACL clause */ - if (rc != LDAP_SUCCESS || match != 0 ) - continue; + if ( acl_mask_dnattr( op, e, val, a, b, i, + matches, count, state, + &b->a_realdn, &ndn ) ) + { + continue; } } @@ -1242,6 +1473,9 @@ dn_match_cleanup:; continue; } + Debug( LDAP_DEBUG_ACL, "<= check a_group_pat: %s\n", + b->a_group_pat.bv_val, 0, 0 ); + /* b->a_group is an unexpanded entry name, expanded it should be an * entry with objectclass group* and we test to see if odn is one of * the values in the attribute group @@ -1293,7 +1527,7 @@ dn_match_cleanup:; continue; } - if ( string_expand( &bv, &b->a_group_pat, + if ( acl_string_expand( &bv, &b->a_group_pat, e->e_nname.bv_val, tmp_nmatch, tmp_matchesp ) ) { @@ -1329,6 +1563,9 @@ dn_match_cleanup:; struct berval bv; char buf[ACL_BUF_SIZE]; + Debug( LDAP_DEBUG_ACL, "<= check a_set_pat: %s\n", + b->a_set_pat.bv_val, 0, 0 ); + if ( b->a_set_style == ACL_STYLE_EXPAND ) { int tmp_nmatch; regmatch_t tmp_matches[2], @@ -1375,7 +1612,7 @@ dn_match_cleanup:; continue; } - if ( string_expand( &bv, &b->a_set_pat, + if ( acl_string_expand( &bv, &b->a_set_pat, e->e_nname.bv_val, tmp_nmatch, tmp_matchesp ) ) { @@ -1386,7 +1623,7 @@ dn_match_cleanup:; bv = b->a_set_pat; } - if ( aci_match_set( &bv, op, e, 0 ) == 0 ) { + if ( acl_match_set( &bv, op, e, NULL ) == 0 ) { continue; } } @@ -1426,195 +1663,76 @@ dn_match_cleanup:; } } -#ifdef SLAP_DYNACL - if ( b->a_dynacl ) { - slap_dynacl_t *da; - slap_access_t tgrant, tdeny; - - /* this case works different from the others above. - * since aci's themselves give permissions, we need - * to first check b->a_access_mask, the ACL's access level. - */ - if ( BER_BVISEMPTY( &e->e_nname ) ) { - /* no ACIs in the root DSE */ - continue; - } - - /* first check if the right being requested - * is allowed by the ACL clause. - */ - if ( ! ACL_GRANT( b->a_access_mask, *mask ) ) { - continue; - } - - /* start out with nothing granted, nothing denied */ - ACL_INIT(tgrant); - ACL_INIT(tdeny); - - for ( da = b->a_dynacl; da; da = da->da_next ) { - slap_access_t grant, deny; + /* check for the "self" modifier in the field */ + if ( b->a_dn.a_self ) { + const char *dummy; + int rc, match = 0; - (void)( *da->da_mask )( da->da_private, op, e, desc, val, nmatch, matches, &grant, &deny ); + ACL_RECORD_VALUE_STATE; - tgrant |= grant; - tdeny |= deny; - } + /* must have DN syntax */ + if ( desc->ad_type->sat_syntax != slap_schema.si_syn_distinguishedName && + !is_at_syntax( desc->ad_type, SLAPD_NAMEUID_SYNTAX )) continue; - /* remove anything that the ACL clause does not allow */ - tgrant &= b->a_access_mask & ACL_PRIV_MASK; - tdeny &= ACL_PRIV_MASK; + /* check if the target is an attribute. */ + if ( val == NULL ) continue; - /* see if we have anything to contribute */ - if( ACL_IS_INVALID(tgrant) && ACL_IS_INVALID(tdeny) ) { + /* a DN must be present */ + if ( BER_BVISEMPTY( &op->o_ndn ) ) { continue; } - /* this could be improved by changing acl_mask so that it can deal with - * by clauses that return grant/deny pairs. Right now, it does either - * additive or subtractive rights, but not both at the same time. So, - * we need to combine the grant/deny pair into a single rights mask in - * a smart way: if either grant or deny is "empty", then we use the - * opposite as is, otherwise we remove any denied rights from the grant - * rights mask and construct an additive mask. + /* target is attribute, check if the attribute value + * is the op dn. */ - if (ACL_IS_INVALID(tdeny)) { - modmask = tgrant | ACL_PRIV_ADDITIVE; - - } else if (ACL_IS_INVALID(tgrant)) { - modmask = tdeny | ACL_PRIV_SUBSTRACTIVE; - - } else { - modmask = (tgrant & ~tdeny) | ACL_PRIV_ADDITIVE; - } + rc = value_match( &match, desc, + desc->ad_type->sat_equality, 0, + val, &op->o_ndn, &dummy ); + /* on match error or no match, fail the ACL clause */ + if ( rc != LDAP_SUCCESS || match != 0 ) + continue; + } - } else -#else /* !SLAP_DYNACL */ +#ifdef SLAP_DYNACL + if ( b->a_dynacl ) { + slap_dynacl_t *da; + slap_access_t tgrant, tdeny; -#ifdef SLAPD_ACI_ENABLED - if ( b->a_aci_at != NULL ) { - Attribute *at; - slap_access_t grant, deny, tgrant, tdeny; - struct berval parent_ndn, - old_parent_ndn = BER_BVNULL; - BerVarray bvals = NULL; - int ret, stop; + Debug( LDAP_DEBUG_ACL, "<= check a_dynacl\n", + 0, 0, 0 ); /* this case works different from the others above. - * since aci's themselves give permissions, we need + * since dynamic ACL's themselves give permissions, we need * to first check b->a_access_mask, the ACL's access level. */ - - if ( BER_BVISEMPTY( &e->e_nname ) ) { - /* no ACIs in the root DSE */ - continue; - } - /* first check if the right being requested * is allowed by the ACL clause. */ - if ( ! ACL_GRANT( b->a_access_mask, *mask ) ) { + if ( ! ACL_PRIV_ISSET( b->a_access_mask, a2pmask ) ) { continue; } + /* start out with nothing granted, nothing denied */ - ACL_INIT(tgrant); - ACL_INIT(tdeny); - - /* get the aci attribute */ - at = attr_find( e->e_attrs, b->a_aci_at ); - if ( at != NULL ) { -#if 0 - /* FIXME: this breaks acl caching; - * see also ACL_RECORD_VALUE_STATE below */ - ACL_RECORD_VALUE_STATE; -#endif - /* the aci is an multi-valued attribute. The - * rights are determined by OR'ing the individual - * rights given by the acis. - */ - for ( i = 0; !BER_BVISNULL( &at->a_nvals[i] ); i++ ) { - if (aci_mask( op, - e, desc, val, - &at->a_nvals[i], - nmatch, matches, - &grant, &deny, SLAP_ACI_SCOPE_ENTRY ) != 0) - { - tgrant |= grant; - tdeny |= deny; - } - } - Debug(LDAP_DEBUG_ACL, "<= aci_mask grant %s deny %s\n", - accessmask2str(tgrant,accessmaskbuf, 1), - accessmask2str(tdeny, accessmaskbuf1, 1), 0); + ACL_INVALIDATE(tgrant); + ACL_INVALIDATE(tdeny); - } - /* If the entry level aci didn't contain anything valid for the - * current operation, climb up the tree and evaluate the - * acis with scope set to subtree - */ - if ( (tgrant == ACL_PRIV_NONE) && (tdeny == ACL_PRIV_NONE) ) { - dnParent(&(e->e_nname), &parent_ndn); - while ( parent_ndn.bv_val != old_parent_ndn.bv_val ) { - old_parent_ndn = parent_ndn; - Debug(LDAP_DEBUG_ACL, "checking ACI of %s\n", parent_ndn.bv_val, 0, 0); - ret = backend_attribute(op, NULL, &parent_ndn, b->a_aci_at, &bvals, ACL_AUTH); - switch(ret){ - case LDAP_SUCCESS : - stop = 0; - if (!bvals){ - break; - } + for ( da = b->a_dynacl; da; da = da->da_next ) { + slap_access_t grant, + deny; - for( i = 0; bvals[i].bv_val != NULL; i++){ -#if 0 - /* FIXME: this breaks acl caching; - * see also ACL_RECORD_VALUE_STATE above */ - ACL_RECORD_VALUE_STATE; -#endif - if (aci_mask(op, e, desc, val, &bvals[i], - nmatch, matches, - &grant, &deny, SLAP_ACI_SCOPE_CHILDREN ) != 0 ) - { - tgrant |= grant; - tdeny |= deny; - /* evaluation stops as soon as either a "deny" or a - * "grant" directive matches. - */ - if( (tgrant != ACL_PRIV_NONE) || (tdeny != ACL_PRIV_NONE) ){ - stop = 1; - } - } - Debug(LDAP_DEBUG_ACL, "<= aci_mask grant %s deny %s\n", - accessmask2str(tgrant,accessmaskbuf, 1), - accessmask2str(tdeny, accessmaskbuf1, 1), 0); - } - break; + ACL_INVALIDATE(grant); + ACL_INVALIDATE(deny); - case LDAP_NO_SUCH_ATTRIBUTE: - /* just go on if the aci-Attribute is not present in - * the current entry - */ - Debug(LDAP_DEBUG_ACL, "no such attribute\n", 0, 0, 0); - stop = 0; - break; + Debug( LDAP_DEBUG_ACL, " <= check a_dynacl: %s\n", + da->da_name, 0, 0 ); - case LDAP_NO_SUCH_OBJECT: - /* We have reached the base object */ - Debug(LDAP_DEBUG_ACL, "no such object\n", 0, 0, 0); - stop = 1; - break; + (void)da->da_mask( da->da_private, op, e, desc, + val, nmatch, matches, &grant, &deny ); - default: - stop = 1; - break; - } - if (stop){ - break; - } - dnParent(&old_parent_ndn, &parent_ndn); - } + tgrant |= grant; + tdeny |= deny; } - /* remove anything that the ACL clause does not allow */ tgrant &= b->a_access_mask & ACL_PRIV_MASK; tdeny &= ACL_PRIV_MASK; @@ -1624,7 +1742,7 @@ dn_match_cleanup:; continue; } - /* this could be improved by changing acl_mask so that it can deal with + /* this could be improved by changing slap_acl_mask so that it can deal with * by clauses that return grant/deny pairs. Right now, it does either * additive or subtractive rights, but not both at the same time. So, * we need to combine the grant/deny pair into a single rights mask in @@ -1643,8 +1761,7 @@ dn_match_cleanup:; } } else -#endif /* SLAPD_ACI_ENABLED */ -#endif /* !SLAP_DYNACL */ +#endif /* SLAP_DYNACL */ { modmask = b->a_access_mask; } @@ -1679,6 +1796,8 @@ dn_match_cleanup:; *mask = modmask; } + a2pmask = *mask; + Debug( LDAP_DEBUG_ACL, "<= acl_mask: [%d] mask: %s\n", i, accessmask2str(*mask, accessmaskbuf, 1), 0 ); @@ -1714,8 +1833,7 @@ int acl_check_modlist( Operation *op, Entry *e, - Modifications *mlist -) + Modifications *mlist ) { struct berval *bv; AccessControlState state = ACL_STATE_INIT; @@ -1752,12 +1870,24 @@ acl_check_modlist( } for ( ; mlist != NULL; mlist = mlist->sml_next ) { + /* + * Internal mods are ignored by ACL_WRITE checking + */ + if ( mlist->sml_flags & SLAP_MOD_INTERNAL ) { + Debug( LDAP_DEBUG_ACL, "acl: internal mod %s:" + " modify access granted\n", + mlist->sml_desc->ad_cname.bv_val, 0, 0 ); + continue; + } + /* * no-user-modification operational attributes are ignored * by ACL_WRITE checking as any found here are not provided * by the user */ - if ( is_at_no_user_mod( mlist->sml_desc->ad_type ) ) { + if ( is_at_no_user_mod( mlist->sml_desc->ad_type ) + && ! ( mlist->sml_flags & SLAP_MOD_MANAGING ) ) + { Debug( LDAP_DEBUG_ACL, "acl: no-user-mod %s:" " modify access granted\n", mlist->sml_desc->ad_cname.bv_val, 0, 0 ); @@ -1766,13 +1896,16 @@ acl_check_modlist( switch ( mlist->sml_op ) { case LDAP_MOD_REPLACE: + case LDAP_MOD_INCREMENT: /* * We must check both permission to delete the whole * attribute and permission to add the specific attributes. * This prevents abuse from selfwriters. */ if ( ! access_allowed( op, e, - mlist->sml_desc, NULL, ACL_WRITE, &state ) ) + mlist->sml_desc, NULL, + ( mlist->sml_flags & SLAP_MOD_MANAGING ) ? ACL_MANAGE : ACL_WDEL, + &state ) ) { ret = 0; goto done; @@ -1790,7 +1923,9 @@ acl_check_modlist( bv->bv_val != NULL; bv++ ) { if ( ! access_allowed( op, e, - mlist->sml_desc, bv, ACL_WRITE, &state ) ) + mlist->sml_desc, bv, + ( mlist->sml_flags & SLAP_MOD_MANAGING ) ? ACL_MANAGE : ACL_WADD, + &state ) ) { ret = 0; goto done; @@ -1801,7 +1936,9 @@ acl_check_modlist( case LDAP_MOD_DELETE: if ( mlist->sml_values == NULL ) { if ( ! access_allowed( op, e, - mlist->sml_desc, NULL, ACL_WRITE, NULL ) ) + mlist->sml_desc, NULL, + ( mlist->sml_flags & SLAP_MOD_MANAGING ) ? ACL_MANAGE : ACL_WDEL, + NULL ) ) { ret = 0; goto done; @@ -1813,7 +1950,9 @@ acl_check_modlist( bv->bv_val != NULL; bv++ ) { if ( ! access_allowed( op, e, - mlist->sml_desc, bv, ACL_WRITE, &state ) ) + mlist->sml_desc, bv, + ( mlist->sml_flags & SLAP_MOD_MANAGING ) ? ACL_MANAGE : ACL_WDEL, + &state ) ) { ret = 0; goto done; @@ -1838,8 +1977,8 @@ done: return( ret ); } -static int -aci_get_part( +int +acl_get_part( struct berval *list, int ix, char sep, @@ -1881,15 +2020,15 @@ aci_get_part( return bv->bv_len; } -typedef struct aci_set_gather_t { +typedef struct acl_set_gather_t { SetCookie *cookie; BerVarray bvals; -} aci_set_gather_t; +} acl_set_gather_t; static int -aci_set_cb_gather( Operation *op, SlapReply *rs ) +acl_set_cb_gather( Operation *op, SlapReply *rs ) { - aci_set_gather_t *p = (aci_set_gather_t *)op->o_callback->sc_private; + acl_set_gather_t *p = (acl_set_gather_t *)op->o_callback->sc_private; if ( rs->sr_type == REP_SEARCH ) { BerValue bvals[ 2 ]; @@ -1932,17 +2071,17 @@ aci_set_cb_gather( Operation *op, SlapReply *rs ) } BerVarray -aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *desc ) +acl_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *desc ) { - AciSetCookie *cp = (AciSetCookie *)cookie; + AclSetCookie *cp = (AclSetCookie *)cookie; int rc = 0; LDAPURLDesc *ludp = NULL; Operation op2 = { 0 }; SlapReply rs = {REP_RESULT}; AttributeName anlist[ 2 ], *anlistp = NULL; int nattrs = 0; - slap_callback cb = { NULL, aci_set_cb_gather, NULL, NULL }; - aci_set_gather_t p = { 0 }; + slap_callback cb = { NULL, acl_set_cb_gather, NULL, NULL }; + acl_set_gather_t p = { 0 }; const char *text = NULL; static struct berval defaultFilter_bv = BER_BVC( "(objectClass=*)" ); @@ -1951,7 +2090,7 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de * also return the syntax or some "comparison cookie". */ if ( strncasecmp( name->bv_val, "ldap:///", STRLENOF( "ldap:///" ) ) != 0 ) { - return aci_set_gather2( cookie, name, desc ); + return acl_set_gather2( cookie, name, desc ); } rc = ldap_url_parse( name->bv_val, &ludp ); @@ -1971,7 +2110,7 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de /* Grab the searchbase and see if an appropriate database can be found */ ber_str2bv( ludp->lud_dn, 0, 0, &op2.o_req_dn ); rc = dnNormalize( 0, NULL, NULL, &op2.o_req_dn, - &op2.o_req_ndn, cp->op->o_tmpmemctx ); + &op2.o_req_ndn, cp->asc_op->o_tmpmemctx ); BER_BVZERO( &op2.o_req_dn ); if ( rc != LDAP_SUCCESS ) { goto url_done; @@ -1986,13 +2125,13 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de /* Grab the filter */ if ( ludp->lud_filter ) { ber_str2bv_x( ludp->lud_filter, 0, 0, &op2.ors_filterstr, - cp->op->o_tmpmemctx ); + cp->asc_op->o_tmpmemctx ); } else { op2.ors_filterstr = defaultFilter_bv; } - op2.ors_filter = str2filter_x( cp->op, op2.ors_filterstr.bv_val ); + op2.ors_filter = str2filter_x( cp->asc_op, op2.ors_filterstr.bv_val ); if ( op2.ors_filter == NULL ) { rc = LDAP_PROTOCOL_ERROR; goto url_done; @@ -2007,7 +2146,7 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de ; anlistp = slap_sl_malloc( sizeof( AttributeName ) * ( nattrs + 2 ), - cp->op->o_tmpmemctx ); + cp->asc_op->o_tmpmemctx ); for ( ; ludp->lud_attrs[ nattrs ]; nattrs++ ) { ber_str2bv( ludp->lud_attrs[ nattrs ], 0, 0, &anlistp[ nattrs ].an_name ); @@ -2030,19 +2169,19 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de p.cookie = cookie; - op2.o_hdr = cp->op->o_hdr; + op2.o_hdr = cp->asc_op->o_hdr; op2.o_tag = LDAP_REQ_SEARCH; op2.o_ndn = op2.o_bd->be_rootndn; op2.o_callback = &cb; - op2.o_time = slap_get_time(); + slap_op_time( &op2.o_time, &op2.o_tincr ); op2.o_do_not_cache = 1; op2.o_is_auth_check = 0; - ber_dupbv_x( &op2.o_req_dn, &op2.o_req_ndn, cp->op->o_tmpmemctx ); + ber_dupbv_x( &op2.o_req_dn, &op2.o_req_ndn, cp->asc_op->o_tmpmemctx ); op2.ors_slimit = SLAP_NO_LIMIT; op2.ors_tlimit = SLAP_NO_LIMIT; op2.ors_attrs = anlistp; op2.ors_attrsonly = 0; - op2.o_private = cp->op->o_private; + op2.o_private = cp->asc_op->o_private; cb.sc_private = &p; @@ -2053,28 +2192,28 @@ aci_set_gather( SetCookie *cookie, struct berval *name, AttributeDescription *de url_done:; if ( op2.ors_filter ) { - filter_free_x( cp->op, op2.ors_filter ); + filter_free_x( cp->asc_op, op2.ors_filter ); } if ( !BER_BVISNULL( &op2.o_req_ndn ) ) { - slap_sl_free( op2.o_req_ndn.bv_val, cp->op->o_tmpmemctx ); + slap_sl_free( op2.o_req_ndn.bv_val, cp->asc_op->o_tmpmemctx ); } if ( !BER_BVISNULL( &op2.o_req_dn ) ) { - slap_sl_free( op2.o_req_dn.bv_val, cp->op->o_tmpmemctx ); + slap_sl_free( op2.o_req_dn.bv_val, cp->asc_op->o_tmpmemctx ); } if ( ludp ) { ldap_free_urldesc( ludp ); } if ( anlistp && anlistp != anlist ) { - slap_sl_free( anlistp, cp->op->o_tmpmemctx ); + slap_sl_free( anlistp, cp->asc_op->o_tmpmemctx ); } return p.bvals; } BerVarray -aci_set_gather2( SetCookie *cookie, struct berval *name, AttributeDescription *desc ) +acl_set_gather2( SetCookie *cookie, struct berval *name, AttributeDescription *desc ) { - AciSetCookie *cp = (AciSetCookie *)cookie; + AclSetCookie *cp = (AclSetCookie *)cookie; BerVarray bvals = NULL; struct berval ndn; int rc = 0; @@ -2083,57 +2222,56 @@ aci_set_gather2( SetCookie *cookie, struct berval *name, AttributeDescription *d * plain strings, since syntax is not known. It should * also return the syntax or some "comparison cookie". */ - rc = dnNormalize( 0, NULL, NULL, name, &ndn, cp->op->o_tmpmemctx ); + rc = dnNormalize( 0, NULL, NULL, name, &ndn, cp->asc_op->o_tmpmemctx ); if ( rc == LDAP_SUCCESS ) { if ( desc == slap_schema.si_ad_entryDN ) { bvals = (BerVarray)slap_sl_malloc( sizeof( BerValue ) * 2, - cp->op->o_tmpmemctx ); + cp->asc_op->o_tmpmemctx ); bvals[ 0 ] = ndn; BER_BVZERO( &bvals[ 1 ] ); BER_BVZERO( &ndn ); } else { - backend_attribute( cp->op, - cp->e, &ndn, desc, &bvals, ACL_NONE ); + backend_attribute( cp->asc_op, + cp->asc_e, &ndn, desc, &bvals, ACL_NONE ); } if ( !BER_BVISNULL( &ndn ) ) { - slap_sl_free( ndn.bv_val, cp->op->o_tmpmemctx ); + slap_sl_free( ndn.bv_val, cp->asc_op->o_tmpmemctx ); } } return bvals; } -static int -aci_match_set ( +int +acl_match_set ( struct berval *subj, Operation *op, Entry *e, - int setref -) + struct berval *default_set_attribute ) { struct berval set = BER_BVNULL; int rc = 0; - AciSetCookie cookie; + AclSetCookie cookie; - if ( setref == 0 ) { + if ( default_set_attribute == NULL ) { ber_dupbv_x( &set, subj, op->o_tmpmemctx ); } else { struct berval subjdn, ndn = BER_BVNULL; struct berval setat; - BerVarray bvals; + BerVarray bvals = NULL; const char *text; AttributeDescription *desc = NULL; /* format of string is "entry/setAttrName" */ - if ( aci_get_part( subj, 0, '/', &subjdn ) < 0 ) { + if ( acl_get_part( subj, 0, '/', &subjdn ) < 0 ) { return 0; } - if ( aci_get_part( subj, 1, '/', &setat ) < 0 ) { - setat = aci_bv_set_attr; + if ( acl_get_part( subj, 1, '/', &setat ) < 0 ) { + setat = *default_set_attribute; } /* @@ -2161,9 +2299,11 @@ aci_match_set ( } if ( !BER_BVISNULL( &set ) ) { - cookie.op = op; - cookie.e = e; - rc = ( slap_set_filter( aci_set_gather, (SetCookie *)&cookie, &set, + cookie.asc_op = op; + cookie.asc_e = e; + rc = ( slap_set_filter( + acl_set_gather, + (SetCookie *)&cookie, &set, &op->o_ndn, &e->e_nname, NULL ) > 0 ); slap_sl_free( set.bv_val, op->o_tmpmemctx ); } @@ -2171,695 +2311,6 @@ aci_match_set ( return(rc); } -#ifdef SLAPD_ACI_ENABLED -static int -aci_list_map_rights( - struct berval *list ) -{ - struct berval bv; - slap_access_t mask; - int i; - - ACL_INIT(mask); - for (i = 0; aci_get_part(list, i, ',', &bv) >= 0; i++) { - if (bv.bv_len <= 0) - continue; - switch (*bv.bv_val) { - case 'c': - ACL_PRIV_SET(mask, ACL_PRIV_COMPARE); - break; - case 's': - /* **** NOTE: draft-ietf-ldapext-aci-model-0.3.txt defines - * the right 's' to mean "set", but in the examples states - * that the right 's' means "search". The latter definition - * is used here. - */ - ACL_PRIV_SET(mask, ACL_PRIV_SEARCH); - break; - case 'r': - ACL_PRIV_SET(mask, ACL_PRIV_READ); - break; - case 'w': - ACL_PRIV_SET(mask, ACL_PRIV_WRITE); - break; - case 'x': - /* **** NOTE: draft-ietf-ldapext-aci-model-0.3.txt does not - * define any equivalent to the AUTH right, so I've just used - * 'x' for now. - */ - ACL_PRIV_SET(mask, ACL_PRIV_AUTH); - break; - default: - break; - } - - } - return(mask); -} - -static int -aci_list_has_attr( - struct berval *list, - const struct berval *attr, - struct berval *val ) -{ - struct berval bv, left, right; - int i; - - for (i = 0; aci_get_part(list, i, ',', &bv) >= 0; i++) { - if (aci_get_part(&bv, 0, '=', &left) < 0 - || aci_get_part(&bv, 1, '=', &right) < 0) - { - if (ber_bvstrcasecmp(attr, &bv) == 0) - return(1); - } else if (val == NULL) { - if (ber_bvstrcasecmp(attr, &left) == 0) - return(1); - } else { - if (ber_bvstrcasecmp(attr, &left) == 0) { - /* this is experimental code that implements a - * simple (prefix) match of the attribute value. - * the ACI draft does not provide for aci's that - * apply to specific values, but it would be - * nice to have. If the part of an aci's - * rights list is of the form =, - * that means the aci applies only to attrs with - * the given value. Furthermore, if the attr is - * of the form =*, then is - * treated as a prefix, and the aci applies to - * any value with that prefix. - * - * Ideally, this would allow r.e. matches. - */ - if (aci_get_part(&right, 0, '*', &left) < 0 - || right.bv_len <= left.bv_len) - { - if (ber_bvstrcasecmp(val, &right) == 0) - return(1); - } else if (val->bv_len >= left.bv_len) { - if (strncasecmp( val->bv_val, left.bv_val, left.bv_len ) == 0) - return(1); - } - } - } - } - return(0); -} - -static slap_access_t -aci_list_get_attr_rights( - struct berval *list, - const struct berval *attr, - struct berval *val ) -{ - struct berval bv; - slap_access_t mask; - int i; - - /* loop through each rights/attr pair, skip first part (action) */ - ACL_INIT(mask); - for (i = 1; aci_get_part(list, i + 1, ';', &bv) >= 0; i += 2) { - if (aci_list_has_attr(&bv, attr, val) == 0) - continue; - if (aci_get_part(list, i, ';', &bv) < 0) - continue; - mask |= aci_list_map_rights(&bv); - } - return(mask); -} - -static int -aci_list_get_rights( - struct berval *list, - const struct berval *attr, - struct berval *val, - slap_access_t *grant, - slap_access_t *deny ) -{ - struct berval perm, actn; - slap_access_t *mask; - int i, found; - - if (attr == NULL || attr->bv_len == 0 - || ber_bvstrcasecmp( attr, &aci_bv_entry ) == 0) { - attr = &aci_bv_br_entry; - } - - found = 0; - ACL_INIT(*grant); - ACL_INIT(*deny); - /* loop through each permissions clause */ - for (i = 0; aci_get_part(list, i, '$', &perm) >= 0; i++) { - if (aci_get_part(&perm, 0, ';', &actn) < 0) - continue; - if (ber_bvstrcasecmp( &aci_bv_grant, &actn ) == 0) { - mask = grant; - } else if (ber_bvstrcasecmp( &aci_bv_deny, &actn ) == 0) { - mask = deny; - } else { - continue; - } - - found = 1; - *mask |= aci_list_get_attr_rights(&perm, attr, val); - *mask |= aci_list_get_attr_rights(&perm, &aci_bv_br_all, NULL); - } - return(found); -} - -static int -aci_group_member ( - struct berval *subj, - struct berval *defgrpoc, - struct berval *defgrpat, - Operation *op, - Entry *e, - int nmatch, - regmatch_t *matches -) -{ - struct berval subjdn; - struct berval grpoc; - struct berval grpat; - ObjectClass *grp_oc = NULL; - AttributeDescription *grp_ad = NULL; - const char *text; - int rc; - - /* format of string is "group/objectClassValue/groupAttrName" */ - if (aci_get_part(subj, 0, '/', &subjdn) < 0) { - return(0); - } - - if (aci_get_part(subj, 1, '/', &grpoc) < 0) { - grpoc = *defgrpoc; - } - - if (aci_get_part(subj, 2, '/', &grpat) < 0) { - grpat = *defgrpat; - } - - rc = slap_bv2ad( &grpat, &grp_ad, &text ); - if( rc != LDAP_SUCCESS ) { - rc = 0; - goto done; - } - rc = 0; - - grp_oc = oc_bvfind( &grpoc ); - - if (grp_oc != NULL && grp_ad != NULL ) { - char buf[ACL_BUF_SIZE]; - struct berval bv, ndn; - bv.bv_len = sizeof( buf ) - 1; - bv.bv_val = (char *)&buf; - if ( string_expand(&bv, &subjdn, - e->e_ndn, nmatch, matches) ) - { - rc = LDAP_OTHER; - goto done; - } - if ( dnNormalize( 0, NULL, NULL, &bv, &ndn, op->o_tmpmemctx ) == LDAP_SUCCESS ) { - rc = ( backend_group( op, e, &ndn, &op->o_ndn, - grp_oc, grp_ad ) == 0 ); - slap_sl_free( ndn.bv_val, op->o_tmpmemctx ); - } - } - -done: - return(rc); -} - -static int -aci_mask( - Operation *op, - Entry *e, - AttributeDescription *desc, - struct berval *val, - struct berval *aci, - int nmatch, - regmatch_t *matches, - slap_access_t *grant, - slap_access_t *deny, - slap_aci_scope_t asserted_scope -) -{ - struct berval bv, scope, perms, type, sdn; - int rc; - - - assert( !BER_BVISNULL( &desc->ad_cname ) ); - - /* parse an aci of the form: - oid # scope # action;rights;attr;rights;attr - $ action;rights;attr;rights;attr # type # subject - - [NOTE: the following comment is very outdated, - as the draft version it refers to (Ando, 2004-11-20)]. - - See draft-ietf-ldapext-aci-model-04.txt section 9.1 for - a full description of the format for this attribute. - Differences: "this" in the draft is "self" here, and - "self" and "public" is in the position of type. - - = {entry|children|subtree} - = {public|users|access-id|subtree|onelevel|children| - self|dnattr|group|role|set|set-ref} - - This routine now supports scope={ENTRY,CHILDREN} - with the semantics: - - ENTRY applies to "entry" and "subtree"; - - CHILDREN aplies to "children" and "subtree" - */ - - /* check that the aci has all 5 components */ - if ( aci_get_part( aci, 4, '#', NULL ) < 0 ) { - return 0; - } - - /* check that the aci family is supported */ - if ( aci_get_part( aci, 0, '#', &bv ) < 0 ) { - return 0; - } - - /* check that the scope matches */ - if ( aci_get_part( aci, 1, '#', &scope ) < 0 ) { - return 0; - } - - /* note: scope can be either ENTRY or CHILDREN; - * they respectively match "entry" and "children" in bv - * both match "subtree" */ - switch ( asserted_scope ) { - case SLAP_ACI_SCOPE_ENTRY: - if ( ber_bvstrcasecmp( &scope, &aci_bv_entry ) != 0 - && ber_bvstrcasecmp( &scope, &aci_bv_subtree ) != 0 ) - { - return 0; - } - break; - - case SLAP_ACI_SCOPE_CHILDREN: - if ( ber_bvstrcasecmp( &scope, &aci_bv_children ) != 0 - && ber_bvstrcasecmp( &scope, &aci_bv_subtree ) != 0 ) - { - return 0; - } - break; - - default: - return 0; - } - - /* get the list of permissions clauses, bail if empty */ - if ( aci_get_part( aci, 2, '#', &perms ) <= 0 ) { - return 0; - } - - /* check if any permissions allow desired access */ - if ( aci_list_get_rights( &perms, &desc->ad_cname, val, grant, deny ) == 0 ) { - return 0; - } - - /* see if we have a DN match */ - if ( aci_get_part( aci, 3, '#', &type ) < 0 ) { - return 0; - } - - /* see if we have a public (i.e. anonymous) access */ - if ( ber_bvstrcasecmp( &aci_bv_public, &type ) == 0 ) { - return 1; - } - - /* otherwise require an identity */ - if ( BER_BVISNULL( &op->o_ndn ) || BER_BVISEMPTY( &op->o_ndn ) ) { - return 0; - } - - /* see if we have a users access */ - if ( ber_bvstrcasecmp( &aci_bv_users, &type ) == 0 ) { - return 1; - } - - /* NOTE: this may fail if a DN contains a valid '#' (unescaped); - * just grab all the berval up to its end (ITS#3303). - * NOTE: the problem could be solved by providing the DN with - * the embedded '#' encoded as hexpairs: "cn=Foo#Bar" would - * become "cn=Foo\23Bar" and be safely used by aci_mask(). */ -#if 0 - if ( aci_get_part( aci, 4, '#', &sdn ) < 0 ) { - return 0; - } -#endif - sdn.bv_val = type.bv_val + type.bv_len + STRLENOF( "#" ); - sdn.bv_len = aci->bv_len - ( sdn.bv_val - aci->bv_val ); - - if ( ber_bvstrcasecmp( &aci_bv_access_id, &type ) == 0 ) { - struct berval ndn; - - rc = dnNormalize( 0, NULL, NULL, &sdn, &ndn, op->o_tmpmemctx ); - if ( rc != LDAP_SUCCESS ) { - return 0; - } - - if ( dn_match( &op->o_ndn, &ndn ) ) { - rc = 1; - } - slap_sl_free( ndn.bv_val, op->o_tmpmemctx ); - - return rc; - - } else if ( ber_bvstrcasecmp( &aci_bv_subtree, &type ) == 0 ) { - struct berval ndn; - - rc = dnNormalize( 0, NULL, NULL, &sdn, &ndn, op->o_tmpmemctx ); - if ( rc != LDAP_SUCCESS ) { - return 0; - } - - if ( dnIsSuffix( &op->o_ndn, &ndn ) ) { - rc = 1; - } - slap_sl_free( ndn.bv_val, op->o_tmpmemctx ); - - return rc; - - } else if ( ber_bvstrcasecmp( &aci_bv_onelevel, &type ) == 0 ) { - struct berval ndn, pndn; - - rc = dnNormalize( 0, NULL, NULL, &sdn, &ndn, op->o_tmpmemctx ); - if ( rc != LDAP_SUCCESS ) { - return 0; - } - - dnParent( &ndn, &pndn ); - - if ( dn_match( &op->o_ndn, &pndn ) ) { - rc = 1; - } - slap_sl_free( ndn.bv_val, op->o_tmpmemctx ); - - return rc; - - } else if ( ber_bvstrcasecmp( &aci_bv_children, &type ) == 0 ) { - struct berval ndn; - - rc = dnNormalize( 0, NULL, NULL, &sdn, &ndn, op->o_tmpmemctx ); - if ( rc != LDAP_SUCCESS ) { - return 0; - } - - if ( !dn_match( &op->o_ndn, &ndn ) - && dnIsSuffix( &op->o_ndn, &ndn ) ) - { - rc = 1; - } - slap_sl_free( ndn.bv_val, op->o_tmpmemctx ); - - return rc; - - } else if ( ber_bvstrcasecmp( &aci_bv_self, &type ) == 0 ) { - if ( dn_match( &op->o_ndn, &e->e_nname ) ) { - return 1; - } - - } else if ( ber_bvstrcasecmp( &aci_bv_dnattr, &type ) == 0 ) { - Attribute *at; - AttributeDescription *ad = NULL; - const char *text; - - rc = slap_bv2ad( &sdn, &ad, &text ); - - if( rc != LDAP_SUCCESS ) { - return 0; - } - - rc = 0; - - for ( at = attrs_find( e->e_attrs, ad ); - at != NULL; - at = attrs_find( at->a_next, ad ) ) - { - if ( value_find_ex( ad, - SLAP_MR_ATTRIBUTE_VALUE_NORMALIZED_MATCH | - SLAP_MR_ASSERTED_VALUE_NORMALIZED_MATCH, - at->a_nvals, - &op->o_ndn, op->o_tmpmemctx ) == 0 ) - { - rc = 1; - break; - } - } - - return rc; - - } else if ( ber_bvstrcasecmp( &aci_bv_group, &type ) == 0 ) { - if ( aci_group_member( &sdn, &aci_bv_group_class, - &aci_bv_group_attr, op, e, nmatch, matches ) ) - { - return 1; - } - - } else if ( ber_bvstrcasecmp( &aci_bv_role, &type ) == 0 ) { - if ( aci_group_member( &sdn, &aci_bv_role_class, - &aci_bv_role_attr, op, e, nmatch, matches ) ) - { - return 1; - } - - } else if ( ber_bvstrcasecmp( &aci_bv_set, &type ) == 0 ) { - if ( aci_match_set( &sdn, op, e, 0 ) ) { - return 1; - } - - } else if ( ber_bvstrcasecmp( &aci_bv_set_ref, &type ) == 0 ) { - if ( aci_match_set( &sdn, op, e, 1 ) ) { - return 1; - } - } - - return 0; -} - -#ifdef SLAP_DYNACL -static int -dynacl_aci_parse( const char *fname, int lineno, slap_style_t sty, const char *right, void **privp ) -{ - AttributeDescription *ad = NULL; - const char *text = NULL; - - if ( sty != ACL_STYLE_REGEX && sty != ACL_STYLE_BASE ) { - fprintf( stderr, "%s: line %d: " - "inappropriate style \"%s\" in \"aci\" by clause\n", - fname, lineno, sty ); - return -1; - } - - if ( right != NULL && *right != '\0' ) { - if ( slap_str2ad( right, &ad, &text ) != LDAP_SUCCESS ) { - fprintf( stderr, - "%s: line %d: aci \"%s\": %s\n", - fname, lineno, right, text ); - return -1; - } - - } else { - ad = slap_schema.si_ad_aci; - } - - if ( !is_at_syntax( ad->ad_type, SLAPD_ACI_SYNTAX) ) { - fprintf( stderr, "%s: line %d: " - "aci \"%s\": inappropriate syntax: %s\n", - fname, lineno, right, - ad->ad_type->sat_syntax_oid ); - return -1; - } - - *privp = (void *)ad; - - return 0; -} - -static int -dynacl_aci_unparse( void *priv, struct berval *bv ) -{ - AttributeDescription *ad = ( AttributeDescription * )priv; - char *ptr; - - assert( ad ); - - 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 int -dynacl_aci_mask( - void *priv, - Operation *op, - Entry *e, - AttributeDescription *desc, - struct berval *val, - int nmatch, - regmatch_t *matches, - slap_access_t *grantp, - slap_access_t *denyp ) -{ - AttributeDescription *ad = ( AttributeDescription * )priv; - Attribute *at; - slap_access_t tgrant, tdeny, grant, deny; -#ifdef LDAP_DEBUG - char accessmaskbuf[ACCESSMASK_MAXLEN]; - char accessmaskbuf1[ACCESSMASK_MAXLEN]; -#endif /* LDAP_DEBUG */ - - /* start out with nothing granted, nothing denied */ - ACL_INIT(tgrant); - ACL_INIT(tdeny); - - /* get the aci attribute */ - at = attr_find( e->e_attrs, ad ); - if ( at != NULL ) { - int i; - - /* the aci is an multi-valued attribute. The - * rights are determined by OR'ing the individual - * rights given by the acis. - */ - for ( i = 0; !BER_BVISNULL( &at->a_nvals[i] ); i++ ) { - if ( aci_mask( op, e, desc, val, &at->a_nvals[i], - nmatch, matches, &grant, &deny, - SLAP_ACI_SCOPE_ENTRY ) != 0 ) - { - tgrant |= grant; - tdeny |= deny; - } - } - - Debug( LDAP_DEBUG_ACL, "<= aci_mask grant %s deny %s\n", - accessmask2str( tgrant, accessmaskbuf, 1 ), - accessmask2str( tdeny, accessmaskbuf1, 1 ), 0 ); - } - - /* If the entry level aci didn't contain anything valid for the - * current operation, climb up the tree and evaluate the - * acis with scope set to subtree - */ - if ( tgrant == ACL_PRIV_NONE && tdeny == ACL_PRIV_NONE ) { - struct berval parent_ndn; - struct berval old_parent_ndn = BER_BVNULL; - -#if 1 - /* to solve the chicken'n'egg problem of accessing - * the OpenLDAPaci attribute, the direct access - * to the entry's attribute is unchecked; however, - * further accesses to OpenLDAPaci values in the - * ancestors occur through backend_attribute(), i.e. - * with the identity of the operation, requiring - * further access checking. For uniformity, this - * makes further requests occur as the rootdn, if - * any, i.e. searching for the OpenLDAPaci attribute - * is considered an internal search. If this is not - * acceptable, then the same check needs be performed - * when accessing the entry's attribute. */ - Operation op2 = *op; - - if ( !BER_BVISNULL( &op->o_bd->be_rootndn ) ) { - op2.o_dn = op->o_bd->be_rootdn; - op2.o_ndn = op->o_bd->be_rootndn; - } -#endif - - dnParent( &e->e_nname, &parent_ndn ); - while ( parent_ndn.bv_val != old_parent_ndn.bv_val ){ - int i; - BerVarray bvals = NULL; - int ret, stop; - - old_parent_ndn = parent_ndn; - Debug( LDAP_DEBUG_ACL, "checking ACI of \"%s\"\n", parent_ndn.bv_val, 0, 0 ); - ret = backend_attribute( &op2, NULL, &parent_ndn, ad, &bvals, ACL_AUTH ); - - switch ( ret ) { - case LDAP_SUCCESS : - stop = 0; - if ( !bvals ) { - break; - } - - for ( i = 0; !BER_BVISNULL( &bvals[i] ); i++) { - if ( aci_mask( op, e, desc, val, - &bvals[i], - nmatch, matches, - &grant, &deny, - SLAP_ACI_SCOPE_CHILDREN ) != 0 ) - { - tgrant |= grant; - tdeny |= deny; - /* evaluation stops as soon as either a "deny" or a - * "grant" directive matches. - */ - if ( tgrant != ACL_PRIV_NONE || tdeny != ACL_PRIV_NONE ) { - stop = 1; - } - } - Debug( LDAP_DEBUG_ACL, "<= aci_mask grant %s deny %s\n", - accessmask2str( tgrant, accessmaskbuf, 1 ), - accessmask2str( tdeny, accessmaskbuf1, 1 ), 0 ); - } - break; - - case LDAP_NO_SUCH_ATTRIBUTE: - /* just go on if the aci-Attribute is not present in - * the current entry - */ - Debug( LDAP_DEBUG_ACL, "no such attribute\n", 0, 0, 0 ); - stop = 0; - break; - - case LDAP_NO_SUCH_OBJECT: - /* We have reached the base object */ - Debug( LDAP_DEBUG_ACL, "no such object\n", 0, 0, 0 ); - stop = 1; - break; - - default: - stop = 1; - break; - } - - if ( stop ) { - break; - } - dnParent( &old_parent_ndn, &parent_ndn ); - } - } - - *grantp = tgrant; - *denyp = tdeny; - - return 0; -} - -/* need to register this at some point */ -static slap_dynacl_t dynacl_aci = { - "aci", - dynacl_aci_parse, - dynacl_aci_unparse, - dynacl_aci_mask, - NULL, - NULL, - NULL -}; - -#endif /* SLAP_DYNACL */ - -#endif /* SLAPD_ACI_ENABLED */ - #ifdef SLAP_DYNACL /* @@ -2917,31 +2368,37 @@ slap_dynacl_get( const char *name ) } #endif /* SLAP_DYNACL */ +/* + * statically built-in dynamic ACL initialization + */ +static int (*acl_init_func[])( void ) = { +#ifdef SLAP_DYNACL + /* TODO: remove when ACI will only be dynamic */ +#if SLAPD_ACI_ENABLED == SLAPD_MOD_STATIC + dynacl_aci_init, +#endif /* SLAPD_ACI_ENABLED */ +#endif /* SLAP_DYNACL */ + + NULL +}; + int acl_init( void ) { - int i, rc; -#ifdef SLAP_DYNACL - slap_dynacl_t *known_dynacl[] = { -#ifdef SLAPD_ACI_ENABLED - &dynacl_aci, -#endif /* SLAPD_ACI_ENABLED */ - NULL - }; + int i, rc; - for ( i = 0; known_dynacl[ i ]; i++ ) { - rc = slap_dynacl_register( known_dynacl[ i ] ); - if ( rc ) { + for ( i = 0; acl_init_func[ i ] != NULL; i++ ) { + rc = (*(acl_init_func[ i ]))(); + if ( rc != 0 ) { return rc; } } -#endif /* SLAP_DYNACL */ return 0; } -static int -string_expand( +int +acl_string_expand( struct berval *bv, struct berval *pat, char *match, @@ -3025,8 +2482,8 @@ string_expand( *dp = '\0'; bv->bv_len = size; - Debug( LDAP_DEBUG_TRACE, "=> string_expand: pattern: %.*s\n", (int)pat->bv_len, pat->bv_val, 0 ); - Debug( LDAP_DEBUG_TRACE, "=> string_expand: expanded: %s\n", bv->bv_val, 0, 0 ); + Debug( LDAP_DEBUG_TRACE, "=> acl_string_expand: pattern: %.*s\n", (int)pat->bv_len, pat->bv_val, 0 ); + Debug( LDAP_DEBUG_TRACE, "=> acl_string_expand: expanded: %s\n", bv->bv_val, 0, 0 ); return 0; } @@ -3052,7 +2509,7 @@ regex_matches( str = ""; }; - string_expand( &bv, pat, buf, nmatch, matches ); + acl_string_expand( &bv, pat, buf, nmatch, matches ); rc = regcomp( &re, newbuf, REG_EXTENDED|REG_ICASE ); if ( rc ) { char error[ACL_BUF_SIZE];