/* $OpenLDAP$ */
/* This work is part of OpenLDAP Software <http://www.openldap.org/>.
*
- * Copyright 1998-2004 The OpenLDAP Foundation.
+ * Copyright 1998-2007 The OpenLDAP Foundation.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
}
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;
}
{
int rtn = LDAP_UNDEFINED_TYPE;
AttributeDescription desc, *d2;
- char *name, *options;
+ char *name, *options, *optn;
char *opt, *next;
int ntags;
int tagslen;
}
/* 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 ) {
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";
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) */
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);
}
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
for( ; attrs->an_name.bv_val; attrs++ ) {
AttributeType *a;
ObjectClass *oc;
- int rc;
if ( attrs->an_desc ) {
int lr;
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
}
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;
}
} 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 );
}
}
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 );
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);
/* 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 ) {
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,
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++;
}
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;
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_oc_exclude = 0;
anew++;
}
- anew->an_name.bv_val = NULL;
+ BER_BVZERO( &anew->an_name );
free( str );
return( an );
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 ) {
+ 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++ ) ;
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 ) {
+ 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 );
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 {
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 {
}
while ( fgets( lcur, LBUFSIZ, fp ) != NULL ) {
- char *str, *s, *next;
- const char *delimstr = brkstr;
- if (c = strchr( lcur, '\n' )) {
+ if ( ( c = strchr( lcur, '\n' ) ) ) {
if ( c == line ) {
*c = '\0';
} else if ( *(c-1) == '\r' ) {
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 )