X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fad.c;h=c81422bda8030e4e95b1097259bc7b99bbdba286;hb=a17df0e810578d593808c6afeb0cdea55a65633c;hp=2aa538e725d29c1663f0a9a0c101e21a6953dd8d;hpb=52fb4b47fe68a3595b594fce911f5c8adffb7191;p=openldap diff --git a/servers/slapd/ad.c b/servers/slapd/ad.c index 2aa538e725..c81422bda8 100644 --- a/servers/slapd/ad.c +++ b/servers/slapd/ad.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 @@ -174,12 +174,15 @@ int slap_bv2ad( } /* find valid base attribute type; parse in place */ - memset( &desc, 0, sizeof( desc )); + memset( &desc, 0, sizeof( desc ) ); desc.ad_cname = *bv; name = bv->bv_val; - options = strchr(name, ';'); - if( options != NULL ) { + options = ber_bvchr( bv, ';' ); + if ( options != NULL && (unsigned) ( options - name ) < bv->bv_len ) { + /* don't go past the end of the berval! */ desc.ad_cname.bv_len = options - name; + } else { + options = NULL; } desc.ad_type = at_bvfind( &desc.ad_cname ); if( desc.ad_type == NULL ) { @@ -247,7 +250,7 @@ int slap_bv2ad( rc = strncasecmp( opt, tags[i].bv_val, (unsigned) optlen < tags[i].bv_len - ? optlen : tags[i].bv_len ); + ? (unsigned) optlen : tags[i].bv_len ); if( rc == 0 && (unsigned)optlen == tags[i].bv_len ) { /* duplicate (ignore) */ @@ -385,7 +388,7 @@ done:; if( lp != desc.ad_tags.bv_val ) { *cp++ = ';'; j = (lp - ? lp - desc.ad_tags.bv_val - 1 + ? (unsigned) (lp - desc.ad_tags.bv_val - 1) : strlen( desc.ad_tags.bv_val )); cp = lutil_strncopy(cp, desc.ad_tags.bv_val, j); } @@ -554,6 +557,20 @@ int ad_inlist( continue; } + if ( ber_bvccmp( &attrs->an_name, '*' ) ) { + if ( !is_at_operational( desc->ad_type ) ) { + return 1; + } + continue; + } + + if ( ber_bvccmp( &attrs->an_name, '+' ) ) { + if ( is_at_operational( desc->ad_type ) ) { + return 1; + } + continue; + } + /* * EXTENSION: see if requested description is @objectClass * if so, return attributes which the class requires/allows @@ -647,15 +664,12 @@ int ad_inlist( } } else { - /* short-circuit this search next time around */ - if (!slap_schema.si_at_undefined->sat_ad) { - const char *text; - slap_bv2undef_ad(&attrs->an_name, - &attrs->an_desc, &text); - } else { - attrs->an_desc = - slap_schema.si_at_undefined->sat_ad; - } + const char *text; + + /* give it a chance of being retrieved by a proxy... */ + (void)slap_bv2undef_ad( &attrs->an_name, + &attrs->an_desc, &text, + SLAP_AD_PROXIED|SLAP_AD_NOINSERT ); } } @@ -666,21 +680,24 @@ int ad_inlist( int slap_str2undef_ad( const char *str, AttributeDescription **ad, - const char **text ) + const char **text, + unsigned flags ) { struct berval bv; bv.bv_val = (char *) str; bv.bv_len = strlen( str ); - return slap_bv2undef_ad( &bv, ad, text ); + return slap_bv2undef_ad( &bv, ad, text, flags ); } int slap_bv2undef_ad( struct berval *bv, AttributeDescription **ad, - const char **text ) + const char **text, + unsigned flags ) { AttributeDescription *desc; + AttributeType *at; assert( ad != NULL ); @@ -695,23 +712,33 @@ int slap_bv2undef_ad( return LDAP_UNDEFINED_TYPE; } - for( desc = slap_schema.si_at_undefined->sat_ad; desc; - desc=desc->ad_next ) - { + /* use the appropriate type */ + if ( flags & SLAP_AD_PROXIED ) { + at = slap_schema.si_at_proxied; + + } else { + at = slap_schema.si_at_undefined; + } + + for( desc = at->sat_ad; desc; desc=desc->ad_next ) { if( desc->ad_cname.bv_len == bv->bv_len && - !strcasecmp( desc->ad_cname.bv_val, bv->bv_val )) + !strcasecmp( desc->ad_cname.bv_val, bv->bv_val ) ) { break; } } - + if( !desc ) { + if ( flags & SLAP_AD_NOINSERT ) { + *text = NULL; + return LDAP_UNDEFINED_TYPE; + } + desc = ch_malloc(sizeof(AttributeDescription) + 1 + bv->bv_len); desc->ad_flags = SLAP_DESC_NONE; - desc->ad_tags.bv_val = NULL; - desc->ad_tags.bv_len = 0; + BER_BVZERO( &desc->ad_tags ); desc->ad_cname.bv_len = bv->bv_len; desc->ad_cname.bv_val = (char *)(desc+1); @@ -720,9 +747,17 @@ int slap_bv2undef_ad( /* canonical to upper case */ ldap_pvt_str2upper( desc->ad_cname.bv_val ); - desc->ad_type = slap_schema.si_at_undefined; + /* shouldn't we protect this for concurrency? */ + desc->ad_type = at; + ldap_pvt_thread_mutex_lock( &ad_undef_mutex ); desc->ad_next = desc->ad_type->sat_ad; desc->ad_type->sat_ad = desc; + ldap_pvt_thread_mutex_unlock( &ad_undef_mutex ); + + Debug( LDAP_DEBUG_ANY, + "%s attributeDescription \"%s\" inserted.\n", + ( flags & SLAP_AD_PROXIED ) ? "PROXIED" : "UNKNOWN", + desc->ad_cname.bv_val, 0 ); } if( !*ad ) { @@ -734,6 +769,62 @@ int slap_bv2undef_ad( return LDAP_SUCCESS; } +static int +undef_promote( + AttributeType *at, + char *name, + AttributeType *nat ) +{ + AttributeDescription **u_ad, **n_ad; + + /* Get to last ad on the new type */ + for ( n_ad = &nat->sat_ad; *n_ad; n_ad = &(*n_ad)->ad_next ) ; + + for ( u_ad = &at->sat_ad; *u_ad; ) { + struct berval bv; + + ber_str2bv( name, 0, 0, &bv ); + + /* remove iff undef == name or undef == name;tag */ + if ( (*u_ad)->ad_cname.bv_len >= bv.bv_len + && strncasecmp( (*u_ad)->ad_cname.bv_val, bv.bv_val, bv.bv_len ) == 0 + && ( (*u_ad)->ad_cname.bv_val[ bv.bv_len ] == '\0' + || (*u_ad)->ad_cname.bv_val[ bv.bv_len ] == ';' ) ) + { + AttributeDescription *tmp = *u_ad; + + *u_ad = (*u_ad)->ad_next; + + tmp->ad_next = NULL; + *n_ad = tmp; + n_ad = &tmp->ad_next; + } else { + u_ad = &(*u_ad)->ad_next; + } + } + + return 0; +} + +int +slap_ad_undef_promote( + char *name, + AttributeType *at ) +{ + int rc; + + ldap_pvt_thread_mutex_lock( &ad_undef_mutex ); + + rc = undef_promote( slap_schema.si_at_undefined, name, at ); + if ( rc == 0 ) { + rc = undef_promote( slap_schema.si_at_proxied, name, at ); + } + + ldap_pvt_thread_mutex_unlock( &ad_undef_mutex ); + + return rc; +} + int an_find( AttributeName *a, @@ -897,8 +988,9 @@ anlist2attrs( AttributeName * anlist ) char **attrs; ObjectClass *oc; - attrs = anlist2charray( anlist, 1 ); - + if ( anlist == NULL ) + return NULL; + for ( i = 0; anlist[i].an_name.bv_val; i++ ) { if ( ( oc = anlist[i].an_oc ) ) { for ( j = 0; oc->soc_required && oc->soc_required[j]; j++ ) ; @@ -911,6 +1003,8 @@ anlist2attrs( AttributeName * anlist ) if ( i == 0 ) return NULL; + attrs = anlist2charray( anlist, 1 ); + n = i; if ( k ) @@ -935,9 +1029,8 @@ anlist2attrs( AttributeName * anlist ) i = 0; while ( attrs && attrs[i] ) { if ( *attrs[i] == '@' ) { + ch_free( attrs[i] ); for ( j = i; attrs[j]; j++ ) { - if ( j == i ) - ch_free( attrs[i] ); attrs[j] = attrs[j+1]; } } else { @@ -949,9 +1042,8 @@ anlist2attrs( AttributeName * anlist ) j = i + 1; while ( attrs && attrs[j] ) { if ( !strcmp( attrs[i], attrs[j] )) { + ch_free( attrs[j] ); for ( k = j; attrs && attrs[k]; k++ ) { - if ( k == j ) - ch_free( attrs[j] ); attrs[k] = attrs[k+1]; } } else {