1 /* schema_init.c - init builtin schema */
4 * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
5 * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
13 #include <ac/string.h>
14 #include <ac/socket.h>
19 #include "ldap_utf8.h"
21 #include "lutil_hash.h"
22 /* We should replace MD5 with a faster hash */
23 #define HASH_BYTES LUTIL_HASH_BYTES
24 #define HASH_CONTEXT lutil_HASH_CTX
25 #define HASH_Init(c) lutil_HASHInit(c)
26 #define HASH_Update(c,buf,len) lutil_HASHUpdate(c,buf,len)
27 #define HASH_Final(d,c) lutil_HASHFinal(d,c)
29 /* recycled validatation routines */
30 #define berValidate blobValidate
32 /* unimplemented pretters */
34 #define integerPretty NULL
36 /* recycled matching routines */
37 #define bitStringMatch octetStringMatch
38 #define integerMatch caseIgnoreIA5Match
39 #define numericStringMatch caseIgnoreIA5Match
40 #define objectIdentifierMatch caseIgnoreIA5Match
41 #define telephoneNumberMatch caseIgnoreIA5Match
42 #define telephoneNumberSubstringsMatch caseIgnoreIA5SubstringsMatch
43 #define generalizedTimeMatch caseIgnoreIA5Match
44 #define generalizedTimeOrderingMatch caseIgnoreIA5Match
45 #define uniqueMemberMatch dnMatch
47 /* approx matching rules */
48 #define directoryStringApproxMatchOID "1.3.6.1.4.1.4203.666.4.4"
49 #define directoryStringApproxMatch approxMatch
50 #define directoryStringApproxIndexer approxIndexer
51 #define directoryStringApproxFilter approxFilter
52 #define IA5StringApproxMatchOID "1.3.6.1.4.1.4203.666.4.5"
53 #define IA5StringApproxMatch approxMatch
54 #define IA5StringApproxIndexer approxIndexer
55 #define IA5StringApproxFilter approxFilter
57 /* orderring matching rules */
58 #define caseIgnoreOrderingMatch caseIgnoreMatch
59 #define caseExactOrderingMatch caseExactMatch
61 /* unimplemented matching routines */
62 #define caseIgnoreListMatch NULL
63 #define caseIgnoreListSubstringsMatch NULL
64 #define protocolInformationMatch NULL
65 #define integerFirstComponentMatch NULL
67 #define OpenLDAPaciMatch NULL
68 #define authPasswordMatch NULL
70 /* recycled indexing/filtering routines */
71 #define dnIndexer caseIgnoreIndexer
72 #define dnFilter caseIgnoreFilter
73 #define integerIndexer caseIgnoreIA5Indexer
74 #define integerFilter caseIgnoreIA5Filter
76 #define telephoneNumberIndexer caseIgnoreIA5Indexer
77 #define telephoneNumberFilter caseIgnoreIA5Filter
78 #define telephoneNumberSubstringsIndexer caseIgnoreIA5SubstringsIndexer
79 #define telephoneNumberSubstringsFilter caseIgnoreIA5SubstringsFilter
81 static char *strcasechr( const char *str, int c )
83 char *lower = strchr( str, TOLOWER(c) );
84 char *upper = strchr( str, TOUPPER(c) );
86 if( lower && upper ) {
87 return lower < upper ? lower : upper;
101 struct berval *value,
102 void *assertedValue )
104 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
107 match = memcmp( value->bv_val,
108 ((struct berval *) assertedValue)->bv_val,
116 /* Index generation function */
117 int octetStringIndexer(
122 struct berval *prefix,
123 struct berval **values,
124 struct berval ***keysp )
128 struct berval **keys;
129 HASH_CONTEXT HASHcontext;
130 unsigned char HASHdigest[HASH_BYTES];
131 struct berval digest;
132 digest.bv_val = HASHdigest;
133 digest.bv_len = sizeof(HASHdigest);
135 for( i=0; values[i] != NULL; i++ ) {
136 /* just count them */
139 /* we should have at least one value at this point */
142 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
144 slen = strlen( syntax->ssyn_oid );
145 mlen = strlen( mr->smr_oid );
147 for( i=0; values[i] != NULL; i++ ) {
148 HASH_Init( &HASHcontext );
149 if( prefix != NULL && prefix->bv_len > 0 ) {
150 HASH_Update( &HASHcontext,
151 prefix->bv_val, prefix->bv_len );
153 HASH_Update( &HASHcontext,
154 syntax->ssyn_oid, slen );
155 HASH_Update( &HASHcontext,
157 HASH_Update( &HASHcontext,
158 values[i]->bv_val, values[i]->bv_len );
159 HASH_Final( HASHdigest, &HASHcontext );
161 keys[i] = ber_bvdup( &digest );
171 /* Index generation function */
172 int octetStringFilter(
177 struct berval *prefix,
179 struct berval ***keysp )
182 struct berval **keys;
183 HASH_CONTEXT HASHcontext;
184 unsigned char HASHdigest[HASH_BYTES];
185 struct berval *value = (struct berval *) assertValue;
186 struct berval digest;
187 digest.bv_val = HASHdigest;
188 digest.bv_len = sizeof(HASHdigest);
190 slen = strlen( syntax->ssyn_oid );
191 mlen = strlen( mr->smr_oid );
193 keys = ch_malloc( sizeof( struct berval * ) * 2 );
195 HASH_Init( &HASHcontext );
196 if( prefix != NULL && prefix->bv_len > 0 ) {
197 HASH_Update( &HASHcontext,
198 prefix->bv_val, prefix->bv_len );
200 HASH_Update( &HASHcontext,
201 syntax->ssyn_oid, slen );
202 HASH_Update( &HASHcontext,
204 HASH_Update( &HASHcontext,
205 value->bv_val, value->bv_len );
206 HASH_Final( HASHdigest, &HASHcontext );
208 keys[0] = ber_bvdup( &digest );
224 if( in->bv_len == 0 ) return LDAP_SUCCESS;
226 dn = ch_strdup( in->bv_val );
229 return LDAP_INVALID_SYNTAX;
231 } else if ( strlen( in->bv_val ) != in->bv_len ) {
232 rc = LDAP_INVALID_SYNTAX;
234 } else if ( dn_validate( dn ) == NULL ) {
235 rc = LDAP_INVALID_SYNTAX;
249 struct berval **normalized )
253 if ( val->bv_len != 0 ) {
255 out = ber_bvstr( UTF8normalize( val->bv_val, UTF8_CASEFOLD ) );
257 dn = dn_validate( out->bv_val );
261 return LDAP_INVALID_SYNTAX;
265 out->bv_len = strlen( dn );
267 out = ber_bvdup( val );
280 struct berval *value,
281 void *assertedValue )
284 struct berval *asserted = (struct berval *) assertedValue;
286 match = value->bv_len - asserted->bv_len;
289 #ifdef USE_DN_NORMALIZE
290 match = strcmp( value->bv_val, asserted->bv_val );
292 match = strcasecmp( value->bv_val, asserted->bv_val );
297 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
298 "dnMatch: %d\n %s\n %s\n", match,
299 value->bv_val, asserted->bv_val ));
301 Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
302 match, value->bv_val, asserted->bv_val );
318 if( in->bv_len == 0 ) return LDAP_SUCCESS;
320 dn = ber_bvdup( in );
322 if( dn->bv_val[dn->bv_len-1] == '\'' ) {
323 /* assume presence of optional UID */
326 for(i=dn->bv_len-2; i>2; i--) {
327 if( dn->bv_val[i] != '0' && dn->bv_val[i] != '1' ) {
331 if( dn->bv_val[i] != '\'' ) {
332 return LDAP_INVALID_SYNTAX;
334 if( dn->bv_val[i-1] != 'B' ) {
335 return LDAP_INVALID_SYNTAX;
337 if( dn->bv_val[i-2] != '#' ) {
338 return LDAP_INVALID_SYNTAX;
341 /* trim the UID to allow use of dn_validate */
342 dn->bv_val[i-2] = '\0';
345 rc = dn_validate( dn->bv_val ) == NULL
346 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
356 struct berval **normalized )
358 struct berval *out = ber_bvdup( val );
360 if( out->bv_len != 0 ) {
364 ber_len_t uidlen = 0;
366 if( out->bv_val[out->bv_len-1] == '\'' ) {
367 /* assume presence of optional UID */
368 uid = strrchr( out->bv_val, '#' );
372 return LDAP_INVALID_SYNTAX;
375 uidlen = out->bv_len - (out->bv_val - uid);
376 /* temporarily trim the UID */
380 #ifdef USE_DN_NORMALIZE
381 dn = dn_normalize( out->bv_val );
383 dn = dn_validate( out->bv_val );
388 return LDAP_INVALID_SYNTAX;
394 /* restore the separator */
397 SAFEMEMCPY( &dn[dnlen], uid, uidlen );
401 out->bv_len = dnlen + uidlen;
413 /* any value allowed */
422 /* any value allowed */
433 /* very unforgiving validation, requires no normalization
434 * before simplistic matching
436 if( in->bv_len < 3 ) {
437 return LDAP_INVALID_SYNTAX;
440 if( in->bv_val[0] != 'B' ||
441 in->bv_val[1] != '\'' ||
442 in->bv_val[in->bv_len-1] != '\'' )
444 return LDAP_INVALID_SYNTAX;
447 for( i=in->bv_len-2; i>1; i-- ) {
448 if( in->bv_val[i] != '0' && in->bv_val[i] != '1' ) {
449 return LDAP_INVALID_SYNTAX;
457 * Handling boolean syntax and matching is quite rigid.
458 * A more flexible approach would be to allow a variety
459 * of strings to be normalized and prettied into TRUE
467 /* very unforgiving validation, requires no normalization
468 * before simplistic matching
471 if( in->bv_len == 4 ) {
472 if( !memcmp( in->bv_val, "TRUE", 4 ) ) {
475 } else if( in->bv_len == 5 ) {
476 if( !memcmp( in->bv_val, "FALSE", 5 ) ) {
481 return LDAP_INVALID_SYNTAX;
490 struct berval *value,
491 void *assertedValue )
493 /* simplistic matching allowed by rigid validation */
494 struct berval *asserted = (struct berval *) assertedValue;
495 *matchp = value->bv_len != asserted->bv_len;
506 unsigned char *u = in->bv_val;
508 if( !in->bv_len ) return LDAP_INVALID_SYNTAX;
510 for( count = in->bv_len; count > 0; count-=len, u+=len ) {
511 /* get the length indicated by the first byte */
512 len = LDAP_UTF8_CHARLEN( u );
514 /* should not be zero */
515 if( len == 0 ) return LDAP_INVALID_SYNTAX;
517 /* make sure len corresponds with the offset
518 to the next character */
519 if( LDAP_UTF8_OFFSET( u ) != len ) return LDAP_INVALID_SYNTAX;
522 if( count != 0 ) return LDAP_INVALID_SYNTAX;
531 struct berval **normalized )
533 struct berval *newval;
536 newval = ch_malloc( sizeof( struct berval ) );
540 /* Ignore initial whitespace */
541 while ( ldap_utf8_isspace( p ) ) {
547 return LDAP_INVALID_SYNTAX;
550 newval->bv_val = ch_strdup( p );
551 p = q = newval->bv_val;
557 if ( ldap_utf8_isspace( p ) ) {
558 len = LDAP_UTF8_COPY(q,p);
563 /* Ignore the extra whitespace */
564 while ( ldap_utf8_isspace( p ) ) {
568 len = LDAP_UTF8_COPY(q,p);
575 assert( *newval->bv_val );
576 assert( newval->bv_val < p );
579 /* cannot start with a space */
580 assert( !ldap_utf8_isspace(newval->bv_val) );
583 * If the string ended in space, backup the pointer one
584 * position. One is enough because the above loop collapsed
585 * all whitespace to a single space.
592 /* cannot end with a space */
593 assert( !ldap_utf8_isspace( LDAP_UTF8_PREV(q) ) );
598 newval->bv_len = q - newval->bv_val;
599 *normalized = newval;
604 /* Returns Unicode cannonically normalized copy of a substring assertion
605 * Skipping attribute description */
606 SubstringsAssertion *
607 UTF8SubstringsassertionNormalize(
608 SubstringsAssertion *sa,
611 SubstringsAssertion *nsa;
614 nsa = (SubstringsAssertion *)ch_calloc( 1, sizeof(SubstringsAssertion) );
619 if( sa->sa_initial != NULL ) {
620 nsa->sa_initial = ber_bvstr( UTF8normalize( sa->sa_initial->bv_val, casefold ) );
621 if( nsa->sa_initial == NULL ) {
626 if( sa->sa_any != NULL ) {
627 for( i=0; sa->sa_any[i] != NULL; i++ ) {
630 nsa->sa_any = (struct berval **)ch_malloc( (i + 1) * sizeof(struct berval *) );
631 for( i=0; sa->sa_any[i] != NULL; i++ ) {
632 nsa->sa_any[i] = ber_bvstr( UTF8normalize( sa->sa_any[i]->bv_val, casefold ) );
633 if( nsa->sa_any[i] == NULL ) {
637 nsa->sa_any[i] = NULL;
640 if( sa->sa_final != NULL ) {
641 nsa->sa_final = ber_bvstr( UTF8normalize( sa->sa_final->bv_val, casefold ) );
642 if( nsa->sa_final == NULL ) {
650 ch_free( nsa->sa_final );
651 ber_bvecfree( nsa->sa_any );
652 ch_free( nsa->sa_initial );
657 /* Strip characters with the 8th bit set */
670 while( *++q & 0x80 ) {
673 p = memmove(p, q, strlen(q) + 1);
681 #ifndef SLAPD_APPROX_OLDSINGLESTRING
683 #if defined(SLAPD_APPROX_INITIALS)
684 #define SLAPD_APPROX_DELIMITER "._ "
685 #define SLAPD_APPROX_WORDLEN 2
687 #define SLAPD_APPROX_DELIMITER " "
688 #define SLAPD_APPROX_WORDLEN 1
697 struct berval *value,
698 void *assertedValue )
700 char *val, *assertv, **values, **words, *c;
701 int i, count, len, nextchunk=0, nextavail=0;
704 /* Yes, this is necessary */
705 val = UTF8normalize( value->bv_val, UTF8_NOCASEFOLD );
710 strip8bitChars( val );
712 /* Yes, this is necessary */
713 assertv = UTF8normalize( ((struct berval *)assertedValue)->bv_val,
715 if( assertv == NULL ) {
720 strip8bitChars( assertv );
721 avlen = strlen( assertv );
723 /* Isolate how many words there are */
724 for( c=val,count=1; *c; c++ ) {
725 c = strpbrk( c, SLAPD_APPROX_DELIMITER );
726 if ( c == NULL ) break;
731 /* Get a phonetic copy of each word */
732 words = (char **)ch_malloc( count * sizeof(char *) );
733 values = (char **)ch_malloc( count * sizeof(char *) );
734 for( c=val,i=0; i<count; i++,c+=strlen(c)+1 ) {
736 values[i] = phonetic(c);
739 /* Work through the asserted value's words, to see if at least some
740 of the words are there, in the same order. */
742 while ( nextchunk < avlen ) {
743 len = strcspn( assertv + nextchunk, SLAPD_APPROX_DELIMITER);
748 #if defined(SLAPD_APPROX_INITIALS)
749 else if( len == 1 ) {
750 /* Single letter words need to at least match one word's initial */
751 for( i=nextavail; i<count; i++ )
752 if( !strncasecmp( assertv+nextchunk, words[i], 1 )) {
759 /* Isolate the next word in the asserted value and phonetic it */
760 assertv[nextchunk+len] = '\0';
761 val = phonetic( assertv + nextchunk );
763 /* See if this phonetic chunk is in the remaining words of *value */
764 for( i=nextavail; i<count; i++ ){
765 if( !strcmp( val, values[i] ) ){
772 /* This chunk in the asserted value was NOT within the *value. */
778 /* Go on to the next word in the asserted value */
782 /* If some of the words were seen, call it a match */
783 if( nextavail > 0 ) {
792 for( i=0; i<count; i++ ) {
793 ch_free( values[i] );
808 struct berval *prefix,
809 struct berval **values,
810 struct berval ***keysp )
813 int i,j, len, wordcount, keycount=0;
814 struct berval **newkeys, **keys=NULL;
816 for( j=0; values[j] != NULL; j++ ) {
817 /* Yes, this is necessary */
818 val = UTF8normalize( values[j]->bv_val, UTF8_NOCASEFOLD );
819 strip8bitChars( val );
821 /* Isolate how many words there are. There will be a key for each */
822 for( wordcount=0,c=val; *c; c++) {
823 len = strcspn(c, SLAPD_APPROX_DELIMITER);
824 if( len >= SLAPD_APPROX_WORDLEN ) wordcount++;
826 if (*c == '\0') break;
830 /* Allocate/increase storage to account for new keys */
831 newkeys = (struct berval **)ch_malloc( (keycount + wordcount + 1)
832 * sizeof(struct berval *) );
833 memcpy( newkeys, keys, keycount * sizeof(struct berval *) );
834 if( keys ) ch_free( keys );
837 /* Get a phonetic copy of each word */
838 for( c=val,i=0; i<wordcount; c+=len+1 ) {
840 if( len < SLAPD_APPROX_WORDLEN ) continue;
841 keys[keycount] = (struct berval *)ch_malloc( sizeof(struct berval) );
842 keys[keycount]->bv_val = phonetic( c );
843 keys[keycount]->bv_len = strlen( keys[keycount]->bv_val );
850 keys[keycount] = NULL;
862 struct berval *prefix,
864 struct berval ***keysp )
868 struct berval **keys;
870 /* Yes, this is necessary */
871 val = UTF8normalize( ((struct berval *)assertValue)->bv_val,
874 keys = (struct berval **)ch_malloc( sizeof(struct berval *) );
879 strip8bitChars( val );
881 /* Isolate how many words there are. There will be a key for each */
882 for( count=0,c=val; *c; c++) {
883 len = strcspn(c, SLAPD_APPROX_DELIMITER);
884 if( len >= SLAPD_APPROX_WORDLEN ) count++;
886 if (*c == '\0') break;
890 /* Allocate storage for new keys */
891 keys = (struct berval **)ch_malloc( (count + 1) * sizeof(struct berval *) );
893 /* Get a phonetic copy of each word */
894 for( c=val,i=0; i<count; c+=len+1 ) {
896 if( len < SLAPD_APPROX_WORDLEN ) continue;
897 keys[i] = ber_bvstr( phonetic( c ) );
911 /* No other form of Approximate Matching is defined */
919 struct berval *value,
920 void *assertedValue )
922 char *vapprox, *avapprox;
925 /* Yes, this is necessary */
926 s = UTF8normalize( value->bv_val, UTF8_NOCASEFOLD );
932 /* Yes, this is necessary */
933 t = UTF8normalize( ((struct berval *)assertedValue)->bv_val,
941 vapprox = phonetic( strip8bitChars( s ) );
942 avapprox = phonetic( strip8bitChars( t ) );
947 *matchp = strcmp( vapprox, avapprox );
961 struct berval *prefix,
962 struct berval **values,
963 struct berval ***keysp )
966 struct berval **keys;
969 for( i=0; values[i] != NULL; i++ ) {
970 /* empty - just count them */
973 /* we should have at least one value at this point */
976 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * (i+1) );
978 /* Copy each value and run it through phonetic() */
979 for( i=0; values[i] != NULL; i++ ) {
980 /* Yes, this is necessary */
981 s = UTF8normalize( values[i]->bv_val, UTF8_NOCASEFOLD );
983 /* strip 8-bit chars and run through phonetic() */
984 keys[i] = ber_bvstr( phonetic( strip8bitChars( s ) ) );
1000 struct berval *prefix,
1002 struct berval ***keysp )
1004 struct berval **keys;
1007 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * 2 );
1009 /* Yes, this is necessary */
1010 s = UTF8normalize( ((struct berval *)assertValue)->bv_val,
1015 /* strip 8-bit chars and run through phonetic() */
1016 keys[0] = ber_bvstr( phonetic( strip8bitChars( s ) ) );
1022 return LDAP_SUCCESS;
1033 struct berval *value,
1034 void *assertedValue )
1036 *matchp = UTF8normcmp( value->bv_val,
1037 ((struct berval *) assertedValue)->bv_val,
1039 return LDAP_SUCCESS;
1043 caseExactSubstringsMatch(
1048 struct berval *value,
1049 void *assertedValue )
1052 SubstringsAssertion *sub;
1058 nav = UTF8normalize( value->bv_val, UTF8_NOCASEFOLD );
1064 left.bv_len = strlen( nav );
1066 sub = UTF8SubstringsassertionNormalize( assertedValue, UTF8_NOCASEFOLD );
1072 /* Add up asserted input length */
1073 if( sub->sa_initial ) {
1074 inlen += sub->sa_initial->bv_len;
1077 for(i=0; sub->sa_any[i] != NULL; i++) {
1078 inlen += sub->sa_any[i]->bv_len;
1081 if( sub->sa_final ) {
1082 inlen += sub->sa_final->bv_len;
1085 if( sub->sa_initial ) {
1086 if( inlen > left.bv_len ) {
1091 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1092 sub->sa_initial->bv_len );
1098 left.bv_val += sub->sa_initial->bv_len;
1099 left.bv_len -= sub->sa_initial->bv_len;
1100 inlen -= sub->sa_initial->bv_len;
1103 if( sub->sa_final ) {
1104 if( inlen > left.bv_len ) {
1109 match = strncmp( sub->sa_final->bv_val,
1110 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1111 sub->sa_final->bv_len );
1117 left.bv_len -= sub->sa_final->bv_len;
1118 inlen -= sub->sa_final->bv_len;
1122 for(i=0; sub->sa_any[i]; i++) {
1127 if( inlen > left.bv_len ) {
1128 /* not enough length */
1133 if( sub->sa_any[i]->bv_len == 0 ) {
1137 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1144 idx = p - left.bv_val;
1145 assert( idx < left.bv_len );
1147 if( idx >= left.bv_len ) {
1148 /* this shouldn't happen */
1155 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1156 /* not enough left */
1161 match = strncmp( left.bv_val,
1162 sub->sa_any[i]->bv_val,
1163 sub->sa_any[i]->bv_len );
1171 left.bv_val += sub->sa_any[i]->bv_len;
1172 left.bv_len -= sub->sa_any[i]->bv_len;
1173 inlen -= sub->sa_any[i]->bv_len;
1180 ch_free( sub->sa_final );
1181 ber_bvecfree( sub->sa_any );
1182 ch_free( sub->sa_initial );
1186 return LDAP_SUCCESS;
1189 /* Index generation function */
1190 int caseExactIndexer(
1195 struct berval *prefix,
1196 struct berval **values,
1197 struct berval ***keysp )
1201 struct berval **keys;
1202 HASH_CONTEXT HASHcontext;
1203 unsigned char HASHdigest[HASH_BYTES];
1204 struct berval digest;
1205 digest.bv_val = HASHdigest;
1206 digest.bv_len = sizeof(HASHdigest);
1208 for( i=0; values[i] != NULL; i++ ) {
1209 /* empty - just count them */
1212 /* we should have at least one value at this point */
1215 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1217 slen = strlen( syntax->ssyn_oid );
1218 mlen = strlen( mr->smr_oid );
1220 for( i=0; values[i] != NULL; i++ ) {
1221 struct berval *value;
1222 value = ber_bvstr( UTF8normalize( values[i]->bv_val,
1223 UTF8_NOCASEFOLD ) );
1225 HASH_Init( &HASHcontext );
1226 if( prefix != NULL && prefix->bv_len > 0 ) {
1227 HASH_Update( &HASHcontext,
1228 prefix->bv_val, prefix->bv_len );
1230 HASH_Update( &HASHcontext,
1231 syntax->ssyn_oid, slen );
1232 HASH_Update( &HASHcontext,
1233 mr->smr_oid, mlen );
1234 HASH_Update( &HASHcontext,
1235 value->bv_val, value->bv_len );
1236 HASH_Final( HASHdigest, &HASHcontext );
1238 ber_bvfree( value );
1240 keys[i] = ber_bvdup( &digest );
1245 return LDAP_SUCCESS;
1248 /* Index generation function */
1249 int caseExactFilter(
1254 struct berval *prefix,
1256 struct berval ***keysp )
1259 struct berval **keys;
1260 HASH_CONTEXT HASHcontext;
1261 unsigned char HASHdigest[HASH_BYTES];
1262 struct berval *value;
1263 struct berval digest;
1264 digest.bv_val = HASHdigest;
1265 digest.bv_len = sizeof(HASHdigest);
1267 slen = strlen( syntax->ssyn_oid );
1268 mlen = strlen( mr->smr_oid );
1270 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1271 UTF8_NOCASEFOLD ) );
1272 /* This usually happens if filter contains bad UTF8 */
1273 if( value == NULL ) {
1274 keys = ch_malloc( sizeof( struct berval * ) );
1276 return LDAP_SUCCESS;
1279 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1281 HASH_Init( &HASHcontext );
1282 if( prefix != NULL && prefix->bv_len > 0 ) {
1283 HASH_Update( &HASHcontext,
1284 prefix->bv_val, prefix->bv_len );
1286 HASH_Update( &HASHcontext,
1287 syntax->ssyn_oid, slen );
1288 HASH_Update( &HASHcontext,
1289 mr->smr_oid, mlen );
1290 HASH_Update( &HASHcontext,
1291 value->bv_val, value->bv_len );
1292 HASH_Final( HASHdigest, &HASHcontext );
1294 keys[0] = ber_bvdup( &digest );
1297 ber_bvfree( value );
1300 return LDAP_SUCCESS;
1303 /* Substrings Index generation function */
1304 int caseExactSubstringsIndexer(
1309 struct berval *prefix,
1310 struct berval **values,
1311 struct berval ***keysp )
1315 struct berval **keys;
1316 struct berval **nvalues;
1318 HASH_CONTEXT HASHcontext;
1319 unsigned char HASHdigest[HASH_BYTES];
1320 struct berval digest;
1321 digest.bv_val = HASHdigest;
1322 digest.bv_len = sizeof(HASHdigest);
1326 for( i=0; values[i] != NULL; i++ ) {
1327 /* empty - just count them */
1330 /* we should have at least one value at this point */
1333 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
1334 for( i=0; values[i] != NULL; i++ ) {
1335 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val,
1336 UTF8_NOCASEFOLD ) );
1341 for( i=0; values[i] != NULL; i++ ) {
1342 /* count number of indices to generate */
1343 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1347 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1348 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1349 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1350 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1352 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1356 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1357 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1358 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1362 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1363 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1364 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1365 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1367 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1373 /* no keys to generate */
1375 return LDAP_SUCCESS;
1378 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1380 slen = strlen( syntax->ssyn_oid );
1381 mlen = strlen( mr->smr_oid );
1384 for( i=0; values[i] != NULL; i++ ) {
1386 struct berval *value;
1388 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
1392 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
1393 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
1395 char pre = SLAP_INDEX_SUBSTR_PREFIX;
1396 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
1398 for( j=0; j<max; j++ ) {
1399 HASH_Init( &HASHcontext );
1400 if( prefix != NULL && prefix->bv_len > 0 ) {
1401 HASH_Update( &HASHcontext,
1402 prefix->bv_val, prefix->bv_len );
1405 HASH_Update( &HASHcontext,
1406 &pre, sizeof( pre ) );
1407 HASH_Update( &HASHcontext,
1408 syntax->ssyn_oid, slen );
1409 HASH_Update( &HASHcontext,
1410 mr->smr_oid, mlen );
1411 HASH_Update( &HASHcontext,
1413 SLAP_INDEX_SUBSTR_MAXLEN );
1414 HASH_Final( HASHdigest, &HASHcontext );
1416 keys[nkeys++] = ber_bvdup( &digest );
1420 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1421 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1423 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
1426 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1427 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1428 HASH_Init( &HASHcontext );
1429 if( prefix != NULL && prefix->bv_len > 0 ) {
1430 HASH_Update( &HASHcontext,
1431 prefix->bv_val, prefix->bv_len );
1433 HASH_Update( &HASHcontext,
1434 &pre, sizeof( pre ) );
1435 HASH_Update( &HASHcontext,
1436 syntax->ssyn_oid, slen );
1437 HASH_Update( &HASHcontext,
1438 mr->smr_oid, mlen );
1439 HASH_Update( &HASHcontext,
1441 HASH_Final( HASHdigest, &HASHcontext );
1443 keys[nkeys++] = ber_bvdup( &digest );
1446 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1447 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1448 HASH_Init( &HASHcontext );
1449 if( prefix != NULL && prefix->bv_len > 0 ) {
1450 HASH_Update( &HASHcontext,
1451 prefix->bv_val, prefix->bv_len );
1453 HASH_Update( &HASHcontext,
1454 &pre, sizeof( pre ) );
1455 HASH_Update( &HASHcontext,
1456 syntax->ssyn_oid, slen );
1457 HASH_Update( &HASHcontext,
1458 mr->smr_oid, mlen );
1459 HASH_Update( &HASHcontext,
1460 &value->bv_val[value->bv_len-j], j );
1461 HASH_Final( HASHdigest, &HASHcontext );
1463 keys[nkeys++] = ber_bvdup( &digest );
1478 ber_bvecfree( nvalues );
1480 return LDAP_SUCCESS;
1483 int caseExactSubstringsFilter(
1488 struct berval *prefix,
1490 struct berval ***keysp )
1492 SubstringsAssertion *sa;
1494 ber_len_t nkeys = 0;
1495 size_t slen, mlen, klen;
1496 struct berval **keys;
1497 HASH_CONTEXT HASHcontext;
1498 unsigned char HASHdigest[HASH_BYTES];
1499 struct berval *value;
1500 struct berval digest;
1502 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_NOCASEFOLD );
1505 return LDAP_SUCCESS;
1508 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1509 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1514 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1516 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1517 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1518 /* don't bother accounting for stepping */
1519 nkeys += sa->sa_any[i]->bv_len -
1520 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1525 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1526 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1533 return LDAP_SUCCESS;
1536 digest.bv_val = HASHdigest;
1537 digest.bv_len = sizeof(HASHdigest);
1539 slen = strlen( syntax->ssyn_oid );
1540 mlen = strlen( mr->smr_oid );
1542 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1545 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1546 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1548 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1549 value = sa->sa_initial;
1551 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1552 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1554 HASH_Init( &HASHcontext );
1555 if( prefix != NULL && prefix->bv_len > 0 ) {
1556 HASH_Update( &HASHcontext,
1557 prefix->bv_val, prefix->bv_len );
1559 HASH_Update( &HASHcontext,
1560 &pre, sizeof( pre ) );
1561 HASH_Update( &HASHcontext,
1562 syntax->ssyn_oid, slen );
1563 HASH_Update( &HASHcontext,
1564 mr->smr_oid, mlen );
1565 HASH_Update( &HASHcontext,
1566 value->bv_val, klen );
1567 HASH_Final( HASHdigest, &HASHcontext );
1569 keys[nkeys++] = ber_bvdup( &digest );
1572 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1574 pre = SLAP_INDEX_SUBSTR_PREFIX;
1575 klen = SLAP_INDEX_SUBSTR_MAXLEN;
1577 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1578 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
1582 value = sa->sa_any[i];
1585 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
1586 j += SLAP_INDEX_SUBSTR_STEP )
1588 HASH_Init( &HASHcontext );
1589 if( prefix != NULL && prefix->bv_len > 0 ) {
1590 HASH_Update( &HASHcontext,
1591 prefix->bv_val, prefix->bv_len );
1593 HASH_Update( &HASHcontext,
1594 &pre, sizeof( pre ) );
1595 HASH_Update( &HASHcontext,
1596 syntax->ssyn_oid, slen );
1597 HASH_Update( &HASHcontext,
1598 mr->smr_oid, mlen );
1599 HASH_Update( &HASHcontext,
1600 &value->bv_val[j], klen );
1601 HASH_Final( HASHdigest, &HASHcontext );
1603 keys[nkeys++] = ber_bvdup( &digest );
1609 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1610 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1612 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1613 value = sa->sa_final;
1615 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1616 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1618 HASH_Init( &HASHcontext );
1619 if( prefix != NULL && prefix->bv_len > 0 ) {
1620 HASH_Update( &HASHcontext,
1621 prefix->bv_val, prefix->bv_len );
1623 HASH_Update( &HASHcontext,
1624 &pre, sizeof( pre ) );
1625 HASH_Update( &HASHcontext,
1626 syntax->ssyn_oid, slen );
1627 HASH_Update( &HASHcontext,
1628 mr->smr_oid, mlen );
1629 HASH_Update( &HASHcontext,
1630 &value->bv_val[value->bv_len-klen], klen );
1631 HASH_Final( HASHdigest, &HASHcontext );
1633 keys[nkeys++] = ber_bvdup( &digest );
1643 ch_free( sa->sa_final );
1644 ber_bvecfree( sa->sa_any );
1645 ch_free( sa->sa_initial );
1648 return LDAP_SUCCESS;
1657 struct berval *value,
1658 void *assertedValue )
1660 *matchp = UTF8normcmp( value->bv_val,
1661 ((struct berval *) assertedValue)->bv_val,
1663 return LDAP_SUCCESS;
1667 caseIgnoreSubstringsMatch(
1672 struct berval *value,
1673 void *assertedValue )
1676 SubstringsAssertion *sub;
1682 nav = UTF8normalize( value->bv_val, UTF8_CASEFOLD );
1688 left.bv_len = strlen( nav );
1690 sub = UTF8SubstringsassertionNormalize( assertedValue, UTF8_CASEFOLD );
1696 /* Add up asserted input length */
1697 if( sub->sa_initial ) {
1698 inlen += sub->sa_initial->bv_len;
1701 for(i=0; sub->sa_any[i] != NULL; i++) {
1702 inlen += sub->sa_any[i]->bv_len;
1705 if( sub->sa_final ) {
1706 inlen += sub->sa_final->bv_len;
1709 if( sub->sa_initial ) {
1710 if( inlen > left.bv_len ) {
1715 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1716 sub->sa_initial->bv_len );
1722 left.bv_val += sub->sa_initial->bv_len;
1723 left.bv_len -= sub->sa_initial->bv_len;
1724 inlen -= sub->sa_initial->bv_len;
1727 if( sub->sa_final ) {
1728 if( inlen > left.bv_len ) {
1733 match = strncmp( sub->sa_final->bv_val,
1734 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1735 sub->sa_final->bv_len );
1741 left.bv_len -= sub->sa_final->bv_len;
1742 inlen -= sub->sa_final->bv_len;
1746 for(i=0; sub->sa_any[i]; i++) {
1751 if( inlen > left.bv_len ) {
1752 /* not enough length */
1757 if( sub->sa_any[i]->bv_len == 0 ) {
1761 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1768 idx = p - left.bv_val;
1769 assert( idx < left.bv_len );
1771 if( idx >= left.bv_len ) {
1772 /* this shouldn't happen */
1779 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1780 /* not enough left */
1785 match = strncmp( left.bv_val,
1786 sub->sa_any[i]->bv_val,
1787 sub->sa_any[i]->bv_len );
1796 left.bv_val += sub->sa_any[i]->bv_len;
1797 left.bv_len -= sub->sa_any[i]->bv_len;
1798 inlen -= sub->sa_any[i]->bv_len;
1805 ch_free( sub->sa_final );
1806 ber_bvecfree( sub->sa_any );
1807 ch_free( sub->sa_initial );
1811 return LDAP_SUCCESS;
1814 /* Index generation function */
1815 int caseIgnoreIndexer(
1820 struct berval *prefix,
1821 struct berval **values,
1822 struct berval ***keysp )
1826 struct berval **keys;
1827 HASH_CONTEXT HASHcontext;
1828 unsigned char HASHdigest[HASH_BYTES];
1829 struct berval digest;
1830 digest.bv_val = HASHdigest;
1831 digest.bv_len = sizeof(HASHdigest);
1833 for( i=0; values[i] != NULL; i++ ) {
1834 /* empty - just count them */
1837 /* we should have at least one value at this point */
1840 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1842 slen = strlen( syntax->ssyn_oid );
1843 mlen = strlen( mr->smr_oid );
1845 for( i=0; values[i] != NULL; i++ ) {
1846 struct berval *value;
1847 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
1848 HASH_Init( &HASHcontext );
1849 if( prefix != NULL && prefix->bv_len > 0 ) {
1850 HASH_Update( &HASHcontext,
1851 prefix->bv_val, prefix->bv_len );
1853 HASH_Update( &HASHcontext,
1854 syntax->ssyn_oid, slen );
1855 HASH_Update( &HASHcontext,
1856 mr->smr_oid, mlen );
1857 HASH_Update( &HASHcontext,
1858 value->bv_val, value->bv_len );
1859 HASH_Final( HASHdigest, &HASHcontext );
1861 ber_bvfree( value );
1863 keys[i] = ber_bvdup( &digest );
1868 return LDAP_SUCCESS;
1871 /* Index generation function */
1872 int caseIgnoreFilter(
1877 struct berval *prefix,
1879 struct berval ***keysp )
1882 struct berval **keys;
1883 HASH_CONTEXT HASHcontext;
1884 unsigned char HASHdigest[HASH_BYTES];
1885 struct berval *value;
1886 struct berval digest;
1887 digest.bv_val = HASHdigest;
1888 digest.bv_len = sizeof(HASHdigest);
1890 slen = strlen( syntax->ssyn_oid );
1891 mlen = strlen( mr->smr_oid );
1893 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1895 /* This usually happens if filter contains bad UTF8 */
1896 if( value == NULL ) {
1897 keys = ch_malloc( sizeof( struct berval * ) );
1899 return LDAP_SUCCESS;
1902 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1904 HASH_Init( &HASHcontext );
1905 if( prefix != NULL && prefix->bv_len > 0 ) {
1906 HASH_Update( &HASHcontext,
1907 prefix->bv_val, prefix->bv_len );
1909 HASH_Update( &HASHcontext,
1910 syntax->ssyn_oid, slen );
1911 HASH_Update( &HASHcontext,
1912 mr->smr_oid, mlen );
1913 HASH_Update( &HASHcontext,
1914 value->bv_val, value->bv_len );
1915 HASH_Final( HASHdigest, &HASHcontext );
1917 keys[0] = ber_bvdup( &digest );
1920 ber_bvfree( value );
1924 return LDAP_SUCCESS;
1927 /* Substrings Index generation function */
1928 int caseIgnoreSubstringsIndexer(
1933 struct berval *prefix,
1934 struct berval **values,
1935 struct berval ***keysp )
1939 struct berval **keys;
1940 struct berval **nvalues;
1942 HASH_CONTEXT HASHcontext;
1943 unsigned char HASHdigest[HASH_BYTES];
1944 struct berval digest;
1945 digest.bv_val = HASHdigest;
1946 digest.bv_len = sizeof(HASHdigest);
1950 for( i=0; values[i] != NULL; i++ ) {
1951 /* empty - just count them */
1954 /* we should have at least one value at this point */
1957 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
1958 for( i=0; values[i] != NULL; i++ ) {
1959 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val,
1965 for( i=0; values[i] != NULL; i++ ) {
1966 /* count number of indices to generate */
1967 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1971 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1972 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1973 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1974 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1976 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1980 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1981 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1982 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1986 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1987 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1988 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1989 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1991 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1997 /* no keys to generate */
1999 return LDAP_SUCCESS;
2002 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2004 slen = strlen( syntax->ssyn_oid );
2005 mlen = strlen( mr->smr_oid );
2008 for( i=0; values[i] != NULL; i++ ) {
2010 struct berval *value;
2012 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2016 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2017 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2019 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2020 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2022 for( j=0; j<max; j++ ) {
2023 HASH_Init( &HASHcontext );
2024 if( prefix != NULL && prefix->bv_len > 0 ) {
2025 HASH_Update( &HASHcontext,
2026 prefix->bv_val, prefix->bv_len );
2029 HASH_Update( &HASHcontext,
2030 &pre, sizeof( pre ) );
2031 HASH_Update( &HASHcontext,
2032 syntax->ssyn_oid, slen );
2033 HASH_Update( &HASHcontext,
2034 mr->smr_oid, mlen );
2035 HASH_Update( &HASHcontext,
2037 SLAP_INDEX_SUBSTR_MAXLEN );
2038 HASH_Final( HASHdigest, &HASHcontext );
2040 keys[nkeys++] = ber_bvdup( &digest );
2044 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2045 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2047 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2050 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2051 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2052 HASH_Init( &HASHcontext );
2053 if( prefix != NULL && prefix->bv_len > 0 ) {
2054 HASH_Update( &HASHcontext,
2055 prefix->bv_val, prefix->bv_len );
2057 HASH_Update( &HASHcontext,
2058 &pre, sizeof( pre ) );
2059 HASH_Update( &HASHcontext,
2060 syntax->ssyn_oid, slen );
2061 HASH_Update( &HASHcontext,
2062 mr->smr_oid, mlen );
2063 HASH_Update( &HASHcontext,
2065 HASH_Final( HASHdigest, &HASHcontext );
2067 keys[nkeys++] = ber_bvdup( &digest );
2070 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2071 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2072 HASH_Init( &HASHcontext );
2073 if( prefix != NULL && prefix->bv_len > 0 ) {
2074 HASH_Update( &HASHcontext,
2075 prefix->bv_val, prefix->bv_len );
2077 HASH_Update( &HASHcontext,
2078 &pre, sizeof( pre ) );
2079 HASH_Update( &HASHcontext,
2080 syntax->ssyn_oid, slen );
2081 HASH_Update( &HASHcontext,
2082 mr->smr_oid, mlen );
2083 HASH_Update( &HASHcontext,
2084 &value->bv_val[value->bv_len-j], j );
2085 HASH_Final( HASHdigest, &HASHcontext );
2087 keys[nkeys++] = ber_bvdup( &digest );
2101 ber_bvecfree( nvalues );
2102 return LDAP_SUCCESS;
2105 int caseIgnoreSubstringsFilter(
2110 struct berval *prefix,
2112 struct berval ***keysp )
2114 SubstringsAssertion *sa;
2116 ber_len_t nkeys = 0;
2117 size_t slen, mlen, klen;
2118 struct berval **keys;
2119 HASH_CONTEXT HASHcontext;
2120 unsigned char HASHdigest[HASH_BYTES];
2121 struct berval *value;
2122 struct berval digest;
2124 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_CASEFOLD );
2127 return LDAP_SUCCESS;
2130 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2131 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2136 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2138 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2139 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2140 /* don't bother accounting for stepping */
2141 nkeys += sa->sa_any[i]->bv_len -
2142 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2147 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2148 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2155 return LDAP_SUCCESS;
2158 digest.bv_val = HASHdigest;
2159 digest.bv_len = sizeof(HASHdigest);
2161 slen = strlen( syntax->ssyn_oid );
2162 mlen = strlen( mr->smr_oid );
2164 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2167 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2168 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2170 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2171 value = sa->sa_initial;
2173 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2174 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2176 HASH_Init( &HASHcontext );
2177 if( prefix != NULL && prefix->bv_len > 0 ) {
2178 HASH_Update( &HASHcontext,
2179 prefix->bv_val, prefix->bv_len );
2181 HASH_Update( &HASHcontext,
2182 &pre, sizeof( pre ) );
2183 HASH_Update( &HASHcontext,
2184 syntax->ssyn_oid, slen );
2185 HASH_Update( &HASHcontext,
2186 mr->smr_oid, mlen );
2187 HASH_Update( &HASHcontext,
2188 value->bv_val, klen );
2189 HASH_Final( HASHdigest, &HASHcontext );
2191 keys[nkeys++] = ber_bvdup( &digest );
2194 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2196 pre = SLAP_INDEX_SUBSTR_PREFIX;
2197 klen = SLAP_INDEX_SUBSTR_MAXLEN;
2199 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2200 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
2204 value = sa->sa_any[i];
2207 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
2208 j += SLAP_INDEX_SUBSTR_STEP )
2210 HASH_Init( &HASHcontext );
2211 if( prefix != NULL && prefix->bv_len > 0 ) {
2212 HASH_Update( &HASHcontext,
2213 prefix->bv_val, prefix->bv_len );
2215 HASH_Update( &HASHcontext,
2216 &pre, sizeof( pre ) );
2217 HASH_Update( &HASHcontext,
2218 syntax->ssyn_oid, slen );
2219 HASH_Update( &HASHcontext,
2220 mr->smr_oid, mlen );
2221 HASH_Update( &HASHcontext,
2222 &value->bv_val[j], klen );
2223 HASH_Final( HASHdigest, &HASHcontext );
2225 keys[nkeys++] = ber_bvdup( &digest );
2230 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2231 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2233 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2234 value = sa->sa_final;
2236 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2237 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2239 HASH_Init( &HASHcontext );
2240 if( prefix != NULL && prefix->bv_len > 0 ) {
2241 HASH_Update( &HASHcontext,
2242 prefix->bv_val, prefix->bv_len );
2244 HASH_Update( &HASHcontext,
2245 &pre, sizeof( pre ) );
2246 HASH_Update( &HASHcontext,
2247 syntax->ssyn_oid, slen );
2248 HASH_Update( &HASHcontext,
2249 mr->smr_oid, mlen );
2250 HASH_Update( &HASHcontext,
2251 &value->bv_val[value->bv_len-klen], klen );
2252 HASH_Final( HASHdigest, &HASHcontext );
2254 keys[nkeys++] = ber_bvdup( &digest );
2264 ch_free( sa->sa_final );
2265 ber_bvecfree( sa->sa_any );
2266 ch_free( sa->sa_initial );
2269 return LDAP_SUCCESS;
2275 struct berval *val )
2279 if( val->bv_len == 0 ) {
2280 /* disallow empty strings */
2281 return LDAP_INVALID_SYNTAX;
2284 if( OID_LEADCHAR(val->bv_val[0]) ) {
2286 for(i=1; i < val->bv_len; i++) {
2287 if( OID_SEPARATOR( val->bv_val[i] ) ) {
2288 if( dot++ ) return 1;
2289 } else if ( OID_CHAR( val->bv_val[i] ) ) {
2292 return LDAP_INVALID_SYNTAX;
2296 return !dot ? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
2298 } else if( DESC_LEADCHAR(val->bv_val[0]) ) {
2299 for(i=1; i < val->bv_len; i++) {
2300 if( !DESC_CHAR(val->bv_val[i] ) ) {
2301 return LDAP_INVALID_SYNTAX;
2305 return LDAP_SUCCESS;
2308 return LDAP_INVALID_SYNTAX;
2314 struct berval *val )
2318 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2320 if( val->bv_val[0] == '+' || val->bv_val[0] == '-' ) {
2321 if( val->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
2322 } else if( !ASCII_DIGIT(val->bv_val[0]) ) {
2323 return LDAP_INVALID_SYNTAX;
2326 for(i=1; i < val->bv_len; i++) {
2327 if( !ASCII_DIGIT(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2330 return LDAP_SUCCESS;
2337 struct berval **normalized )
2340 struct berval *newval;
2346 negative = ( *p == '-' );
2347 if( *p == '-' || *p == '+' ) p++;
2349 /* Ignore leading zeros */
2350 while ( *p == '0' ) p++;
2352 newval = (struct berval *) ch_malloc( sizeof(struct berval) );
2355 newval->bv_val = ch_strdup("0");
2360 newval->bv_val = ch_malloc( val->bv_len + 1 );
2364 newval->bv_val[newval->bv_len++] = '-';
2367 for( ; *p != '\0'; p++ ) {
2368 newval->bv_val[newval->bv_len++] = *p;
2372 *normalized = newval;
2373 return LDAP_SUCCESS;
2377 countryStringValidate(
2379 struct berval *val )
2381 if( val->bv_len != 2 ) return LDAP_INVALID_SYNTAX;
2383 if( !SLAP_PRINTABLE(val->bv_val[0]) ) {
2384 return LDAP_INVALID_SYNTAX;
2386 if( !SLAP_PRINTABLE(val->bv_val[1]) ) {
2387 return LDAP_INVALID_SYNTAX;
2390 return LDAP_SUCCESS;
2394 printableStringValidate(
2396 struct berval *val )
2400 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2402 for(i=0; i < val->bv_len; i++) {
2403 if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
2404 return LDAP_INVALID_SYNTAX;
2408 return LDAP_SUCCESS;
2412 printablesStringValidate(
2414 struct berval *val )
2418 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2420 for(i=0; i < val->bv_len; i++) {
2421 if( !SLAP_PRINTABLES(val->bv_val[i]) ) {
2422 return LDAP_INVALID_SYNTAX;
2426 return LDAP_SUCCESS;
2432 struct berval *val )
2436 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2438 for(i=0; i < val->bv_len; i++) {
2439 if( !isascii(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2442 return LDAP_SUCCESS;
2449 struct berval **normalized )
2451 struct berval *newval;
2454 newval = ch_malloc( sizeof( struct berval ) );
2458 /* Ignore initial whitespace */
2459 while ( ASCII_SPACE( *p ) ) {
2465 return LDAP_INVALID_SYNTAX;
2468 newval->bv_val = ch_strdup( p );
2469 p = q = newval->bv_val;
2472 if ( ASCII_SPACE( *p ) ) {
2475 /* Ignore the extra whitespace */
2476 while ( ASCII_SPACE( *p ) ) {
2484 assert( *newval->bv_val );
2485 assert( newval->bv_val < p );
2488 /* cannot start with a space */
2489 assert( !ASCII_SPACE(*newval->bv_val) );
2492 * If the string ended in space, backup the pointer one
2493 * position. One is enough because the above loop collapsed
2494 * all whitespace to a single space.
2497 if ( ASCII_SPACE( q[-1] ) ) {
2501 /* cannot end with a space */
2502 assert( !ASCII_SPACE( q[-1] ) );
2504 /* null terminate */
2507 newval->bv_len = q - newval->bv_val;
2508 *normalized = newval;
2510 return LDAP_SUCCESS;
2519 struct berval *value,
2520 void *assertedValue )
2522 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
2525 match = strncmp( value->bv_val,
2526 ((struct berval *) assertedValue)->bv_val,
2531 return LDAP_SUCCESS;
2535 caseExactIA5SubstringsMatch(
2540 struct berval *value,
2541 void *assertedValue )
2544 SubstringsAssertion *sub = assertedValue;
2545 struct berval left = *value;
2549 /* Add up asserted input length */
2550 if( sub->sa_initial ) {
2551 inlen += sub->sa_initial->bv_len;
2554 for(i=0; sub->sa_any[i] != NULL; i++) {
2555 inlen += sub->sa_any[i]->bv_len;
2558 if( sub->sa_final ) {
2559 inlen += sub->sa_final->bv_len;
2562 if( sub->sa_initial ) {
2563 if( inlen > left.bv_len ) {
2568 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
2569 sub->sa_initial->bv_len );
2575 left.bv_val += sub->sa_initial->bv_len;
2576 left.bv_len -= sub->sa_initial->bv_len;
2577 inlen -= sub->sa_initial->bv_len;
2580 if( sub->sa_final ) {
2581 if( inlen > left.bv_len ) {
2586 match = strncmp( sub->sa_final->bv_val,
2587 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
2588 sub->sa_final->bv_len );
2594 left.bv_len -= sub->sa_final->bv_len;
2595 inlen -= sub->sa_final->bv_len;
2599 for(i=0; sub->sa_any[i]; i++) {
2604 if( inlen > left.bv_len ) {
2605 /* not enough length */
2610 if( sub->sa_any[i]->bv_len == 0 ) {
2614 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
2621 idx = p - left.bv_val;
2622 assert( idx < left.bv_len );
2624 if( idx >= left.bv_len ) {
2625 /* this shouldn't happen */
2632 if( sub->sa_any[i]->bv_len > left.bv_len ) {
2633 /* not enough left */
2638 match = strncmp( left.bv_val,
2639 sub->sa_any[i]->bv_val,
2640 sub->sa_any[i]->bv_len );
2648 left.bv_val += sub->sa_any[i]->bv_len;
2649 left.bv_len -= sub->sa_any[i]->bv_len;
2650 inlen -= sub->sa_any[i]->bv_len;
2656 return LDAP_SUCCESS;
2659 /* Index generation function */
2660 int caseExactIA5Indexer(
2665 struct berval *prefix,
2666 struct berval **values,
2667 struct berval ***keysp )
2671 struct berval **keys;
2672 HASH_CONTEXT HASHcontext;
2673 unsigned char HASHdigest[HASH_BYTES];
2674 struct berval digest;
2675 digest.bv_val = HASHdigest;
2676 digest.bv_len = sizeof(HASHdigest);
2678 for( i=0; values[i] != NULL; i++ ) {
2679 /* empty - just count them */
2682 /* we should have at least one value at this point */
2685 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
2687 slen = strlen( syntax->ssyn_oid );
2688 mlen = strlen( mr->smr_oid );
2690 for( i=0; values[i] != NULL; i++ ) {
2691 struct berval *value = values[i];
2693 HASH_Init( &HASHcontext );
2694 if( prefix != NULL && prefix->bv_len > 0 ) {
2695 HASH_Update( &HASHcontext,
2696 prefix->bv_val, prefix->bv_len );
2698 HASH_Update( &HASHcontext,
2699 syntax->ssyn_oid, slen );
2700 HASH_Update( &HASHcontext,
2701 mr->smr_oid, mlen );
2702 HASH_Update( &HASHcontext,
2703 value->bv_val, value->bv_len );
2704 HASH_Final( HASHdigest, &HASHcontext );
2706 keys[i] = ber_bvdup( &digest );
2711 return LDAP_SUCCESS;
2714 /* Index generation function */
2715 int caseExactIA5Filter(
2720 struct berval *prefix,
2722 struct berval ***keysp )
2725 struct berval **keys;
2726 HASH_CONTEXT HASHcontext;
2727 unsigned char HASHdigest[HASH_BYTES];
2728 struct berval *value;
2729 struct berval digest;
2730 digest.bv_val = HASHdigest;
2731 digest.bv_len = sizeof(HASHdigest);
2733 slen = strlen( syntax->ssyn_oid );
2734 mlen = strlen( mr->smr_oid );
2736 value = (struct berval *) assertValue;
2738 keys = ch_malloc( sizeof( struct berval * ) * 2 );
2740 HASH_Init( &HASHcontext );
2741 if( prefix != NULL && prefix->bv_len > 0 ) {
2742 HASH_Update( &HASHcontext,
2743 prefix->bv_val, prefix->bv_len );
2745 HASH_Update( &HASHcontext,
2746 syntax->ssyn_oid, slen );
2747 HASH_Update( &HASHcontext,
2748 mr->smr_oid, mlen );
2749 HASH_Update( &HASHcontext,
2750 value->bv_val, value->bv_len );
2751 HASH_Final( HASHdigest, &HASHcontext );
2753 keys[0] = ber_bvdup( &digest );
2757 return LDAP_SUCCESS;
2760 /* Substrings Index generation function */
2761 int caseExactIA5SubstringsIndexer(
2766 struct berval *prefix,
2767 struct berval **values,
2768 struct berval ***keysp )
2772 struct berval **keys;
2773 HASH_CONTEXT HASHcontext;
2774 unsigned char HASHdigest[HASH_BYTES];
2775 struct berval digest;
2776 digest.bv_val = HASHdigest;
2777 digest.bv_len = sizeof(HASHdigest);
2779 /* we should have at least one value at this point */
2780 assert( values != NULL && values[0] != NULL );
2783 for( i=0; values[i] != NULL; i++ ) {
2784 /* count number of indices to generate */
2785 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
2789 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2790 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2791 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2792 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2794 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2798 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2799 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2800 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2804 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2805 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2806 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2807 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2809 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2815 /* no keys to generate */
2817 return LDAP_SUCCESS;
2820 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2822 slen = strlen( syntax->ssyn_oid );
2823 mlen = strlen( mr->smr_oid );
2826 for( i=0; values[i] != NULL; i++ ) {
2828 struct berval *value;
2831 if( value->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2833 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2834 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2836 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2837 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2839 for( j=0; j<max; j++ ) {
2840 HASH_Init( &HASHcontext );
2841 if( prefix != NULL && prefix->bv_len > 0 ) {
2842 HASH_Update( &HASHcontext,
2843 prefix->bv_val, prefix->bv_len );
2846 HASH_Update( &HASHcontext,
2847 &pre, sizeof( pre ) );
2848 HASH_Update( &HASHcontext,
2849 syntax->ssyn_oid, slen );
2850 HASH_Update( &HASHcontext,
2851 mr->smr_oid, mlen );
2852 HASH_Update( &HASHcontext,
2854 SLAP_INDEX_SUBSTR_MAXLEN );
2855 HASH_Final( HASHdigest, &HASHcontext );
2857 keys[nkeys++] = ber_bvdup( &digest );
2861 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2862 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2864 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2867 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2868 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2869 HASH_Init( &HASHcontext );
2870 if( prefix != NULL && prefix->bv_len > 0 ) {
2871 HASH_Update( &HASHcontext,
2872 prefix->bv_val, prefix->bv_len );
2874 HASH_Update( &HASHcontext,
2875 &pre, sizeof( pre ) );
2876 HASH_Update( &HASHcontext,
2877 syntax->ssyn_oid, slen );
2878 HASH_Update( &HASHcontext,
2879 mr->smr_oid, mlen );
2880 HASH_Update( &HASHcontext,
2882 HASH_Final( HASHdigest, &HASHcontext );
2884 keys[nkeys++] = ber_bvdup( &digest );
2887 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2888 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2889 HASH_Init( &HASHcontext );
2890 if( prefix != NULL && prefix->bv_len > 0 ) {
2891 HASH_Update( &HASHcontext,
2892 prefix->bv_val, prefix->bv_len );
2894 HASH_Update( &HASHcontext,
2895 &pre, sizeof( pre ) );
2896 HASH_Update( &HASHcontext,
2897 syntax->ssyn_oid, slen );
2898 HASH_Update( &HASHcontext,
2899 mr->smr_oid, mlen );
2900 HASH_Update( &HASHcontext,
2901 &value->bv_val[value->bv_len-j], j );
2902 HASH_Final( HASHdigest, &HASHcontext );
2904 keys[nkeys++] = ber_bvdup( &digest );
2918 return LDAP_SUCCESS;
2921 int caseExactIA5SubstringsFilter(
2926 struct berval *prefix,
2928 struct berval ***keysp )
2930 SubstringsAssertion *sa = assertValue;
2932 ber_len_t nkeys = 0;
2933 size_t slen, mlen, klen;
2934 struct berval **keys;
2935 HASH_CONTEXT HASHcontext;
2936 unsigned char HASHdigest[HASH_BYTES];
2937 struct berval *value;
2938 struct berval digest;
2940 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
2941 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2946 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
2948 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2949 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2950 /* don't bother accounting for stepping */
2951 nkeys += sa->sa_any[i]->bv_len -
2952 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2957 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
2958 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2965 return LDAP_SUCCESS;
2968 digest.bv_val = HASHdigest;
2969 digest.bv_len = sizeof(HASHdigest);
2971 slen = strlen( syntax->ssyn_oid );
2972 mlen = strlen( mr->smr_oid );
2974 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2977 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
2978 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2980 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2981 value = sa->sa_initial;
2983 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2984 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2986 HASH_Init( &HASHcontext );
2987 if( prefix != NULL && prefix->bv_len > 0 ) {
2988 HASH_Update( &HASHcontext,
2989 prefix->bv_val, prefix->bv_len );
2991 HASH_Update( &HASHcontext,
2992 &pre, sizeof( pre ) );
2993 HASH_Update( &HASHcontext,
2994 syntax->ssyn_oid, slen );
2995 HASH_Update( &HASHcontext,
2996 mr->smr_oid, mlen );
2997 HASH_Update( &HASHcontext,
2998 value->bv_val, klen );
2999 HASH_Final( HASHdigest, &HASHcontext );
3001 keys[nkeys++] = ber_bvdup( &digest );
3004 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
3006 pre = SLAP_INDEX_SUBSTR_PREFIX;
3007 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3009 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3010 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3014 value = sa->sa_any[i];
3017 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3018 j += SLAP_INDEX_SUBSTR_STEP )
3020 HASH_Init( &HASHcontext );
3021 if( prefix != NULL && prefix->bv_len > 0 ) {
3022 HASH_Update( &HASHcontext,
3023 prefix->bv_val, prefix->bv_len );
3025 HASH_Update( &HASHcontext,
3026 &pre, sizeof( pre ) );
3027 HASH_Update( &HASHcontext,
3028 syntax->ssyn_oid, slen );
3029 HASH_Update( &HASHcontext,
3030 mr->smr_oid, mlen );
3031 HASH_Update( &HASHcontext,
3032 &value->bv_val[j], klen );
3033 HASH_Final( HASHdigest, &HASHcontext );
3035 keys[nkeys++] = ber_bvdup( &digest );
3040 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
3041 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3043 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3044 value = sa->sa_final;
3046 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3047 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3049 HASH_Init( &HASHcontext );
3050 if( prefix != NULL && prefix->bv_len > 0 ) {
3051 HASH_Update( &HASHcontext,
3052 prefix->bv_val, prefix->bv_len );
3054 HASH_Update( &HASHcontext,
3055 &pre, sizeof( pre ) );
3056 HASH_Update( &HASHcontext,
3057 syntax->ssyn_oid, slen );
3058 HASH_Update( &HASHcontext,
3059 mr->smr_oid, mlen );
3060 HASH_Update( &HASHcontext,
3061 &value->bv_val[value->bv_len-klen], klen );
3062 HASH_Final( HASHdigest, &HASHcontext );
3064 keys[nkeys++] = ber_bvdup( &digest );
3075 return LDAP_SUCCESS;
3084 struct berval *value,
3085 void *assertedValue )
3087 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
3089 if( match == 0 && value->bv_len ) {
3090 match = strncasecmp( value->bv_val,
3091 ((struct berval *) assertedValue)->bv_val,
3096 return LDAP_SUCCESS;
3100 caseIgnoreIA5SubstringsMatch(
3105 struct berval *value,
3106 void *assertedValue )
3109 SubstringsAssertion *sub = assertedValue;
3110 struct berval left = *value;
3114 /* Add up asserted input length */
3115 if( sub->sa_initial ) {
3116 inlen += sub->sa_initial->bv_len;
3119 for(i=0; sub->sa_any[i] != NULL; i++) {
3120 inlen += sub->sa_any[i]->bv_len;
3123 if( sub->sa_final ) {
3124 inlen += sub->sa_final->bv_len;
3127 if( sub->sa_initial ) {
3128 if( inlen > left.bv_len ) {
3133 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
3134 sub->sa_initial->bv_len );
3140 left.bv_val += sub->sa_initial->bv_len;
3141 left.bv_len -= sub->sa_initial->bv_len;
3142 inlen -= sub->sa_initial->bv_len;
3145 if( sub->sa_final ) {
3146 if( inlen > left.bv_len ) {
3151 match = strncasecmp( sub->sa_final->bv_val,
3152 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
3153 sub->sa_final->bv_len );
3159 left.bv_len -= sub->sa_final->bv_len;
3160 inlen -= sub->sa_final->bv_len;
3164 for(i=0; sub->sa_any[i]; i++) {
3169 if( inlen > left.bv_len ) {
3170 /* not enough length */
3175 if( sub->sa_any[i]->bv_len == 0 ) {
3179 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
3186 idx = p - left.bv_val;
3187 assert( idx < left.bv_len );
3189 if( idx >= left.bv_len ) {
3190 /* this shouldn't happen */
3197 if( sub->sa_any[i]->bv_len > left.bv_len ) {
3198 /* not enough left */
3203 match = strncasecmp( left.bv_val,
3204 sub->sa_any[i]->bv_val,
3205 sub->sa_any[i]->bv_len );
3214 left.bv_val += sub->sa_any[i]->bv_len;
3215 left.bv_len -= sub->sa_any[i]->bv_len;
3216 inlen -= sub->sa_any[i]->bv_len;
3222 return LDAP_SUCCESS;
3225 /* Index generation function */
3226 int caseIgnoreIA5Indexer(
3231 struct berval *prefix,
3232 struct berval **values,
3233 struct berval ***keysp )
3237 struct berval **keys;
3238 HASH_CONTEXT HASHcontext;
3239 unsigned char HASHdigest[HASH_BYTES];
3240 struct berval digest;
3241 digest.bv_val = HASHdigest;
3242 digest.bv_len = sizeof(HASHdigest);
3244 /* we should have at least one value at this point */
3245 assert( values != NULL && values[0] != NULL );
3247 for( i=0; values[i] != NULL; i++ ) {
3248 /* just count them */
3251 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
3253 slen = strlen( syntax->ssyn_oid );
3254 mlen = strlen( mr->smr_oid );
3256 for( i=0; values[i] != NULL; i++ ) {
3257 struct berval *value = ber_bvdup( values[i] );
3258 ldap_pvt_str2upper( value->bv_val );
3260 HASH_Init( &HASHcontext );
3261 if( prefix != NULL && prefix->bv_len > 0 ) {
3262 HASH_Update( &HASHcontext,
3263 prefix->bv_val, prefix->bv_len );
3265 HASH_Update( &HASHcontext,
3266 syntax->ssyn_oid, slen );
3267 HASH_Update( &HASHcontext,
3268 mr->smr_oid, mlen );
3269 HASH_Update( &HASHcontext,
3270 value->bv_val, value->bv_len );
3271 HASH_Final( HASHdigest, &HASHcontext );
3273 ber_bvfree( value );
3275 keys[i] = ber_bvdup( &digest );
3280 return LDAP_SUCCESS;
3283 /* Index generation function */
3284 int caseIgnoreIA5Filter(
3289 struct berval *prefix,
3291 struct berval ***keysp )
3294 struct berval **keys;
3295 HASH_CONTEXT HASHcontext;
3296 unsigned char HASHdigest[HASH_BYTES];
3297 struct berval *value;
3298 struct berval digest;
3299 digest.bv_val = HASHdigest;
3300 digest.bv_len = sizeof(HASHdigest);
3302 slen = strlen( syntax->ssyn_oid );
3303 mlen = strlen( mr->smr_oid );
3305 value = ber_bvdup( (struct berval *) assertValue );
3306 ldap_pvt_str2upper( value->bv_val );
3308 keys = ch_malloc( sizeof( struct berval * ) * 2 );
3310 HASH_Init( &HASHcontext );
3311 if( prefix != NULL && prefix->bv_len > 0 ) {
3312 HASH_Update( &HASHcontext,
3313 prefix->bv_val, prefix->bv_len );
3315 HASH_Update( &HASHcontext,
3316 syntax->ssyn_oid, slen );
3317 HASH_Update( &HASHcontext,
3318 mr->smr_oid, mlen );
3319 HASH_Update( &HASHcontext,
3320 value->bv_val, value->bv_len );
3321 HASH_Final( HASHdigest, &HASHcontext );
3323 keys[0] = ber_bvdup( &digest );
3326 ber_bvfree( value );
3330 return LDAP_SUCCESS;
3333 /* Substrings Index generation function */
3334 int caseIgnoreIA5SubstringsIndexer(
3339 struct berval *prefix,
3340 struct berval **values,
3341 struct berval ***keysp )
3345 struct berval **keys;
3346 HASH_CONTEXT HASHcontext;
3347 unsigned char HASHdigest[HASH_BYTES];
3348 struct berval digest;
3349 digest.bv_val = HASHdigest;
3350 digest.bv_len = sizeof(HASHdigest);
3352 /* we should have at least one value at this point */
3353 assert( values != NULL && values[0] != NULL );
3356 for( i=0; values[i] != NULL; i++ ) {
3357 /* count number of indices to generate */
3358 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
3362 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3363 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3364 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3365 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3367 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3371 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
3372 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3373 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3377 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3378 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3379 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3380 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3382 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3388 /* no keys to generate */
3390 return LDAP_SUCCESS;
3393 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3395 slen = strlen( syntax->ssyn_oid );
3396 mlen = strlen( mr->smr_oid );
3399 for( i=0; values[i] != NULL; i++ ) {
3401 struct berval *value;
3403 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
3405 value = ber_bvdup( values[i] );
3406 ldap_pvt_str2upper( value->bv_val );
3408 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
3409 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
3411 char pre = SLAP_INDEX_SUBSTR_PREFIX;
3412 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
3414 for( j=0; j<max; j++ ) {
3415 HASH_Init( &HASHcontext );
3416 if( prefix != NULL && prefix->bv_len > 0 ) {
3417 HASH_Update( &HASHcontext,
3418 prefix->bv_val, prefix->bv_len );
3421 HASH_Update( &HASHcontext,
3422 &pre, sizeof( pre ) );
3423 HASH_Update( &HASHcontext,
3424 syntax->ssyn_oid, slen );
3425 HASH_Update( &HASHcontext,
3426 mr->smr_oid, mlen );
3427 HASH_Update( &HASHcontext,
3429 SLAP_INDEX_SUBSTR_MAXLEN );
3430 HASH_Final( HASHdigest, &HASHcontext );
3432 keys[nkeys++] = ber_bvdup( &digest );
3436 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3437 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3439 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
3442 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3443 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3444 HASH_Init( &HASHcontext );
3445 if( prefix != NULL && prefix->bv_len > 0 ) {
3446 HASH_Update( &HASHcontext,
3447 prefix->bv_val, prefix->bv_len );
3449 HASH_Update( &HASHcontext,
3450 &pre, sizeof( pre ) );
3451 HASH_Update( &HASHcontext,
3452 syntax->ssyn_oid, slen );
3453 HASH_Update( &HASHcontext,
3454 mr->smr_oid, mlen );
3455 HASH_Update( &HASHcontext,
3457 HASH_Final( HASHdigest, &HASHcontext );
3459 keys[nkeys++] = ber_bvdup( &digest );
3462 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3463 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3464 HASH_Init( &HASHcontext );
3465 if( prefix != NULL && prefix->bv_len > 0 ) {
3466 HASH_Update( &HASHcontext,
3467 prefix->bv_val, prefix->bv_len );
3469 HASH_Update( &HASHcontext,
3470 &pre, sizeof( pre ) );
3471 HASH_Update( &HASHcontext,
3472 syntax->ssyn_oid, slen );
3473 HASH_Update( &HASHcontext,
3474 mr->smr_oid, mlen );
3475 HASH_Update( &HASHcontext,
3476 &value->bv_val[value->bv_len-j], j );
3477 HASH_Final( HASHdigest, &HASHcontext );
3479 keys[nkeys++] = ber_bvdup( &digest );
3484 ber_bvfree( value );
3495 return LDAP_SUCCESS;
3498 int caseIgnoreIA5SubstringsFilter(
3503 struct berval *prefix,
3505 struct berval ***keysp )
3507 SubstringsAssertion *sa = assertValue;
3509 ber_len_t nkeys = 0;
3510 size_t slen, mlen, klen;
3511 struct berval **keys;
3512 HASH_CONTEXT HASHcontext;
3513 unsigned char HASHdigest[HASH_BYTES];
3514 struct berval *value;
3515 struct berval digest;
3517 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3518 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3523 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3525 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3526 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3527 /* don't bother accounting for stepping */
3528 nkeys += sa->sa_any[i]->bv_len -
3529 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3534 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3535 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3542 return LDAP_SUCCESS;
3545 digest.bv_val = HASHdigest;
3546 digest.bv_len = sizeof(HASHdigest);
3548 slen = strlen( syntax->ssyn_oid );
3549 mlen = strlen( mr->smr_oid );
3551 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3554 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3555 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3557 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3558 value = ber_bvdup( sa->sa_initial );
3559 ldap_pvt_str2upper( value->bv_val );
3561 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3562 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3564 HASH_Init( &HASHcontext );
3565 if( prefix != NULL && prefix->bv_len > 0 ) {
3566 HASH_Update( &HASHcontext,
3567 prefix->bv_val, prefix->bv_len );
3569 HASH_Update( &HASHcontext,
3570 &pre, sizeof( pre ) );
3571 HASH_Update( &HASHcontext,
3572 syntax->ssyn_oid, slen );
3573 HASH_Update( &HASHcontext,
3574 mr->smr_oid, mlen );
3575 HASH_Update( &HASHcontext,
3576 value->bv_val, klen );
3577 HASH_Final( HASHdigest, &HASHcontext );
3579 ber_bvfree( value );
3580 keys[nkeys++] = ber_bvdup( &digest );
3583 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3585 pre = SLAP_INDEX_SUBSTR_PREFIX;
3586 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3588 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3589 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3593 value = ber_bvdup( sa->sa_any[i] );
3594 ldap_pvt_str2upper( value->bv_val );
3597 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3598 j += SLAP_INDEX_SUBSTR_STEP )
3600 HASH_Init( &HASHcontext );
3601 if( prefix != NULL && prefix->bv_len > 0 ) {
3602 HASH_Update( &HASHcontext,
3603 prefix->bv_val, prefix->bv_len );
3605 HASH_Update( &HASHcontext,
3606 &pre, sizeof( pre ) );
3607 HASH_Update( &HASHcontext,
3608 syntax->ssyn_oid, slen );
3609 HASH_Update( &HASHcontext,
3610 mr->smr_oid, mlen );
3611 HASH_Update( &HASHcontext,
3612 &value->bv_val[j], klen );
3613 HASH_Final( HASHdigest, &HASHcontext );
3615 keys[nkeys++] = ber_bvdup( &digest );
3618 ber_bvfree( value );
3622 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3623 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3625 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3626 value = ber_bvdup( sa->sa_final );
3627 ldap_pvt_str2upper( value->bv_val );
3629 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3630 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3632 HASH_Init( &HASHcontext );
3633 if( prefix != NULL && prefix->bv_len > 0 ) {
3634 HASH_Update( &HASHcontext,
3635 prefix->bv_val, prefix->bv_len );
3637 HASH_Update( &HASHcontext,
3638 &pre, sizeof( pre ) );
3639 HASH_Update( &HASHcontext,
3640 syntax->ssyn_oid, slen );
3641 HASH_Update( &HASHcontext,
3642 mr->smr_oid, mlen );
3643 HASH_Update( &HASHcontext,
3644 &value->bv_val[value->bv_len-klen], klen );
3645 HASH_Final( HASHdigest, &HASHcontext );
3647 ber_bvfree( value );
3648 keys[nkeys++] = ber_bvdup( &digest );
3659 return LDAP_SUCCESS;
3663 numericStringValidate(
3669 for(i=0; i < in->bv_len; i++) {
3670 if( !SLAP_NUMERIC(in->bv_val[i]) ) {
3671 return LDAP_INVALID_SYNTAX;
3675 return LDAP_SUCCESS;
3679 numericStringNormalize(
3682 struct berval **normalized )
3684 /* removal all spaces */
3685 struct berval *newval;
3688 newval = ch_malloc( sizeof( struct berval ) );
3689 newval->bv_val = ch_malloc( val->bv_len + 1 );
3695 if ( ASCII_SPACE( *p ) ) {
3696 /* Ignore whitespace */
3703 /* we should have copied no more then is in val */
3704 assert( (q - newval->bv_val) <= (p - val->bv_val) );
3706 /* null terminate */
3709 newval->bv_len = q - newval->bv_val;
3710 *normalized = newval;
3712 return LDAP_SUCCESS;
3716 objectIdentifierFirstComponentMatch(
3721 struct berval *value,
3722 void *assertedValue )
3724 int rc = LDAP_SUCCESS;
3726 struct berval *asserted = (struct berval *) assertedValue;
3730 if( value->bv_len == 0 || value->bv_val[0] != '(' /*')'*/ ) {
3731 return LDAP_INVALID_SYNTAX;
3734 /* trim leading white space */
3735 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < value->bv_len; i++ ) {
3739 /* grab next word */
3740 oid.bv_val = &value->bv_val[i];
3741 oid.bv_len = value->bv_len - i;
3742 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < oid.bv_len; i++ ) {
3747 /* insert attributeTypes, objectclass check here */
3748 if( OID_LEADCHAR(asserted->bv_val[0]) ) {
3749 rc = objectIdentifierMatch( &match, flags, syntax, mr, &oid, asserted );
3752 char *stored = ch_malloc( oid.bv_len + 1 );
3753 AC_MEMCPY( stored, oid.bv_val, oid.bv_len );
3754 stored[oid.bv_len] = '\0';
3756 if ( !strcmp( syntax->ssyn_oid, SLAP_SYNTAX_MATCHINGRULES_OID ) ) {
3757 MatchingRule *asserted_mr = mr_find( asserted->bv_val );
3758 MatchingRule *stored_mr = mr_find( stored );
3760 if( asserted_mr == NULL ) {
3761 rc = SLAPD_COMPARE_UNDEFINED;
3763 match = asserted_mr != stored_mr;
3766 } else if ( !strcmp( syntax->ssyn_oid,
3767 SLAP_SYNTAX_ATTRIBUTETYPES_OID ) )
3769 AttributeType *asserted_at = at_find( asserted->bv_val );
3770 AttributeType *stored_at = at_find( stored );
3772 if( asserted_at == NULL ) {
3773 rc = SLAPD_COMPARE_UNDEFINED;
3775 match = asserted_at != stored_at;
3778 } else if ( !strcmp( syntax->ssyn_oid,
3779 SLAP_SYNTAX_OBJECTCLASSES_OID ) )
3781 ObjectClass *asserted_oc = oc_find( asserted->bv_val );
3782 ObjectClass *stored_oc = oc_find( stored );
3784 if( asserted_oc == NULL ) {
3785 rc = SLAPD_COMPARE_UNDEFINED;
3787 match = asserted_oc != stored_oc;
3795 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
3796 "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
3797 match, value->bv_val, asserted->bv_val ));
3799 Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
3800 "%d\n\t\"%s\"\n\t\"%s\"\n",
3801 match, value->bv_val, asserted->bv_val );
3805 if( rc == LDAP_SUCCESS ) *matchp = match;
3810 check_time_syntax (struct berval *val,
3814 static int ceiling[9] = { 99, 99, 11, 30, 23, 59, 59, 12, 59 };
3815 static int mdays[2][12] = {
3816 /* non-leap years */
3817 { 30, 27, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 },
3819 { 30, 28, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 }
3822 int part, c, tzoffset, leapyear = 0 ;
3824 if( val->bv_len == 0 ) {
3825 return LDAP_INVALID_SYNTAX;
3828 p = (char *)val->bv_val;
3829 e = p + val->bv_len;
3831 /* Ignore initial whitespace */
3832 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3836 if (e - p < 13 - (2 * start)) {
3837 return LDAP_INVALID_SYNTAX;
3840 for (part = 0; part < 9; part++) {
3844 for (part = start; part < 7; part++) {
3846 if ((part == 6) && (c == 'Z' || c == '+' || c == '-')) {
3853 return LDAP_INVALID_SYNTAX;
3855 if (c < 0 || c > 9) {
3856 return LDAP_INVALID_SYNTAX;
3862 return LDAP_INVALID_SYNTAX;
3864 if (c < 0 || c > 9) {
3865 return LDAP_INVALID_SYNTAX;
3870 if (part == 2 || part == 3) {
3873 if (parts[part] < 0) {
3874 return LDAP_INVALID_SYNTAX;
3876 if (parts[part] > ceiling[part]) {
3877 return LDAP_INVALID_SYNTAX;
3881 /* leapyear check for the Gregorian calendar (year>1581) */
3882 if (((parts[1] % 4 == 0) && (parts[1] != 0)) ||
3883 ((parts[0] % 4 == 0) && (parts[1] == 0)))
3888 if (parts[3] > mdays[leapyear][parts[2]]) {
3889 return LDAP_INVALID_SYNTAX;
3894 tzoffset = 0; /* UTC */
3895 } else if (c != '+' && c != '-') {
3896 return LDAP_INVALID_SYNTAX;
3900 } else /* c == '+' */ {
3905 return LDAP_INVALID_SYNTAX;
3908 for (part = 7; part < 9; part++) {
3910 if (c < 0 || c > 9) {
3911 return LDAP_INVALID_SYNTAX;
3916 if (c < 0 || c > 9) {
3917 return LDAP_INVALID_SYNTAX;
3921 if (parts[part] < 0 || parts[part] > ceiling[part]) {
3922 return LDAP_INVALID_SYNTAX;
3927 /* Ignore trailing whitespace */
3928 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3932 return LDAP_INVALID_SYNTAX;
3935 switch ( tzoffset ) {
3936 case -1: /* negativ offset to UTC, ie west of Greenwich */
3937 parts[4] += parts[7];
3938 parts[5] += parts[8];
3939 for (part = 6; --part > 0; ) { /* offset is just hhmm, no seconds */
3943 c = mdays[leapyear][parts[2]];
3945 if (parts[part] > c) {
3946 parts[part] -= c + 1;
3951 case 1: /* positive offset to UTC, ie east of Greenwich */
3952 parts[4] -= parts[7];
3953 parts[5] -= parts[8];
3954 for (part = 6; --part > 0; ) {
3958 /* first arg to % needs to be non negativ */
3959 c = mdays[leapyear][(parts[2] - 1 + 12) % 12];
3961 if (parts[part] < 0) {
3962 parts[part] += c + 1;
3967 case 0: /* already UTC */
3971 return LDAP_SUCCESS;
3978 struct berval **normalized )
3983 rc = check_time_syntax(val, 1, parts);
3984 if (rc != LDAP_SUCCESS) {
3989 out = ch_malloc( sizeof(struct berval) );
3991 return LBER_ERROR_MEMORY;
3994 out->bv_val = ch_malloc( 14 );
3995 if ( out->bv_val == NULL ) {
3997 return LBER_ERROR_MEMORY;
4000 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ldZ",
4001 parts[1], parts[2] + 1, parts[3] + 1,
4002 parts[4], parts[5], parts[6] );
4006 return LDAP_SUCCESS;
4016 return check_time_syntax(in, 1, parts);
4020 generalizedTimeValidate(
4026 return check_time_syntax(in, 0, parts);
4030 generalizedTimeNormalize(
4033 struct berval **normalized )
4038 rc = check_time_syntax(val, 0, parts);
4039 if (rc != LDAP_SUCCESS) {
4044 out = ch_malloc( sizeof(struct berval) );
4046 return LBER_ERROR_MEMORY;
4049 out->bv_val = ch_malloc( 16 );
4050 if ( out->bv_val == NULL ) {
4052 return LBER_ERROR_MEMORY;
4055 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ld%02ldZ",
4056 parts[0], parts[1], parts[2] + 1, parts[3] + 1,
4057 parts[4], parts[5], parts[6] );
4061 return LDAP_SUCCESS;
4065 nisNetgroupTripleValidate(
4067 struct berval *val )
4072 if ( val->bv_len == 0 ) {
4073 return LDAP_INVALID_SYNTAX;
4076 p = (char *)val->bv_val;
4077 e = p + val->bv_len;
4079 if ( *p != '(' /*')'*/ ) {
4080 return LDAP_INVALID_SYNTAX;
4083 for ( p++; ( p < e ) && ( *p != ')' ); p++ ) {
4087 return LDAP_INVALID_SYNTAX;
4090 } else if ( !ATTR_CHAR( *p ) ) {
4091 return LDAP_INVALID_SYNTAX;
4095 if ( ( commas != 2 ) || ( *p != /*'('*/ ')' ) ) {
4096 return LDAP_INVALID_SYNTAX;
4102 return LDAP_INVALID_SYNTAX;
4105 return LDAP_SUCCESS;
4109 bootParameterValidate(
4111 struct berval *val )
4115 if ( val->bv_len == 0 ) {
4116 return LDAP_INVALID_SYNTAX;
4119 p = (char *)val->bv_val;
4120 e = p + val->bv_len;
4123 for (; ( p < e ) && ( *p != '=' ); p++ ) {
4124 if ( !ATTR_CHAR( *p ) ) {
4125 return LDAP_INVALID_SYNTAX;
4130 return LDAP_INVALID_SYNTAX;
4134 for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
4135 if ( !ATTR_CHAR( *p ) ) {
4136 return LDAP_INVALID_SYNTAX;
4141 return LDAP_INVALID_SYNTAX;
4145 for ( p++; p < e; p++ ) {
4146 if ( !ATTR_CHAR( *p ) ) {
4147 return LDAP_INVALID_SYNTAX;
4151 return LDAP_SUCCESS;
4154 struct syntax_defs_rec {
4157 slap_syntax_validate_func *sd_validate;
4158 slap_syntax_transform_func *sd_normalize;
4159 slap_syntax_transform_func *sd_pretty;
4160 #ifdef SLAPD_BINARY_CONVERSION
4161 slap_syntax_transform_func *sd_ber2str;
4162 slap_syntax_transform_func *sd_str2ber;
4166 #define X_BINARY "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
4167 #define X_NOT_H_R "X-NOT-HUMAN-READABLE 'TRUE' "
4169 struct syntax_defs_rec syntax_defs[] = {
4170 {"( 1.3.6.1.4.1.1466.115.121.1.1 DESC 'ACI Item' " X_BINARY X_NOT_H_R ")",
4171 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, NULL, NULL, NULL},
4172 {"( 1.3.6.1.4.1.1466.115.121.1.2 DESC 'Access Point' " X_NOT_H_R ")",
4173 0, NULL, NULL, NULL},
4174 {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )",
4175 0, NULL, NULL, NULL},
4176 {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' " X_NOT_H_R ")",
4177 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4178 {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' " X_NOT_H_R ")",
4179 SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4180 {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )",
4181 0, bitStringValidate, NULL, NULL },
4182 {"( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
4183 0, booleanValidate, NULL, NULL},
4184 {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' "
4185 X_BINARY X_NOT_H_R ")",
4186 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4187 {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'Certificate List' "
4188 X_BINARY X_NOT_H_R ")",
4189 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4190 {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'Certificate Pair' "
4191 X_BINARY X_NOT_H_R ")",
4192 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4193 {"( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )",
4194 0, countryStringValidate, IA5StringNormalize, NULL},
4195 {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'Distinguished Name' )",
4196 0, dnValidate, dnNormalize, dnPretty},
4197 {"( 1.3.6.1.4.1.1466.115.121.1.13 DESC 'Data Quality' )",
4198 0, NULL, NULL, NULL},
4199 {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )",
4200 0, NULL, NULL, NULL},
4201 {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )",
4202 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4203 {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )",
4204 0, NULL, NULL, NULL},
4205 {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )",
4206 0, NULL, NULL, NULL},
4207 {"( 1.3.6.1.4.1.1466.115.121.1.19 DESC 'DSA Quality' )",
4208 0, NULL, NULL, NULL},
4209 {"( 1.3.6.1.4.1.1466.115.121.1.20 DESC 'DSE Type' )",
4210 0, NULL, NULL, NULL},
4211 {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )",
4212 0, NULL, NULL, NULL},
4213 {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number' )",
4214 0, printablesStringValidate, IA5StringNormalize, NULL},
4215 {"( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' " X_NOT_H_R ")",
4216 SLAP_SYNTAX_BLOB, NULL, NULL, NULL},
4217 {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )",
4218 0, generalizedTimeValidate, generalizedTimeNormalize, NULL},
4219 {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )",
4220 0, NULL, NULL, NULL},
4221 {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )",
4222 0, IA5StringValidate, IA5StringNormalize, NULL},
4223 {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'Integer' )",
4224 0, integerValidate, integerNormalize, integerPretty},
4225 {"( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' " X_NOT_H_R ")",
4226 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4227 {"( 1.3.6.1.4.1.1466.115.121.1.29 DESC 'Master And Shadow Access Points' )",
4228 0, NULL, NULL, NULL},
4229 {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )",
4230 0, NULL, NULL, NULL},
4231 {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )",
4232 0, NULL, NULL, NULL},
4233 {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'Mail Preference' )",
4234 0, NULL, NULL, NULL},
4235 {"( 1.3.6.1.4.1.1466.115.121.1.33 DESC 'MHS OR Address' )",
4236 0, NULL, NULL, NULL},
4237 {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )",
4238 0, nameUIDValidate, nameUIDNormalize, NULL},
4239 {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )",
4240 0, NULL, NULL, NULL},
4241 {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )",
4242 0, numericStringValidate, numericStringNormalize, NULL},
4243 {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )",
4244 0, NULL, NULL, NULL},
4245 {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )",
4246 0, oidValidate, NULL, NULL},
4247 {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )",
4248 0, IA5StringValidate, IA5StringNormalize, NULL},
4249 {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )",
4250 0, blobValidate, NULL, NULL},
4251 {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )",
4252 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4253 {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'Protocol Information' )",
4254 0, NULL, NULL, NULL},
4255 {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'Presentation Address' )",
4256 0, NULL, NULL, NULL},
4257 {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )",
4258 0, printableStringValidate, IA5StringNormalize, NULL},
4259 {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'Supported Algorithm' "
4260 X_BINARY X_NOT_H_R ")",
4261 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4262 {"( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )",
4263 0, printableStringValidate, IA5StringNormalize, NULL},
4264 {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )",
4265 0, NULL, NULL, NULL},
4266 {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )",
4267 0, printableStringValidate, IA5StringNormalize, NULL},
4268 {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )",
4269 0, utcTimeValidate, utcTimeNormalize, NULL},
4270 {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )",
4271 0, NULL, NULL, NULL},
4272 {"( 1.3.6.1.4.1.1466.115.121.1.55 DESC 'Modify Rights' )",
4273 0, NULL, NULL, NULL},
4274 {"( 1.3.6.1.4.1.1466.115.121.1.56 DESC 'LDAP Schema Definition' )",
4275 0, NULL, NULL, NULL},
4276 {"( 1.3.6.1.4.1.1466.115.121.1.57 DESC 'LDAP Schema Description' )",
4277 0, NULL, NULL, NULL},
4278 {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )",
4279 0, NULL, NULL, NULL},
4281 /* RFC 2307 NIS Syntaxes */
4282 {"( 1.3.6.1.1.1.0.0 DESC 'RFC2307 NIS Netgroup Triple' )",
4283 0, nisNetgroupTripleValidate, NULL, NULL},
4284 {"( 1.3.6.1.1.1.0.1 DESC 'RFC2307 Boot Parameter' )",
4285 0, bootParameterValidate, NULL, NULL},
4287 /* OpenLDAP Experimental Syntaxes */
4288 {"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
4289 0, UTF8StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
4291 {"( 1.3.6.1.4.1.4203.666.2.2 DESC 'OpenLDAP authPassword' )",
4292 0, NULL, NULL, NULL},
4294 /* OpenLDAP Void Syntax */
4295 {"( 1.3.6.1.4.1.4203.1.1.1 DESC 'OpenLDAP void' )" ,
4296 SLAP_SYNTAX_HIDE, inValidate, NULL, NULL},
4297 {NULL, 0, NULL, NULL, NULL}
4300 struct mrule_defs_rec {
4302 slap_mask_t mrd_usage;
4303 slap_mr_convert_func * mrd_convert;
4304 slap_mr_normalize_func * mrd_normalize;
4305 slap_mr_match_func * mrd_match;
4306 slap_mr_indexer_func * mrd_indexer;
4307 slap_mr_filter_func * mrd_filter;
4309 char * mrd_associated;
4313 * Other matching rules in X.520 that we do not use (yet):
4315 * 2.5.13.9 numericStringOrderingMatch
4316 * 2.5.13.15 integerOrderingMatch
4317 * 2.5.13.18 octetStringOrderingMatch
4318 * 2.5.13.19 octetStringSubstringsMatch
4319 * 2.5.13.25 uTCTimeMatch
4320 * 2.5.13.26 uTCTimeOrderingMatch
4321 * 2.5.13.31 directoryStringFirstComponentMatch
4322 * 2.5.13.32 wordMatch
4323 * 2.5.13.33 keywordMatch
4324 * 2.5.13.34 certificateExactMatch
4325 * 2.5.13.35 certificateMatch
4326 * 2.5.13.36 certificatePairExactMatch
4327 * 2.5.13.37 certificatePairMatch
4328 * 2.5.13.38 certificateListExactMatch
4329 * 2.5.13.39 certificateListMatch
4330 * 2.5.13.40 algorithmIdentifierMatch
4331 * 2.5.13.41 storedPrefixMatch
4332 * 2.5.13.42 attributeCertificateMatch
4333 * 2.5.13.43 readerAndKeyIDMatch
4334 * 2.5.13.44 attributeIntegrityMatch
4337 struct mrule_defs_rec mrule_defs[] = {
4339 * EQUALITY matching rules must be listed after associated APPROX
4340 * matching rules. So, we list all APPROX matching rules first.
4342 {"( " directoryStringApproxMatchOID " NAME 'directoryStringApproxMatch' "
4343 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4344 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4346 directoryStringApproxMatch,
4347 directoryStringApproxIndexer,
4348 directoryStringApproxFilter,
4351 {"( " IA5StringApproxMatchOID " NAME 'IA5StringApproxMatch' "
4352 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4353 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4355 IA5StringApproxMatch,
4356 IA5StringApproxIndexer,
4357 IA5StringApproxFilter,
4361 * Other matching rules
4364 {"( 2.5.13.0 NAME 'objectIdentifierMatch' "
4365 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4366 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4368 objectIdentifierMatch, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4371 {"( 2.5.13.1 NAME 'distinguishedNameMatch' "
4372 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
4373 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4375 dnMatch, dnIndexer, dnFilter,
4378 {"( 2.5.13.2 NAME 'caseIgnoreMatch' "
4379 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4380 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4382 caseIgnoreMatch, caseIgnoreIndexer, caseIgnoreFilter,
4383 directoryStringApproxMatchOID },
4385 {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' "
4386 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4389 caseIgnoreOrderingMatch, NULL, NULL,
4392 {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' "
4393 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4394 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4396 caseIgnoreSubstringsMatch,
4397 caseIgnoreSubstringsIndexer,
4398 caseIgnoreSubstringsFilter,
4401 {"( 2.5.13.5 NAME 'caseExactMatch' "
4402 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4403 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4405 caseExactMatch, caseExactIndexer, caseExactFilter,
4406 directoryStringApproxMatchOID },
4408 {"( 2.5.13.6 NAME 'caseExactOrderingMatch' "
4409 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4412 caseExactOrderingMatch, NULL, NULL,
4415 {"( 2.5.13.7 NAME 'caseExactSubstringsMatch' "
4416 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4417 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4419 caseExactSubstringsMatch,
4420 caseExactSubstringsIndexer,
4421 caseExactSubstringsFilter,
4424 {"( 2.5.13.8 NAME 'numericStringMatch' "
4425 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
4426 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4429 caseIgnoreIA5Indexer,
4430 caseIgnoreIA5Filter,
4433 {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' "
4434 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4435 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4437 caseIgnoreIA5SubstringsMatch,
4438 caseIgnoreIA5SubstringsIndexer,
4439 caseIgnoreIA5SubstringsFilter,
4442 {"( 2.5.13.11 NAME 'caseIgnoreListMatch' "
4443 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )",
4444 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4446 caseIgnoreListMatch, NULL, NULL,
4449 {"( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch' "
4450 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4451 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4453 caseIgnoreListSubstringsMatch, NULL, NULL,
4456 {"( 2.5.13.13 NAME 'booleanMatch' "
4457 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )",
4458 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4460 booleanMatch, NULL, NULL,
4463 {"( 2.5.13.14 NAME 'integerMatch' "
4464 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4465 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4467 integerMatch, integerIndexer, integerFilter,
4470 {"( 2.5.13.16 NAME 'bitStringMatch' "
4471 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )",
4472 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4474 bitStringMatch, NULL, NULL,
4477 {"( 2.5.13.17 NAME 'octetStringMatch' "
4478 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4479 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4481 octetStringMatch, octetStringIndexer, octetStringFilter,
4484 {"( 2.5.13.20 NAME 'telephoneNumberMatch' "
4485 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
4486 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4488 telephoneNumberMatch,
4489 telephoneNumberIndexer,
4490 telephoneNumberFilter,
4493 {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' "
4494 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4495 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4497 telephoneNumberSubstringsMatch,
4498 telephoneNumberSubstringsIndexer,
4499 telephoneNumberSubstringsFilter,
4502 {"( 2.5.13.22 NAME 'presentationAddressMatch' "
4503 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )",
4504 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4509 {"( 2.5.13.23 NAME 'uniqueMemberMatch' "
4510 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )",
4511 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4513 uniqueMemberMatch, NULL, NULL,
4516 {"( 2.5.13.24 NAME 'protocolInformationMatch' "
4517 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )",
4518 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4520 protocolInformationMatch, NULL, NULL,
4523 {"( 2.5.13.27 NAME 'generalizedTimeMatch' "
4524 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4525 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4527 generalizedTimeMatch, NULL, NULL,
4530 {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' "
4531 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4534 generalizedTimeOrderingMatch, NULL, NULL,
4537 {"( 2.5.13.29 NAME 'integerFirstComponentMatch' "
4538 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4539 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4541 integerFirstComponentMatch, NULL, NULL,
4544 {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' "
4545 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4546 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4548 objectIdentifierFirstComponentMatch, NULL, NULL,
4551 {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' "
4552 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4553 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4555 caseExactIA5Match, caseExactIA5Indexer, caseExactIA5Filter,
4556 IA5StringApproxMatchOID },
4558 {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' "
4559 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4560 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4562 caseIgnoreIA5Match, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4563 IA5StringApproxMatchOID },
4565 {"( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch' "
4566 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4569 caseIgnoreIA5SubstringsMatch,
4570 caseIgnoreIA5SubstringsIndexer,
4571 caseIgnoreIA5SubstringsFilter,
4574 {"( 1.3.6.1.4.1.4203.1.2.1 NAME 'caseExactIA5SubstringsMatch' "
4575 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4578 caseExactIA5SubstringsMatch,
4579 caseExactIA5SubstringsIndexer,
4580 caseExactIA5SubstringsFilter,
4583 {"( 1.3.6.1.4.1.4203.666.4.1 NAME 'authPasswordMatch' "
4584 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4587 authPasswordMatch, NULL, NULL,
4590 {"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
4591 "SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
4594 OpenLDAPaciMatch, NULL, NULL,
4597 {NULL, SLAP_MR_NONE, NULL, NULL, NULL, NULL}
4606 /* we should only be called once (from main) */
4607 assert( schema_init_done == 0 );
4609 for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
4610 res = register_syntax( syntax_defs[i].sd_desc,
4611 syntax_defs[i].sd_flags,
4612 syntax_defs[i].sd_validate,
4613 syntax_defs[i].sd_normalize,
4614 syntax_defs[i].sd_pretty
4615 #ifdef SLAPD_BINARY_CONVERSION
4617 syntax_defs[i].sd_ber2str,
4618 syntax_defs[i].sd_str2ber
4623 fprintf( stderr, "schema_init: Error registering syntax %s\n",
4624 syntax_defs[i].sd_desc );
4629 for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
4630 if( mrule_defs[i].mrd_usage == SLAP_MR_NONE ) {
4632 "schema_init: Ingoring unusable matching rule %s\n",
4633 mrule_defs[i].mrd_desc );
4637 res = register_matching_rule(
4638 mrule_defs[i].mrd_desc,
4639 mrule_defs[i].mrd_usage,
4640 mrule_defs[i].mrd_convert,
4641 mrule_defs[i].mrd_normalize,
4642 mrule_defs[i].mrd_match,
4643 mrule_defs[i].mrd_indexer,
4644 mrule_defs[i].mrd_filter,
4645 mrule_defs[i].mrd_associated );
4649 "schema_init: Error registering matching rule %s\n",
4650 mrule_defs[i].mrd_desc );
4654 schema_init_done = 1;
4655 return LDAP_SUCCESS;