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 /* we should have at least one value at this point */
136 assert( values != NULL && values[0] != NULL );
138 for( i=0; values[i] != NULL; i++ ) {
139 /* just count them */
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 #ifdef USE_DN_NORMALIZE
256 out = ber_bvstr( UTF8normalize( val->bv_val, UTF8_CASEFOLD ) );
258 out = ber_bvdup( val );
259 ldap_pvt_str2upper( out->bv_val );
261 dn = dn_validate( out->bv_val );
265 return LDAP_INVALID_SYNTAX;
269 out->bv_len = strlen( dn );
271 out = ber_bvdup( val );
284 struct berval *value,
285 void *assertedValue )
288 struct berval *asserted = (struct berval *) assertedValue;
290 match = value->bv_len - asserted->bv_len;
293 #ifdef USE_DN_NORMALIZE
294 match = strcmp( value->bv_val, asserted->bv_val );
296 match = strcasecmp( value->bv_val, asserted->bv_val );
301 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
302 "dnMatch: %d\n %s\n %s\n", match,
303 value->bv_val, asserted->bv_val ));
305 Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
306 match, value->bv_val, asserted->bv_val );
322 if( in->bv_len == 0 ) return LDAP_SUCCESS;
324 dn = ber_bvdup( in );
326 if( dn->bv_val[dn->bv_len-1] == '\'' ) {
327 /* assume presence of optional UID */
330 for(i=dn->bv_len-2; i>2; i--) {
331 if( dn->bv_val[i] != '0' && dn->bv_val[i] != '1' ) {
335 if( dn->bv_val[i] != '\'' ) {
336 return LDAP_INVALID_SYNTAX;
338 if( dn->bv_val[i-1] != 'B' ) {
339 return LDAP_INVALID_SYNTAX;
341 if( dn->bv_val[i-2] != '#' ) {
342 return LDAP_INVALID_SYNTAX;
345 /* trim the UID to allow use of dn_validate */
346 dn->bv_val[i-2] = '\0';
349 rc = dn_validate( dn->bv_val ) == NULL
350 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
360 struct berval **normalized )
362 struct berval *out = ber_bvdup( val );
364 if( out->bv_len != 0 ) {
368 ber_len_t uidlen = 0;
370 if( out->bv_val[out->bv_len-1] == '\'' ) {
371 /* assume presence of optional UID */
372 uid = strrchr( out->bv_val, '#' );
376 return LDAP_INVALID_SYNTAX;
379 uidlen = out->bv_len - (out->bv_val - uid);
380 /* temporarily trim the UID */
384 #ifdef USE_DN_NORMALIZE
385 dn = dn_normalize( out->bv_val );
387 dn = dn_validate( out->bv_val );
392 return LDAP_INVALID_SYNTAX;
398 /* restore the separator */
401 SAFEMEMCPY( &dn[dnlen], uid, uidlen );
405 out->bv_len = dnlen + uidlen;
417 /* any value allowed */
426 /* any value allowed */
437 /* very unforgiving validation, requires no normalization
438 * before simplistic matching
440 if( in->bv_len < 3 ) {
441 return LDAP_INVALID_SYNTAX;
444 if( in->bv_val[0] != 'B' ||
445 in->bv_val[1] != '\'' ||
446 in->bv_val[in->bv_len-1] != '\'' )
448 return LDAP_INVALID_SYNTAX;
451 for( i=in->bv_len-2; i>1; i-- ) {
452 if( in->bv_val[i] != '0' && in->bv_val[i] != '1' ) {
453 return LDAP_INVALID_SYNTAX;
461 * Handling boolean syntax and matching is quite rigid.
462 * A more flexible approach would be to allow a variety
463 * of strings to be normalized and prettied into TRUE
471 /* very unforgiving validation, requires no normalization
472 * before simplistic matching
475 if( in->bv_len == 4 ) {
476 if( !memcmp( in->bv_val, "TRUE", 4 ) ) {
479 } else if( in->bv_len == 5 ) {
480 if( !memcmp( in->bv_val, "FALSE", 5 ) ) {
485 return LDAP_INVALID_SYNTAX;
494 struct berval *value,
495 void *assertedValue )
497 /* simplistic matching allowed by rigid validation */
498 struct berval *asserted = (struct berval *) assertedValue;
499 *matchp = value->bv_len != asserted->bv_len;
503 /* case insensitive UTF8 strncmp with offset for second string */
506 struct berval *right,
512 ber_len_t rlen, llen;
513 ber_len_t rslen, lslen;
514 ldap_unicode_t ru, lu;
515 ldap_unicode_t ruu, luu;
517 rslen = len < right->bv_len ? len : right->bv_len;
518 lslen = len + offset < left->bv_len ? len : left->bv_len;
520 for( r = 0, l = offset;
521 r < rslen && l < lslen;
525 * XXYYZ: we convert to ucs4 even though -llunicode
526 * expects ucs2 in an unsigned long
528 ru = ldap_x_utf8_to_ucs4( &right->bv_val[r] );
529 if( ru == LDAP_UCS4_INVALID ) {
533 lu = ldap_x_utf8_to_ucs4( &left->bv_val[l] );
534 if( lu == LDAP_UCS4_INVALID ) {
538 ruu = uctoupper( ru );
539 luu = uctoupper( lu );
543 } else if( luu > ruu ) {
547 rlen = LDAP_UTF8_CHARLEN( &right->bv_val[r] );
548 llen = LDAP_UTF8_CHARLEN( &left->bv_val[l] );
564 static char *UTF8casechr( const char *str, const char *c )
566 char *p, *lower, *upper;
567 ldap_ucs4_t tch, ch = ldap_x_utf8_to_ucs4(c);
569 tch = uctolower ( ch );
570 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
571 if( ldap_x_utf8_to_ucs4( p ) == tch ) {
575 lower = *p != '\0' ? p : NULL;
577 tch = uctoupper ( ch );
578 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
579 if( ldap_x_utf8_to_ucs4( p ) == tch ) {
583 upper = *p != '\0' ? p : NULL;
585 if( lower && upper ) {
586 return lower < upper ? lower : upper;
587 } else if ( lower ) {
601 unsigned char *u = in->bv_val;
603 if( !in->bv_len ) return LDAP_INVALID_SYNTAX;
605 for( count = in->bv_len; count > 0; count-=len, u+=len ) {
606 /* get the length indicated by the first byte */
607 len = LDAP_UTF8_CHARLEN( u );
609 /* should not be zero */
610 if( len == 0 ) return LDAP_INVALID_SYNTAX;
612 /* make sure len corresponds with the offset
613 to the next character */
614 if( LDAP_UTF8_OFFSET( u ) != len ) return LDAP_INVALID_SYNTAX;
617 if( count != 0 ) return LDAP_INVALID_SYNTAX;
626 struct berval **normalized )
628 struct berval *newval;
631 newval = ch_malloc( sizeof( struct berval ) );
635 /* Ignore initial whitespace */
636 while ( ldap_utf8_isspace( p ) ) {
642 return LDAP_INVALID_SYNTAX;
645 newval->bv_val = ch_strdup( p );
646 p = q = newval->bv_val;
652 if ( ldap_utf8_isspace( p ) ) {
653 len = LDAP_UTF8_COPY(q,p);
658 /* Ignore the extra whitespace */
659 while ( ldap_utf8_isspace( p ) ) {
663 len = LDAP_UTF8_COPY(q,p);
670 assert( *newval->bv_val );
671 assert( newval->bv_val < p );
674 /* cannot start with a space */
675 assert( !ldap_utf8_isspace(newval->bv_val) );
678 * If the string ended in space, backup the pointer one
679 * position. One is enough because the above loop collapsed
680 * all whitespace to a single space.
687 /* cannot end with a space */
688 assert( !ldap_utf8_isspace( LDAP_UTF8_PREV(q) ) );
693 newval->bv_len = q - newval->bv_val;
694 *normalized = newval;
699 /* Returns Unicode cannonically normalized copy of a substring assertion
700 * Skipping attribute description */
701 SubstringsAssertion *
702 UTF8SubstringsassertionNormalize(
703 SubstringsAssertion *sa,
706 SubstringsAssertion *nsa;
709 nsa = (SubstringsAssertion *)ch_calloc( 1, sizeof(SubstringsAssertion) );
714 if( sa->sa_initial != NULL ) {
715 nsa->sa_initial = ber_bvstr( UTF8normalize( sa->sa_initial->bv_val, casefold ) );
716 if( nsa->sa_initial == NULL ) {
721 if( sa->sa_any != NULL ) {
722 for( i=0; sa->sa_any[i] != NULL; i++ ) {
725 nsa->sa_any = (struct berval **)ch_malloc( (i + 1) * sizeof(struct berval *) );
726 for( i=0; sa->sa_any[i] != NULL; i++ ) {
727 nsa->sa_any[i] = ber_bvstr( UTF8normalize( sa->sa_any[i]->bv_val, casefold ) );
728 if( nsa->sa_any[i] == NULL ) {
732 nsa->sa_any[i] = NULL;
735 if( sa->sa_final != NULL ) {
736 nsa->sa_final = ber_bvstr( UTF8normalize( sa->sa_final->bv_val, casefold ) );
737 if( nsa->sa_final == NULL ) {
745 ch_free( nsa->sa_final );
746 ber_bvecfree( nsa->sa_any );
747 ch_free( nsa->sa_initial );
752 #if defined(SLAPD_APPROX_MULTISTRING)
754 #if defined(SLAPD_APPROX_INITIALS)
755 #define SLAPD_APPROX_DELIMITER "._ "
756 #define SLAPD_APPROX_WORDLEN 2
758 #define SLAPD_APPROX_DELIMITER " "
759 #define SLAPD_APPROX_WORDLEN 1
768 struct berval *value,
769 void *assertedValue )
771 char *val, *assertv, **values, **words, *c;
772 int i, count, len, nextchunk=0, nextavail=0;
775 /* Isolate how many words there are */
776 val = ch_strdup( value->bv_val );
777 for( c=val,count=1; *c; c++ ) {
778 c = strpbrk( c, SLAPD_APPROX_DELIMITER );
779 if ( c == NULL ) break;
784 /* Get a phonetic copy of each word */
785 words = (char **)ch_malloc( count * sizeof(char *) );
786 values = (char **)ch_malloc( count * sizeof(char *) );
787 for( c=val,i=0; i<count; i++,c+=strlen(c)+1 ) {
789 values[i] = phonetic(c);
793 /* Work through the asserted value's words, to see if at least some
794 of the words are there, in the same order. */
795 assertv = ch_strdup( ((struct berval *)assertedValue)->bv_val );
797 while ( nextchunk < ((struct berval *)assertedValue)->bv_len ) {
798 len = strcspn( assertv + nextchunk, SLAPD_APPROX_DELIMITER);
803 #if defined(SLAPD_APPROX_INITIALS)
804 else if( len == 1 ) {
805 /* Single letter words need to at least match one word's initial */
806 for( i=nextavail; i<count; i++ )
807 if( !strncasecmp( assertv+nextchunk, words[i], 1 )) {
814 /* Isolate the next word in the asserted value and phonetic it */
815 assertv[nextchunk+len] = '\0';
816 val = phonetic( assertv + nextchunk );
818 /* See if this phonetic chunk is in the remaining words of *value */
819 for( i=nextavail; i<count; i++ ){
820 if( !strcmp( val, values[i] ) ){
827 /* This chunk in the asserted value was NOT within the *value. */
833 /* Go on to the next word in the asserted value */
837 /* If some of the words were seen, call it a match */
838 if( nextavail > 0 ) {
847 for( i=0; i<count; i++ ) {
848 ch_free( values[i] );
864 struct berval *prefix,
865 struct berval **values,
866 struct berval ***keysp )
869 int i,j, len, wordcount, keycount=0;
870 struct berval **newkeys, **keys=NULL;
873 for( j=0; values[j] != NULL; j++ ) {
875 /* Isolate how many words there are. There will be a key for each */
876 val = ch_strdup( values[j]->bv_val );
877 for( wordcount=0,c=val; *c; c++) {
878 len = strcspn(c, SLAPD_APPROX_DELIMITER);
879 if( len >= SLAPD_APPROX_WORDLEN ) wordcount++;
881 if (*c == '\0') break;
885 /* Allocate/increase storage to account for new keys */
886 newkeys = (struct berval **)ch_malloc( (keycount + wordcount + 1)
887 * sizeof(struct berval *) );
888 memcpy( newkeys, keys, keycount * sizeof(struct berval *) );
889 if( keys ) ch_free( keys );
892 /* Get a phonetic copy of each word */
893 for( c=val,i=0; i<wordcount; c+=len+1 ) {
895 if( len < SLAPD_APPROX_WORDLEN ) continue;
896 keys[keycount] = (struct berval *)ch_malloc( sizeof(struct berval) );
897 keys[keycount]->bv_val = phonetic( c );
898 keys[keycount]->bv_len = strlen( keys[keycount]->bv_val );
905 keys[keycount] = NULL;
918 struct berval *prefix,
920 struct berval ***keysp )
924 struct berval **keys;
927 /* Isolate how many words there are. There will be a key for each */
928 val = ch_strdup( ((struct berval *)assertValue)->bv_val );
929 for( count=0,c=val; *c; c++) {
930 len = strcspn(c, SLAPD_APPROX_DELIMITER);
931 if( len >= SLAPD_APPROX_WORDLEN ) count++;
933 if (*c == '\0') break;
937 /* Allocate storage for new keys */
938 keys = (struct berval **)ch_malloc( (count + 1) * sizeof(struct berval *) );
940 /* Get a phonetic copy of each word */
941 for( c=val,i=0; i<count; c+=len+1 ) {
943 if( len < SLAPD_APPROX_WORDLEN ) continue;
944 keys[i] = (struct berval *)ch_malloc( sizeof(struct berval) );
945 keys[i]->bv_val = phonetic( c );
946 keys[i]->bv_len = strlen( keys[i]->bv_val );
960 /* No other form of Approximate Matching is defined */
968 struct berval *value,
969 void *assertedValue )
971 char *vapprox, *avapprox;
973 vapprox = phonetic( value->bv_val );
974 avapprox = phonetic( ((struct berval *)assertedValue)->bv_val);
976 *matchp = strcmp( vapprox, avapprox );
990 struct berval *prefix,
991 struct berval **values,
992 struct berval ***keysp )
995 struct berval **keys;
998 for( i=0; values[i] != NULL; i++ ) {
999 /* just count them */
1003 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * (i+1) );
1005 /* Copy each value and run it through phonetic() */
1006 for( i=0; values[i] != NULL; i++ ) {
1007 keys[i] = ch_malloc( sizeof( struct berval * ) );
1008 keys[i]->bv_val = phonetic( values[i]->bv_val );
1009 keys[i]->bv_len = strlen( keys[i]->bv_val );
1014 return LDAP_SUCCESS;
1024 struct berval *prefix,
1026 struct berval ***keysp )
1028 struct berval **keys;
1031 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * 2 );
1033 /* Copy the value and run it through phonetic() */
1034 keys[0] = ch_malloc( sizeof( struct berval * ) );
1035 keys[0]->bv_val = phonetic( ((struct berval *)assertValue)->bv_val );
1036 keys[0]->bv_len = strlen( keys[0]->bv_val );
1040 return LDAP_SUCCESS;
1051 struct berval *value,
1052 void *assertedValue )
1054 *matchp = UTF8normcmp( value->bv_val,
1055 ((struct berval *) assertedValue)->bv_val,
1057 return LDAP_SUCCESS;
1061 caseExactSubstringsMatch(
1066 struct berval *value,
1067 void *assertedValue )
1070 SubstringsAssertion *sub;
1076 nav = UTF8normalize( value->bv_val, UTF8_NOCASEFOLD );
1082 left.bv_len = strlen( nav );
1084 sub = UTF8SubstringsassertionNormalize( assertedValue, UTF8_NOCASEFOLD );
1090 /* Add up asserted input length */
1091 if( sub->sa_initial ) {
1092 inlen += sub->sa_initial->bv_len;
1095 for(i=0; sub->sa_any[i] != NULL; i++) {
1096 inlen += sub->sa_any[i]->bv_len;
1099 if( sub->sa_final ) {
1100 inlen += sub->sa_final->bv_len;
1103 if( sub->sa_initial ) {
1104 if( inlen > left.bv_len ) {
1109 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1110 sub->sa_initial->bv_len );
1116 left.bv_val += sub->sa_initial->bv_len;
1117 left.bv_len -= sub->sa_initial->bv_len;
1118 inlen -= sub->sa_initial->bv_len;
1121 if( sub->sa_final ) {
1122 if( inlen > left.bv_len ) {
1127 match = strncmp( sub->sa_final->bv_val,
1128 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1129 sub->sa_final->bv_len );
1135 left.bv_len -= sub->sa_final->bv_len;
1136 inlen -= sub->sa_final->bv_len;
1140 for(i=0; sub->sa_any[i]; i++) {
1145 if( inlen > left.bv_len ) {
1146 /* not enough length */
1151 if( sub->sa_any[i]->bv_len == 0 ) {
1155 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1162 idx = p - left.bv_val;
1163 assert( idx < left.bv_len );
1165 if( idx >= left.bv_len ) {
1166 /* this shouldn't happen */
1173 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1174 /* not enough left */
1179 match = strncmp( left.bv_val,
1180 sub->sa_any[i]->bv_val,
1181 sub->sa_any[i]->bv_len );
1189 left.bv_val += sub->sa_any[i]->bv_len;
1190 left.bv_len -= sub->sa_any[i]->bv_len;
1191 inlen -= sub->sa_any[i]->bv_len;
1198 ch_free( sub->sa_final );
1199 ber_bvecfree( sub->sa_any );
1200 ch_free( sub->sa_initial );
1204 return LDAP_SUCCESS;
1207 /* Index generation function */
1208 int caseExactIndexer(
1213 struct berval *prefix,
1214 struct berval **values,
1215 struct berval ***keysp )
1219 struct berval **keys;
1220 HASH_CONTEXT HASHcontext;
1221 unsigned char HASHdigest[HASH_BYTES];
1222 struct berval digest;
1223 digest.bv_val = HASHdigest;
1224 digest.bv_len = sizeof(HASHdigest);
1226 /* we should have at least one value at this point */
1227 assert( values != NULL && values[0] != NULL );
1229 for( i=0; values[i] != NULL; i++ ) {
1230 /* just count them */
1233 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1235 slen = strlen( syntax->ssyn_oid );
1236 mlen = strlen( mr->smr_oid );
1238 for( i=0; values[i] != NULL; i++ ) {
1239 struct berval *value;
1240 value = ber_bvstr( UTF8normalize( values[i]->bv_val,
1241 UTF8_NOCASEFOLD ) );
1243 HASH_Init( &HASHcontext );
1244 if( prefix != NULL && prefix->bv_len > 0 ) {
1245 HASH_Update( &HASHcontext,
1246 prefix->bv_val, prefix->bv_len );
1248 HASH_Update( &HASHcontext,
1249 syntax->ssyn_oid, slen );
1250 HASH_Update( &HASHcontext,
1251 mr->smr_oid, mlen );
1252 HASH_Update( &HASHcontext,
1253 value->bv_val, value->bv_len );
1254 HASH_Final( HASHdigest, &HASHcontext );
1256 ber_bvfree( value );
1258 keys[i] = ber_bvdup( &digest );
1263 return LDAP_SUCCESS;
1266 /* Index generation function */
1267 int caseExactFilter(
1272 struct berval *prefix,
1274 struct berval ***keysp )
1277 struct berval **keys;
1278 HASH_CONTEXT HASHcontext;
1279 unsigned char HASHdigest[HASH_BYTES];
1280 struct berval *value;
1281 struct berval digest;
1282 digest.bv_val = HASHdigest;
1283 digest.bv_len = sizeof(HASHdigest);
1285 slen = strlen( syntax->ssyn_oid );
1286 mlen = strlen( mr->smr_oid );
1288 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1289 UTF8_NOCASEFOLD ) );
1290 /* This usually happens if filter contains bad UTF8 */
1291 if( value == NULL ) {
1292 keys = ch_malloc( sizeof( struct berval * ) );
1294 return LDAP_SUCCESS;
1297 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1299 HASH_Init( &HASHcontext );
1300 if( prefix != NULL && prefix->bv_len > 0 ) {
1301 HASH_Update( &HASHcontext,
1302 prefix->bv_val, prefix->bv_len );
1304 HASH_Update( &HASHcontext,
1305 syntax->ssyn_oid, slen );
1306 HASH_Update( &HASHcontext,
1307 mr->smr_oid, mlen );
1308 HASH_Update( &HASHcontext,
1309 value->bv_val, value->bv_len );
1310 HASH_Final( HASHdigest, &HASHcontext );
1312 keys[0] = ber_bvdup( &digest );
1316 ber_bvfree( value );
1320 return LDAP_SUCCESS;
1323 /* Substrings Index generation function */
1324 int caseExactSubstringsIndexer(
1329 struct berval *prefix,
1330 struct berval **values,
1331 struct berval ***keysp )
1335 struct berval **keys;
1336 struct berval **nvalues;
1338 HASH_CONTEXT HASHcontext;
1339 unsigned char HASHdigest[HASH_BYTES];
1340 struct berval digest;
1341 digest.bv_val = HASHdigest;
1342 digest.bv_len = sizeof(HASHdigest);
1344 /* we should have at least one value at this point */
1345 assert( values != NULL && values[0] != NULL );
1349 /* create normalized copy of values */
1350 for( i=0; values[i] != NULL; i++ ) {
1353 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
1354 for( i=0; values[i] != NULL; i++ ) {
1355 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val,
1356 UTF8_NOCASEFOLD ) );
1361 for( i=0; values[i] != NULL; i++ ) {
1362 /* count number of indices to generate */
1363 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1367 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1368 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1369 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1370 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1372 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1376 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1377 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1378 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1382 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1383 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1384 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1385 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1387 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1393 /* no keys to generate */
1395 return LDAP_SUCCESS;
1398 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1400 slen = strlen( syntax->ssyn_oid );
1401 mlen = strlen( mr->smr_oid );
1404 for( i=0; values[i] != NULL; i++ ) {
1406 struct berval *value;
1408 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
1412 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
1413 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
1415 char pre = SLAP_INDEX_SUBSTR_PREFIX;
1416 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
1418 for( j=0; j<max; j++ ) {
1419 HASH_Init( &HASHcontext );
1420 if( prefix != NULL && prefix->bv_len > 0 ) {
1421 HASH_Update( &HASHcontext,
1422 prefix->bv_val, prefix->bv_len );
1425 HASH_Update( &HASHcontext,
1426 &pre, sizeof( pre ) );
1427 HASH_Update( &HASHcontext,
1428 syntax->ssyn_oid, slen );
1429 HASH_Update( &HASHcontext,
1430 mr->smr_oid, mlen );
1431 HASH_Update( &HASHcontext,
1433 SLAP_INDEX_SUBSTR_MAXLEN );
1434 HASH_Final( HASHdigest, &HASHcontext );
1436 keys[nkeys++] = ber_bvdup( &digest );
1440 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1441 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1443 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
1446 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1447 pre = SLAP_INDEX_SUBSTR_INITIAL_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,
1461 HASH_Final( HASHdigest, &HASHcontext );
1463 keys[nkeys++] = ber_bvdup( &digest );
1466 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1467 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1468 HASH_Init( &HASHcontext );
1469 if( prefix != NULL && prefix->bv_len > 0 ) {
1470 HASH_Update( &HASHcontext,
1471 prefix->bv_val, prefix->bv_len );
1473 HASH_Update( &HASHcontext,
1474 &pre, sizeof( pre ) );
1475 HASH_Update( &HASHcontext,
1476 syntax->ssyn_oid, slen );
1477 HASH_Update( &HASHcontext,
1478 mr->smr_oid, mlen );
1479 HASH_Update( &HASHcontext,
1480 &value->bv_val[value->bv_len-j], j );
1481 HASH_Final( HASHdigest, &HASHcontext );
1483 keys[nkeys++] = ber_bvdup( &digest );
1498 ber_bvecfree( nvalues );
1500 return LDAP_SUCCESS;
1503 int caseExactSubstringsFilter(
1508 struct berval *prefix,
1510 struct berval ***keysp )
1512 SubstringsAssertion *sa;
1514 ber_len_t nkeys = 0;
1515 size_t slen, mlen, klen;
1516 struct berval **keys;
1517 HASH_CONTEXT HASHcontext;
1518 unsigned char HASHdigest[HASH_BYTES];
1519 struct berval *value;
1520 struct berval digest;
1522 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_NOCASEFOLD );
1525 return LDAP_SUCCESS;
1528 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1529 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1534 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1536 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1537 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1538 /* don't bother accounting for stepping */
1539 nkeys += sa->sa_any[i]->bv_len -
1540 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1545 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1546 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1553 return LDAP_SUCCESS;
1556 digest.bv_val = HASHdigest;
1557 digest.bv_len = sizeof(HASHdigest);
1559 slen = strlen( syntax->ssyn_oid );
1560 mlen = strlen( mr->smr_oid );
1562 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1565 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1566 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1568 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1569 value = sa->sa_initial;
1571 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1572 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1574 HASH_Init( &HASHcontext );
1575 if( prefix != NULL && prefix->bv_len > 0 ) {
1576 HASH_Update( &HASHcontext,
1577 prefix->bv_val, prefix->bv_len );
1579 HASH_Update( &HASHcontext,
1580 &pre, sizeof( pre ) );
1581 HASH_Update( &HASHcontext,
1582 syntax->ssyn_oid, slen );
1583 HASH_Update( &HASHcontext,
1584 mr->smr_oid, mlen );
1585 HASH_Update( &HASHcontext,
1586 value->bv_val, klen );
1587 HASH_Final( HASHdigest, &HASHcontext );
1589 keys[nkeys++] = ber_bvdup( &digest );
1592 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1594 pre = SLAP_INDEX_SUBSTR_PREFIX;
1595 klen = SLAP_INDEX_SUBSTR_MAXLEN;
1597 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1598 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
1602 value = sa->sa_any[i];
1605 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
1606 j += SLAP_INDEX_SUBSTR_STEP )
1608 HASH_Init( &HASHcontext );
1609 if( prefix != NULL && prefix->bv_len > 0 ) {
1610 HASH_Update( &HASHcontext,
1611 prefix->bv_val, prefix->bv_len );
1613 HASH_Update( &HASHcontext,
1614 &pre, sizeof( pre ) );
1615 HASH_Update( &HASHcontext,
1616 syntax->ssyn_oid, slen );
1617 HASH_Update( &HASHcontext,
1618 mr->smr_oid, mlen );
1619 HASH_Update( &HASHcontext,
1620 &value->bv_val[j], klen );
1621 HASH_Final( HASHdigest, &HASHcontext );
1623 keys[nkeys++] = ber_bvdup( &digest );
1629 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1630 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1632 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1633 value = sa->sa_final;
1635 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1636 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1638 HASH_Init( &HASHcontext );
1639 if( prefix != NULL && prefix->bv_len > 0 ) {
1640 HASH_Update( &HASHcontext,
1641 prefix->bv_val, prefix->bv_len );
1643 HASH_Update( &HASHcontext,
1644 &pre, sizeof( pre ) );
1645 HASH_Update( &HASHcontext,
1646 syntax->ssyn_oid, slen );
1647 HASH_Update( &HASHcontext,
1648 mr->smr_oid, mlen );
1649 HASH_Update( &HASHcontext,
1650 &value->bv_val[value->bv_len-klen], klen );
1651 HASH_Final( HASHdigest, &HASHcontext );
1653 keys[nkeys++] = ber_bvdup( &digest );
1663 ch_free( sa->sa_final );
1664 ber_bvecfree( sa->sa_any );
1665 ch_free( sa->sa_initial );
1668 return LDAP_SUCCESS;
1677 struct berval *value,
1678 void *assertedValue )
1680 *matchp = UTF8normcmp( value->bv_val,
1681 ((struct berval *) assertedValue)->bv_val,
1683 return LDAP_SUCCESS;
1687 caseIgnoreSubstringsMatch(
1692 struct berval *value,
1693 void *assertedValue )
1696 SubstringsAssertion *sub;
1702 nav = UTF8normalize( value->bv_val, UTF8_CASEFOLD );
1708 left.bv_len = strlen( nav );
1710 sub = UTF8SubstringsassertionNormalize( assertedValue, UTF8_CASEFOLD );
1716 /* Add up asserted input length */
1717 if( sub->sa_initial ) {
1718 inlen += sub->sa_initial->bv_len;
1721 for(i=0; sub->sa_any[i] != NULL; i++) {
1722 inlen += sub->sa_any[i]->bv_len;
1725 if( sub->sa_final ) {
1726 inlen += sub->sa_final->bv_len;
1729 if( sub->sa_initial ) {
1730 if( inlen > left.bv_len ) {
1735 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1736 sub->sa_initial->bv_len );
1742 left.bv_val += sub->sa_initial->bv_len;
1743 left.bv_len -= sub->sa_initial->bv_len;
1744 inlen -= sub->sa_initial->bv_len;
1747 if( sub->sa_final ) {
1748 if( inlen > left.bv_len ) {
1753 match = strncmp( sub->sa_final->bv_val,
1754 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1755 sub->sa_final->bv_len );
1761 left.bv_len -= sub->sa_final->bv_len;
1762 inlen -= sub->sa_final->bv_len;
1766 for(i=0; sub->sa_any[i]; i++) {
1771 if( inlen > left.bv_len ) {
1772 /* not enough length */
1777 if( sub->sa_any[i]->bv_len == 0 ) {
1781 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1788 idx = p - left.bv_val;
1789 assert( idx < left.bv_len );
1791 if( idx >= left.bv_len ) {
1792 /* this shouldn't happen */
1799 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1800 /* not enough left */
1805 match = strncmp( left.bv_val,
1806 sub->sa_any[i]->bv_val,
1807 sub->sa_any[i]->bv_len );
1816 left.bv_val += sub->sa_any[i]->bv_len;
1817 left.bv_len -= sub->sa_any[i]->bv_len;
1818 inlen -= sub->sa_any[i]->bv_len;
1825 ch_free( sub->sa_final );
1826 ber_bvecfree( sub->sa_any );
1827 ch_free( sub->sa_initial );
1831 return LDAP_SUCCESS;
1834 /* Index generation function */
1835 int caseIgnoreIndexer(
1840 struct berval *prefix,
1841 struct berval **values,
1842 struct berval ***keysp )
1846 struct berval **keys;
1847 HASH_CONTEXT HASHcontext;
1848 unsigned char HASHdigest[HASH_BYTES];
1849 struct berval digest;
1850 digest.bv_val = HASHdigest;
1851 digest.bv_len = sizeof(HASHdigest);
1853 /* we should have at least one value at this point */
1854 assert( values != NULL && values[0] != NULL );
1856 for( i=0; values[i] != NULL; i++ ) {
1857 /* just count them */
1860 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1862 slen = strlen( syntax->ssyn_oid );
1863 mlen = strlen( mr->smr_oid );
1865 for( i=0; values[i] != NULL; i++ ) {
1866 struct berval *value;
1867 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
1868 HASH_Init( &HASHcontext );
1869 if( prefix != NULL && prefix->bv_len > 0 ) {
1870 HASH_Update( &HASHcontext,
1871 prefix->bv_val, prefix->bv_len );
1873 HASH_Update( &HASHcontext,
1874 syntax->ssyn_oid, slen );
1875 HASH_Update( &HASHcontext,
1876 mr->smr_oid, mlen );
1877 HASH_Update( &HASHcontext,
1878 value->bv_val, value->bv_len );
1879 HASH_Final( HASHdigest, &HASHcontext );
1881 ber_bvfree( value );
1883 keys[i] = ber_bvdup( &digest );
1888 return LDAP_SUCCESS;
1891 /* Index generation function */
1892 int caseIgnoreFilter(
1897 struct berval *prefix,
1899 struct berval ***keysp )
1902 struct berval **keys;
1903 HASH_CONTEXT HASHcontext;
1904 unsigned char HASHdigest[HASH_BYTES];
1905 struct berval *value;
1906 struct berval digest;
1907 digest.bv_val = HASHdigest;
1908 digest.bv_len = sizeof(HASHdigest);
1910 slen = strlen( syntax->ssyn_oid );
1911 mlen = strlen( mr->smr_oid );
1913 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1915 /* This usually happens if filter contains bad UTF8 */
1916 if( value == NULL ) {
1917 keys = ch_malloc( sizeof( struct berval * ) );
1919 return LDAP_SUCCESS;
1922 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1924 HASH_Init( &HASHcontext );
1925 if( prefix != NULL && prefix->bv_len > 0 ) {
1926 HASH_Update( &HASHcontext,
1927 prefix->bv_val, prefix->bv_len );
1929 HASH_Update( &HASHcontext,
1930 syntax->ssyn_oid, slen );
1931 HASH_Update( &HASHcontext,
1932 mr->smr_oid, mlen );
1933 HASH_Update( &HASHcontext,
1934 value->bv_val, value->bv_len );
1935 HASH_Final( HASHdigest, &HASHcontext );
1937 keys[0] = ber_bvdup( &digest );
1940 ber_bvfree( value );
1944 return LDAP_SUCCESS;
1947 /* Substrings Index generation function */
1948 int caseIgnoreSubstringsIndexer(
1953 struct berval *prefix,
1954 struct berval **values,
1955 struct berval ***keysp )
1959 struct berval **keys;
1960 struct berval **nvalues;
1962 HASH_CONTEXT HASHcontext;
1963 unsigned char HASHdigest[HASH_BYTES];
1964 struct berval digest;
1965 digest.bv_val = HASHdigest;
1966 digest.bv_len = sizeof(HASHdigest);
1968 /* we should have at least one value at this point */
1969 assert( values != NULL && values[0] != NULL );
1973 /* create normalized copy of values */
1974 for( i=0; values[i] != NULL; i++ ) {
1977 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
1978 for( i=0; values[i] != NULL; i++ ) {
1979 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val,
1985 for( i=0; values[i] != NULL; i++ ) {
1986 /* count number of indices to generate */
1987 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1991 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1992 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1993 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1994 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1996 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2000 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2001 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2002 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2006 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2007 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2008 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2009 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2011 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2017 /* no keys to generate */
2019 return LDAP_SUCCESS;
2022 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2024 slen = strlen( syntax->ssyn_oid );
2025 mlen = strlen( mr->smr_oid );
2028 for( i=0; values[i] != NULL; i++ ) {
2030 struct berval *value;
2032 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2036 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2037 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2039 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2040 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2042 for( j=0; j<max; j++ ) {
2043 HASH_Init( &HASHcontext );
2044 if( prefix != NULL && prefix->bv_len > 0 ) {
2045 HASH_Update( &HASHcontext,
2046 prefix->bv_val, prefix->bv_len );
2049 HASH_Update( &HASHcontext,
2050 &pre, sizeof( pre ) );
2051 HASH_Update( &HASHcontext,
2052 syntax->ssyn_oid, slen );
2053 HASH_Update( &HASHcontext,
2054 mr->smr_oid, mlen );
2055 HASH_Update( &HASHcontext,
2057 SLAP_INDEX_SUBSTR_MAXLEN );
2058 HASH_Final( HASHdigest, &HASHcontext );
2060 keys[nkeys++] = ber_bvdup( &digest );
2064 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2065 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2067 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2070 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2071 pre = SLAP_INDEX_SUBSTR_INITIAL_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,
2085 HASH_Final( HASHdigest, &HASHcontext );
2087 keys[nkeys++] = ber_bvdup( &digest );
2090 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2091 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2092 HASH_Init( &HASHcontext );
2093 if( prefix != NULL && prefix->bv_len > 0 ) {
2094 HASH_Update( &HASHcontext,
2095 prefix->bv_val, prefix->bv_len );
2097 HASH_Update( &HASHcontext,
2098 &pre, sizeof( pre ) );
2099 HASH_Update( &HASHcontext,
2100 syntax->ssyn_oid, slen );
2101 HASH_Update( &HASHcontext,
2102 mr->smr_oid, mlen );
2103 HASH_Update( &HASHcontext,
2104 &value->bv_val[value->bv_len-j], j );
2105 HASH_Final( HASHdigest, &HASHcontext );
2107 keys[nkeys++] = ber_bvdup( &digest );
2121 ber_bvecfree( nvalues );
2122 return LDAP_SUCCESS;
2125 int caseIgnoreSubstringsFilter(
2130 struct berval *prefix,
2132 struct berval ***keysp )
2134 SubstringsAssertion *sa;
2136 ber_len_t nkeys = 0;
2137 size_t slen, mlen, klen;
2138 struct berval **keys;
2139 HASH_CONTEXT HASHcontext;
2140 unsigned char HASHdigest[HASH_BYTES];
2141 struct berval *value;
2142 struct berval digest;
2144 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_CASEFOLD );
2147 return LDAP_SUCCESS;
2150 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2151 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2156 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2158 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2159 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2160 /* don't bother accounting for stepping */
2161 nkeys += sa->sa_any[i]->bv_len -
2162 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2167 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2168 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2175 return LDAP_SUCCESS;
2178 digest.bv_val = HASHdigest;
2179 digest.bv_len = sizeof(HASHdigest);
2181 slen = strlen( syntax->ssyn_oid );
2182 mlen = strlen( mr->smr_oid );
2184 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2187 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2188 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2190 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2191 value = sa->sa_initial;
2193 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2194 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2196 HASH_Init( &HASHcontext );
2197 if( prefix != NULL && prefix->bv_len > 0 ) {
2198 HASH_Update( &HASHcontext,
2199 prefix->bv_val, prefix->bv_len );
2201 HASH_Update( &HASHcontext,
2202 &pre, sizeof( pre ) );
2203 HASH_Update( &HASHcontext,
2204 syntax->ssyn_oid, slen );
2205 HASH_Update( &HASHcontext,
2206 mr->smr_oid, mlen );
2207 HASH_Update( &HASHcontext,
2208 value->bv_val, klen );
2209 HASH_Final( HASHdigest, &HASHcontext );
2211 keys[nkeys++] = ber_bvdup( &digest );
2214 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2216 pre = SLAP_INDEX_SUBSTR_PREFIX;
2217 klen = SLAP_INDEX_SUBSTR_MAXLEN;
2219 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2220 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
2224 value = sa->sa_any[i];
2227 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
2228 j += SLAP_INDEX_SUBSTR_STEP )
2230 HASH_Init( &HASHcontext );
2231 if( prefix != NULL && prefix->bv_len > 0 ) {
2232 HASH_Update( &HASHcontext,
2233 prefix->bv_val, prefix->bv_len );
2235 HASH_Update( &HASHcontext,
2236 &pre, sizeof( pre ) );
2237 HASH_Update( &HASHcontext,
2238 syntax->ssyn_oid, slen );
2239 HASH_Update( &HASHcontext,
2240 mr->smr_oid, mlen );
2241 HASH_Update( &HASHcontext,
2242 &value->bv_val[j], klen );
2243 HASH_Final( HASHdigest, &HASHcontext );
2245 keys[nkeys++] = ber_bvdup( &digest );
2250 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2251 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2253 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2254 value = sa->sa_final;
2256 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2257 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2259 HASH_Init( &HASHcontext );
2260 if( prefix != NULL && prefix->bv_len > 0 ) {
2261 HASH_Update( &HASHcontext,
2262 prefix->bv_val, prefix->bv_len );
2264 HASH_Update( &HASHcontext,
2265 &pre, sizeof( pre ) );
2266 HASH_Update( &HASHcontext,
2267 syntax->ssyn_oid, slen );
2268 HASH_Update( &HASHcontext,
2269 mr->smr_oid, mlen );
2270 HASH_Update( &HASHcontext,
2271 &value->bv_val[value->bv_len-klen], klen );
2272 HASH_Final( HASHdigest, &HASHcontext );
2274 keys[nkeys++] = ber_bvdup( &digest );
2284 ch_free( sa->sa_final );
2285 ber_bvecfree( sa->sa_any );
2286 ch_free( sa->sa_initial );
2289 return LDAP_SUCCESS;
2295 struct berval *val )
2299 if( val->bv_len == 0 ) {
2300 /* disallow empty strings */
2301 return LDAP_INVALID_SYNTAX;
2304 if( OID_LEADCHAR(val->bv_val[0]) ) {
2306 for(i=1; i < val->bv_len; i++) {
2307 if( OID_SEPARATOR( val->bv_val[i] ) ) {
2308 if( dot++ ) return 1;
2309 } else if ( OID_CHAR( val->bv_val[i] ) ) {
2312 return LDAP_INVALID_SYNTAX;
2316 return !dot ? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
2318 } else if( DESC_LEADCHAR(val->bv_val[0]) ) {
2319 for(i=1; i < val->bv_len; i++) {
2320 if( !DESC_CHAR(val->bv_val[i] ) ) {
2321 return LDAP_INVALID_SYNTAX;
2325 return LDAP_SUCCESS;
2328 return LDAP_INVALID_SYNTAX;
2334 struct berval *val )
2338 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2340 if( val->bv_val[0] == '+' || val->bv_val[0] == '-' ) {
2341 if( val->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
2342 } else if( !ASCII_DIGIT(val->bv_val[0]) ) {
2343 return LDAP_INVALID_SYNTAX;
2346 for(i=1; i < val->bv_len; i++) {
2347 if( !ASCII_DIGIT(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2350 return LDAP_SUCCESS;
2357 struct berval **normalized )
2360 struct berval *newval;
2366 negative = ( *p == '-' );
2367 if( *p == '-' || *p == '+' ) p++;
2369 /* Ignore leading zeros */
2370 while ( *p == '0' ) p++;
2372 newval = (struct berval *) ch_malloc( sizeof(struct berval) );
2375 newval->bv_val = ch_strdup("0");
2380 newval->bv_val = ch_malloc( val->bv_len + 1 );
2384 newval->bv_val[newval->bv_len++] = '-';
2387 for( ; *p != '\0'; p++ ) {
2388 newval->bv_val[newval->bv_len++] = *p;
2392 *normalized = newval;
2393 return LDAP_SUCCESS;
2397 countryStringValidate(
2399 struct berval *val )
2401 if( val->bv_len != 2 ) return LDAP_INVALID_SYNTAX;
2403 if( !SLAP_PRINTABLE(val->bv_val[0]) ) {
2404 return LDAP_INVALID_SYNTAX;
2406 if( !SLAP_PRINTABLE(val->bv_val[1]) ) {
2407 return LDAP_INVALID_SYNTAX;
2410 return LDAP_SUCCESS;
2414 printableStringValidate(
2416 struct berval *val )
2420 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2422 for(i=0; i < val->bv_len; i++) {
2423 if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
2424 return LDAP_INVALID_SYNTAX;
2428 return LDAP_SUCCESS;
2432 printablesStringValidate(
2434 struct berval *val )
2438 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2440 for(i=0; i < val->bv_len; i++) {
2441 if( !SLAP_PRINTABLES(val->bv_val[i]) ) {
2442 return LDAP_INVALID_SYNTAX;
2446 return LDAP_SUCCESS;
2452 struct berval *val )
2456 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2458 for(i=0; i < val->bv_len; i++) {
2459 if( !isascii(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2462 return LDAP_SUCCESS;
2469 struct berval **normalized )
2471 struct berval *newval;
2474 newval = ch_malloc( sizeof( struct berval ) );
2478 /* Ignore initial whitespace */
2479 while ( ASCII_SPACE( *p ) ) {
2485 return LDAP_INVALID_SYNTAX;
2488 newval->bv_val = ch_strdup( p );
2489 p = q = newval->bv_val;
2492 if ( ASCII_SPACE( *p ) ) {
2495 /* Ignore the extra whitespace */
2496 while ( ASCII_SPACE( *p ) ) {
2504 assert( *newval->bv_val );
2505 assert( newval->bv_val < p );
2508 /* cannot start with a space */
2509 assert( !ASCII_SPACE(*newval->bv_val) );
2512 * If the string ended in space, backup the pointer one
2513 * position. One is enough because the above loop collapsed
2514 * all whitespace to a single space.
2517 if ( ASCII_SPACE( q[-1] ) ) {
2521 /* cannot end with a space */
2522 assert( !ASCII_SPACE( q[-1] ) );
2524 /* null terminate */
2527 newval->bv_len = q - newval->bv_val;
2528 *normalized = newval;
2530 return LDAP_SUCCESS;
2539 struct berval *value,
2540 void *assertedValue )
2542 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
2545 match = strncmp( value->bv_val,
2546 ((struct berval *) assertedValue)->bv_val,
2551 return LDAP_SUCCESS;
2555 caseExactIA5SubstringsMatch(
2560 struct berval *value,
2561 void *assertedValue )
2564 SubstringsAssertion *sub = assertedValue;
2565 struct berval left = *value;
2569 /* Add up asserted input length */
2570 if( sub->sa_initial ) {
2571 inlen += sub->sa_initial->bv_len;
2574 for(i=0; sub->sa_any[i] != NULL; i++) {
2575 inlen += sub->sa_any[i]->bv_len;
2578 if( sub->sa_final ) {
2579 inlen += sub->sa_final->bv_len;
2582 if( sub->sa_initial ) {
2583 if( inlen > left.bv_len ) {
2588 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
2589 sub->sa_initial->bv_len );
2595 left.bv_val += sub->sa_initial->bv_len;
2596 left.bv_len -= sub->sa_initial->bv_len;
2597 inlen -= sub->sa_initial->bv_len;
2600 if( sub->sa_final ) {
2601 if( inlen > left.bv_len ) {
2606 match = strncmp( sub->sa_final->bv_val,
2607 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
2608 sub->sa_final->bv_len );
2614 left.bv_len -= sub->sa_final->bv_len;
2615 inlen -= sub->sa_final->bv_len;
2619 for(i=0; sub->sa_any[i]; i++) {
2624 if( inlen > left.bv_len ) {
2625 /* not enough length */
2630 if( sub->sa_any[i]->bv_len == 0 ) {
2634 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
2641 idx = p - left.bv_val;
2642 assert( idx < left.bv_len );
2644 if( idx >= left.bv_len ) {
2645 /* this shouldn't happen */
2652 if( sub->sa_any[i]->bv_len > left.bv_len ) {
2653 /* not enough left */
2658 match = strncmp( left.bv_val,
2659 sub->sa_any[i]->bv_val,
2660 sub->sa_any[i]->bv_len );
2668 left.bv_val += sub->sa_any[i]->bv_len;
2669 left.bv_len -= sub->sa_any[i]->bv_len;
2670 inlen -= sub->sa_any[i]->bv_len;
2676 return LDAP_SUCCESS;
2679 /* Index generation function */
2680 int caseExactIA5Indexer(
2685 struct berval *prefix,
2686 struct berval **values,
2687 struct berval ***keysp )
2691 struct berval **keys;
2692 HASH_CONTEXT HASHcontext;
2693 unsigned char HASHdigest[HASH_BYTES];
2694 struct berval digest;
2695 digest.bv_val = HASHdigest;
2696 digest.bv_len = sizeof(HASHdigest);
2698 /* we should have at least one value at this point */
2699 assert( values != NULL && values[0] != NULL );
2701 for( i=0; values[i] != NULL; i++ ) {
2702 /* just count them */
2705 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
2707 slen = strlen( syntax->ssyn_oid );
2708 mlen = strlen( mr->smr_oid );
2710 for( i=0; values[i] != NULL; i++ ) {
2711 struct berval *value = values[i];
2713 HASH_Init( &HASHcontext );
2714 if( prefix != NULL && prefix->bv_len > 0 ) {
2715 HASH_Update( &HASHcontext,
2716 prefix->bv_val, prefix->bv_len );
2718 HASH_Update( &HASHcontext,
2719 syntax->ssyn_oid, slen );
2720 HASH_Update( &HASHcontext,
2721 mr->smr_oid, mlen );
2722 HASH_Update( &HASHcontext,
2723 value->bv_val, value->bv_len );
2724 HASH_Final( HASHdigest, &HASHcontext );
2726 keys[i] = ber_bvdup( &digest );
2731 return LDAP_SUCCESS;
2734 /* Index generation function */
2735 int caseExactIA5Filter(
2740 struct berval *prefix,
2742 struct berval ***keysp )
2745 struct berval **keys;
2746 HASH_CONTEXT HASHcontext;
2747 unsigned char HASHdigest[HASH_BYTES];
2748 struct berval *value;
2749 struct berval digest;
2750 digest.bv_val = HASHdigest;
2751 digest.bv_len = sizeof(HASHdigest);
2753 slen = strlen( syntax->ssyn_oid );
2754 mlen = strlen( mr->smr_oid );
2756 value = (struct berval *) assertValue;
2758 keys = ch_malloc( sizeof( struct berval * ) * 2 );
2760 HASH_Init( &HASHcontext );
2761 if( prefix != NULL && prefix->bv_len > 0 ) {
2762 HASH_Update( &HASHcontext,
2763 prefix->bv_val, prefix->bv_len );
2765 HASH_Update( &HASHcontext,
2766 syntax->ssyn_oid, slen );
2767 HASH_Update( &HASHcontext,
2768 mr->smr_oid, mlen );
2769 HASH_Update( &HASHcontext,
2770 value->bv_val, value->bv_len );
2771 HASH_Final( HASHdigest, &HASHcontext );
2773 keys[0] = ber_bvdup( &digest );
2777 return LDAP_SUCCESS;
2780 /* Substrings Index generation function */
2781 int caseExactIA5SubstringsIndexer(
2786 struct berval *prefix,
2787 struct berval **values,
2788 struct berval ***keysp )
2792 struct berval **keys;
2793 HASH_CONTEXT HASHcontext;
2794 unsigned char HASHdigest[HASH_BYTES];
2795 struct berval digest;
2796 digest.bv_val = HASHdigest;
2797 digest.bv_len = sizeof(HASHdigest);
2799 /* we should have at least one value at this point */
2800 assert( values != NULL && values[0] != NULL );
2803 for( i=0; values[i] != NULL; i++ ) {
2804 /* count number of indices to generate */
2805 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
2809 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2810 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2811 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2812 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2814 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2818 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2819 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2820 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2824 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2825 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2826 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2827 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2829 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2835 /* no keys to generate */
2837 return LDAP_SUCCESS;
2840 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2842 slen = strlen( syntax->ssyn_oid );
2843 mlen = strlen( mr->smr_oid );
2846 for( i=0; values[i] != NULL; i++ ) {
2848 struct berval *value;
2851 if( value->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2853 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2854 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2856 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2857 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2859 for( j=0; j<max; j++ ) {
2860 HASH_Init( &HASHcontext );
2861 if( prefix != NULL && prefix->bv_len > 0 ) {
2862 HASH_Update( &HASHcontext,
2863 prefix->bv_val, prefix->bv_len );
2866 HASH_Update( &HASHcontext,
2867 &pre, sizeof( pre ) );
2868 HASH_Update( &HASHcontext,
2869 syntax->ssyn_oid, slen );
2870 HASH_Update( &HASHcontext,
2871 mr->smr_oid, mlen );
2872 HASH_Update( &HASHcontext,
2874 SLAP_INDEX_SUBSTR_MAXLEN );
2875 HASH_Final( HASHdigest, &HASHcontext );
2877 keys[nkeys++] = ber_bvdup( &digest );
2881 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2882 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2884 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2887 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2888 pre = SLAP_INDEX_SUBSTR_INITIAL_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,
2902 HASH_Final( HASHdigest, &HASHcontext );
2904 keys[nkeys++] = ber_bvdup( &digest );
2907 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2908 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2909 HASH_Init( &HASHcontext );
2910 if( prefix != NULL && prefix->bv_len > 0 ) {
2911 HASH_Update( &HASHcontext,
2912 prefix->bv_val, prefix->bv_len );
2914 HASH_Update( &HASHcontext,
2915 &pre, sizeof( pre ) );
2916 HASH_Update( &HASHcontext,
2917 syntax->ssyn_oid, slen );
2918 HASH_Update( &HASHcontext,
2919 mr->smr_oid, mlen );
2920 HASH_Update( &HASHcontext,
2921 &value->bv_val[value->bv_len-j], j );
2922 HASH_Final( HASHdigest, &HASHcontext );
2924 keys[nkeys++] = ber_bvdup( &digest );
2938 return LDAP_SUCCESS;
2941 int caseExactIA5SubstringsFilter(
2946 struct berval *prefix,
2948 struct berval ***keysp )
2950 SubstringsAssertion *sa = assertValue;
2952 ber_len_t nkeys = 0;
2953 size_t slen, mlen, klen;
2954 struct berval **keys;
2955 HASH_CONTEXT HASHcontext;
2956 unsigned char HASHdigest[HASH_BYTES];
2957 struct berval *value;
2958 struct berval digest;
2960 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
2961 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2966 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
2968 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2969 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2970 /* don't bother accounting for stepping */
2971 nkeys += sa->sa_any[i]->bv_len -
2972 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2977 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
2978 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2985 return LDAP_SUCCESS;
2988 digest.bv_val = HASHdigest;
2989 digest.bv_len = sizeof(HASHdigest);
2991 slen = strlen( syntax->ssyn_oid );
2992 mlen = strlen( mr->smr_oid );
2994 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2997 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
2998 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3000 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3001 value = sa->sa_initial;
3003 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3004 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3006 HASH_Init( &HASHcontext );
3007 if( prefix != NULL && prefix->bv_len > 0 ) {
3008 HASH_Update( &HASHcontext,
3009 prefix->bv_val, prefix->bv_len );
3011 HASH_Update( &HASHcontext,
3012 &pre, sizeof( pre ) );
3013 HASH_Update( &HASHcontext,
3014 syntax->ssyn_oid, slen );
3015 HASH_Update( &HASHcontext,
3016 mr->smr_oid, mlen );
3017 HASH_Update( &HASHcontext,
3018 value->bv_val, klen );
3019 HASH_Final( HASHdigest, &HASHcontext );
3021 keys[nkeys++] = ber_bvdup( &digest );
3024 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
3026 pre = SLAP_INDEX_SUBSTR_PREFIX;
3027 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3029 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3030 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3034 value = sa->sa_any[i];
3037 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3038 j += SLAP_INDEX_SUBSTR_STEP )
3040 HASH_Init( &HASHcontext );
3041 if( prefix != NULL && prefix->bv_len > 0 ) {
3042 HASH_Update( &HASHcontext,
3043 prefix->bv_val, prefix->bv_len );
3045 HASH_Update( &HASHcontext,
3046 &pre, sizeof( pre ) );
3047 HASH_Update( &HASHcontext,
3048 syntax->ssyn_oid, slen );
3049 HASH_Update( &HASHcontext,
3050 mr->smr_oid, mlen );
3051 HASH_Update( &HASHcontext,
3052 &value->bv_val[j], klen );
3053 HASH_Final( HASHdigest, &HASHcontext );
3055 keys[nkeys++] = ber_bvdup( &digest );
3060 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
3061 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3063 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3064 value = sa->sa_final;
3066 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3067 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3069 HASH_Init( &HASHcontext );
3070 if( prefix != NULL && prefix->bv_len > 0 ) {
3071 HASH_Update( &HASHcontext,
3072 prefix->bv_val, prefix->bv_len );
3074 HASH_Update( &HASHcontext,
3075 &pre, sizeof( pre ) );
3076 HASH_Update( &HASHcontext,
3077 syntax->ssyn_oid, slen );
3078 HASH_Update( &HASHcontext,
3079 mr->smr_oid, mlen );
3080 HASH_Update( &HASHcontext,
3081 &value->bv_val[value->bv_len-klen], klen );
3082 HASH_Final( HASHdigest, &HASHcontext );
3084 keys[nkeys++] = ber_bvdup( &digest );
3095 return LDAP_SUCCESS;
3104 struct berval *value,
3105 void *assertedValue )
3107 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
3109 if( match == 0 && value->bv_len ) {
3110 match = strncasecmp( value->bv_val,
3111 ((struct berval *) assertedValue)->bv_val,
3116 return LDAP_SUCCESS;
3120 caseIgnoreIA5SubstringsMatch(
3125 struct berval *value,
3126 void *assertedValue )
3129 SubstringsAssertion *sub = assertedValue;
3130 struct berval left = *value;
3134 /* Add up asserted input length */
3135 if( sub->sa_initial ) {
3136 inlen += sub->sa_initial->bv_len;
3139 for(i=0; sub->sa_any[i] != NULL; i++) {
3140 inlen += sub->sa_any[i]->bv_len;
3143 if( sub->sa_final ) {
3144 inlen += sub->sa_final->bv_len;
3147 if( sub->sa_initial ) {
3148 if( inlen > left.bv_len ) {
3153 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
3154 sub->sa_initial->bv_len );
3160 left.bv_val += sub->sa_initial->bv_len;
3161 left.bv_len -= sub->sa_initial->bv_len;
3162 inlen -= sub->sa_initial->bv_len;
3165 if( sub->sa_final ) {
3166 if( inlen > left.bv_len ) {
3171 match = strncasecmp( sub->sa_final->bv_val,
3172 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
3173 sub->sa_final->bv_len );
3179 left.bv_len -= sub->sa_final->bv_len;
3180 inlen -= sub->sa_final->bv_len;
3184 for(i=0; sub->sa_any[i]; i++) {
3189 if( inlen > left.bv_len ) {
3190 /* not enough length */
3195 if( sub->sa_any[i]->bv_len == 0 ) {
3199 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
3206 idx = p - left.bv_val;
3207 assert( idx < left.bv_len );
3209 if( idx >= left.bv_len ) {
3210 /* this shouldn't happen */
3217 if( sub->sa_any[i]->bv_len > left.bv_len ) {
3218 /* not enough left */
3223 match = strncasecmp( left.bv_val,
3224 sub->sa_any[i]->bv_val,
3225 sub->sa_any[i]->bv_len );
3234 left.bv_val += sub->sa_any[i]->bv_len;
3235 left.bv_len -= sub->sa_any[i]->bv_len;
3236 inlen -= sub->sa_any[i]->bv_len;
3242 return LDAP_SUCCESS;
3245 /* Index generation function */
3246 int caseIgnoreIA5Indexer(
3251 struct berval *prefix,
3252 struct berval **values,
3253 struct berval ***keysp )
3257 struct berval **keys;
3258 HASH_CONTEXT HASHcontext;
3259 unsigned char HASHdigest[HASH_BYTES];
3260 struct berval digest;
3261 digest.bv_val = HASHdigest;
3262 digest.bv_len = sizeof(HASHdigest);
3264 /* we should have at least one value at this point */
3265 assert( values != NULL && values[0] != NULL );
3267 for( i=0; values[i] != NULL; i++ ) {
3268 /* just count them */
3271 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
3273 slen = strlen( syntax->ssyn_oid );
3274 mlen = strlen( mr->smr_oid );
3276 for( i=0; values[i] != NULL; i++ ) {
3277 struct berval *value = ber_bvdup( values[i] );
3278 ldap_pvt_str2upper( value->bv_val );
3280 HASH_Init( &HASHcontext );
3281 if( prefix != NULL && prefix->bv_len > 0 ) {
3282 HASH_Update( &HASHcontext,
3283 prefix->bv_val, prefix->bv_len );
3285 HASH_Update( &HASHcontext,
3286 syntax->ssyn_oid, slen );
3287 HASH_Update( &HASHcontext,
3288 mr->smr_oid, mlen );
3289 HASH_Update( &HASHcontext,
3290 value->bv_val, value->bv_len );
3291 HASH_Final( HASHdigest, &HASHcontext );
3293 ber_bvfree( value );
3295 keys[i] = ber_bvdup( &digest );
3300 return LDAP_SUCCESS;
3303 /* Index generation function */
3304 int caseIgnoreIA5Filter(
3309 struct berval *prefix,
3311 struct berval ***keysp )
3314 struct berval **keys;
3315 HASH_CONTEXT HASHcontext;
3316 unsigned char HASHdigest[HASH_BYTES];
3317 struct berval *value;
3318 struct berval digest;
3319 digest.bv_val = HASHdigest;
3320 digest.bv_len = sizeof(HASHdigest);
3322 slen = strlen( syntax->ssyn_oid );
3323 mlen = strlen( mr->smr_oid );
3325 value = ber_bvdup( (struct berval *) assertValue );
3326 ldap_pvt_str2upper( value->bv_val );
3328 keys = ch_malloc( sizeof( struct berval * ) * 2 );
3330 HASH_Init( &HASHcontext );
3331 if( prefix != NULL && prefix->bv_len > 0 ) {
3332 HASH_Update( &HASHcontext,
3333 prefix->bv_val, prefix->bv_len );
3335 HASH_Update( &HASHcontext,
3336 syntax->ssyn_oid, slen );
3337 HASH_Update( &HASHcontext,
3338 mr->smr_oid, mlen );
3339 HASH_Update( &HASHcontext,
3340 value->bv_val, value->bv_len );
3341 HASH_Final( HASHdigest, &HASHcontext );
3343 keys[0] = ber_bvdup( &digest );
3346 ber_bvfree( value );
3350 return LDAP_SUCCESS;
3353 /* Substrings Index generation function */
3354 int caseIgnoreIA5SubstringsIndexer(
3359 struct berval *prefix,
3360 struct berval **values,
3361 struct berval ***keysp )
3365 struct berval **keys;
3366 HASH_CONTEXT HASHcontext;
3367 unsigned char HASHdigest[HASH_BYTES];
3368 struct berval digest;
3369 digest.bv_val = HASHdigest;
3370 digest.bv_len = sizeof(HASHdigest);
3372 /* we should have at least one value at this point */
3373 assert( values != NULL && values[0] != NULL );
3376 for( i=0; values[i] != NULL; i++ ) {
3377 /* count number of indices to generate */
3378 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
3382 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3383 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3384 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3385 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3387 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3391 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
3392 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3393 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3397 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3398 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3399 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3400 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3402 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3408 /* no keys to generate */
3410 return LDAP_SUCCESS;
3413 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3415 slen = strlen( syntax->ssyn_oid );
3416 mlen = strlen( mr->smr_oid );
3419 for( i=0; values[i] != NULL; i++ ) {
3421 struct berval *value;
3423 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
3425 value = ber_bvdup( values[i] );
3426 ldap_pvt_str2upper( value->bv_val );
3428 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
3429 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
3431 char pre = SLAP_INDEX_SUBSTR_PREFIX;
3432 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
3434 for( j=0; j<max; j++ ) {
3435 HASH_Init( &HASHcontext );
3436 if( prefix != NULL && prefix->bv_len > 0 ) {
3437 HASH_Update( &HASHcontext,
3438 prefix->bv_val, prefix->bv_len );
3441 HASH_Update( &HASHcontext,
3442 &pre, sizeof( pre ) );
3443 HASH_Update( &HASHcontext,
3444 syntax->ssyn_oid, slen );
3445 HASH_Update( &HASHcontext,
3446 mr->smr_oid, mlen );
3447 HASH_Update( &HASHcontext,
3449 SLAP_INDEX_SUBSTR_MAXLEN );
3450 HASH_Final( HASHdigest, &HASHcontext );
3452 keys[nkeys++] = ber_bvdup( &digest );
3456 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3457 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3459 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
3462 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3463 pre = SLAP_INDEX_SUBSTR_INITIAL_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,
3477 HASH_Final( HASHdigest, &HASHcontext );
3479 keys[nkeys++] = ber_bvdup( &digest );
3482 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3483 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3484 HASH_Init( &HASHcontext );
3485 if( prefix != NULL && prefix->bv_len > 0 ) {
3486 HASH_Update( &HASHcontext,
3487 prefix->bv_val, prefix->bv_len );
3489 HASH_Update( &HASHcontext,
3490 &pre, sizeof( pre ) );
3491 HASH_Update( &HASHcontext,
3492 syntax->ssyn_oid, slen );
3493 HASH_Update( &HASHcontext,
3494 mr->smr_oid, mlen );
3495 HASH_Update( &HASHcontext,
3496 &value->bv_val[value->bv_len-j], j );
3497 HASH_Final( HASHdigest, &HASHcontext );
3499 keys[nkeys++] = ber_bvdup( &digest );
3504 ber_bvfree( value );
3515 return LDAP_SUCCESS;
3518 int caseIgnoreIA5SubstringsFilter(
3523 struct berval *prefix,
3525 struct berval ***keysp )
3527 SubstringsAssertion *sa = assertValue;
3529 ber_len_t nkeys = 0;
3530 size_t slen, mlen, klen;
3531 struct berval **keys;
3532 HASH_CONTEXT HASHcontext;
3533 unsigned char HASHdigest[HASH_BYTES];
3534 struct berval *value;
3535 struct berval digest;
3537 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3538 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3543 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3545 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3546 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3547 /* don't bother accounting for stepping */
3548 nkeys += sa->sa_any[i]->bv_len -
3549 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3554 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3555 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3562 return LDAP_SUCCESS;
3565 digest.bv_val = HASHdigest;
3566 digest.bv_len = sizeof(HASHdigest);
3568 slen = strlen( syntax->ssyn_oid );
3569 mlen = strlen( mr->smr_oid );
3571 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3574 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3575 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3577 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3578 value = ber_bvdup( sa->sa_initial );
3579 ldap_pvt_str2upper( value->bv_val );
3581 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3582 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3584 HASH_Init( &HASHcontext );
3585 if( prefix != NULL && prefix->bv_len > 0 ) {
3586 HASH_Update( &HASHcontext,
3587 prefix->bv_val, prefix->bv_len );
3589 HASH_Update( &HASHcontext,
3590 &pre, sizeof( pre ) );
3591 HASH_Update( &HASHcontext,
3592 syntax->ssyn_oid, slen );
3593 HASH_Update( &HASHcontext,
3594 mr->smr_oid, mlen );
3595 HASH_Update( &HASHcontext,
3596 value->bv_val, klen );
3597 HASH_Final( HASHdigest, &HASHcontext );
3599 ber_bvfree( value );
3600 keys[nkeys++] = ber_bvdup( &digest );
3603 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3605 pre = SLAP_INDEX_SUBSTR_PREFIX;
3606 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3608 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3609 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3613 value = ber_bvdup( sa->sa_any[i] );
3614 ldap_pvt_str2upper( value->bv_val );
3617 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3618 j += SLAP_INDEX_SUBSTR_STEP )
3620 HASH_Init( &HASHcontext );
3621 if( prefix != NULL && prefix->bv_len > 0 ) {
3622 HASH_Update( &HASHcontext,
3623 prefix->bv_val, prefix->bv_len );
3625 HASH_Update( &HASHcontext,
3626 &pre, sizeof( pre ) );
3627 HASH_Update( &HASHcontext,
3628 syntax->ssyn_oid, slen );
3629 HASH_Update( &HASHcontext,
3630 mr->smr_oid, mlen );
3631 HASH_Update( &HASHcontext,
3632 &value->bv_val[j], klen );
3633 HASH_Final( HASHdigest, &HASHcontext );
3635 keys[nkeys++] = ber_bvdup( &digest );
3638 ber_bvfree( value );
3642 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3643 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3645 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3646 value = ber_bvdup( sa->sa_final );
3647 ldap_pvt_str2upper( value->bv_val );
3649 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3650 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3652 HASH_Init( &HASHcontext );
3653 if( prefix != NULL && prefix->bv_len > 0 ) {
3654 HASH_Update( &HASHcontext,
3655 prefix->bv_val, prefix->bv_len );
3657 HASH_Update( &HASHcontext,
3658 &pre, sizeof( pre ) );
3659 HASH_Update( &HASHcontext,
3660 syntax->ssyn_oid, slen );
3661 HASH_Update( &HASHcontext,
3662 mr->smr_oid, mlen );
3663 HASH_Update( &HASHcontext,
3664 &value->bv_val[value->bv_len-klen], klen );
3665 HASH_Final( HASHdigest, &HASHcontext );
3667 ber_bvfree( value );
3668 keys[nkeys++] = ber_bvdup( &digest );
3679 return LDAP_SUCCESS;
3683 numericStringValidate(
3689 for(i=0; i < in->bv_len; i++) {
3690 if( !SLAP_NUMERIC(in->bv_val[i]) ) {
3691 return LDAP_INVALID_SYNTAX;
3695 return LDAP_SUCCESS;
3699 numericStringNormalize(
3702 struct berval **normalized )
3704 /* removal all spaces */
3705 struct berval *newval;
3708 newval = ch_malloc( sizeof( struct berval ) );
3709 newval->bv_val = ch_malloc( val->bv_len + 1 );
3715 if ( ASCII_SPACE( *p ) ) {
3716 /* Ignore whitespace */
3723 assert( newval->bv_val <= p );
3726 /* null terminate */
3729 newval->bv_len = q - newval->bv_val;
3730 *normalized = newval;
3732 return LDAP_SUCCESS;
3736 objectIdentifierFirstComponentMatch(
3741 struct berval *value,
3742 void *assertedValue )
3744 int rc = LDAP_SUCCESS;
3746 struct berval *asserted = (struct berval *) assertedValue;
3750 if( value->bv_len == 0 || value->bv_val[0] != '(' /*')'*/ ) {
3751 return LDAP_INVALID_SYNTAX;
3754 /* trim leading white space */
3755 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < value->bv_len; i++ ) {
3759 /* grab next word */
3760 oid.bv_val = &value->bv_val[i];
3761 oid.bv_len = value->bv_len - i;
3762 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < oid.bv_len; i++ ) {
3767 /* insert attributeTypes, objectclass check here */
3768 if( OID_LEADCHAR(asserted->bv_val[0]) ) {
3769 rc = objectIdentifierMatch( &match, flags, syntax, mr, &oid, asserted );
3772 char *stored = ch_malloc( oid.bv_len + 1 );
3773 AC_MEMCPY( stored, oid.bv_val, oid.bv_len );
3774 stored[oid.bv_len] = '\0';
3776 if ( !strcmp( syntax->ssyn_oid, SLAP_SYNTAX_MATCHINGRULES_OID ) ) {
3777 MatchingRule *asserted_mr = mr_find( asserted->bv_val );
3778 MatchingRule *stored_mr = mr_find( stored );
3780 if( asserted_mr == NULL ) {
3781 rc = SLAPD_COMPARE_UNDEFINED;
3783 match = asserted_mr != stored_mr;
3786 } else if ( !strcmp( syntax->ssyn_oid,
3787 SLAP_SYNTAX_ATTRIBUTETYPES_OID ) )
3789 AttributeType *asserted_at = at_find( asserted->bv_val );
3790 AttributeType *stored_at = at_find( stored );
3792 if( asserted_at == NULL ) {
3793 rc = SLAPD_COMPARE_UNDEFINED;
3795 match = asserted_at != stored_at;
3798 } else if ( !strcmp( syntax->ssyn_oid,
3799 SLAP_SYNTAX_OBJECTCLASSES_OID ) )
3801 ObjectClass *asserted_oc = oc_find( asserted->bv_val );
3802 ObjectClass *stored_oc = oc_find( stored );
3804 if( asserted_oc == NULL ) {
3805 rc = SLAPD_COMPARE_UNDEFINED;
3807 match = asserted_oc != stored_oc;
3815 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
3816 "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
3817 match, value->bv_val, asserted->bv_val ));
3819 Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
3820 "%d\n\t\"%s\"\n\t\"%s\"\n",
3821 match, value->bv_val, asserted->bv_val );
3825 if( rc == LDAP_SUCCESS ) *matchp = match;
3830 check_time_syntax (struct berval *val,
3834 static int ceiling[9] = { 99, 99, 11, 30, 23, 59, 59, 12, 59 };
3835 static int mdays[2][12] = {
3836 /* non-leap years */
3837 { 30, 27, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 },
3839 { 30, 28, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 }
3842 int part, c, tzoffset, leapyear = 0 ;
3844 if( val->bv_len == 0 ) {
3845 return LDAP_INVALID_SYNTAX;
3848 p = (char *)val->bv_val;
3849 e = p + val->bv_len;
3851 /* Ignore initial whitespace */
3852 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3856 if (e - p < 13 - (2 * start)) {
3857 return LDAP_INVALID_SYNTAX;
3860 for (part = 0; part < 9; part++) {
3864 for (part = start; part < 7; part++) {
3866 if ((part == 6) && (c == 'Z' || c == '+' || c == '-')) {
3873 return LDAP_INVALID_SYNTAX;
3875 if (c < 0 || c > 9) {
3876 return LDAP_INVALID_SYNTAX;
3882 return LDAP_INVALID_SYNTAX;
3884 if (c < 0 || c > 9) {
3885 return LDAP_INVALID_SYNTAX;
3890 if (part == 2 || part == 3) {
3893 if (parts[part] < 0) {
3894 return LDAP_INVALID_SYNTAX;
3896 if (parts[part] > ceiling[part]) {
3897 return LDAP_INVALID_SYNTAX;
3901 /* leapyear check for the Gregorian calendar (year>1581) */
3902 if (((parts[1] % 4 == 0) && (parts[1] != 0)) ||
3903 ((parts[0] % 4 == 0) && (parts[1] == 0)))
3908 if (parts[3] > mdays[leapyear][parts[2]]) {
3909 return LDAP_INVALID_SYNTAX;
3914 tzoffset = 0; /* UTC */
3915 } else if (c != '+' && c != '-') {
3916 return LDAP_INVALID_SYNTAX;
3920 } else /* c == '+' */ {
3925 return LDAP_INVALID_SYNTAX;
3928 for (part = 7; part < 9; part++) {
3930 if (c < 0 || c > 9) {
3931 return LDAP_INVALID_SYNTAX;
3936 if (c < 0 || c > 9) {
3937 return LDAP_INVALID_SYNTAX;
3941 if (parts[part] < 0 || parts[part] > ceiling[part]) {
3942 return LDAP_INVALID_SYNTAX;
3947 /* Ignore trailing whitespace */
3948 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3952 return LDAP_INVALID_SYNTAX;
3955 switch ( tzoffset ) {
3956 case -1: /* negativ offset to UTC, ie west of Greenwich */
3957 parts[4] += parts[7];
3958 parts[5] += parts[8];
3959 for (part = 6; --part > 0; ) { /* offset is just hhmm, no seconds */
3963 c = mdays[leapyear][parts[2]];
3965 if (parts[part] > c) {
3966 parts[part] -= c + 1;
3971 case 1: /* positive offset to UTC, ie east of Greenwich */
3972 parts[4] -= parts[7];
3973 parts[5] -= parts[8];
3974 for (part = 6; --part > 0; ) {
3978 /* first arg to % needs to be non negativ */
3979 c = mdays[leapyear][(parts[2] - 1 + 12) % 12];
3981 if (parts[part] < 0) {
3982 parts[part] += c + 1;
3987 case 0: /* already UTC */
3991 return LDAP_SUCCESS;
3998 struct berval **normalized )
4003 rc = check_time_syntax(val, 1, parts);
4004 if (rc != LDAP_SUCCESS) {
4009 out = ch_malloc( sizeof(struct berval) );
4011 return LBER_ERROR_MEMORY;
4014 out->bv_val = ch_malloc( 14 );
4015 if ( out->bv_val == NULL ) {
4017 return LBER_ERROR_MEMORY;
4020 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ldZ",
4021 parts[1], parts[2] + 1, parts[3] + 1,
4022 parts[4], parts[5], parts[6] );
4026 return LDAP_SUCCESS;
4036 return check_time_syntax(in, 1, parts);
4040 generalizedTimeValidate(
4046 return check_time_syntax(in, 0, parts);
4050 generalizedTimeNormalize(
4053 struct berval **normalized )
4058 rc = check_time_syntax(val, 0, parts);
4059 if (rc != LDAP_SUCCESS) {
4064 out = ch_malloc( sizeof(struct berval) );
4066 return LBER_ERROR_MEMORY;
4069 out->bv_val = ch_malloc( 16 );
4070 if ( out->bv_val == NULL ) {
4072 return LBER_ERROR_MEMORY;
4075 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ld%02ldZ",
4076 parts[0], parts[1], parts[2] + 1, parts[3] + 1,
4077 parts[4], parts[5], parts[6] );
4081 return LDAP_SUCCESS;
4085 nisNetgroupTripleValidate(
4087 struct berval *val )
4092 if ( val->bv_len == 0 ) {
4093 return LDAP_INVALID_SYNTAX;
4096 p = (char *)val->bv_val;
4097 e = p + val->bv_len;
4099 if ( *p != '(' /*')'*/ ) {
4100 return LDAP_INVALID_SYNTAX;
4103 for ( p++; ( p < e ) && ( *p != ')' ); p++ ) {
4107 return LDAP_INVALID_SYNTAX;
4110 } else if ( !ATTR_CHAR( *p ) ) {
4111 return LDAP_INVALID_SYNTAX;
4115 if ( ( commas != 2 ) || ( *p != /*'('*/ ')' ) ) {
4116 return LDAP_INVALID_SYNTAX;
4122 return LDAP_INVALID_SYNTAX;
4125 return LDAP_SUCCESS;
4129 bootParameterValidate(
4131 struct berval *val )
4135 if ( val->bv_len == 0 ) {
4136 return LDAP_INVALID_SYNTAX;
4139 p = (char *)val->bv_val;
4140 e = p + val->bv_len;
4143 for (; ( p < e ) && ( *p != '=' ); p++ ) {
4144 if ( !ATTR_CHAR( *p ) ) {
4145 return LDAP_INVALID_SYNTAX;
4150 return LDAP_INVALID_SYNTAX;
4154 for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
4155 if ( !ATTR_CHAR( *p ) ) {
4156 return LDAP_INVALID_SYNTAX;
4161 return LDAP_INVALID_SYNTAX;
4165 for ( p++; p < e; p++ ) {
4166 if ( !ATTR_CHAR( *p ) ) {
4167 return LDAP_INVALID_SYNTAX;
4171 return LDAP_SUCCESS;
4174 struct syntax_defs_rec {
4177 slap_syntax_validate_func *sd_validate;
4178 slap_syntax_transform_func *sd_normalize;
4179 slap_syntax_transform_func *sd_pretty;
4180 #ifdef SLAPD_BINARY_CONVERSION
4181 slap_syntax_transform_func *sd_ber2str;
4182 slap_syntax_transform_func *sd_str2ber;
4186 #define X_BINARY "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
4187 #define X_NOT_H_R "X-NOT-HUMAN-READABLE 'TRUE' "
4189 struct syntax_defs_rec syntax_defs[] = {
4190 {"( 1.3.6.1.4.1.1466.115.121.1.1 DESC 'ACI Item' " X_BINARY X_NOT_H_R ")",
4191 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, NULL, NULL, NULL},
4192 {"( 1.3.6.1.4.1.1466.115.121.1.2 DESC 'Access Point' " X_NOT_H_R ")",
4193 0, NULL, NULL, NULL},
4194 {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )",
4195 0, NULL, NULL, NULL},
4196 {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' " X_NOT_H_R ")",
4197 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4198 {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' " X_NOT_H_R ")",
4199 SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4200 {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )",
4201 0, bitStringValidate, NULL, NULL },
4202 {"( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
4203 0, booleanValidate, NULL, NULL},
4204 {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' "
4205 X_BINARY X_NOT_H_R ")",
4206 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4207 {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'Certificate List' "
4208 X_BINARY X_NOT_H_R ")",
4209 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4210 {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'Certificate Pair' "
4211 X_BINARY X_NOT_H_R ")",
4212 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4213 {"( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )",
4214 0, countryStringValidate, IA5StringNormalize, NULL},
4215 {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'Distinguished Name' )",
4216 0, dnValidate, dnNormalize, dnPretty},
4217 {"( 1.3.6.1.4.1.1466.115.121.1.13 DESC 'Data Quality' )",
4218 0, NULL, NULL, NULL},
4219 {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )",
4220 0, NULL, NULL, NULL},
4221 {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )",
4222 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4223 {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )",
4224 0, NULL, NULL, NULL},
4225 {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )",
4226 0, NULL, NULL, NULL},
4227 {"( 1.3.6.1.4.1.1466.115.121.1.19 DESC 'DSA Quality' )",
4228 0, NULL, NULL, NULL},
4229 {"( 1.3.6.1.4.1.1466.115.121.1.20 DESC 'DSE Type' )",
4230 0, NULL, NULL, NULL},
4231 {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )",
4232 0, NULL, NULL, NULL},
4233 {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number' )",
4234 0, printablesStringValidate, IA5StringNormalize, NULL},
4235 {"( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' " X_NOT_H_R ")",
4236 SLAP_SYNTAX_BLOB, NULL, NULL, NULL},
4237 {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )",
4238 0, generalizedTimeValidate, generalizedTimeNormalize, NULL},
4239 {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )",
4240 0, NULL, NULL, NULL},
4241 {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )",
4242 0, IA5StringValidate, IA5StringNormalize, NULL},
4243 {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'Integer' )",
4244 0, integerValidate, integerNormalize, integerPretty},
4245 {"( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' " X_NOT_H_R ")",
4246 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4247 {"( 1.3.6.1.4.1.1466.115.121.1.29 DESC 'Master And Shadow Access Points' )",
4248 0, NULL, NULL, NULL},
4249 {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )",
4250 0, NULL, NULL, NULL},
4251 {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )",
4252 0, NULL, NULL, NULL},
4253 {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'Mail Preference' )",
4254 0, NULL, NULL, NULL},
4255 {"( 1.3.6.1.4.1.1466.115.121.1.33 DESC 'MHS OR Address' )",
4256 0, NULL, NULL, NULL},
4257 {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )",
4258 0, nameUIDValidate, nameUIDNormalize, NULL},
4259 {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )",
4260 0, NULL, NULL, NULL},
4261 {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )",
4262 0, numericStringValidate, numericStringNormalize, NULL},
4263 {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )",
4264 0, NULL, NULL, NULL},
4265 {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )",
4266 0, oidValidate, NULL, NULL},
4267 {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )",
4268 0, IA5StringValidate, IA5StringNormalize, NULL},
4269 {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )",
4270 0, blobValidate, NULL, NULL},
4271 {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )",
4272 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4273 {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'Protocol Information' )",
4274 0, NULL, NULL, NULL},
4275 {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'Presentation Address' )",
4276 0, NULL, NULL, NULL},
4277 {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )",
4278 0, printableStringValidate, IA5StringNormalize, NULL},
4279 {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'Supported Algorithm' "
4280 X_BINARY X_NOT_H_R ")",
4281 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4282 {"( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )",
4283 0, printableStringValidate, IA5StringNormalize, NULL},
4284 {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )",
4285 0, NULL, NULL, NULL},
4286 {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )",
4287 0, printableStringValidate, IA5StringNormalize, NULL},
4288 {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )",
4289 0, utcTimeValidate, utcTimeNormalize, NULL},
4290 {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )",
4291 0, NULL, NULL, NULL},
4292 {"( 1.3.6.1.4.1.1466.115.121.1.55 DESC 'Modify Rights' )",
4293 0, NULL, NULL, NULL},
4294 {"( 1.3.6.1.4.1.1466.115.121.1.56 DESC 'LDAP Schema Definition' )",
4295 0, NULL, NULL, NULL},
4296 {"( 1.3.6.1.4.1.1466.115.121.1.57 DESC 'LDAP Schema Description' )",
4297 0, NULL, NULL, NULL},
4298 {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )",
4299 0, NULL, NULL, NULL},
4301 /* RFC 2307 NIS Syntaxes */
4302 {"( 1.3.6.1.1.1.0.0 DESC 'RFC2307 NIS Netgroup Triple' )",
4303 0, nisNetgroupTripleValidate, NULL, NULL},
4304 {"( 1.3.6.1.1.1.0.1 DESC 'RFC2307 Boot Parameter' )",
4305 0, bootParameterValidate, NULL, NULL},
4307 /* OpenLDAP Experimental Syntaxes */
4308 {"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
4309 0, UTF8StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
4311 {"( 1.3.6.1.4.1.4203.666.2.2 DESC 'OpenLDAP authPassword' )",
4312 0, NULL, NULL, NULL},
4314 /* OpenLDAP Void Syntax */
4315 {"( 1.3.6.1.4.1.4203.1.1.1 DESC 'OpenLDAP void' )" ,
4316 SLAP_SYNTAX_HIDE, inValidate, NULL, NULL},
4317 {NULL, 0, NULL, NULL, NULL}
4320 struct mrule_defs_rec {
4322 slap_mask_t mrd_usage;
4323 slap_mr_convert_func * mrd_convert;
4324 slap_mr_normalize_func * mrd_normalize;
4325 slap_mr_match_func * mrd_match;
4326 slap_mr_indexer_func * mrd_indexer;
4327 slap_mr_filter_func * mrd_filter;
4329 char * mrd_associated;
4333 * Other matching rules in X.520 that we do not use (yet):
4335 * 2.5.13.9 numericStringOrderingMatch
4336 * 2.5.13.15 integerOrderingMatch
4337 * 2.5.13.18 octetStringOrderingMatch
4338 * 2.5.13.19 octetStringSubstringsMatch
4339 * 2.5.13.25 uTCTimeMatch
4340 * 2.5.13.26 uTCTimeOrderingMatch
4341 * 2.5.13.31 directoryStringFirstComponentMatch
4342 * 2.5.13.32 wordMatch
4343 * 2.5.13.33 keywordMatch
4344 * 2.5.13.34 certificateExactMatch
4345 * 2.5.13.35 certificateMatch
4346 * 2.5.13.36 certificatePairExactMatch
4347 * 2.5.13.37 certificatePairMatch
4348 * 2.5.13.38 certificateListExactMatch
4349 * 2.5.13.39 certificateListMatch
4350 * 2.5.13.40 algorithmIdentifierMatch
4351 * 2.5.13.41 storedPrefixMatch
4352 * 2.5.13.42 attributeCertificateMatch
4353 * 2.5.13.43 readerAndKeyIDMatch
4354 * 2.5.13.44 attributeIntegrityMatch
4357 struct mrule_defs_rec mrule_defs[] = {
4359 * EQUALITY matching rules must be listed after associated APPROX
4360 * matching rules. So, we list all APPROX matching rules first.
4362 {"( " directoryStringApproxMatchOID " NAME 'directoryStringApproxMatch' "
4363 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4364 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4366 directoryStringApproxMatch,
4367 directoryStringApproxIndexer,
4368 directoryStringApproxFilter,
4371 {"( " IA5StringApproxMatchOID " NAME 'IA5StringApproxMatch' "
4372 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4373 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4375 IA5StringApproxMatch,
4376 IA5StringApproxIndexer,
4377 IA5StringApproxFilter,
4381 * Other matching rules
4384 {"( 2.5.13.0 NAME 'objectIdentifierMatch' "
4385 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4386 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4388 objectIdentifierMatch, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4391 {"( 2.5.13.1 NAME 'distinguishedNameMatch' "
4392 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
4393 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4395 dnMatch, dnIndexer, dnFilter,
4398 {"( 2.5.13.2 NAME 'caseIgnoreMatch' "
4399 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4400 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4402 caseIgnoreMatch, caseIgnoreIndexer, caseIgnoreFilter,
4403 directoryStringApproxMatchOID },
4405 {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' "
4406 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4409 caseIgnoreOrderingMatch, NULL, NULL,
4412 {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' "
4413 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4414 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4416 caseIgnoreSubstringsMatch,
4417 caseIgnoreSubstringsIndexer,
4418 caseIgnoreSubstringsFilter,
4421 {"( 2.5.13.5 NAME 'caseExactMatch' "
4422 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4423 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4425 caseExactMatch, caseExactIndexer, caseExactFilter,
4426 directoryStringApproxMatchOID },
4428 {"( 2.5.13.6 NAME 'caseExactOrderingMatch' "
4429 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4432 caseExactOrderingMatch, NULL, NULL,
4435 {"( 2.5.13.7 NAME 'caseExactSubstringsMatch' "
4436 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4437 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4439 caseExactSubstringsMatch,
4440 caseExactSubstringsIndexer,
4441 caseExactSubstringsFilter,
4444 {"( 2.5.13.8 NAME 'numericStringMatch' "
4445 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
4446 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4449 caseIgnoreIA5Indexer,
4450 caseIgnoreIA5Filter,
4453 {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' "
4454 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4455 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4457 caseIgnoreIA5SubstringsMatch,
4458 caseIgnoreIA5SubstringsIndexer,
4459 caseIgnoreIA5SubstringsFilter,
4462 {"( 2.5.13.11 NAME 'caseIgnoreListMatch' "
4463 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )",
4464 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4466 caseIgnoreListMatch, NULL, NULL,
4469 {"( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch' "
4470 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4471 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4473 caseIgnoreListSubstringsMatch, NULL, NULL,
4476 {"( 2.5.13.13 NAME 'booleanMatch' "
4477 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )",
4478 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4480 booleanMatch, NULL, NULL,
4483 {"( 2.5.13.14 NAME 'integerMatch' "
4484 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4485 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4487 integerMatch, integerIndexer, integerFilter,
4490 {"( 2.5.13.16 NAME 'bitStringMatch' "
4491 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )",
4492 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4494 bitStringMatch, NULL, NULL,
4497 {"( 2.5.13.17 NAME 'octetStringMatch' "
4498 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4499 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4501 octetStringMatch, octetStringIndexer, octetStringFilter,
4504 {"( 2.5.13.20 NAME 'telephoneNumberMatch' "
4505 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
4506 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4508 telephoneNumberMatch,
4509 telephoneNumberIndexer,
4510 telephoneNumberFilter,
4513 {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' "
4514 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4515 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4517 telephoneNumberSubstringsMatch,
4518 telephoneNumberSubstringsIndexer,
4519 telephoneNumberSubstringsFilter,
4522 {"( 2.5.13.22 NAME 'presentationAddressMatch' "
4523 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )",
4524 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4529 {"( 2.5.13.23 NAME 'uniqueMemberMatch' "
4530 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )",
4531 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4533 uniqueMemberMatch, NULL, NULL,
4536 {"( 2.5.13.24 NAME 'protocolInformationMatch' "
4537 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )",
4538 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4540 protocolInformationMatch, NULL, NULL,
4543 {"( 2.5.13.27 NAME 'generalizedTimeMatch' "
4544 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4545 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4547 generalizedTimeMatch, NULL, NULL,
4550 {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' "
4551 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4554 generalizedTimeOrderingMatch, NULL, NULL,
4557 {"( 2.5.13.29 NAME 'integerFirstComponentMatch' "
4558 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4559 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4561 integerFirstComponentMatch, NULL, NULL,
4564 {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' "
4565 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4566 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4568 objectIdentifierFirstComponentMatch, NULL, NULL,
4571 {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' "
4572 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4573 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4575 caseExactIA5Match, caseExactIA5Indexer, caseExactIA5Filter,
4576 IA5StringApproxMatchOID },
4578 {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' "
4579 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4580 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4582 caseIgnoreIA5Match, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4583 IA5StringApproxMatchOID },
4585 {"( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch' "
4586 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4589 caseIgnoreIA5SubstringsMatch,
4590 caseIgnoreIA5SubstringsIndexer,
4591 caseIgnoreIA5SubstringsFilter,
4594 {"( 1.3.6.1.4.1.4203.1.2.1 NAME 'caseExactIA5SubstringsMatch' "
4595 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4598 caseExactIA5SubstringsMatch,
4599 caseExactIA5SubstringsIndexer,
4600 caseExactIA5SubstringsFilter,
4603 {"( 1.3.6.1.4.1.4203.666.4.1 NAME 'authPasswordMatch' "
4604 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4607 authPasswordMatch, NULL, NULL,
4610 {"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
4611 "SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
4614 OpenLDAPaciMatch, NULL, NULL,
4617 {NULL, SLAP_MR_NONE, NULL, NULL, NULL, NULL}
4626 /* we should only be called once (from main) */
4627 assert( schema_init_done == 0 );
4629 for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
4630 res = register_syntax( syntax_defs[i].sd_desc,
4631 syntax_defs[i].sd_flags,
4632 syntax_defs[i].sd_validate,
4633 syntax_defs[i].sd_normalize,
4634 syntax_defs[i].sd_pretty
4635 #ifdef SLAPD_BINARY_CONVERSION
4637 syntax_defs[i].sd_ber2str,
4638 syntax_defs[i].sd_str2ber
4643 fprintf( stderr, "schema_init: Error registering syntax %s\n",
4644 syntax_defs[i].sd_desc );
4649 for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
4650 if( mrule_defs[i].mrd_usage == SLAP_MR_NONE ) {
4652 "schema_init: Ingoring unusable matching rule %s\n",
4653 mrule_defs[i].mrd_desc );
4657 res = register_matching_rule(
4658 mrule_defs[i].mrd_desc,
4659 mrule_defs[i].mrd_usage,
4660 mrule_defs[i].mrd_convert,
4661 mrule_defs[i].mrd_normalize,
4662 mrule_defs[i].mrd_match,
4663 mrule_defs[i].mrd_indexer,
4664 mrule_defs[i].mrd_filter,
4665 mrule_defs[i].mrd_associated );
4669 "schema_init: Error registering matching rule %s\n",
4670 mrule_defs[i].mrd_desc );
4674 schema_init_done = 1;
4675 return LDAP_SUCCESS;