#define caseExactMatchOID "2.5.13.5"
#define caseExactSubstringsMatchOID "2.5.13.7"
-static char *strcasechr( const char *str, int c )
+static char *bvcasechr( struct berval *bv, int c, ber_len_t *len )
{
- char *lower = strchr( str, TOLOWER(c) );
- char *upper = strchr( str, TOUPPER(c) );
+ ber_len_t i;
+ int lower = TOLOWER( c );
+ int upper = TOUPPER( c );
- if( lower && upper ) {
- return lower < upper ? lower : upper;
- } else if ( lower ) {
- return lower;
- } else {
- return upper;
+ if( c == 0 ) return NULL;
+
+ for( i=0; i < bv->bv_len; i++ ) {
+ if( upper == bv->bv_val[i] || lower == bv->bv_val[i] ) {
+ *len = i;
+ return &bv->bv_val[i];
+ }
}
+
+ return NULL;
}
static int
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval *value = (struct berval *) assertValue;
for( count = in->bv_len; count > 0; count-=len, u+=len ) {
/* get the length indicated by the first byte */
- len = LDAP_UTF8_CHARLEN( u );
+ len = LDAP_UTF8_CHARLEN2( u, len );
- /* should not be zero */
- if( len == 0 ) return LDAP_INVALID_SYNTAX;
+ /* very basic checks */
+ switch( len ) {
+ case 6:
+ if( (u[5] & 0xC0) != 0x80 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ case 5:
+ if( (u[4] & 0xC0) != 0x80 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ case 4:
+ if( (u[3] & 0xC0) != 0x80 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ case 3:
+ if( (u[2] & 0xC0 )!= 0x80 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ case 2:
+ if( (u[1] & 0xC0) != 0x80 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ case 1:
+ /* CHARLEN already validated it */
+ break;
+ default:
+ return LDAP_INVALID_SYNTAX;
+ }
/* make sure len corresponds with the offset
to the next character */
err:
if ( nsa->sa_final.bv_val ) free( nsa->sa_final.bv_val );
- if ( nsa->sa_any )bvarray_free( nsa->sa_any );
+ if ( nsa->sa_any )ber_bvarray_free( nsa->sa_any );
if ( nsa->sa_initial.bv_val ) free( nsa->sa_initial.bv_val );
ch_free( nsa );
return NULL;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
char *val, *c;
int i,j, len, wordcount, keycount=0;
struct berval *newkeys;
- BVarray keys=NULL;
+ BerVarray keys=NULL;
for( j=0; values[j].bv_val != NULL; j++ ) {
/* Yes, this is necessary */
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
char *val, *c;
int i, count, len;
- BVarray keys;
+ BerVarray keys;
/* Yes, this is necessary */
val = UTF8normalize( ((struct berval *)assertValue),
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
- BVarray *keys;
+ BerVarray *keys;
char *s;
for( i=0; values[i].bv_val != NULL; i++ ) {
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
- BVarray keys;
+ BerVarray keys;
char *s;
keys = (struct berval *)ch_malloc( sizeof( struct berval * ) * 2 );
}
idx = p - left.bv_val;
- assert( idx < left.bv_len );
if( idx >= left.bv_len ) {
/* this shouldn't happen */
if ( sub->sa_final.bv_val )
ch_free( sub->sa_final.bv_val );
if ( sub->sa_any )
- bvarray_free( sub->sa_any );
+ ber_bvarray_free( sub->sa_any );
if ( sub->sa_initial.bv_val )
ch_free( sub->sa_initial.bv_val );
ch_free( sub );
free( nav );
if( sub != NULL ) {
if ( sub->sa_final.bv_val ) free( sub->sa_final.bv_val );
- if ( sub->sa_any ) bvarray_free( sub->sa_any );
+ if ( sub->sa_any ) ber_bvarray_free( sub->sa_any );
if ( sub->sa_initial.bv_val ) free( sub->sa_initial.bv_val );
ch_free( sub );
}
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
unsigned casefold;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
unsigned casefold;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval value;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
unsigned casefold;
ber_len_t i, nkeys;
size_t slen, mlen;
- BVarray keys;
- BVarray nvalues;
+ BerVarray keys;
+ BerVarray nvalues;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
if( nkeys == 0 ) {
/* no keys to generate */
*keysp = NULL;
- bvarray_free( nvalues );
+ ber_bvarray_free( nvalues );
return LDAP_SUCCESS;
}
*keysp = NULL;
}
- bvarray_free( nvalues );
+ ber_bvarray_free( nvalues );
return LDAP_SUCCESS;
}
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
SubstringsAssertion *sa;
char pre;
unsigned casefold;
ber_len_t nkeys = 0;
size_t slen, mlen, klen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval *value;
if( nkeys == 0 ) {
if ( sa->sa_final.bv_val ) free( sa->sa_final.bv_val );
- if ( sa->sa_any ) bvarray_free( sa->sa_any );
+ if ( sa->sa_any ) ber_bvarray_free( sa->sa_any );
if ( sa->sa_initial.bv_val ) free( sa->sa_initial.bv_val );
ch_free( sa );
*keysp = NULL;
*keysp = NULL;
}
if ( sa->sa_final.bv_val ) free( sa->sa_final.bv_val );
- if ( sa->sa_any ) bvarray_free( sa->sa_any );
+ if ( sa->sa_any ) ber_bvarray_free( sa->sa_any );
if ( sa->sa_initial.bv_val ) free( sa->sa_initial.bv_val );
ch_free( sa );
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
- BVarray keys;
+ BerVarray keys;
/* we should have at least one value at this point */
assert( values != NULL && values[0].bv_val != NULL );
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
- BVarray keys;
+ BerVarray keys;
keys = ch_malloc( sizeof( struct berval ) * 2 );
integerNormalize( syntax, assertValue, &keys[0] );
}
idx = p - left.bv_val;
- assert( idx < left.bv_len );
if( idx >= left.bv_len ) {
/* this shouldn't happen */
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval *value;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
ber_len_t i, nkeys;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
SubstringsAssertion *sa = assertValue;
char pre;
ber_len_t nkeys = 0;
size_t slen, mlen, klen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval *value;
continue;
}
- p = strcasechr( left.bv_val, *sub->sa_any[i].bv_val );
+ p = bvcasechr( &left, *sub->sa_any[i].bv_val, &idx );
if( p == NULL ) {
match = 1;
goto done;
}
- idx = p - left.bv_val;
assert( idx < left.bv_len );
-
if( idx >= left.bv_len ) {
/* this shouldn't happen */
return LDAP_OTHER;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval value;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
ber_len_t i, nkeys;
size_t slen, mlen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval digest;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
SubstringsAssertion *sa = assertValue;
char pre;
ber_len_t nkeys = 0;
size_t slen, mlen, klen;
- BVarray keys;
+ BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
struct berval value;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- BVarray values,
- BVarray *keysp )
+ BerVarray values,
+ BerVarray *keysp )
{
int i;
- BVarray keys;
+ BerVarray keys;
X509 *xcert;
unsigned char *p;
struct berval * serial;
MatchingRule *mr,
struct berval *prefix,
void * assertValue,
- BVarray *keysp )
+ BerVarray *keysp )
{
- BVarray keys;
+ BerVarray keys;
struct berval *asserted_serial;
struct berval *asserted_issuer_dn;
UTF8StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
NULL, NULL},
+#ifdef SLAPD_AUTHPASSWD
/* needs updating */
{"( 1.3.6.1.4.1.4203.666.2.2 DESC 'OpenLDAP authPassword' )",
SLAP_SYNTAX_HIDE, NULL, NULL, NULL},
+#endif
/* OpenLDAP Void Syntax */
{"( 1.3.6.1.4.1.4203.1.1.1 DESC 'OpenLDAP void' )" ,
caseExactIA5SubstringsFilter,
NULL},
+#ifdef SLAPD_AUTHPASSWD
/* needs updating */
{"( 1.3.6.1.4.1.4203.666.4.1 NAME 'authPasswordMatch' "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
NULL, NULL,
authPasswordMatch, NULL, NULL,
NULL},
+#endif
{"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
"SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
};
int
-schema_init( void )
+slap_schema_init( void )
{
int res;
int i;
);
if ( res ) {
- fprintf( stderr, "schema_init: Error registering syntax %s\n",
+ fprintf( stderr, "slap_schema_init: Error registering syntax %s\n",
syntax_defs[i].sd_desc );
return LDAP_OTHER;
}
for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
if( mrule_defs[i].mrd_usage == SLAP_MR_NONE ) {
fprintf( stderr,
- "schema_init: Ingoring unusable matching rule %s\n",
+ "slap_schema_init: Ingoring unusable matching rule %s\n",
mrule_defs[i].mrd_desc );
continue;
}
if ( res ) {
fprintf( stderr,
- "schema_init: Error registering matching rule %s\n",
+ "slap_schema_init: Error registering matching rule %s\n",
mrule_defs[i].mrd_desc );
return LDAP_OTHER;
}
}
+
+ res = slap_schema_load();
schema_init_done = 1;
- return LDAP_SUCCESS;
+ return res;
}
void