X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fad.c;h=5b264409754484dec79e07c86934adcddacfe5ae;hb=20965abe9c5bb80d79e5ad791cd2b59ec60259b5;hp=360da3ca94fe61d7b21ebc8fb53bc16d36517357;hpb=65760c064ebd9f62048593dca1945d6344651196;p=openldap diff --git a/servers/slapd/ad.c b/servers/slapd/ad.c index 360da3ca94..5b26440975 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-2004 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,15 +24,54 @@ #include #include -#include "ldap_pvt.h" #include "slap.h" +#include "lutil.h" + +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; + +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 ) { ber_len_t i; - if( !AD_CHAR( bv->bv_val[0] ) ) { + if( !AD_LEADCHAR( bv->bv_val[0] ) ) { return 1; } @@ -45,18 +93,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,26 +150,26 @@ int slap_bv2ad( AttributeDescription desc, *d2; char *name, *options; 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; } @@ -147,9 +195,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; @@ -178,17 +226,15 @@ 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; + 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 +242,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 + ? 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 +281,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 +330,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 +346,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; + dlen += sizeof(";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; - } - 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; + 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( 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 +436,30 @@ 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; + const char *subtags, *subp, *subdelimp; 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; - sublang =sublangbv->bv_val; - suplang =suplangbv->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; } @@ -403,24 +476,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,25 +508,117 @@ 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 + * else if requested description is !objectClass, return + * attributes which the class does not require/allow */ 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 '@': /* @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 ); + attrs->an_oc_exclude = 0; + if ( oc && attrs->an_name.bv_val[0] == '!' ) { + attrs->an_oc_exclude = 1; + } + } break; + + default: /* old (deprecated) way */ + oc = oc_bvfind( &attrs->an_name ); + } attrs->an_oc = oc; } if( oc != NULL ) { + if ( attrs->an_oc_exclude ) { + int gotit = 0; + + 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; @@ -457,10 +627,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; + } + } } } @@ -468,9 +641,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; + } + } } } @@ -513,13 +688,13 @@ int slap_bv2undef_ad( 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; } @@ -538,8 +713,8 @@ int slap_bv2undef_ad( 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); @@ -580,8 +755,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 ) @@ -608,6 +792,7 @@ str2anlist( AttributeName *an, char *in, const char *brkstr ) } an = ch_realloc( an, ( i + j + 1 ) * sizeof( AttributeName ) ); + BER_BVZERO( &an[i + j].an_name ); anew = an + i; for ( s = ldap_pvt_strtok( str, brkstr, &lasts ); s != NULL; @@ -615,22 +800,335 @@ str2anlist( AttributeName *an, char *in, const char *brkstr ) { anew->an_desc = NULL; anew->an_oc = NULL; + anew->an_oc_exclude = 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_oc_exclude = 1; + } + } break; + + default: + /* old (deprecated) way */ + anew->an_oc = oc_bvfind( &anew->an_name ); + if ( !anew->an_oc ) { + goto reterr; + } } } anew++; } - anew->an_name.bv_val = NULL; + anew->an_name.bv_val = NULL; free( str ); return( an ); + +reterr: + for ( i = 0; an[i].an_name.bv_val; i++ ) { + free( an[i].an_name.bv_val ); + } + free( an ); + /* + * overwrites input string + * on error! + */ + strcpy( in, s ); + free( str ); + return NULL; +} + +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; + + attrs = anlist2charray( anlist, 1 ); + + 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; + + 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] == '@' ) { + for ( j = i; attrs[j]; j++ ) { + if ( j == i ) + ch_free( attrs[i] ); + 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] )) { + for ( k = j; attrs && attrs[k]; k++ ) { + if ( k == j ) + ch_free( attrs[j] ); + 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 ) { + char *str, *s, *next; + const char *delimstr = brkstr; + 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 ) + return NULL; + 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] ) ) { + 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] == '-'); + + 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; +} + +/* 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; +}