X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fad.c;h=c9601a3a10b33be83fd806f5a9ae55763d0d4c48;hb=c3960b98d3b5fbd6ebeb200ca7799ece7b766d50;hp=2aa538e725d29c1663f0a9a0c101e21a6953dd8d;hpb=52fb4b47fe68a3595b594fce911f5c8adffb7191;p=openldap diff --git a/servers/slapd/ad.c b/servers/slapd/ad.c index 2aa538e725..c9601a3a10 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 @@ -124,20 +124,21 @@ int slap_str2ad( } static char *strchrlen( - const char *p, + const char *beg, + const char *end, const char ch, int *len ) { - int i; + const char *p; - for( i=0; p[i]; i++ ) { - if( p[i] == ch ) { - *len = i; - return (char *) &p[i]; + for( p=beg; *p && p < end; p++ ) { + if( *p == ch ) { + *len = p - beg; + return (char *) p; } } - *len = i; + *len = p - beg; return NULL; } @@ -148,7 +149,7 @@ int slap_bv2ad( { int rtn = LDAP_UNDEFINED_TYPE; AttributeDescription desc, *d2; - char *name, *options; + char *name, *options, *optn; char *opt, *next; int ntags; int tagslen; @@ -174,12 +175,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 ) { @@ -198,11 +202,12 @@ int slap_bv2ad( ntags = 0; memset( tags, 0, sizeof( tags )); tagslen = 0; + optn = bv->bv_val + bv->bv_len; for( opt=options; opt != NULL; opt=next ) { int optlen; opt++; - next = strchrlen( opt, ';', &optlen ); + next = strchrlen( opt, optn, ';', &optlen ); if( optlen == 0 ) { *text = "zero length option is invalid"; @@ -247,7 +252,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 +390,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); } @@ -440,19 +445,21 @@ static int is_ad_subtags( struct berval *subtagsbv, struct berval *suptagsbv ) { - const char *suptags, *supp, *supdelimp; - const char *subtags, *subp, *subdelimp; + const char *suptags, *supp, *supdelimp, *supn; + const char *subtags, *subp, *subdelimp, *subn; int suplen, sublen; subtags =subtagsbv->bv_val; suptags =suptagsbv->bv_val; + subn = subtags + subtagsbv->bv_len; + supn = suptags + suptagsbv->bv_len; for( supp=suptags ; supp; supp=supdelimp ) { - supdelimp = strchrlen( supp, ';', &suplen ); + supdelimp = strchrlen( supp, supn, ';', &suplen ); if( supdelimp ) supdelimp++; for( subp=subtags ; subp; subp=subdelimp ) { - subdelimp = strchrlen( subp, ';', &sublen ); + subdelimp = strchrlen( subp, subn, ';', &sublen ); if( subdelimp ) subdelimp++; if ( suplen > sublen @@ -554,6 +561,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 +668,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 +684,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 +716,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 +751,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 +773,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 +992,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 +1007,8 @@ anlist2attrs( AttributeName * anlist ) if ( i == 0 ) return NULL; + attrs = anlist2charray( anlist, 1 ); + n = i; if ( k ) @@ -935,9 +1033,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 +1046,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 { @@ -1085,6 +1181,15 @@ ad_define_option( const char *name, const char *fname, int lineno ) return 0; } +void +ad_unparse_options( BerVarray *res ) +{ + int i; + for ( i = 0; i < option_count; i++ ) { + value_add_one( res, &options[i].name ); + } +} + /* Find the definition of the option name or prefix matching the arguments */ static Attr_option * ad_find_option_definition( const char *opt, int optlen )