/* recycled matching routines */
#define bitStringMatch octetStringMatch
#define numericStringMatch caseIgnoreIA5Match
-#define objectIdentifierMatch caseIgnoreIA5Match
+#define objectIdentifierMatch octetStringMatch
#define telephoneNumberMatch caseIgnoreIA5Match
#define telephoneNumberSubstringsMatch caseIgnoreIA5SubstringsMatch
#define generalizedTimeMatch caseIgnoreIA5Match
}
/* Index generation function */
-static int octetStringIndexer(
+int octetStringIndexer(
slap_mask_t use,
slap_mask_t flags,
Syntax *syntax,
}
keys[i].bv_val = NULL;
+ keys[i].bv_len = 0;
*keysp = keys;
}
/* Index generation function */
-static int octetStringFilter(
+int octetStringFilter(
slap_mask_t use,
slap_mask_t flags,
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
size_t slen, mlen;
BerVarray keys;
HASH_CONTEXT HASHcontext;
unsigned char HASHdigest[HASH_BYTES];
- struct berval *value = (struct berval *) assertValue;
+ struct berval *value = (struct berval *) assertedValue;
struct berval digest;
digest.bv_val = HASHdigest;
digest.bv_len = sizeof(HASHdigest);
ber_dupbv( keys, &digest );
keys[1].bv_val = NULL;
+ keys[1].bv_len = 0;
*keysp = keys;
return LDAP_SUCCESS;
}
-static int
-nameUIDValidate(
- Syntax *syntax,
- struct berval *in )
-{
- int rc;
- struct berval dn;
-
- if( in->bv_len == 0 ) return LDAP_SUCCESS;
-
- ber_dupbv( &dn, in );
- if( !dn.bv_val ) return LDAP_OTHER;
-
- if( dn.bv_val[dn.bv_len-1] == 'B'
- && dn.bv_val[dn.bv_len-2] == '\'' )
- {
- /* assume presence of optional UID */
- ber_len_t i;
-
- for(i=dn.bv_len-3; i>1; i--) {
- if( dn.bv_val[i] != '0' && dn.bv_val[i] != '1' ) {
- break;
- }
- }
- if( dn.bv_val[i] != '\'' ||
- dn.bv_val[i-1] != '#' ) {
- ber_memfree( dn.bv_val );
- return LDAP_INVALID_SYNTAX;
- }
-
- /* trim the UID to allow use of dnValidate */
- dn.bv_val[i-1] = '\0';
- dn.bv_len = i-1;
- }
-
- rc = dnValidate( NULL, &dn );
-
- ber_memfree( dn.bv_val );
- return rc;
-}
-
-static int
-nameUIDNormalize(
- Syntax *syntax,
- struct berval *val,
- struct berval *normalized )
-{
- struct berval out;
- int rc;
-
- ber_dupbv( &out, val );
- if( out.bv_len != 0 ) {
- ber_len_t dnlen;
- char *uid = NULL;
- ber_len_t uidlen = 0;
-
- if( out.bv_val[out.bv_len-1] == '\'' ) {
- /* assume presence of optional UID */
- uid = strrchr( out.bv_val, '#' );
-
- if( uid == NULL ) {
- free( out.bv_val );
- return LDAP_INVALID_SYNTAX;
- }
-
- uidlen = out.bv_len - (uid - out.bv_val);
- /* temporarily trim the UID */
- *uid = '\0';
- out.bv_len -= uidlen;
- }
-
-#ifdef USE_DN_NORMALIZE
- rc = dnNormalize2( NULL, &out, normalized );
-#else
- rc = dnPretty2( NULL, &out, normalized );
-#endif
-
- if( rc != LDAP_SUCCESS ) {
- free( out.bv_val );
- return LDAP_INVALID_SYNTAX;
- }
-
- dnlen = normalized->bv_len;
-
- if( uidlen ) {
- struct berval b2;
- b2.bv_val = ch_malloc(dnlen + uidlen + 1);
- AC_MEMCPY( b2.bv_val, normalized->bv_val, dnlen );
-
- /* restore the separator */
- *uid = '#';
- /* shift the UID */
- AC_MEMCPY( normalized->bv_val+dnlen, uid, uidlen );
- b2.bv_len = dnlen + uidlen;
- normalized->bv_val[dnlen+uidlen] = '\0';
- free(normalized->bv_val);
- *normalized = b2;
- }
- free( out.bv_val );
- }
-
- return LDAP_SUCCESS;
-}
-
static int
inValidate(
Syntax *syntax,
struct berval *in )
{
- /* any value allowed */
- return LDAP_OTHER;
+ /* no value allowed */
+ return LDAP_INVALID_SYNTAX;
}
static int
return LDAP_SUCCESS;
}
+static int
+nameUIDValidate(
+ Syntax *syntax,
+ struct berval *in )
+{
+ int rc;
+ struct berval dn;
+
+ if( in->bv_len == 0 ) return LDAP_SUCCESS;
+
+ ber_dupbv( &dn, in );
+ if( !dn.bv_val ) return LDAP_OTHER;
+
+ if( dn.bv_val[dn.bv_len-1] == 'B'
+ && dn.bv_val[dn.bv_len-2] == '\'' )
+ {
+ /* assume presence of optional UID */
+ ber_len_t i;
+
+ for(i=dn.bv_len-3; i>1; i--) {
+ if( dn.bv_val[i] != '0' && dn.bv_val[i] != '1' ) {
+ break;
+ }
+ }
+ if( dn.bv_val[i] != '\'' || dn.bv_val[i-1] != '#' ) {
+ ber_memfree( dn.bv_val );
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ /* trim the UID to allow use of dnValidate */
+ dn.bv_val[i-1] = '\0';
+ dn.bv_len = i-1;
+ }
+
+ rc = dnValidate( NULL, &dn );
+
+ ber_memfree( dn.bv_val );
+ return rc;
+}
+
+static int
+nameUIDNormalize(
+ Syntax *syntax,
+ struct berval *val,
+ struct berval *normalized )
+{
+ struct berval out;
+ int rc;
+
+ ber_dupbv( &out, val );
+ if( out.bv_len != 0 ) {
+ struct berval uidin = { 0, NULL };
+ struct berval uidout = { 0, NULL };
+
+ if( out.bv_val[out.bv_len-1] == 'B'
+ && out.bv_val[out.bv_len-2] == '\'' )
+ {
+ /* assume presence of optional UID */
+ uidin.bv_val = strrchr( out.bv_val, '#' );
+
+ if( uidin.bv_val == NULL ) {
+ free( out.bv_val );
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ uidin.bv_len = out.bv_len - (uidin.bv_val - out.bv_val);
+ out.bv_len -= uidin.bv_len--;
+
+ /* temporarily trim the UID */
+ *(uidin.bv_val++) = '\0';
+
+ rc = bitStringNormalize( syntax, &uidin, &uidout );
+
+ if( rc != LDAP_SUCCESS ) {
+ free( out.bv_val );
+ return LDAP_INVALID_SYNTAX;
+ }
+ }
+
+#ifdef USE_DN_NORMALIZE
+ rc = dnNormalize2( NULL, &out, normalized );
+#else
+ rc = dnPretty2( NULL, &out, normalized );
+#endif
+
+ if( rc != LDAP_SUCCESS ) {
+ free( out.bv_val );
+ free( uidout.bv_val );
+ return LDAP_INVALID_SYNTAX;
+ }
+
+ if( uidout.bv_len ) {
+ normalized->bv_val = ch_realloc( normalized->bv_val,
+ normalized->bv_len + uidout.bv_len + sizeof("#") );
+
+ /* insert the separator */
+ normalized->bv_val[normalized->bv_len++] = '#';
+
+ /* append the UID */
+ AC_MEMCPY( &normalized->bv_val[normalized->bv_len],
+ uidout.bv_val, uidout.bv_len );
+ normalized->bv_len += uidout.bv_len;
+
+ /* terminate */
+ normalized->bv_val[normalized->bv_len] = '\0';
+ }
+
+ free( out.bv_val );
+ }
+
+ return LDAP_SUCCESS;
+}
+
/*
* Handling boolean syntax and matching is quite rigid.
* A more flexible approach would be to allow a variety
return LDAP_SUCCESS;
}
+/*-------------------------------------------------------------------
+LDAP/X.500 string syntax / matching rules have a few oddities. This
+comment attempts to detail how slapd(8) treats them.
+
+Summary:
+ StringSyntax X.500 LDAP Matching
+ DirectoryString CHOICE UTF8 i/e + ignore insignificant spaces
+ PrintableString subset subset i/e + ignore insignificant spaces
+ NumericString subset subset ignore all spaces
+ IA5String ASCII ASCII i/e + ignore insignificant spaces
+ TeletexString T.61 T.61 i/e + ignore insignificant spaces
+
+ TelephoneNumber subset subset i + ignore all spaces and "-"
+
+ See draft-ietf-ldapbis-strpro for details (once published).
+
+
+Directory String -
+ In X.500(93), a directory string can be either a PrintableString,
+ a bmpString, or a UniversalString (e.g., UCS (a subset of Unicode)).
+ In later versions, more CHOICEs were added. In all cases the string
+ must be non-empty.
+
+ In LDPAv3, a directory string is a UTF-8 encoded UCS string.
+
+ For matching, there are both case ignore and exact rules. Both
+ also require that "insignificant" spaces be ignored.
+ spaces before the first non-space are ignored;
+ spaces after the last non-space are ignored;
+ spaces after a space are ignored.
+ Note: by these rules (and as clarified in X.520), a string of only
+ spaces is to be treated as if held one space, not empty (which
+ would be a syntax error).
+
+NumericString
+ In ASN.1, numeric string is just a string of digits and spaces
+ and could be empty. However, in X.500, all attribute values of
+ numeric string carry a non-empty constraint. For example:
+
+ internationalISDNNumber ATTRIBUTE ::= {
+ WITH SYNTAX InternationalISDNNumber
+ EQUALITY MATCHING RULE numericStringMatch
+ SUBSTRINGS MATCHING RULE numericStringSubstringsMatch
+ ID id-at-internationalISDNNumber }
+ InternationalISDNNumber ::=
+ NumericString (SIZE(1..ub-international-isdn-number))
+
+ Unforunately, some assertion values are don't carry the same
+ constraint (but its unclear how such an assertion could ever
+ be true). In LDAP, there is one syntax (numericString) not two
+ (numericString with constraint, numericString without constraint).
+ This should be treated as numericString with non-empty constraint.
+ Note that while someone may have no ISDN number, there are no ISDN
+ numbers which are zero length.
+
+ In matching, spaces are ignored.
+
+PrintableString
+ In ASN.1, Printable string is just a string of printable characters
+ and can be empty. In X.500, semantics much like NumericString (see
+ serialNumber for a like example) excepting uses insignificant space
+ handling instead of ignore all spaces.
+
+IA5String
+ Basically same as PrintableString. There are no examples in X.500,
+ but same logic applies. So we require them to be non-empty as
+ well.
+
+-------------------------------------------------------------------*/
+
static int
UTF8StringValidate(
Syntax *syntax,
char *p, *q, *s, *e;
int len = 0;
+ /* validator should have refused an empty string */
+ assert( val->bv_len );
+
p = val->bv_val;
/* Ignore initial whitespace */
/* All space is ASCII. All ASCII is 1 byte */
for ( ; p < val->bv_val + val->bv_len && ASCII_SPACE( p[ 0 ] ); p++ );
- ber_mem2bv( p, val->bv_len - (p - val->bv_val), 1, normalized );
- e = normalized->bv_val + val->bv_len - (p - val->bv_val);
+ normalized->bv_len = val->bv_len - (p - val->bv_val);
+
+ if( !normalized->bv_len ) {
+ ber_mem2bv( " ", 1, 1, normalized );
+ return LDAP_SUCCESS;
+ }
+
+ ber_mem2bv( p, normalized->bv_len, 1, normalized );
+ e = normalized->bv_val + normalized->bv_len;
- assert( normalized->bv_len );
assert( normalized->bv_val );
p = q = normalized->bv_val;
}
}
- assert( normalized->bv_val < p );
+ assert( normalized->bv_val <= p );
assert( q+len <= p );
/* cannot start with a space */
- assert( !ASCII_SPACE(normalized->bv_val[0]) );
+ assert( !ASCII_SPACE( normalized->bv_val[0] ) );
/*
* If the string ended in space, backup the pointer one
for( i=0; sa->sa_any[i].bv_val != NULL; i++ ) {
/* empty */
}
- nsa->sa_any = (struct berval *)ch_malloc( (i + 1) * sizeof(struct berval) );
+ nsa->sa_any = (struct berval *)
+ ch_malloc( (i + 1) * sizeof(struct berval) );
+
for( i=0; sa->sa_any[i].bv_val != NULL; i++ ) {
UTF8bvnormalize( &sa->sa_any[i], &nsa->sa_any[i],
- casefold );
+ casefold );
if( nsa->sa_any[i].bv_val == NULL ) {
goto err;
}
err:
if ( nsa->sa_final.bv_val ) free( nsa->sa_final.bv_val );
- if ( nsa->sa_any )ber_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;
}
/* Yes, this is necessary */
- assertv = UTF8bvnormalize( ((struct berval *)assertedValue), NULL, LDAP_UTF8_APPROX );
+ assertv = UTF8bvnormalize( ((struct berval *)assertedValue),
+ NULL, LDAP_UTF8_APPROX );
if( assertv == NULL ) {
ber_bvfree( nval );
*matchp = 1;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
char *c;
BerVarray keys;
/* Yes, this is necessary */
- val = UTF8bvnormalize( ((struct berval *)assertValue), NULL, LDAP_UTF8_APPROX );
+ val = UTF8bvnormalize( ((struct berval *)assertedValue),
+ NULL, LDAP_UTF8_APPROX );
if( val == NULL || val->bv_val == NULL ) {
keys = (struct berval *)ch_malloc( sizeof(struct berval) );
keys[0].bv_val = NULL;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
BerVarray keys;
keys = (struct berval *)ch_malloc( sizeof( struct berval * ) * 2 );
/* Yes, this is necessary */
- s = UTF8normalize( ((struct berval *)assertValue),
+ s = UTF8normalize( ((struct berval *)assertedValue),
UTF8_NOCASEFOLD );
if( s == NULL ) {
keys[0] = NULL;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
unsigned casefold;
casefold = ( mr != caseExactMatchingRule )
? LDAP_UTF8_CASEFOLD : LDAP_UTF8_NOCASEFOLD;
- UTF8bvnormalize( (struct berval *) assertValue, &value, casefold );
+ UTF8bvnormalize( (struct berval *) assertedValue, &value, casefold );
/* This usually happens if filter contains bad UTF8 */
if( value.bv_val == NULL ) {
keys = ch_malloc( sizeof( struct berval ) );
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
SubstringsAssertion *sa;
casefold = ( mr != caseExactSubstringsMatchingRule )
? LDAP_UTF8_CASEFOLD : LDAP_UTF8_NOCASEFOLD;
- sa = UTF8SubstringsassertionNormalize( assertValue, casefold );
+ sa = UTF8SubstringsassertionNormalize( assertedValue, casefold );
if( sa == NULL ) {
*keysp = NULL;
return LDAP_SUCCESS;
{
char *p, *q;
+ /* validator should have refused an empty string */
+ assert( val->bv_len );
+
q = normalized->bv_val = ch_malloc( val->bv_len + 1 );
- for( p = val->bv_val; *p; p++ )
- if ( ! ( ASCII_SPACE( *p ) || *p == '-' ))
+ for( p = val->bv_val; *p; p++ ) {
+ if ( ! ( ASCII_SPACE( *p ) || *p == '-' )) {
*q++ = *p;
+ }
+ }
*q = '\0';
normalized->bv_len = q - normalized->bv_val;
+ if( normalized->bv_len == 0 ) {
+ free( normalized->bv_val );
+ return LDAP_INVALID_SYNTAX;
+ }
+
return LDAP_SUCCESS;
}
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
size_t slen, mlen;
slen = syntax->ssyn_oidlen;
mlen = mr->smr_oidlen;
- integerNormalize( syntax, assertValue, &norm );
+ integerNormalize( syntax, assertedValue, &norm );
keys = ch_malloc( sizeof( struct berval ) * 2 );
{
ber_len_t i;
+ if( val->bv_len == 0 ) return LDAP_INVALID_SYNTAX;
+
for(i=0; i < val->bv_len; i++) {
if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
return LDAP_INVALID_SYNTAX;
Syntax *syntax,
struct berval *val )
{
- ber_len_t i;
+ ber_len_t i, len;
- for(i=0; i < val->bv_len; i++) {
- if( !SLAP_PRINTABLES(val->bv_val[i]) ) {
+ if( val->bv_len == 0 ) return LDAP_INVALID_SYNTAX;
+
+ for(i=0,len=0; i < val->bv_len; i++) {
+ int c = val->bv_val[i];
+
+ if( c == '$' ) {
+ if( len == 0 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+ len = 0;
+
+ } else if ( SLAP_PRINTABLE(c) ) {
+ len++;
+ } else {
return LDAP_INVALID_SYNTAX;
}
}
+ if( len == 0 ) {
+ return LDAP_INVALID_SYNTAX;
+ }
+
return LDAP_SUCCESS;
}
{
ber_len_t i;
+ if( val->bv_len == 0 ) return LDAP_INVALID_SYNTAX;
+
for(i=0; i < val->bv_len; i++) {
if( !LDAP_ASCII(val->bv_val[i]) ) {
return LDAP_INVALID_SYNTAX;
{
char *p, *q;
+ assert( val->bv_len );
+
p = val->bv_val;
/* Ignore initial whitespace */
normalized->bv_len = q - normalized->bv_val;
+ if( normalized->bv_len == 0 ) {
+ normalized->bv_val = ch_realloc( normalized->bv_val, 2 );
+ normalized->bv_val[0] = ' ';
+ normalized->bv_val[1] = '\0';
+ normalized->bv_len = 1;
+ }
+
return LDAP_SUCCESS;
}
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
size_t slen, mlen;
slen = syntax->ssyn_oidlen;
mlen = mr->smr_oidlen;
- value = (struct berval *) assertValue;
+ value = (struct berval *) assertedValue;
keys = ch_malloc( sizeof( struct berval ) * 2 );
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
- SubstringsAssertion *sa = assertValue;
+ SubstringsAssertion *sa = assertedValue;
char pre;
ber_len_t nkeys = 0;
size_t slen, mlen, klen;
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
size_t slen, mlen;
slen = syntax->ssyn_oidlen;
mlen = mr->smr_oidlen;
- ber_dupbv( &value, (struct berval *) assertValue );
+ ber_dupbv( &value, (struct berval *) assertedValue );
ldap_pvt_str2lower( value.bv_val );
keys = ch_malloc( sizeof( struct berval ) * 2 );
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
- SubstringsAssertion *sa = assertValue;
+ SubstringsAssertion *sa = assertedValue;
char pre;
ber_len_t nkeys = 0;
size_t slen, mlen, klen;
{
ber_len_t i;
+ if( in->bv_len == 0 ) return LDAP_INVALID_SYNTAX;
+
for(i=0; i < in->bv_len; i++) {
if( !SLAP_NUMERIC(in->bv_val[i]) ) {
return LDAP_INVALID_SYNTAX;
/* removal all spaces */
char *p, *q;
+ assert( val->bv_len );
+
normalized->bv_val = ch_malloc( val->bv_len + 1 );
p = val->bv_val;
normalized->bv_len = q - normalized->bv_val;
+ if( normalized->bv_len == 0 ) {
+ normalized->bv_val = ch_realloc( normalized->bv_val, 2 );
+ normalized->bv_val[0] = ' ';
+ normalized->bv_val[1] = '\0';
+ normalized->bv_len = 1;
+ }
+
return LDAP_SUCCESS;
}
}
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
- match, value->bv_val, asserted->bv_val ));
+ LDAP_LOG( CONFIG, ENTRY,
+ "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
+ match, value->bv_val, asserted->bv_val );
#else
Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
"%d\n\t\"%s\"\n\t\"%s\"\n",
xcert = d2i_X509(NULL, &p, in->bv_len);
if ( !xcert ) {
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactConvert: error parsing cert: %s\n",
- ERR_error_string(ERR_get_error(),NULL)));
+ LDAP_LOG( CONFIG, ENTRY,
+ "certificateExactConvert: error parsing cert: %s\n",
+ ERR_error_string(ERR_get_error(),NULL), 0, 0 );
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactConvert: "
"error parsing cert: %s\n",
*p++ = '\0';
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactConvert: \n %s\n",
- out->bv_val));
+ LDAP_LOG( CONFIG, ARGS,
+ "certificateExactConvert: \n %s\n", out->bv_val, 0, 0 );
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactConvert "
"\n\t\"%s\"\n",
xcert = d2i_X509(NULL, &p, value->bv_len);
if ( !xcert ) {
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactMatch: error parsing cert: %s\n",
- ERR_error_string(ERR_get_error(),NULL)));
+ LDAP_LOG( CONFIG, ENTRY,
+ "certificateExactMatch: error parsing cert: %s\n",
+ ERR_error_string(ERR_get_error(),NULL), 0, 0 );
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactMatch: "
"error parsing cert: %s\n",
}
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactMatch: %d\n %s $ %s\n %s $ %s\n",
- *matchp, serial.bv_val, issuer_dn.bv_val,
- asserted_serial.bv_val, asserted_issuer_dn.bv_val));
+ LDAP_LOG( CONFIG, ARGS, "certificateExactMatch "
+ "%d\n\t\"%s $ %s\"\n",
+ *matchp, serial.bv_val, issuer_dn.bv_val );
+ LDAP_LOG( CONFIG, ARGS, "\t\"%s $ %s\"\n",
+ asserted_serial.bv_val, asserted_issuer_dn.bv_val,
+ 0 );
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactMatch "
"%d\n\t\"%s $ %s\"\n",
xcert = d2i_X509(NULL, &p, values[i].bv_len);
if ( !xcert ) {
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactIndexer: error parsing cert: %s\n",
- ERR_error_string(ERR_get_error(),NULL)));
+ LDAP_LOG( CONFIG, ENTRY,
+ "certificateExactIndexer: error parsing cert: %s\n",
+ ERR_error_string(ERR_get_error(),NULL), 0, 0);
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactIndexer: "
"error parsing cert: %s\n",
&keys[i] );
ber_memfree(serial.bv_val);
#ifdef NEW_LOGGING
- LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
- "certificateExactIndexer: returning: %s\n",
- keys[i].bv_val));
+ LDAP_LOG( CONFIG, ENTRY,
+ "certificateExactIndexer: returning: %s\n", keys[i].bv_val, 0, 0);
#else
Debug( LDAP_DEBUG_ARGS, "certificateExactIndexer: "
"returning: %s\n",
Syntax *syntax,
MatchingRule *mr,
struct berval *prefix,
- void * assertValue,
+ void * assertedValue,
BerVarray *keysp )
{
BerVarray keys;
struct berval asserted_serial;
- serial_and_issuer_parse(assertValue,
+ serial_and_issuer_parse(assertedValue,
&asserted_serial,
NULL);
return LDAP_INVALID_SYNTAX;
}
- } else if ( !ATTR_CHAR( *p ) ) {
+ } else if ( !AD_CHAR( *p ) ) {
return LDAP_INVALID_SYNTAX;
}
}
/* key */
for (; ( p < e ) && ( *p != '=' ); p++ ) {
- if ( !ATTR_CHAR( *p ) ) {
+ if ( !AD_CHAR( *p ) ) {
return LDAP_INVALID_SYNTAX;
}
}
/* server */
for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
- if ( !ATTR_CHAR( *p ) ) {
+ if ( !AD_CHAR( *p ) ) {
return LDAP_INVALID_SYNTAX;
}
}
/* path */
for ( p++; p < e; p++ ) {
- if ( !ATTR_CHAR( *p ) ) {
+ if ( !SLAP_PRINTABLE( *p ) ) {
return LDAP_INVALID_SYNTAX;
}
}
return LDAP_SUCCESS;
}
-static struct syntax_defs_rec {
- char *sd_desc;
#define X_BINARY "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
#define X_NOT_H_R "X-NOT-HUMAN-READABLE 'TRUE' "
- int sd_flags;
- slap_syntax_validate_func *sd_validate;
- slap_syntax_transform_func *sd_normalize;
- slap_syntax_transform_func *sd_pretty;
-#ifdef SLAPD_BINARY_CONVERSION
- slap_syntax_transform_func *sd_ber2str;
- slap_syntax_transform_func *sd_str2ber;
-#endif
-} syntax_defs[] = {
+
+static slap_syntax_defs_rec syntax_defs[] = {
{"( 1.3.6.1.4.1.1466.115.121.1.1 DESC 'ACI Item' "
X_BINARY X_NOT_H_R ")",
SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, NULL, NULL, NULL},
* 2.5.13.43 readerAndKeyIDMatch
* 2.5.13.44 attributeIntegrityMatch
*/
-static struct mrule_defs_rec {
- char * mrd_desc;
- slap_mask_t mrd_usage;
- slap_mr_convert_func * mrd_convert;
- slap_mr_normalize_func * mrd_normalize;
- slap_mr_match_func * mrd_match;
- slap_mr_indexer_func * mrd_indexer;
- slap_mr_filter_func * mrd_filter;
-
- char * mrd_associated;
-} mrule_defs[] = {
+static slap_mrule_defs_rec mrule_defs[] = {
/*
* EQUALITY matching rules must be listed after associated APPROX
* matching rules. So, we list all APPROX matching rules first.
slap_schema_init( void )
{
int res;
- int i;
+ int i = 0;
/* we should only be called once (from main) */
assert( schema_init_done == 0 );
for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
- res = register_syntax( syntax_defs[i].sd_desc,
- syntax_defs[i].sd_flags,
- syntax_defs[i].sd_validate,
- syntax_defs[i].sd_normalize,
- syntax_defs[i].sd_pretty
-#ifdef SLAPD_BINARY_CONVERSION
- ,
- syntax_defs[i].sd_ber2str,
- syntax_defs[i].sd_str2ber
-#endif
- );
+ res = register_syntax( &syntax_defs[i] );
if ( res ) {
fprintf( stderr, "slap_schema_init: Error registering syntax %s\n",
continue;
}
- res = register_matching_rule(
- mrule_defs[i].mrd_desc,
- mrule_defs[i].mrd_usage,
- mrule_defs[i].mrd_convert,
- mrule_defs[i].mrd_normalize,
- mrule_defs[i].mrd_match,
- mrule_defs[i].mrd_indexer,
- mrule_defs[i].mrd_filter,
- mrule_defs[i].mrd_associated );
+ res = register_matching_rule( &mrule_defs[i] );
if ( res ) {
fprintf( stderr,