X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fad.c;h=4c118c4313f84803fdba2ab68ac6f3aba226976f;hb=e229b7c3984c026a8b5b84dfe8355801d21f4a3b;hp=89cf5ab1eac9682fcc67050e9539fb9024e7e5e1;hpb=cc7d1433bb4de3d808f5218e32fdaccccdd07c16;p=openldap diff --git a/servers/slapd/ad.c b/servers/slapd/ad.c index 89cf5ab1ea..4c118c4313 100644 --- a/servers/slapd/ad.c +++ b/servers/slapd/ad.c @@ -1,9 +1,18 @@ +/* ad.c - routines for dealing with attribute descriptions */ /* $OpenLDAP$ */ -/* - * Copyright 1998-2002 The OpenLDAP Foundation, All Rights Reserved. - * COPYING RESTRICTIONS APPLY, see COPYRIGHT file +/* This work is part of OpenLDAP Software . + * + * Copyright 1998-2009 The OpenLDAP Foundation. + * All rights reserved. + * + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. + * + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . */ -/* ad.c - routines for dealing with attribute descriptions */ #include "portable.h" @@ -15,20 +24,71 @@ #include #include -#include "ldap_pvt.h" #include "slap.h" +#include "lutil.h" + +static struct berval bv_no_attrs = BER_BVC( LDAP_NO_ATTRS ); +static struct berval bv_all_user_attrs = BER_BVC( "*" ); +static struct berval bv_all_operational_attrs = BER_BVC( "+" ); + +static AttributeName anlist_no_attrs[] = { + { BER_BVC( LDAP_NO_ATTRS ), NULL, 0, NULL }, + { BER_BVNULL, NULL, 0, NULL } +}; + +static AttributeName anlist_all_user_attributes[] = { + { BER_BVC( LDAP_ALL_USER_ATTRIBUTES ), NULL, 0, NULL }, + { BER_BVNULL, NULL, 0, NULL } +}; + +static AttributeName anlist_all_operational_attributes[] = { + { BER_BVC( LDAP_ALL_OPERATIONAL_ATTRIBUTES ), NULL, 0, NULL }, + { BER_BVNULL, NULL, 0, NULL } +}; + +static AttributeName anlist_all_attributes[] = { + { BER_BVC( LDAP_ALL_USER_ATTRIBUTES ), NULL, 0, NULL }, + { BER_BVC( LDAP_ALL_OPERATIONAL_ATTRIBUTES ), NULL, 0, NULL }, + { BER_BVNULL, NULL, 0, NULL } +}; + +AttributeName *slap_anlist_no_attrs = anlist_no_attrs; +AttributeName *slap_anlist_all_user_attributes = anlist_all_user_attributes; +AttributeName *slap_anlist_all_operational_attributes = anlist_all_operational_attributes; +AttributeName *slap_anlist_all_attributes = anlist_all_attributes; + +struct berval * slap_bv_no_attrs = &bv_no_attrs; +struct berval * slap_bv_all_user_attrs = &bv_all_user_attrs; +struct berval * slap_bv_all_operational_attrs = &bv_all_operational_attrs; + +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 = { BER_BVC("lang-"), 1 }; + +/* Options sorted by name, and number of options */ +static Attr_option *options = &lang_option; +static int option_count = 1; + +static int msad_range_hack = 0; + +static Attr_option *ad_find_option_definition( const char *opt, int optlen ); static int ad_keystring( struct berval *bv ) { ber_len_t i; - if( !AD_CHAR( bv->bv_val[0] ) ) { + if( !AD_LEADCHAR( bv->bv_val[0] ) ) { return 1; } for( i=1; ibv_len; i++ ) { - if( !AD_CHAR( bv->bv_val[i] ) ) { + if( !AD_CHAR( bv->bv_val[i] )) { + if ( msad_range_hack && bv->bv_val[i] == '=' ) + continue; return 1; } } @@ -45,18 +105,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 ); @@ -76,20 +136,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; } @@ -100,38 +161,42 @@ int slap_bv2ad( { int rtn = LDAP_UNDEFINED_TYPE; AttributeDescription desc, *d2; - char *name, *options; + char *name, *options, *optn; char *opt, *next; - 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 */ - if( bv == NULL || bv->bv_len == 0 ) { - *text = "empty attribute description"; + if( bv == NULL || BER_BVISNULL( bv ) || BER_BVISEMPTY( bv ) ) { + *text = "empty AttributeDescription"; return rtn; } /* make sure description is IA5 */ if( ad_keystring( bv ) ) { - *text = "attribute description contains inappropriate characters"; + *text = "AttributeDescription contains inappropriate characters"; return rtn; } /* find valid base attribute type; parse in place */ - memset( &desc, 0, sizeof( desc )); desc.ad_cname = *bv; + desc.ad_flags = 0; + BER_BVZERO( &desc.ad_tags ); 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 ) { @@ -147,21 +212,21 @@ int slap_bv2ad( /* * parse options in place */ - nlang = 0; - memset( langs, 0, sizeof( langs )); - langlen = 0; + ntags = 0; + 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"; return rtn; - } else if ( optlen == sizeof("binary")-1 && - strncasecmp( opt, "binary", sizeof("binary")-1 ) == 0 ) + } else if ( optlen == STRLENOF("binary") && + strncasecmp( opt, "binary", STRLENOF("binary") ) == 0 ) { /* binary option */ if( slap_ad_is_binary( &desc ) ) { @@ -178,17 +243,16 @@ int slap_bv2ad( 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; + if( opt[optlen-1] == '-' || + ( opt[optlen-1] == '=' && msad_range_hack )) { + 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; } @@ -196,38 +260,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, - (unsigned) optlen < langs[i].bv_len - ? optlen : langs[i].bv_len ); + rc = strncasecmp( opt, tags[i].bv_val, + (unsigned) optlen < tags[i].bv_len + ? (unsigned) optlen : tags[i].bv_len ); - if( rc == 0 && (unsigned)optlen == langs[i].bv_len ) { + if( rc == 0 && (unsigned)optlen == tags[i].bv_len ) { /* duplicate (ignore) */ goto done; } else if ( rc > 0 || - ( rc == 0 && (unsigned)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 +299,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; } @@ -284,12 +348,12 @@ done:; 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,44 +364,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) { - dlen = desc.ad_type->sat_cname.bv_len; - if (desc.ad_lang.bv_len) { - dlen += 1+desc.ad_lang.bv_len; + 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; } - if( slap_ad_is_binary( &desc ) ) { - dlen += sizeof(";binary")-1; + if ( slap_ad_is_binary( &desc ) ) { + dlen += 1 + STRLENOF(";binary") + desc.ad_tags.bv_len; } } - d2 = ch_malloc(sizeof(AttributeDescription) + dlen + 1); + 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_type->sat_cname.bv_len; - d2->ad_lang.bv_len = desc.ad_lang.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")-1; + op = cp; + lp = NULL; + if( desc.ad_tags.bv_len ) { + lp = desc.ad_tags.bv_val; + while( strncasecmp(lp, "binary", STRLENOF("binary")) < 0 + && (lp = strchr( lp, ';' )) != NULL ) + ++lp; + if( lp != desc.ad_tags.bv_val ) { + *cp++ = ';'; + j = (lp + ? (unsigned) (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 @@ -363,30 +454,32 @@ done:; return LDAP_SUCCESS; } -static int is_ad_sublang( - struct berval *sublangbv, - struct berval *suplangbv ) +static int is_ad_subtags( + struct berval *subtagsbv, + struct berval *suptagsbv ) { - const char *suplang, *supp, *supdelimp; - const char *sublang, *subp, *subdelimp; + const char *suptags, *supp, *supdelimp, *supn; + const char *subtags, *subp, *subdelimp, *subn; int suplen, sublen; - if( suplangbv->bv_len == 0 ) return 1; - if( sublangbv->bv_len == 0 ) return 0; + subtags =subtagsbv->bv_val; + suptags =suptagsbv->bv_val; + subn = subtags + subtagsbv->bv_len; + supn = suptags + suptagsbv->bv_len; - sublang =sublangbv->bv_val; - suplang =suplangbv->bv_val; - - for( supp=suplang ; supp; supp=supdelimp ) { - supdelimp = strchrlen( supp, ';', &suplen ); + for( supp=suptags ; supp; supp=supdelimp ) { + supdelimp = strchrlen( supp, supn, ';', &suplen ); if( supdelimp ) supdelimp++; - for( subp=sublang ; subp; subp=subdelimp ) { - subdelimp = strchrlen( subp, ';', &sublen ); + for( subp=subtags ; subp; subp=subdelimp ) { + subdelimp = strchrlen( subp, subn, ';', &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; } @@ -403,24 +496,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, &super->ad_lang )) { + /* 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( @@ -430,35 +528,132 @@ 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; + } + + 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 an object class + * EXTENSION: see if requested description is @objectClass * if so, return attributes which the class requires/allows + * else if requested description is !objectClass, return + * attributes which the class does not require/allow */ - oc = attrs->an_oc; - if( oc == NULL && attrs->an_name.bv_val ) { - switch( attrs->an_name.bv_val[0] ) { - case '+': - case '-': { - 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: + if ( !( attrs->an_flags & SLAP_AN_OCINITED )) { + if( attrs->an_name.bv_val ) { + switch( attrs->an_name.bv_val[0] ) { + case '@': /* @objectClass */ + case '+': /* +objectClass (deprecated) */ + case '!': { /* exclude */ + 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 ); + if ( oc && attrs->an_name.bv_val[0] == '!' ) { + attrs->an_flags |= SLAP_AN_OCEXCLUDE; + } else { + attrs->an_flags &= ~SLAP_AN_OCEXCLUDE; + } + } break; + + default: /* old (deprecated) way */ oc = oc_bvfind( &attrs->an_name ); + } + attrs->an_oc = oc; } - attrs->an_oc = oc; + attrs->an_flags |= SLAP_AN_OCINITED; } + oc = attrs->an_oc; if( oc != NULL ) { + if ( attrs->an_flags & SLAP_AN_OCEXCLUDE ) { + if ( oc == slap_schema.si_oc_extensibleObject ) { + /* extensibleObject allows the return of anything */ + return 0; + } + + if( oc->soc_required ) { + /* allow return of required attributes */ + int i; + + for ( i = 0; oc->soc_required[i] != NULL; i++ ) { + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == oc->soc_required[i] ) { + return 0; + } + } + } + } + + if( oc->soc_allowed ) { + /* allow return of allowed attributes */ + int i; + for ( i = 0; oc->soc_allowed[i] != NULL; i++ ) { + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == oc->soc_allowed[i] ) { + return 0; + } + } + } + } + + return 1; + } + if ( oc == slap_schema.si_oc_extensibleObject ) { /* extensibleObject allows the return of anything */ return 1; @@ -467,10 +662,13 @@ int ad_inlist( if( oc->soc_required ) { /* 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_required[i] ); - if( rc ) return 1; + for (a = desc->ad_type; a; a=a->sat_sup) { + if ( a == oc->soc_required[i] ) { + return 1; + } + } } } @@ -478,22 +676,21 @@ 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; + } + } } } } 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 ); } } @@ -504,52 +701,65 @@ 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 ); if( bv == NULL || bv->bv_len == 0 ) { - *text = "empty attribute description"; + *text = "empty AttributeDescription"; return LDAP_UNDEFINED_TYPE; } /* make sure description is IA5 */ if( ad_keystring( bv ) ) { - *text = "attribute description contains inappropriate characters"; + *text = "AttributeDescription contains inappropriate characters"; 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_lang.bv_val = NULL; - desc->ad_lang.bv_len = 0; + BER_BVZERO( &desc->ad_tags ); desc->ad_cname.bv_len = bv->bv_len; desc->ad_cname.bv_val = (char *)(desc+1); @@ -558,9 +768,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 ) { @@ -572,6 +790,83 @@ int slap_bv2undef_ad( return LDAP_SUCCESS; } +AttributeDescription * +slap_bv2tmp_ad( + struct berval *bv, + void *memctx ) +{ + AttributeDescription *ad = + slap_sl_mfuncs.bmf_malloc( sizeof(AttributeDescription) + + bv->bv_len + 1, memctx ); + + ad->ad_cname.bv_val = (char *)(ad+1); + strncpy( ad->ad_cname.bv_val, bv->bv_val, bv->bv_len+1 ); + ad->ad_cname.bv_len = bv->bv_len; + ad->ad_flags = SLAP_DESC_TEMPORARY; + ad->ad_type = slap_schema.si_at_undefined; + + return ad; +} + +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_type = nat; + tmp->ad_next = NULL; + /* ad_cname was contiguous, no leak here */ + tmp->ad_cname = nat->sat_cname; + *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, @@ -590,8 +885,17 @@ 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 '@' (or '+') is + * prepended, an objectclass name is searched instead; if a '!' + * is prepended, the objectclass name is negated. + * + * 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 ) @@ -604,13 +908,17 @@ str2anlist( AttributeName *an, char *in, const char *brkstr ) AttributeName *anew; /* find last element in list */ - for (i = 0; an && an[i].an_name.bv_val; i++); + i = 0; + if ( an != NULL ) { + for ( i = 0; !BER_BVISNULL( &an[ i ].an_name ) ; i++) + ; + } /* protect the input string from strtok */ str = ch_strdup( in ); /* Count words in string */ - j=1; + j = 1; for ( s = str; *s; s++ ) { if ( strchr( brkstr, *s ) != NULL ) { j++; @@ -623,24 +931,371 @@ str2anlist( AttributeName *an, char *in, const char *brkstr ) s != NULL; s = ldap_pvt_strtok( NULL, brkstr, &lasts ) ) { + /* put a stop mark */ + BER_BVZERO( &anew[1].an_name ); + anew->an_desc = NULL; anew->an_oc = NULL; + anew->an_flags = 0; 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 ) { + goto reterr; + } + } break; + + case '@': + case '+': /* (deprecated) */ + 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 ) { + goto reterr; + } + + if ( anew->an_name.bv_val[0] == '!' ) { + anew->an_flags |= SLAP_AN_OCEXCLUDE; + } + } break; + + default: + /* old (deprecated) way */ + anew->an_oc = oc_bvfind( &anew->an_name ); + if ( !anew->an_oc ) { + goto reterr; + } } } + anew->an_flags |= SLAP_AN_OCINITED; anew++; } - anew->an_name.bv_val = NULL; + BER_BVZERO( &anew->an_name ); free( str ); return( an ); + +reterr: + anlist_free( an, 1, NULL ); + + /* + * overwrites input string + * on error! + */ + strcpy( in, s ); + free( str ); + return NULL; +} + +void +anlist_free( AttributeName *an, int freename, void *ctx ) +{ + if ( an == NULL ) { + return; + } + + if ( freename ) { + int i; + + for ( i = 0; an[i].an_name.bv_val; i++ ) { + ber_memfree_x( an[i].an_name.bv_val, ctx ); + } + } + + ber_memfree_x( an, ctx ); } +char **anlist2charray_x( AttributeName *an, int dup, void *ctx ) +{ + char **attrs; + int i; + + if ( an != NULL ) { + for ( i = 0; !BER_BVISNULL( &an[i].an_name ); i++ ) + ; + attrs = (char **) slap_sl_malloc( (i + 1) * sizeof(char *), ctx ); + for ( i = 0; !BER_BVISNULL( &an[i].an_name ); i++ ) { + if ( dup ) + attrs[i] = ch_strdup( an[i].an_name.bv_val ); + else + attrs[i] = an[i].an_name.bv_val; + } + attrs[i] = NULL; + } else { + attrs = NULL; + } + + return attrs; +} + +char **anlist2charray( AttributeName *an, int dup ) +{ + return anlist2charray_x( an, dup, NULL ); +} + +char** +anlist2attrs( AttributeName * anlist ) +{ + int i, j, k = 0; + int n; + char **attrs; + ObjectClass *oc; + + 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++ ) ; + k += j; + for ( j = 0; oc->soc_allowed && oc->soc_allowed[j]; j++ ) ; + k += j; + } + } + + if ( i == 0 ) + return NULL; + + attrs = anlist2charray( anlist, 1 ); + + n = i; + + if ( k ) + attrs = (char **) ch_realloc( attrs, (i + k + 1) * sizeof( char * )); + + 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++ ) { + attrs[n++] = ch_strdup( + oc->soc_required[j]->sat_cname.bv_val ); + } + for ( j = 0; oc->soc_allowed && oc->soc_allowed[j]; j++ ) { + attrs[n++] = ch_strdup( + oc->soc_allowed[j]->sat_cname.bv_val ); + } + } + } + + if ( attrs ) + attrs[n] = NULL; + + i = 0; + while ( attrs && attrs[i] ) { + if ( *attrs[i] == '@' ) { + ch_free( attrs[i] ); + for ( j = i; attrs[j]; j++ ) { + attrs[j] = attrs[j+1]; + } + } else { + i++; + } + } + + for ( i = 0; attrs && attrs[i]; i++ ) { + j = i + 1; + while ( attrs && attrs[j] ) { + if ( !strcmp( attrs[i], attrs[j] )) { + ch_free( attrs[j] ); + for ( k = j; attrs && attrs[k]; k++ ) { + attrs[k] = attrs[k+1]; + } + } else { + j++; + } + } + } + + if ( i != n ) + attrs = (char **) ch_realloc( attrs, (i+1) * sizeof( char * )); + + return attrs; +} + +#define LBUFSIZ 80 +AttributeName* +file2anlist( AttributeName *an, const char *fname, const char *brkstr ) +{ + FILE *fp; + char *line = NULL; + char *lcur = NULL; + char *c; + size_t lmax = LBUFSIZ; + + fp = fopen( fname, "r" ); + if ( fp == NULL ) { + Debug( LDAP_DEBUG_ANY, + "get_attrs_from_file: failed to open attribute list file " + "\"%s\": %s\n", fname, strerror(errno), 0 ); + return NULL; + } + + lcur = line = (char *) ch_malloc( lmax ); + if ( !line ) { + Debug( LDAP_DEBUG_ANY, + "get_attrs_from_file: could not allocate memory\n", + 0, 0, 0 ); + fclose(fp); + return NULL; + } + + while ( fgets( lcur, LBUFSIZ, fp ) != NULL ) { + if ( ( c = strchr( lcur, '\n' ) ) ) { + if ( c == line ) { + *c = '\0'; + } else if ( *(c-1) == '\r' ) { + *(c-1) = '\0'; + } else { + *c = '\0'; + } + } else { + lmax += LBUFSIZ; + line = (char *) ch_realloc( line, lmax ); + if ( !line ) { + Debug( LDAP_DEBUG_ANY, + "get_attrs_from_file: could not allocate memory\n", + 0, 0, 0 ); + fclose(fp); + return NULL; + } + lcur = line + strlen( line ); + continue; + } + an = str2anlist( an, line, brkstr ); + if ( an == NULL ) + break; + lcur = line; + } + ch_free( line ); + fclose(fp); + return an; +} +#undef LBUFSIZ + +/* 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] ) ) { + /* allow trailing '=', same as '-' */ + if ( name[optlen] == '=' && !name[optlen+1] ) { + msad_range_hack = 1; + continue; + } + Debug( LDAP_DEBUG_ANY, + "%s: line %d: illegal option name \"%s\"\n", + fname, lineno, name ); + 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 ) ) { + Debug( LDAP_DEBUG_ANY, + "%s: line %d: option \"%s\" is already defined\n", + fname, lineno, name ); + 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] == '-') || + (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 ) { + Debug( LDAP_DEBUG_ANY, + "%s: line %d: option \"%s\" overrides previous option\n", + fname, lineno, name ); + return 1; + } + + option_count++; + 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 ) +{ + 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; +}