X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;ds=sidebyside;f=servers%2Fslapd%2Fad.c;h=c65934f1541835460556a0eb25cebf432d35b8a3;hb=a78c03bb4a9285d5a42dc7907fc212dbf162a7c1;hp=49f5f734a718ba662b16ceea8da9c05ed31a8e7c;hpb=bf371dcce9f46321ecd2953a953bca64a1431a9e;p=openldap diff --git a/servers/slapd/ad.c b/servers/slapd/ad.c index 49f5f734a7..c65934f154 100644 --- a/servers/slapd/ad.c +++ b/servers/slapd/ad.c @@ -1,6 +1,6 @@ /* $OpenLDAP$ */ /* - * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. + * Copyright 1998-2003 The OpenLDAP Foundation, All Rights Reserved. * COPYING RESTRICTIONS APPLY, see COPYRIGHT file */ /* ad.c - routines for dealing with attribute descriptions */ @@ -17,6 +17,20 @@ #include "ldap_pvt.h" #include "slap.h" +#include "lutil.h" + +typedef struct Attr_option { + struct berval name; /* option name or prefix */ + int prefix; /* NAME is a tag and range prefix */ +} Attr_option; + +static Attr_option lang_option = { { sizeof("lang-")-1, "lang-" }, 1 }; + +/* Options sorted by name, and number of options */ +static Attr_option *options = &lang_option; +static int option_count = 1; + +static Attr_option *ad_find_option_definition( const char *opt, int optlen ); static int ad_keystring( struct berval *bv ) @@ -45,18 +59,18 @@ void ad_destroy( AttributeDescription *ad ) } } -/* Is there an AttributeDescription for this type that uses this language? */ -AttributeDescription * ad_find_lang( +/* Is there an AttributeDescription for this type that uses these tags? */ +AttributeDescription * ad_find_tags( AttributeType *type, - struct berval *lang ) + struct berval *tags ) { AttributeDescription *ad; ldap_pvt_thread_mutex_lock( &type->sat_ad_mutex ); for (ad = type->sat_ad; ad; ad=ad->ad_next) { - if (ad->ad_lang.bv_len == lang->bv_len && - !strcasecmp(ad->ad_lang.bv_val, lang->bv_val)) + if (ad->ad_tags.bv_len == tags->bv_len && + !strcasecmp(ad->ad_tags.bv_val, tags->bv_val)) break; } ldap_pvt_thread_mutex_unlock( &type->sat_ad_mutex ); @@ -102,15 +116,14 @@ int slap_bv2ad( AttributeDescription desc, *d2; char *name, *options; char *opt, *next; - char *s, *ptr; - int nlang; - int langlen; + int ntags; + int tagslen; /* hardcoded limits for speed */ -#define MAX_LANG_OPTIONS 128 - struct berval langs[MAX_LANG_OPTIONS+1]; -#define MAX_LANG_LEN 1024 - char langbuf[MAX_LANG_LEN]; +#define MAX_TAGGING_OPTIONS 128 + struct berval tags[MAX_TAGGING_OPTIONS+1]; +#define MAX_TAGS_LEN 1024 + char tagbuf[MAX_TAGS_LEN]; assert( ad != NULL ); assert( *ad == NULL ); /* temporary */ @@ -148,9 +161,9 @@ int slap_bv2ad( /* * parse options in place */ - nlang = 0; - memset( langs, 0, sizeof( langs )); - langlen = 0; + ntags = 0; + memset( tags, 0, sizeof( tags )); + tagslen = 0; for( opt=options; opt != NULL; opt=next ) { int optlen; @@ -172,24 +185,22 @@ int slap_bv2ad( if( !slap_syntax_is_binary( desc.ad_type->sat_syntax )) { /* not stored in binary, disallow option */ - *text = "option \"binary\" with type not supported"; + *text = "option \"binary\" not supported with type"; return rtn; } desc.ad_flags |= SLAP_DESC_BINARY; continue; - } else if ( optlen >= sizeof("lang-")-1 && - strncasecmp( opt, "lang-", sizeof("lang-")-1 ) == 0 ) - { + } else if ( ad_find_option_definition( opt, optlen ) ) { int i; if( opt[optlen-1] == '-' ) { - desc.ad_flags |= SLAP_DESC_LANG_RANGE; + desc.ad_flags |= SLAP_DESC_TAG_RANGE; } - if( nlang >= MAX_LANG_OPTIONS ) { - *text = "too many language options"; + if( ntags >= MAX_TAGGING_OPTIONS ) { + *text = "too many tagging options"; return rtn; } @@ -197,37 +208,38 @@ int slap_bv2ad( * tags should be presented in sorted order, * so run the array in reverse. */ - for( i=nlang-1; i>=0; i-- ) { + for( i=ntags-1; i>=0; i-- ) { int rc; - rc = strncasecmp( opt, langs[i].bv_val, - optlen < langs[i].bv_len ? optlen : langs[i].bv_len ); + rc = strncasecmp( opt, tags[i].bv_val, + (unsigned) optlen < tags[i].bv_len + ? optlen : tags[i].bv_len ); - if( rc == 0 && optlen == langs[i].bv_len ) { + if( rc == 0 && (unsigned)optlen == tags[i].bv_len ) { /* duplicate (ignore) */ goto done; } else if ( rc > 0 || - ( rc == 0 && optlen > langs[i].bv_len )) + ( rc == 0 && (unsigned)optlen > tags[i].bv_len )) { - AC_MEMCPY( &langs[i+1], &langs[i], - (nlang-i)*sizeof(struct berval) ); - langs[i].bv_val = opt; - langs[i].bv_len = optlen; + AC_MEMCPY( &tags[i+2], &tags[i+1], + (ntags-i-1)*sizeof(struct berval) ); + tags[i+1].bv_val = opt; + tags[i+1].bv_len = optlen; goto done; } } - if( nlang ) { - AC_MEMCPY( &langs[1], &langs[0], - nlang*sizeof(struct berval) ); + if( ntags ) { + AC_MEMCPY( &tags[1], &tags[0], + ntags*sizeof(struct berval) ); } - langs[0].bv_val = opt; - langs[0].bv_len = optlen; + tags[0].bv_val = opt; + tags[0].bv_len = optlen; done:; - langlen += optlen + 1; - nlang++; + tagslen += optlen + 1; + ntags++; } else { *text = "unrecognized option"; @@ -235,27 +247,27 @@ done:; } } - if( nlang > 0 ) { + if( ntags > 0 ) { int i; - if( langlen > MAX_LANG_LEN ) { - *text = "language options too long"; + if( tagslen > MAX_TAGS_LEN ) { + *text = "tagging options too long"; return rtn; } - desc.ad_lang.bv_val = langbuf; - langlen = 0; + desc.ad_tags.bv_val = tagbuf; + tagslen = 0; - for( i=0; iad_flags != desc.ad_flags ) { continue; } - if( d2->ad_lang.bv_len != desc.ad_lang.bv_len ) { + if( d2->ad_tags.bv_len != desc.ad_tags.bv_len ) { continue; } - if( d2->ad_lang.bv_len == 0 ) { + if( d2->ad_tags.bv_len == 0 ) { break; } - if( strncasecmp( d2->ad_lang.bv_val, desc.ad_lang.bv_val, - desc.ad_lang.bv_len ) == 0 ) + if( strncasecmp( d2->ad_tags.bv_val, desc.ad_tags.bv_val, + desc.ad_tags.bv_len ) == 0 ) { break; } @@ -278,18 +290,18 @@ done:; /* Not found, add new one */ while (d2 == NULL) { - int dlen = 0; + size_t dlen = 0; ldap_pvt_thread_mutex_lock( &desc.ad_type->sat_ad_mutex ); /* check again now that we've locked */ for (d2 = desc.ad_type->sat_ad; d2; d2=d2->ad_next) { if (d2->ad_flags != desc.ad_flags) continue; - if (d2->ad_lang.bv_len != desc.ad_lang.bv_len) + if (d2->ad_tags.bv_len != desc.ad_tags.bv_len) continue; - if (d2->ad_lang.bv_len == 0) + if (d2->ad_tags.bv_len == 0) break; - if (strncasecmp(d2->ad_lang.bv_val, desc.ad_lang.bv_val, - desc.ad_lang.bv_len) == 0) + if (strncasecmp(d2->ad_tags.bv_val, desc.ad_tags.bv_val, + desc.ad_tags.bv_len) == 0) break; } if (d2) { @@ -300,43 +312,71 @@ done:; /* Allocate a single contiguous block. If there are no * options, we just need space for the AttrDesc structure. * Otherwise, we need to tack on the full name length + - * options length. + * options length, + maybe tagging options length again. */ - if (desc.ad_lang.bv_len || desc.ad_flags != SLAP_DESC_NONE) { - if (desc.ad_lang.bv_len) { - dlen = desc.ad_lang.bv_len+1; + if (desc.ad_tags.bv_len || desc.ad_flags != SLAP_DESC_NONE) { + dlen = desc.ad_type->sat_cname.bv_len + 1; + if (desc.ad_tags.bv_len) { + dlen += 1+desc.ad_tags.bv_len; } - dlen += desc.ad_type->sat_cname.bv_len+1; if( slap_ad_is_binary( &desc ) ) { - dlen += sizeof("binary"); + dlen += sizeof(";binary")+desc.ad_tags.bv_len; } } d2 = ch_malloc(sizeof(AttributeDescription) + dlen); + d2->ad_next = NULL; d2->ad_type = desc.ad_type; d2->ad_flags = desc.ad_flags; - d2->ad_cname.bv_len = desc.ad_cname.bv_len; - d2->ad_lang.bv_len = desc.ad_lang.bv_len; + d2->ad_cname.bv_len = desc.ad_type->sat_cname.bv_len; + d2->ad_tags.bv_len = desc.ad_tags.bv_len; + if (dlen == 0) { d2->ad_cname.bv_val = d2->ad_type->sat_cname.bv_val; - d2->ad_lang.bv_val = NULL; + d2->ad_tags.bv_val = NULL; } else { + char *cp, *op, *lp; + int j; d2->ad_cname.bv_val = (char *)(d2+1); strcpy(d2->ad_cname.bv_val, d2->ad_type->sat_cname.bv_val); + cp = d2->ad_cname.bv_val + d2->ad_cname.bv_len; if( slap_ad_is_binary( &desc ) ) { - strcpy(d2->ad_cname.bv_val+d2->ad_cname.bv_len, - ";binary"); - d2->ad_cname.bv_len += sizeof("binary"); + op = cp; + lp = NULL; + if( desc.ad_tags.bv_len ) { + lp = desc.ad_tags.bv_val; + while( strncasecmp(lp, "binary", sizeof("binary")-1) < 0 + && (lp = strchr( lp, ';' )) != NULL ) + ++lp; + if( lp != desc.ad_tags.bv_val ) { + *cp++ = ';'; + j = (lp + ? lp - desc.ad_tags.bv_val - 1 + : strlen( desc.ad_tags.bv_val )); + cp = lutil_strncopy(cp, desc.ad_tags.bv_val, j); + } + } + cp = lutil_strcopy(cp, ";binary"); + if( lp != NULL ) { + *cp++ = ';'; + cp = lutil_strcopy(cp, lp); + } + d2->ad_cname.bv_len = cp - d2->ad_cname.bv_val; + if( desc.ad_tags.bv_len ) + ldap_pvt_str2lower(op); + j = 1; + } else { + j = 0; } - if( d2->ad_lang.bv_len ) { - d2->ad_cname.bv_val[d2->ad_cname.bv_len++]=';'; - d2->ad_lang.bv_val = d2->ad_cname.bv_val+ - d2->ad_cname.bv_len; - strncpy(d2->ad_lang.bv_val,desc.ad_lang.bv_val, - d2->ad_lang.bv_len); - d2->ad_lang.bv_val[d2->ad_lang.bv_len] = '\0'; - ldap_pvt_str2lower(d2->ad_lang.bv_val); - d2->ad_cname.bv_len += d2->ad_lang.bv_len; + if( desc.ad_tags.bv_len ) { + lp = d2->ad_cname.bv_val + d2->ad_cname.bv_len + j; + if ( j == 0 ) + *lp++ = ';'; + d2->ad_tags.bv_val = lp; + strcpy(lp, desc.ad_tags.bv_val); + ldap_pvt_str2lower(lp); + if( j == 0 ) + d2->ad_cname.bv_len += 1 + desc.ad_tags.bv_len; } } /* Add new desc to list. We always want the bare Desc with @@ -362,27 +402,30 @@ done:; return LDAP_SUCCESS; } -static int is_ad_sublang( - const char *sublang, - const char *suplang ) +static int is_ad_subtags( + struct berval *subtagsbv, + struct berval *suptagsbv ) { - const char *supp, *supdelimp; - const char *subp, *subdelimp; + const char *suptags, *supp, *supdelimp; + const char *subtags, *subp, *subdelimp; int suplen, sublen; - if( suplang == NULL ) return 1; - if( sublang == NULL ) return 0; + subtags =subtagsbv->bv_val; + suptags =suptagsbv->bv_val; - for( supp=suplang ; supp; supp=supdelimp ) { + for( supp=suptags ; supp; supp=supdelimp ) { supdelimp = strchrlen( supp, ';', &suplen ); if( supdelimp ) supdelimp++; - for( subp=sublang ; subp; subp=subdelimp ) { + for( subp=subtags ; subp; subp=subdelimp ) { subdelimp = strchrlen( subp, ';', &sublen ); if( subdelimp ) subdelimp++; - if ((( suplen < sublen && supp[suplen-1] == '-' ) || - suplen == sublen ) && strncmp( supp, subp, suplen ) == 0 ) + if ( suplen > sublen + ? ( suplen-1 == sublen && supp[suplen-1] == '-' + && strncmp( supp, subp, sublen ) == 0 ) + : ( ( suplen == sublen || supp[suplen-1] == '-' ) + && strncmp( supp, subp, suplen ) == 0 ) ) { goto match; } @@ -399,24 +442,29 @@ int is_ad_subtype( AttributeDescription *super ) { + AttributeType *a; int lr; - if( !is_at_subtype( sub->ad_type, super->ad_type ) ) { + for ( a = sub->ad_type; a; a=a->sat_sup ) { + if ( a == super->ad_type ) break; + } + if( !a ) { return 0; } /* ensure sub does support all flags of super */ - lr = sub->ad_lang.bv_len ? SLAP_DESC_LANG_RANGE : 0; + lr = sub->ad_tags.bv_len ? SLAP_DESC_TAG_RANGE : 0; if(( super->ad_flags & ( sub->ad_flags | lr )) != super->ad_flags ) { return 0; } - /* check for language tags */ - if ( !is_ad_sublang( sub->ad_lang.bv_val, super->ad_lang.bv_val )) { + /* check for tagging options */ + if ( super->ad_tags.bv_len == 0 ) + return 1; + if ( sub->ad_tags.bv_len == 0 ) return 0; - } - return 1; + return is_ad_subtags( &sub->ad_tags, &super->ad_tags ); } int ad_inlist( @@ -426,22 +474,69 @@ int ad_inlist( if (! attrs ) return 0; for( ; attrs->an_name.bv_val; attrs++ ) { + AttributeType *a; ObjectClass *oc; int rc; if ( attrs->an_desc ) { - if ( is_ad_subtype( desc, attrs->an_desc )) + int lr; + + if ( desc == attrs->an_desc ) { return 1; + } + + /* + * EXTENSION: if requested description is preceeded by + * a '-' character, do not match on subtypes. + */ + if ( attrs->an_name.bv_val[0] == '-' ) { + continue; + } + + /* Is this a subtype of the requested attr? */ + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == attrs->an_desc->ad_type ) + break; + } + if ( !a ) { + continue; + } + /* Does desc support all the requested flags? */ + lr = desc->ad_tags.bv_len ? SLAP_DESC_TAG_RANGE : 0; + if(( attrs->an_desc->ad_flags & (desc->ad_flags | lr)) + != attrs->an_desc->ad_flags ) { + continue; + } + /* Do the descs have compatible tags? */ + if ( attrs->an_desc->ad_tags.bv_len == 0 ) { + return 1; + } + if ( desc->ad_tags.bv_len == 0) { + continue; + } + if ( is_ad_subtags( &desc->ad_tags, + &attrs->an_desc->ad_tags ) ) { + return 1; + } continue; } /* - * EXTENSION: see if requested description is an object class + * EXTENSION: see if requested description is +objectClass * if so, return attributes which the class requires/allows */ oc = attrs->an_oc; - if( oc == NULL ) { - oc = oc_bvfind( &attrs->an_name ); + if( oc == NULL && attrs->an_name.bv_val ) { + switch( attrs->an_name.bv_val[0] ) { + case '+': { /* new way */ + struct berval ocname; + ocname.bv_len = attrs->an_name.bv_len - 1; + ocname.bv_val = &attrs->an_name.bv_val[1]; + oc = oc_bvfind( &ocname ); + } break; + default: /* old (deprecated) way */ + oc = oc_bvfind( &attrs->an_name ); + } attrs->an_oc = oc; } if( oc != NULL ) { @@ -454,9 +549,11 @@ int ad_inlist( /* allow return of required attributes */ int i; for ( i = 0; oc->soc_required[i] != NULL; i++ ) { - rc = is_at_subtype( desc->ad_type, - oc->soc_allowed[i] ); - if( rc ) return 1; + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == oc->soc_required[i] ) { + return 1; + } + } } } @@ -464,9 +561,11 @@ int ad_inlist( /* allow return of allowed attributes */ int i; for ( i = 0; oc->soc_allowed[i] != NULL; i++ ) { - rc = is_at_subtype( desc->ad_type, - oc->soc_allowed[i] ); - if( rc ) return 1; + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == oc->soc_allowed[i] ) { + return 1; + } + } } } @@ -530,12 +629,12 @@ int slap_bv2undef_ad( } if( !desc ) { - desc = ch_malloc(sizeof(AttributeDescription) + - bv->bv_len + 1); + desc = ch_malloc(sizeof(AttributeDescription) + 1 + + bv->bv_len); desc->ad_flags = SLAP_DESC_NONE; - desc->ad_lang.bv_val = NULL; - desc->ad_lang.bv_len = 0; + desc->ad_tags.bv_val = NULL; + desc->ad_tags.bv_len = 0; desc->ad_cname.bv_len = bv->bv_len; desc->ad_cname.bv_val = (char *)(desc+1); @@ -576,8 +675,16 @@ an_find( return( 0 ); } -/* Convert a delimited string into a list of AttributeNames; Add on - * to an existing list if it was given. +/* + * Convert a delimited string into a list of AttributeNames; + * add on to an existing list if it was given. If the string + * is not a valid attribute name, if a '-' is prepended it is + * skipped and the remaining name is tried again; if a '+' is + * prepended, an objectclass name is searched instead. + * + * NOTE: currently, if a valid attribute name is not found, + * the same string is also checked as valid objectclass name; + * however, this behavior is deprecated. */ AttributeName * str2anlist( AttributeName *an, char *in, const char *brkstr ) @@ -614,19 +721,179 @@ str2anlist( AttributeName *an, char *in, const char *brkstr ) ber_str2bv(s, 0, 1, &anew->an_name); slap_bv2ad(&anew->an_name, &anew->an_desc, &text); if ( !anew->an_desc ) { - anew->an_oc = oc_bvfind( &anew->an_name ); - if ( !anew->an_oc ) { - free( an ); - /* overwrites input string on error! */ - strcpy( in, s ); - return NULL; + switch( anew->an_name.bv_val[0] ) { + case '-': { + struct berval adname; + adname.bv_len = anew->an_name.bv_len - 1; + adname.bv_val = &anew->an_name.bv_val[1]; + slap_bv2ad(&adname, &anew->an_desc, &text); + if ( !anew->an_desc ) { + free( an ); + /* + * overwrites input string + * on error! + */ + strcpy( in, s ); + return NULL; + } + } break; + + case '+': { + struct berval ocname; + ocname.bv_len = anew->an_name.bv_len - 1; + ocname.bv_val = &anew->an_name.bv_val[1]; + anew->an_oc = oc_bvfind( &ocname ); + if ( !anew->an_oc ) { + free( an ); + /* + * overwrites input string + * on error! + */ + strcpy( in, s ); + return NULL; + } + } break; + + default: + /* old (deprecated) way */ + anew->an_oc = oc_bvfind( &anew->an_name ); + if ( !anew->an_oc ) { + free( an ); + /* overwrites input string on error! */ + strcpy( in, s ); + return NULL; + } } } anew++; } - anew->an_name.bv_val = NULL; + anew->an_name.bv_val = NULL; free( str ); return( an ); } + +/* Define an attribute option. */ +int +ad_define_option( const char *name, const char *fname, int lineno ) +{ + int i; + unsigned int optlen; + + if ( options == &lang_option ) { + options = NULL; + option_count = 0; + } + if ( name == NULL ) + return 0; + + optlen = 0; + do { + if ( !DESC_CHAR( name[optlen] ) ) { +#ifdef NEW_LOGGING + LDAP_LOG( CONFIG, CRIT, + "%s: line %d: illegal option name \"%s\"\n", + fname, lineno, name ); +#else + Debug( LDAP_DEBUG_ANY, + "%s: line %d: illegal option name \"%s\"\n", + fname, lineno, name ); +#endif + return 1; + } + } while ( name[++optlen] ); + + options = ch_realloc( options, + (option_count+1) * sizeof(Attr_option) ); + + if ( strcasecmp( name, "binary" ) == 0 + || ad_find_option_definition( name, optlen ) ) { +#ifdef NEW_LOGGING + LDAP_LOG( CONFIG, CRIT, + "%s: line %d: option \"%s\" is already defined\n", + fname, lineno, name ); +#else + Debug( LDAP_DEBUG_ANY, + "%s: line %d: option \"%s\" is already defined\n", + fname, lineno, name ); +#endif + return 1; + } + + for ( i = option_count; i; --i ) { + if ( strcasecmp( name, options[i-1].name.bv_val ) >= 0 ) + break; + options[i] = options[i-1]; + } + + options[i].name.bv_val = ch_strdup( name ); + options[i].name.bv_len = optlen; + options[i].prefix = (name[optlen-1] == '-'); + + if ( i != option_count && + options[i].prefix && + optlen < options[i+1].name.bv_len && + strncasecmp( name, options[i+1].name.bv_val, optlen ) == 0 ) { +#ifdef NEW_LOGGING + LDAP_LOG( CONFIG, CRIT, + "%s: line %d: option \"%s\" overrides previous option\n", + fname, lineno, name ); +#else + Debug( LDAP_DEBUG_ANY, + "%s: line %d: option \"%s\" overrides previous option\n", + fname, lineno, name ); +#endif + return 1; + } + + option_count++; + return 0; +} + +/* Find the definition of the option name or prefix matching the arguments */ +static Attr_option * +ad_find_option_definition( const char *opt, int optlen ) +{ + int top = 0, bot = option_count; + while ( top < bot ) { + int mid = (top + bot) / 2; + int mlen = options[mid].name.bv_len; + char *mname = options[mid].name.bv_val; + int j; + if ( optlen < mlen ) { + j = strncasecmp( opt, mname, optlen ) - 1; + } else { + j = strncasecmp( opt, mname, mlen ); + if ( j==0 && (optlen==mlen || options[mid].prefix) ) + return &options[mid]; + } + if ( j < 0 ) + bot = mid; + else + top = mid + 1; + } + return NULL; +} + +MatchingRule *ad_mr( + AttributeDescription *ad, + unsigned usage ) +{ + switch( usage & SLAP_MR_TYPE_MASK ) { + case SLAP_MR_NONE: + case SLAP_MR_EQUALITY: + return ad->ad_type->sat_equality; + break; + case SLAP_MR_ORDERING: + return ad->ad_type->sat_ordering; + break; + case SLAP_MR_SUBSTR: + return ad->ad_type->sat_substr; + break; + case SLAP_MR_EXT: + default: + assert( 0 /* ad_mr: bad usage */); + } + return NULL; +}