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>
22 #include "lutil_md5.h"
23 /* We should replace MD5 with a faster hash */
24 #define HASH_BYTES LUTIL_MD5_BYTES
25 #define HASH_CONTEXT lutil_MD5_CTX
26 #define HASH_Init(c) lutil_MD5Init(c)
27 #define HASH_Update(c,buf,len) lutil_MD5Update(c,buf,len)
28 #define HASH_Final(d,c) lutil_MD5Final(d,c)
30 #include "lutil_hash.h"
31 /* We should replace MD5 with a faster hash */
32 #define HASH_BYTES LUTIL_HASH_BYTES
33 #define HASH_CONTEXT lutil_HASH_CTX
34 #define HASH_Init(c) lutil_HASHInit(c)
35 #define HASH_Update(c,buf,len) lutil_HASHUpdate(c,buf,len)
36 #define HASH_Final(d,c) lutil_HASHFinal(d,c)
39 /* recycled validatation routines */
40 #define berValidate blobValidate
42 /* unimplemented pretters */
44 #define integerPretty NULL
46 /* recycled matching routines */
47 #define bitStringMatch octetStringMatch
48 #define integerMatch caseIgnoreIA5Match
49 #define numericStringMatch caseIgnoreIA5Match
50 #define objectIdentifierMatch caseIgnoreIA5Match
51 #define telephoneNumberMatch caseIgnoreIA5Match
52 #define telephoneNumberSubstringsMatch caseIgnoreIA5SubstringsMatch
53 #define generalizedTimeMatch caseIgnoreIA5Match
54 #define generalizedTimeOrderingMatch caseIgnoreIA5Match
55 #define uniqueMemberMatch dnMatch
57 /* approx matching rules */
58 #define directoryStringApproxMatchOID "1.3.6.1.4.1.4203.666.4.4"
59 #define directoryStringApproxMatch approxMatch
60 #define directoryStringApproxIndexer approxIndexer
61 #define directoryStringApproxFilter approxFilter
62 #define IA5StringApproxMatchOID "1.3.6.1.4.1.4203.666.4.5"
63 #define IA5StringApproxMatch approxMatch
64 #define IA5StringApproxIndexer approxIndexer
65 #define IA5StringApproxFilter approxFilter
67 /* orderring matching rules */
68 #define caseIgnoreOrderingMatch caseIgnoreMatch
69 #define caseExactOrderingMatch caseExactMatch
71 /* unimplemented matching routines */
72 #define caseIgnoreListMatch NULL
73 #define caseIgnoreListSubstringsMatch NULL
74 #define protocolInformationMatch NULL
75 #define integerFirstComponentMatch NULL
77 #define OpenLDAPaciMatch NULL
78 #define authPasswordMatch NULL
80 /* recycled indexing/filtering routines */
81 #define dnIndexer caseIgnoreIndexer
82 #define dnFilter caseIgnoreFilter
83 #define integerIndexer caseIgnoreIA5Indexer
84 #define integerFilter caseIgnoreIA5Filter
86 #define telephoneNumberIndexer caseIgnoreIA5Indexer
87 #define telephoneNumberFilter caseIgnoreIA5Filter
88 #define telephoneNumberSubstringsIndexer caseIgnoreIA5SubstringsIndexer
89 #define telephoneNumberSubstringsFilter caseIgnoreIA5SubstringsFilter
91 static char *strcasechr( const char *str, int c )
93 char *lower = strchr( str, TOLOWER(c) );
94 char *upper = strchr( str, TOUPPER(c) );
96 if( lower && upper ) {
97 return lower < upper ? lower : upper;
111 struct berval *value,
112 void *assertedValue )
114 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
117 match = memcmp( value->bv_val,
118 ((struct berval *) assertedValue)->bv_val,
126 /* Index generation function */
127 int octetStringIndexer(
132 struct berval *prefix,
133 struct berval **values,
134 struct berval ***keysp )
138 struct berval **keys;
139 HASH_CONTEXT HASHcontext;
140 unsigned char HASHdigest[HASH_BYTES];
141 struct berval digest;
142 digest.bv_val = HASHdigest;
143 digest.bv_len = sizeof(HASHdigest);
145 /* we should have at least one value at this point */
146 assert( values != NULL && values[0] != NULL );
148 for( i=0; values[i] != NULL; i++ ) {
149 /* just count them */
152 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
154 slen = strlen( syntax->ssyn_oid );
155 mlen = strlen( mr->smr_oid );
157 for( i=0; values[i] != NULL; i++ ) {
158 HASH_Init( &HASHcontext );
159 if( prefix != NULL && prefix->bv_len > 0 ) {
160 HASH_Update( &HASHcontext,
161 prefix->bv_val, prefix->bv_len );
163 HASH_Update( &HASHcontext,
164 syntax->ssyn_oid, slen );
165 HASH_Update( &HASHcontext,
167 HASH_Update( &HASHcontext,
168 values[i]->bv_val, values[i]->bv_len );
169 HASH_Final( HASHdigest, &HASHcontext );
171 keys[i] = ber_bvdup( &digest );
181 /* Index generation function */
182 int octetStringFilter(
187 struct berval *prefix,
189 struct berval ***keysp )
192 struct berval **keys;
193 HASH_CONTEXT HASHcontext;
194 unsigned char HASHdigest[HASH_BYTES];
195 struct berval *value = (struct berval *) assertValue;
196 struct berval digest;
197 digest.bv_val = HASHdigest;
198 digest.bv_len = sizeof(HASHdigest);
200 slen = strlen( syntax->ssyn_oid );
201 mlen = strlen( mr->smr_oid );
203 keys = ch_malloc( sizeof( struct berval * ) * 2 );
205 HASH_Init( &HASHcontext );
206 if( prefix != NULL && prefix->bv_len > 0 ) {
207 HASH_Update( &HASHcontext,
208 prefix->bv_val, prefix->bv_len );
210 HASH_Update( &HASHcontext,
211 syntax->ssyn_oid, slen );
212 HASH_Update( &HASHcontext,
214 HASH_Update( &HASHcontext,
215 value->bv_val, value->bv_len );
216 HASH_Final( HASHdigest, &HASHcontext );
218 keys[0] = ber_bvdup( &digest );
234 if( in->bv_len == 0 ) return LDAP_SUCCESS;
236 dn = get_validated_dn( in->bv_val, 0, 0 );
238 rc = ( dn == NULL ) ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
250 struct berval **normalized )
254 if ( val->bv_len == 0 ) {
255 out = ber_bvdup( val );
258 #ifdef USE_DN_NORMALIZE
259 dn = get_validated_dn( val->bv_val, 1, 1 );
261 dn = get_validated_dn( val->bv_val, 0, 0 );
264 return LDAP_INVALID_SYNTAX;
267 out = (struct berval *)ch_malloc(sizeof(struct berval));
269 out->bv_len = strlen( dn );
282 struct berval *value,
283 void *assertedValue )
286 struct berval *asserted = (struct berval *) assertedValue;
288 match = value->bv_len - asserted->bv_len;
291 #ifdef USE_DN_NORMALIZE
292 match = strcmp( value->bv_val, asserted->bv_val );
294 match = strcasecmp( value->bv_val, asserted->bv_val );
299 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
300 "dnMatch: %d\n %s\n %s\n", match,
301 value->bv_val, asserted->bv_val ));
303 Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
304 match, value->bv_val, asserted->bv_val );
320 if( in->bv_len == 0 ) return LDAP_SUCCESS;
322 dn = ber_bvdup( in );
324 if( dn->bv_val[dn->bv_len-1] == '\'' ) {
325 /* assume presence of optional UID */
328 for(i=dn->bv_len-2; i>2; i--) {
329 if( dn->bv_val[i] != '0' && dn->bv_val[i] != '1' ) {
333 if( dn->bv_val[i] != '\'' ) {
334 return LDAP_INVALID_SYNTAX;
336 if( dn->bv_val[i-1] != 'B' ) {
337 return LDAP_INVALID_SYNTAX;
339 if( dn->bv_val[i-2] != '#' ) {
340 return LDAP_INVALID_SYNTAX;
343 /* trim the UID to allow use of dn_validate */
344 dn->bv_val[i-2] = '\0';
347 rc = dn_validate( dn->bv_val ) == NULL
348 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
358 struct berval **normalized )
360 struct berval *out = ber_bvdup( val );
362 if( out->bv_len != 0 ) {
366 ber_len_t uidlen = 0;
368 if( out->bv_val[out->bv_len-1] == '\'' ) {
369 /* assume presence of optional UID */
370 uid = strrchr( out->bv_val, '#' );
374 return LDAP_INVALID_SYNTAX;
377 uidlen = out->bv_len - (out->bv_val - uid);
378 /* temporarily trim the UID */
382 #ifdef USE_DN_NORMALIZE
383 dn = dn_normalize( out->bv_val );
385 dn = dn_validate( out->bv_val );
390 return LDAP_INVALID_SYNTAX;
396 /* restore the separator */
399 SAFEMEMCPY( &dn[dnlen], uid, uidlen );
403 out->bv_len = dnlen + uidlen;
415 /* any value allowed */
424 /* any value allowed */
435 /* very unforgiving validation, requires no normalization
436 * before simplistic matching
438 if( in->bv_len < 3 ) {
439 return LDAP_INVALID_SYNTAX;
442 if( in->bv_val[0] != 'B' ||
443 in->bv_val[1] != '\'' ||
444 in->bv_val[in->bv_len-1] != '\'' )
446 return LDAP_INVALID_SYNTAX;
449 for( i=in->bv_len-2; i>1; i-- ) {
450 if( in->bv_val[i] != '0' && in->bv_val[i] != '1' ) {
451 return LDAP_INVALID_SYNTAX;
459 * Handling boolean syntax and matching is quite rigid.
460 * A more flexible approach would be to allow a variety
461 * of strings to be normalized and prettied into TRUE
469 /* very unforgiving validation, requires no normalization
470 * before simplistic matching
473 if( in->bv_len == 4 ) {
474 if( !memcmp( in->bv_val, "TRUE", 4 ) ) {
477 } else if( in->bv_len == 5 ) {
478 if( !memcmp( in->bv_val, "FALSE", 5 ) ) {
483 return LDAP_INVALID_SYNTAX;
492 struct berval *value,
493 void *assertedValue )
495 /* simplistic matching allowed by rigid validation */
496 struct berval *asserted = (struct berval *) assertedValue;
497 *matchp = value->bv_len != asserted->bv_len;
502 /* case insensitive UTF8 strncmp with offset for second string */
505 struct berval *right,
511 ber_len_t rlen, llen;
512 ber_len_t rslen, lslen;
513 ldap_unicode_t ru, lu;
514 ldap_unicode_t ruu, luu;
516 rslen = len < right->bv_len ? len : right->bv_len;
517 lslen = len + offset < left->bv_len ? len : left->bv_len;
519 for( r = 0, l = offset;
520 r < rslen && l < lslen;
524 * XXYYZ: we convert to ucs4 even though -llunicode
525 * expects ucs2 in an unsigned long
527 ru = ldap_utf8_to_ucs4( &right->bv_val[r] );
528 if( ru == LDAP_UCS4_INVALID ) {
532 lu = ldap_utf8_to_ucs4( &left->bv_val[l] );
533 if( lu == LDAP_UCS4_INVALID ) {
537 ruu = uctoupper( ru );
538 luu = uctoupper( lu );
542 } else if( luu > ruu ) {
546 rlen = LDAP_UTF8_CHARLEN( &right->bv_val[r] );
547 llen = LDAP_UTF8_CHARLEN( &left->bv_val[l] );
563 static char *UTF8casechr( const char *str, const char *c )
565 char *p, *lower, *upper;
566 ldap_ucs4_t tch, ch = ldap_utf8_to_ucs4(c);
568 tch = uctolower ( ch );
569 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
570 if( ldap_utf8_to_ucs4( p ) == tch ) {
574 lower = *p != '\0' ? p : NULL;
576 tch = uctoupper ( ch );
577 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
578 if( ldap_utf8_to_ucs4( p ) == tch ) {
582 upper = *p != '\0' ? p : NULL;
584 if( lower && upper ) {
585 return lower < upper ? lower : upper;
586 } 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;
700 /* Returns Unicode cannonically normalized copy of a substring assertion
701 * Skipping attribute description */
702 SubstringsAssertion *
703 UTF8SubstringsassertionNormalize(
704 SubstringsAssertion *sa,
707 SubstringsAssertion *nsa;
710 nsa = (SubstringsAssertion *)ch_calloc( 1, sizeof(SubstringsAssertion) );
715 if( sa->sa_initial != NULL ) {
716 nsa->sa_initial = ber_bvstr( UTF8normalize( sa->sa_initial->bv_val, casefold ) );
717 if( nsa->sa_initial == NULL ) {
722 if( sa->sa_any != NULL ) {
723 for( i=0; sa->sa_any[i] != NULL; i++ ) {
726 nsa->sa_any = (struct berval **)ch_malloc( (i + 1) * sizeof(struct berval *) );
727 for( i=0; sa->sa_any[i] != NULL; i++ ) {
728 nsa->sa_any[i] = ber_bvstr( UTF8normalize( sa->sa_any[i]->bv_val, casefold ) );
729 if( nsa->sa_any[i] == NULL ) {
733 nsa->sa_any[i] = NULL;
736 if( sa->sa_final != NULL ) {
737 nsa->sa_final = ber_bvstr( UTF8normalize( sa->sa_final->bv_val, casefold ) );
738 if( nsa->sa_final == NULL ) {
746 ch_free( nsa->sa_final );
747 ber_bvecfree( nsa->sa_any );
748 ch_free( nsa->sa_initial );
754 #if defined(SLAPD_APPROX_MULTISTRING)
756 #if defined(SLAPD_APPROX_INITIALS)
757 #define SLAPD_APPROX_DELIMITER "._ "
758 #define SLAPD_APPROX_WORDLEN 2
760 #define SLAPD_APPROX_DELIMITER " "
761 #define SLAPD_APPROX_WORDLEN 1
770 struct berval *value,
771 void *assertedValue )
773 char *val, *assertv, **values, **words, *c;
774 int i, count, len, nextchunk=0, nextavail=0;
777 /* Isolate how many words there are */
778 val = ch_strdup( value->bv_val );
779 for( c=val,count=1; *c; c++ ) {
780 c = strpbrk( c, SLAPD_APPROX_DELIMITER );
781 if ( c == NULL ) break;
786 /* Get a phonetic copy of each word */
787 words = (char **)ch_malloc( count * sizeof(char *) );
788 values = (char **)ch_malloc( count * sizeof(char *) );
789 for( c=val,i=0; i<count; i++,c+=strlen(c)+1 ) {
791 values[i] = phonetic(c);
795 /* Work through the asserted value's words, to see if at least some
796 of the words are there, in the same order. */
797 assertv = ch_strdup( ((struct berval *)assertedValue)->bv_val );
799 while ( nextchunk < ((struct berval *)assertedValue)->bv_len ) {
800 len = strcspn( assertv + nextchunk, SLAPD_APPROX_DELIMITER);
805 #if defined(SLAPD_APPROX_INITIALS)
806 else if( len == 1 ) {
807 /* Single letter words need to at least match one word's initial */
808 for( i=nextavail; i<count; i++ )
809 if( !strncasecmp( assertv+nextchunk, words[i], 1 )) {
816 /* Isolate the next word in the asserted value and phonetic it */
817 assertv[nextchunk+len] = '\0';
818 val = phonetic( assertv + nextchunk );
820 /* See if this phonetic chunk is in the remaining words of *value */
821 for( i=nextavail; i<count; i++ ){
822 if( !strcmp( val, values[i] ) ){
829 /* This chunk in the asserted value was NOT within the *value. */
835 /* Go on to the next word in the asserted value */
839 /* If some of the words were seen, call it a match */
840 if( nextavail > 0 ) {
849 for( i=0; i<count; i++ ) {
850 ch_free( values[i] );
866 struct berval *prefix,
867 struct berval **values,
868 struct berval ***keysp )
871 int i,j, len, wordcount, keycount=0;
872 struct berval **newkeys, **keys=NULL;
875 for( j=0; values[j] != NULL; j++ ) {
877 /* Isolate how many words there are. There will be a key for each */
878 val = ch_strdup( values[j]->bv_val );
879 for( wordcount=0,c=val; *c; c++) {
880 len = strcspn(c, SLAPD_APPROX_DELIMITER);
881 if( len >= SLAPD_APPROX_WORDLEN ) wordcount++;
883 if (*c == '\0') break;
887 /* Allocate/increase storage to account for new keys */
888 newkeys = (struct berval **)ch_malloc( (keycount + wordcount + 1)
889 * sizeof(struct berval *) );
890 memcpy( newkeys, keys, keycount * sizeof(struct berval *) );
891 if( keys ) ch_free( keys );
894 /* Get a phonetic copy of each word */
895 for( c=val,i=0; i<wordcount; c+=len+1 ) {
897 if( len < SLAPD_APPROX_WORDLEN ) continue;
898 keys[keycount] = (struct berval *)ch_malloc( sizeof(struct berval) );
899 keys[keycount]->bv_val = phonetic( c );
900 keys[keycount]->bv_len = strlen( keys[keycount]->bv_val );
907 keys[keycount] = NULL;
920 struct berval *prefix,
922 struct berval ***keysp )
926 struct berval **keys;
929 /* Isolate how many words there are. There will be a key for each */
930 val = ch_strdup( ((struct berval *)assertValue)->bv_val );
931 for( count=0,c=val; *c; c++) {
932 len = strcspn(c, SLAPD_APPROX_DELIMITER);
933 if( len >= SLAPD_APPROX_WORDLEN ) count++;
935 if (*c == '\0') break;
939 /* Allocate storage for new keys */
940 keys = (struct berval **)ch_malloc( (count + 1) * sizeof(struct berval *) );
942 /* Get a phonetic copy of each word */
943 for( c=val,i=0; i<count; c+=len+1 ) {
945 if( len < SLAPD_APPROX_WORDLEN ) continue;
946 keys[i] = (struct berval *)ch_malloc( sizeof(struct berval) );
947 keys[i]->bv_val = phonetic( c );
948 keys[i]->bv_len = strlen( keys[i]->bv_val );
962 /* No other form of Approximate Matching is defined */
970 struct berval *value,
971 void *assertedValue )
973 char *vapprox, *avapprox;
975 vapprox = phonetic( value->bv_val );
976 avapprox = phonetic( ((struct berval *)assertedValue)->bv_val);
978 *matchp = strcmp( vapprox, avapprox );
992 struct berval *prefix,
993 struct berval **values,
994 struct berval ***keysp )
997 struct berval **keys;
1000 for( i=0; values[i] != NULL; i++ ) {
1001 /* just count them */
1005 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * (i+1) );
1007 /* Copy each value and run it through phonetic() */
1008 for( i=0; values[i] != NULL; i++ ) {
1009 keys[i] = ch_malloc( sizeof( struct berval * ) );
1010 keys[i]->bv_val = phonetic( values[i]->bv_val );
1011 keys[i]->bv_len = strlen( keys[i]->bv_val );
1016 return LDAP_SUCCESS;
1026 struct berval *prefix,
1028 struct berval ***keysp )
1030 struct berval **keys;
1033 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * 2 );
1035 /* Copy the value and run it through phonetic() */
1036 keys[0] = ch_malloc( sizeof( struct berval * ) );
1037 keys[0]->bv_val = phonetic( ((struct berval *)assertValue)->bv_val );
1038 keys[0]->bv_len = strlen( keys[0]->bv_val );
1042 return LDAP_SUCCESS;
1053 struct berval *value,
1054 void *assertedValue )
1056 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
1059 match = strncmp( value->bv_val,
1060 ((struct berval *) assertedValue)->bv_val,
1065 return LDAP_SUCCESS;
1069 caseExactSubstringsMatch(
1074 struct berval *value,
1075 void *assertedValue )
1078 SubstringsAssertion *sub = assertedValue;
1079 struct berval left = *value;
1083 /* Add up asserted input length */
1084 if( sub->sa_initial ) {
1085 inlen += sub->sa_initial->bv_len;
1088 for(i=0; sub->sa_any[i] != NULL; i++) {
1089 inlen += sub->sa_any[i]->bv_len;
1092 if( sub->sa_final ) {
1093 inlen += sub->sa_final->bv_len;
1096 if( sub->sa_initial ) {
1097 if( inlen > left.bv_len ) {
1102 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1103 sub->sa_initial->bv_len );
1109 left.bv_val += sub->sa_initial->bv_len;
1110 left.bv_len -= sub->sa_initial->bv_len;
1111 inlen -= sub->sa_initial->bv_len;
1114 if( sub->sa_final ) {
1115 if( inlen > left.bv_len ) {
1120 match = strncmp( sub->sa_final->bv_val,
1121 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1122 sub->sa_final->bv_len );
1128 left.bv_len -= sub->sa_final->bv_len;
1129 inlen -= sub->sa_final->bv_len;
1133 for(i=0; sub->sa_any[i]; i++) {
1138 if( inlen > left.bv_len ) {
1139 /* not enough length */
1144 if( sub->sa_any[i]->bv_len == 0 ) {
1148 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1155 idx = p - left.bv_val;
1156 assert( idx < left.bv_len );
1158 if( idx >= left.bv_len ) {
1159 /* this shouldn't happen */
1166 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1167 /* not enough left */
1172 match = strncmp( left.bv_val,
1173 sub->sa_any[i]->bv_val,
1174 sub->sa_any[i]->bv_len );
1182 left.bv_val += sub->sa_any[i]->bv_len;
1183 left.bv_len -= sub->sa_any[i]->bv_len;
1184 inlen -= sub->sa_any[i]->bv_len;
1190 return LDAP_SUCCESS;
1193 /* Index generation function */
1194 int caseExactIndexer(
1199 struct berval *prefix,
1200 struct berval **values,
1201 struct berval ***keysp )
1205 struct berval **keys;
1206 HASH_CONTEXT HASHcontext;
1207 unsigned char HASHdigest[HASH_BYTES];
1208 struct berval digest;
1209 digest.bv_val = HASHdigest;
1210 digest.bv_len = sizeof(HASHdigest);
1212 /* we should have at least one value at this point */
1213 assert( values != NULL && values[0] != NULL );
1215 for( i=0; values[i] != NULL; i++ ) {
1216 /* just count them */
1219 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1221 slen = strlen( syntax->ssyn_oid );
1222 mlen = strlen( mr->smr_oid );
1224 for( i=0; values[i] != NULL; i++ ) {
1225 struct berval *value;
1227 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_NOCASEFOLD ) );
1232 HASH_Init( &HASHcontext );
1233 if( prefix != NULL && prefix->bv_len > 0 ) {
1234 HASH_Update( &HASHcontext,
1235 prefix->bv_val, prefix->bv_len );
1237 HASH_Update( &HASHcontext,
1238 syntax->ssyn_oid, slen );
1239 HASH_Update( &HASHcontext,
1240 mr->smr_oid, mlen );
1241 HASH_Update( &HASHcontext,
1242 value->bv_val, value->bv_len );
1243 HASH_Final( HASHdigest, &HASHcontext );
1246 ber_bvfree( value );
1249 keys[i] = ber_bvdup( &digest );
1254 return LDAP_SUCCESS;
1257 /* Index generation function */
1258 int caseExactFilter(
1263 struct berval *prefix,
1265 struct berval ***keysp )
1268 struct berval **keys;
1269 HASH_CONTEXT HASHcontext;
1270 unsigned char HASHdigest[HASH_BYTES];
1271 struct berval *value;
1272 struct berval digest;
1273 digest.bv_val = HASHdigest;
1274 digest.bv_len = sizeof(HASHdigest);
1276 slen = strlen( syntax->ssyn_oid );
1277 mlen = strlen( mr->smr_oid );
1280 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1281 UTF8_NOCASEFOLD ) );
1282 /* This usually happens if filter contains bad UTF8 */
1283 if( value == NULL ) {
1284 keys = ch_malloc( sizeof( struct berval * ) );
1286 return LDAP_SUCCESS;
1289 value = (struct berval *) assertValue;
1292 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1294 HASH_Init( &HASHcontext );
1295 if( prefix != NULL && prefix->bv_len > 0 ) {
1296 HASH_Update( &HASHcontext,
1297 prefix->bv_val, prefix->bv_len );
1299 HASH_Update( &HASHcontext,
1300 syntax->ssyn_oid, slen );
1301 HASH_Update( &HASHcontext,
1302 mr->smr_oid, mlen );
1303 HASH_Update( &HASHcontext,
1304 value->bv_val, value->bv_len );
1305 HASH_Final( HASHdigest, &HASHcontext );
1307 keys[0] = ber_bvdup( &digest );
1311 ber_bvfree( value );
1315 return LDAP_SUCCESS;
1318 /* Substrings Index generation function */
1319 int caseExactSubstringsIndexer(
1324 struct berval *prefix,
1325 struct berval **values,
1326 struct berval ***keysp )
1330 struct berval **keys;
1332 struct berval **nvalues;
1335 HASH_CONTEXT HASHcontext;
1336 unsigned char HASHdigest[HASH_BYTES];
1337 struct berval digest;
1338 digest.bv_val = HASHdigest;
1339 digest.bv_len = sizeof(HASHdigest);
1341 /* we should have at least one value at this point */
1342 assert( values != NULL && values[0] != NULL );
1347 /* create normalized copy of values */
1348 for( i=0; values[i] != NULL; i++ ) {
1351 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
1352 for( i=0; values[i] != NULL; i++ ) {
1353 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_NOCASEFOLD ) );
1359 for( i=0; values[i] != NULL; i++ ) {
1360 /* count number of indices to generate */
1361 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1365 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1366 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1367 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1368 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1370 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1374 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1375 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1376 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1380 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1381 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1382 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1383 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1385 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1391 /* no keys to generate */
1393 return LDAP_SUCCESS;
1396 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1398 slen = strlen( syntax->ssyn_oid );
1399 mlen = strlen( mr->smr_oid );
1402 for( i=0; values[i] != NULL; i++ ) {
1404 struct berval *value;
1406 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
1410 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
1411 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
1413 char pre = SLAP_INDEX_SUBSTR_PREFIX;
1414 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
1416 for( j=0; j<max; j++ ) {
1417 HASH_Init( &HASHcontext );
1418 if( prefix != NULL && prefix->bv_len > 0 ) {
1419 HASH_Update( &HASHcontext,
1420 prefix->bv_val, prefix->bv_len );
1423 HASH_Update( &HASHcontext,
1424 &pre, sizeof( pre ) );
1425 HASH_Update( &HASHcontext,
1426 syntax->ssyn_oid, slen );
1427 HASH_Update( &HASHcontext,
1428 mr->smr_oid, mlen );
1429 HASH_Update( &HASHcontext,
1431 SLAP_INDEX_SUBSTR_MAXLEN );
1432 HASH_Final( HASHdigest, &HASHcontext );
1434 keys[nkeys++] = ber_bvdup( &digest );
1438 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1439 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1441 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
1444 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1445 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1446 HASH_Init( &HASHcontext );
1447 if( prefix != NULL && prefix->bv_len > 0 ) {
1448 HASH_Update( &HASHcontext,
1449 prefix->bv_val, prefix->bv_len );
1451 HASH_Update( &HASHcontext,
1452 &pre, sizeof( pre ) );
1453 HASH_Update( &HASHcontext,
1454 syntax->ssyn_oid, slen );
1455 HASH_Update( &HASHcontext,
1456 mr->smr_oid, mlen );
1457 HASH_Update( &HASHcontext,
1459 HASH_Final( HASHdigest, &HASHcontext );
1461 keys[nkeys++] = ber_bvdup( &digest );
1464 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1465 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1466 HASH_Init( &HASHcontext );
1467 if( prefix != NULL && prefix->bv_len > 0 ) {
1468 HASH_Update( &HASHcontext,
1469 prefix->bv_val, prefix->bv_len );
1471 HASH_Update( &HASHcontext,
1472 &pre, sizeof( pre ) );
1473 HASH_Update( &HASHcontext,
1474 syntax->ssyn_oid, slen );
1475 HASH_Update( &HASHcontext,
1476 mr->smr_oid, mlen );
1477 HASH_Update( &HASHcontext,
1478 &value->bv_val[value->bv_len-j], j );
1479 HASH_Final( HASHdigest, &HASHcontext );
1481 keys[nkeys++] = ber_bvdup( &digest );
1497 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;
1523 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_NOCASEFOLD );
1529 return LDAP_SUCCESS;
1532 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1533 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1538 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1540 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1541 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1542 /* don't bother accounting for stepping */
1543 nkeys += sa->sa_any[i]->bv_len -
1544 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1549 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1550 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1557 return LDAP_SUCCESS;
1560 digest.bv_val = HASHdigest;
1561 digest.bv_len = sizeof(HASHdigest);
1563 slen = strlen( syntax->ssyn_oid );
1564 mlen = strlen( mr->smr_oid );
1566 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1569 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1570 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1572 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1573 value = sa->sa_initial;
1575 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1576 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1578 HASH_Init( &HASHcontext );
1579 if( prefix != NULL && prefix->bv_len > 0 ) {
1580 HASH_Update( &HASHcontext,
1581 prefix->bv_val, prefix->bv_len );
1583 HASH_Update( &HASHcontext,
1584 &pre, sizeof( pre ) );
1585 HASH_Update( &HASHcontext,
1586 syntax->ssyn_oid, slen );
1587 HASH_Update( &HASHcontext,
1588 mr->smr_oid, mlen );
1589 HASH_Update( &HASHcontext,
1590 value->bv_val, klen );
1591 HASH_Final( HASHdigest, &HASHcontext );
1593 keys[nkeys++] = ber_bvdup( &digest );
1596 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1598 pre = SLAP_INDEX_SUBSTR_PREFIX;
1599 klen = SLAP_INDEX_SUBSTR_MAXLEN;
1601 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1602 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
1606 value = sa->sa_any[i];
1609 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
1610 j += SLAP_INDEX_SUBSTR_STEP )
1612 HASH_Init( &HASHcontext );
1613 if( prefix != NULL && prefix->bv_len > 0 ) {
1614 HASH_Update( &HASHcontext,
1615 prefix->bv_val, prefix->bv_len );
1617 HASH_Update( &HASHcontext,
1618 &pre, sizeof( pre ) );
1619 HASH_Update( &HASHcontext,
1620 syntax->ssyn_oid, slen );
1621 HASH_Update( &HASHcontext,
1622 mr->smr_oid, mlen );
1623 HASH_Update( &HASHcontext,
1624 &value->bv_val[j], klen );
1625 HASH_Final( HASHdigest, &HASHcontext );
1627 keys[nkeys++] = ber_bvdup( &digest );
1633 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1634 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1636 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1637 value = sa->sa_final;
1639 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1640 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1642 HASH_Init( &HASHcontext );
1643 if( prefix != NULL && prefix->bv_len > 0 ) {
1644 HASH_Update( &HASHcontext,
1645 prefix->bv_val, prefix->bv_len );
1647 HASH_Update( &HASHcontext,
1648 &pre, sizeof( pre ) );
1649 HASH_Update( &HASHcontext,
1650 syntax->ssyn_oid, slen );
1651 HASH_Update( &HASHcontext,
1652 mr->smr_oid, mlen );
1653 HASH_Update( &HASHcontext,
1654 &value->bv_val[value->bv_len-klen], klen );
1655 HASH_Final( HASHdigest, &HASHcontext );
1657 keys[nkeys++] = ber_bvdup( &digest );
1668 ch_free( sa->sa_final );
1669 ber_bvecfree( sa->sa_any );
1670 ch_free( sa->sa_initial );
1674 return LDAP_SUCCESS;
1683 struct berval *value,
1684 void *assertedValue )
1687 *matchp = UTF8normcmp( value->bv_val,
1688 ((struct berval *) assertedValue)->bv_val,
1691 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
1694 match = strncasecmp( value->bv_val,
1695 ((struct berval *) assertedValue)->bv_val,
1701 return LDAP_SUCCESS;
1705 caseIgnoreSubstringsMatch(
1710 struct berval *value,
1711 void *assertedValue )
1714 SubstringsAssertion *sub = assertedValue;
1715 struct berval left = *value;
1719 /* Add up asserted input length */
1720 if( sub->sa_initial ) {
1721 inlen += sub->sa_initial->bv_len;
1724 for(i=0; sub->sa_any[i] != NULL; i++) {
1725 inlen += sub->sa_any[i]->bv_len;
1728 if( sub->sa_final ) {
1729 inlen += sub->sa_final->bv_len;
1732 if( sub->sa_initial ) {
1733 if( inlen > left.bv_len ) {
1739 match = UTF8oncasecmp( sub->sa_initial, &left,
1740 sub->sa_initial->bv_len, 0 );
1742 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
1743 sub->sa_initial->bv_len );
1750 left.bv_val += sub->sa_initial->bv_len;
1751 left.bv_len -= sub->sa_initial->bv_len;
1752 inlen -= sub->sa_initial->bv_len;
1755 if( sub->sa_final ) {
1756 if( inlen > left.bv_len ) {
1762 match = UTF8oncasecmp( sub->sa_final, &left,
1763 sub->sa_final->bv_len,
1764 left.bv_len - sub->sa_final->bv_len );
1766 match = strncasecmp( sub->sa_final->bv_val,
1767 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1768 sub->sa_final->bv_len );
1775 left.bv_len -= sub->sa_final->bv_len;
1776 inlen -= sub->sa_final->bv_len;
1780 for(i=0; sub->sa_any[i]; i++) {
1785 if( inlen > left.bv_len ) {
1786 /* not enough length */
1791 if( sub->sa_any[i]->bv_len == 0 ) {
1796 p = UTF8casechr( left.bv_val, sub->sa_any[i]->bv_val );
1798 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
1806 idx = p - left.bv_val;
1807 assert( idx < left.bv_len );
1809 if( idx >= left.bv_len ) {
1810 /* this shouldn't happen */
1817 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1818 /* not enough left */
1824 match = UTF8oncasecmp( &left, sub->sa_any[i],
1825 sub->sa_any[i]->bv_len, 0 );
1828 int len = LDAP_UTF8_CHARLEN( left.bv_val );
1834 match = strncasecmp( left.bv_val,
1835 sub->sa_any[i]->bv_val,
1836 sub->sa_any[i]->bv_len );
1846 left.bv_val += sub->sa_any[i]->bv_len;
1847 left.bv_len -= sub->sa_any[i]->bv_len;
1848 inlen -= sub->sa_any[i]->bv_len;
1854 return LDAP_SUCCESS;
1857 /* Index generation function */
1858 int caseIgnoreIndexer(
1863 struct berval *prefix,
1864 struct berval **values,
1865 struct berval ***keysp )
1869 struct berval **keys;
1870 HASH_CONTEXT HASHcontext;
1871 unsigned char HASHdigest[HASH_BYTES];
1872 struct berval digest;
1873 digest.bv_val = HASHdigest;
1874 digest.bv_len = sizeof(HASHdigest);
1876 /* we should have at least one value at this point */
1877 assert( values != NULL && values[0] != NULL );
1879 for( i=0; values[i] != NULL; i++ ) {
1880 /* just count them */
1883 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1885 slen = strlen( syntax->ssyn_oid );
1886 mlen = strlen( mr->smr_oid );
1888 for( i=0; values[i] != NULL; i++ ) {
1889 struct berval *value;
1891 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
1893 value = ber_bvdup( values[i] );
1894 ldap_pvt_str2upper( value->bv_val );
1896 HASH_Init( &HASHcontext );
1897 if( prefix != NULL && prefix->bv_len > 0 ) {
1898 HASH_Update( &HASHcontext,
1899 prefix->bv_val, prefix->bv_len );
1901 HASH_Update( &HASHcontext,
1902 syntax->ssyn_oid, slen );
1903 HASH_Update( &HASHcontext,
1904 mr->smr_oid, mlen );
1905 HASH_Update( &HASHcontext,
1906 value->bv_val, value->bv_len );
1907 HASH_Final( HASHdigest, &HASHcontext );
1909 ber_bvfree( value );
1911 keys[i] = ber_bvdup( &digest );
1916 return LDAP_SUCCESS;
1919 /* Index generation function */
1920 int caseIgnoreFilter(
1925 struct berval *prefix,
1927 struct berval ***keysp )
1930 struct berval **keys;
1931 HASH_CONTEXT HASHcontext;
1932 unsigned char HASHdigest[HASH_BYTES];
1933 struct berval *value;
1934 struct berval digest;
1935 digest.bv_val = HASHdigest;
1936 digest.bv_len = sizeof(HASHdigest);
1938 slen = strlen( syntax->ssyn_oid );
1939 mlen = strlen( mr->smr_oid );
1942 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val,
1944 /* This usually happens if filter contains bad UTF8 */
1945 if( value == NULL ) {
1946 keys = ch_malloc( sizeof( struct berval * ) );
1948 return LDAP_SUCCESS;
1951 value = ber_bvdup( (struct berval *) assertValue );
1952 ldap_pvt_str2upper( value->bv_val );
1955 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1957 HASH_Init( &HASHcontext );
1958 if( prefix != NULL && prefix->bv_len > 0 ) {
1959 HASH_Update( &HASHcontext,
1960 prefix->bv_val, prefix->bv_len );
1962 HASH_Update( &HASHcontext,
1963 syntax->ssyn_oid, slen );
1964 HASH_Update( &HASHcontext,
1965 mr->smr_oid, mlen );
1966 HASH_Update( &HASHcontext,
1967 value->bv_val, value->bv_len );
1968 HASH_Final( HASHdigest, &HASHcontext );
1970 keys[0] = ber_bvdup( &digest );
1973 ber_bvfree( value );
1977 return LDAP_SUCCESS;
1980 /* Substrings Index generation function */
1981 int caseIgnoreSubstringsIndexer(
1986 struct berval *prefix,
1987 struct berval **values,
1988 struct berval ***keysp )
1992 struct berval **keys;
1994 struct berval **nvalues;
1997 HASH_CONTEXT HASHcontext;
1998 unsigned char HASHdigest[HASH_BYTES];
1999 struct berval digest;
2000 digest.bv_val = HASHdigest;
2001 digest.bv_len = sizeof(HASHdigest);
2003 /* we should have at least one value at this point */
2004 assert( values != NULL && values[0] != NULL );
2009 /* create normalized copy of values */
2010 for( i=0; values[i] != NULL; i++ ) {
2013 nvalues = ch_malloc( sizeof( struct berval * ) * (i+1) );
2014 for( i=0; values[i] != NULL; i++ ) {
2015 nvalues[i] = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
2021 for( i=0; values[i] != NULL; i++ ) {
2022 /* count number of indices to generate */
2023 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
2027 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2028 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2029 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2030 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2032 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2036 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2037 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2038 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2042 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2043 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2044 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2045 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2047 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2053 /* no keys to generate */
2055 return LDAP_SUCCESS;
2058 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2060 slen = strlen( syntax->ssyn_oid );
2061 mlen = strlen( mr->smr_oid );
2064 for( i=0; values[i] != NULL; i++ ) {
2066 struct berval *value;
2068 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2073 value = ber_bvdup( values[i] );
2074 ldap_pvt_str2upper( value->bv_val );
2077 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2078 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2080 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2081 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2083 for( j=0; j<max; j++ ) {
2084 HASH_Init( &HASHcontext );
2085 if( prefix != NULL && prefix->bv_len > 0 ) {
2086 HASH_Update( &HASHcontext,
2087 prefix->bv_val, prefix->bv_len );
2090 HASH_Update( &HASHcontext,
2091 &pre, sizeof( pre ) );
2092 HASH_Update( &HASHcontext,
2093 syntax->ssyn_oid, slen );
2094 HASH_Update( &HASHcontext,
2095 mr->smr_oid, mlen );
2096 HASH_Update( &HASHcontext,
2098 SLAP_INDEX_SUBSTR_MAXLEN );
2099 HASH_Final( HASHdigest, &HASHcontext );
2101 keys[nkeys++] = ber_bvdup( &digest );
2105 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2106 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2108 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2111 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2112 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2113 HASH_Init( &HASHcontext );
2114 if( prefix != NULL && prefix->bv_len > 0 ) {
2115 HASH_Update( &HASHcontext,
2116 prefix->bv_val, prefix->bv_len );
2118 HASH_Update( &HASHcontext,
2119 &pre, sizeof( pre ) );
2120 HASH_Update( &HASHcontext,
2121 syntax->ssyn_oid, slen );
2122 HASH_Update( &HASHcontext,
2123 mr->smr_oid, mlen );
2124 HASH_Update( &HASHcontext,
2126 HASH_Final( HASHdigest, &HASHcontext );
2128 keys[nkeys++] = ber_bvdup( &digest );
2131 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2132 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2133 HASH_Init( &HASHcontext );
2134 if( prefix != NULL && prefix->bv_len > 0 ) {
2135 HASH_Update( &HASHcontext,
2136 prefix->bv_val, prefix->bv_len );
2138 HASH_Update( &HASHcontext,
2139 &pre, sizeof( pre ) );
2140 HASH_Update( &HASHcontext,
2141 syntax->ssyn_oid, slen );
2142 HASH_Update( &HASHcontext,
2143 mr->smr_oid, mlen );
2144 HASH_Update( &HASHcontext,
2145 &value->bv_val[value->bv_len-j], j );
2146 HASH_Final( HASHdigest, &HASHcontext );
2148 keys[nkeys++] = ber_bvdup( &digest );
2153 ber_bvfree( value );
2166 ber_bvecfree( nvalues );
2168 return LDAP_SUCCESS;
2171 int caseIgnoreSubstringsFilter(
2176 struct berval *prefix,
2178 struct berval ***keysp )
2180 SubstringsAssertion *sa;
2182 ber_len_t nkeys = 0;
2183 size_t slen, mlen, klen;
2184 struct berval **keys;
2185 HASH_CONTEXT HASHcontext;
2186 unsigned char HASHdigest[HASH_BYTES];
2187 struct berval *value;
2188 struct berval digest;
2191 sa = UTF8SubstringsassertionNormalize( assertValue, UTF8_CASEFOLD );
2197 return LDAP_SUCCESS;
2200 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2201 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2206 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2208 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2209 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2210 /* don't bother accounting for stepping */
2211 nkeys += sa->sa_any[i]->bv_len -
2212 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2217 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2218 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2225 return LDAP_SUCCESS;
2228 digest.bv_val = HASHdigest;
2229 digest.bv_len = sizeof(HASHdigest);
2231 slen = strlen( syntax->ssyn_oid );
2232 mlen = strlen( mr->smr_oid );
2234 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2237 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2238 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2240 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2242 value = sa->sa_initial;
2244 value = ber_bvdup( sa->sa_initial );
2245 ldap_pvt_str2upper( value->bv_val );
2248 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2249 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2251 HASH_Init( &HASHcontext );
2252 if( prefix != NULL && prefix->bv_len > 0 ) {
2253 HASH_Update( &HASHcontext,
2254 prefix->bv_val, prefix->bv_len );
2256 HASH_Update( &HASHcontext,
2257 &pre, sizeof( pre ) );
2258 HASH_Update( &HASHcontext,
2259 syntax->ssyn_oid, slen );
2260 HASH_Update( &HASHcontext,
2261 mr->smr_oid, mlen );
2262 HASH_Update( &HASHcontext,
2263 value->bv_val, klen );
2264 HASH_Final( HASHdigest, &HASHcontext );
2267 ber_bvfree( value );
2269 keys[nkeys++] = ber_bvdup( &digest );
2272 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2274 pre = SLAP_INDEX_SUBSTR_PREFIX;
2275 klen = SLAP_INDEX_SUBSTR_MAXLEN;
2277 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2278 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
2283 value = sa->sa_any[i];
2285 value = ber_bvdup( sa->sa_any[i] );
2286 ldap_pvt_str2upper( value->bv_val );
2290 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
2291 j += SLAP_INDEX_SUBSTR_STEP )
2293 HASH_Init( &HASHcontext );
2294 if( prefix != NULL && prefix->bv_len > 0 ) {
2295 HASH_Update( &HASHcontext,
2296 prefix->bv_val, prefix->bv_len );
2298 HASH_Update( &HASHcontext,
2299 &pre, sizeof( pre ) );
2300 HASH_Update( &HASHcontext,
2301 syntax->ssyn_oid, slen );
2302 HASH_Update( &HASHcontext,
2303 mr->smr_oid, mlen );
2304 HASH_Update( &HASHcontext,
2305 &value->bv_val[j], klen );
2306 HASH_Final( HASHdigest, &HASHcontext );
2308 keys[nkeys++] = ber_bvdup( &digest );
2312 ber_bvfree( value );
2317 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2318 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2320 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2322 value = sa->sa_final;
2324 value = ber_bvdup( sa->sa_final );
2325 ldap_pvt_str2upper( value->bv_val );
2328 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2329 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2331 HASH_Init( &HASHcontext );
2332 if( prefix != NULL && prefix->bv_len > 0 ) {
2333 HASH_Update( &HASHcontext,
2334 prefix->bv_val, prefix->bv_len );
2336 HASH_Update( &HASHcontext,
2337 &pre, sizeof( pre ) );
2338 HASH_Update( &HASHcontext,
2339 syntax->ssyn_oid, slen );
2340 HASH_Update( &HASHcontext,
2341 mr->smr_oid, mlen );
2342 HASH_Update( &HASHcontext,
2343 &value->bv_val[value->bv_len-klen], klen );
2344 HASH_Final( HASHdigest, &HASHcontext );
2347 ber_bvfree( value );
2349 keys[nkeys++] = ber_bvdup( &digest );
2360 ch_free( sa->sa_final );
2361 ber_bvecfree( sa->sa_any );
2362 ch_free( sa->sa_initial );
2366 return LDAP_SUCCESS;
2372 struct berval *val )
2376 if( val->bv_len == 0 ) {
2377 /* disallow empty strings */
2378 return LDAP_INVALID_SYNTAX;
2381 if( OID_LEADCHAR(val->bv_val[0]) ) {
2383 for(i=1; i < val->bv_len; i++) {
2384 if( OID_SEPARATOR( val->bv_val[i] ) ) {
2385 if( dot++ ) return 1;
2386 } else if ( OID_CHAR( val->bv_val[i] ) ) {
2389 return LDAP_INVALID_SYNTAX;
2393 return !dot ? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
2395 } else if( DESC_LEADCHAR(val->bv_val[0]) ) {
2396 for(i=1; i < val->bv_len; i++) {
2397 if( !DESC_CHAR(val->bv_val[i] ) ) {
2398 return LDAP_INVALID_SYNTAX;
2402 return LDAP_SUCCESS;
2405 return LDAP_INVALID_SYNTAX;
2411 struct berval *val )
2415 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2417 if( val->bv_val[0] == '+' || val->bv_val[0] == '-' ) {
2418 if( val->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
2419 } else if( !ASCII_DIGIT(val->bv_val[0]) ) {
2420 return LDAP_INVALID_SYNTAX;
2423 for(i=1; i < val->bv_len; i++) {
2424 if( !ASCII_DIGIT(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2427 return LDAP_SUCCESS;
2434 struct berval **normalized )
2437 struct berval *newval;
2443 negative = ( *p == '-' );
2444 if( *p == '-' || *p == '+' ) p++;
2446 /* Ignore leading zeros */
2447 while ( *p == '0' ) p++;
2449 newval = (struct berval *) ch_malloc( sizeof(struct berval) );
2452 newval->bv_val = ch_strdup("0");
2457 newval->bv_val = ch_malloc( val->bv_len + 1 );
2461 newval->bv_val[newval->bv_len++] = '-';
2464 for( ; *p != '\0'; p++ ) {
2465 newval->bv_val[newval->bv_len++] = *p;
2469 *normalized = newval;
2470 return LDAP_SUCCESS;
2474 countryStringValidate(
2476 struct berval *val )
2478 if( val->bv_len != 2 ) return LDAP_INVALID_SYNTAX;
2480 if( !SLAP_PRINTABLE(val->bv_val[0]) ) {
2481 return LDAP_INVALID_SYNTAX;
2483 if( !SLAP_PRINTABLE(val->bv_val[1]) ) {
2484 return LDAP_INVALID_SYNTAX;
2487 return LDAP_SUCCESS;
2491 printableStringValidate(
2493 struct berval *val )
2497 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2499 for(i=0; i < val->bv_len; i++) {
2500 if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
2501 return LDAP_INVALID_SYNTAX;
2505 return LDAP_SUCCESS;
2509 printablesStringValidate(
2511 struct berval *val )
2515 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2517 for(i=0; i < val->bv_len; i++) {
2518 if( !SLAP_PRINTABLES(val->bv_val[i]) ) {
2519 return LDAP_INVALID_SYNTAX;
2523 return LDAP_SUCCESS;
2529 struct berval *val )
2533 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2535 for(i=0; i < val->bv_len; i++) {
2536 if( !isascii(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2539 return LDAP_SUCCESS;
2546 struct berval **normalized )
2548 struct berval *newval;
2551 newval = ch_malloc( sizeof( struct berval ) );
2555 /* Ignore initial whitespace */
2556 while ( ASCII_SPACE( *p ) ) {
2562 return LDAP_INVALID_SYNTAX;
2565 newval->bv_val = ch_strdup( p );
2566 p = q = newval->bv_val;
2569 if ( ASCII_SPACE( *p ) ) {
2572 /* Ignore the extra whitespace */
2573 while ( ASCII_SPACE( *p ) ) {
2581 assert( *newval->bv_val );
2582 assert( newval->bv_val < p );
2585 /* cannot start with a space */
2586 assert( !ASCII_SPACE(*newval->bv_val) );
2589 * If the string ended in space, backup the pointer one
2590 * position. One is enough because the above loop collapsed
2591 * all whitespace to a single space.
2594 if ( ASCII_SPACE( q[-1] ) ) {
2598 /* cannot end with a space */
2599 assert( !ASCII_SPACE( q[-1] ) );
2601 /* null terminate */
2604 newval->bv_len = q - newval->bv_val;
2605 *normalized = newval;
2607 return LDAP_SUCCESS;
2616 struct berval *value,
2617 void *assertedValue )
2619 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
2622 match = strncmp( value->bv_val,
2623 ((struct berval *) assertedValue)->bv_val,
2628 return LDAP_SUCCESS;
2632 caseExactIA5SubstringsMatch(
2637 struct berval *value,
2638 void *assertedValue )
2641 SubstringsAssertion *sub = assertedValue;
2642 struct berval left = *value;
2646 /* Add up asserted input length */
2647 if( sub->sa_initial ) {
2648 inlen += sub->sa_initial->bv_len;
2651 for(i=0; sub->sa_any[i] != NULL; i++) {
2652 inlen += sub->sa_any[i]->bv_len;
2655 if( sub->sa_final ) {
2656 inlen += sub->sa_final->bv_len;
2659 if( sub->sa_initial ) {
2660 if( inlen > left.bv_len ) {
2665 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
2666 sub->sa_initial->bv_len );
2672 left.bv_val += sub->sa_initial->bv_len;
2673 left.bv_len -= sub->sa_initial->bv_len;
2674 inlen -= sub->sa_initial->bv_len;
2677 if( sub->sa_final ) {
2678 if( inlen > left.bv_len ) {
2683 match = strncmp( sub->sa_final->bv_val,
2684 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
2685 sub->sa_final->bv_len );
2691 left.bv_len -= sub->sa_final->bv_len;
2692 inlen -= sub->sa_final->bv_len;
2696 for(i=0; sub->sa_any[i]; i++) {
2701 if( inlen > left.bv_len ) {
2702 /* not enough length */
2707 if( sub->sa_any[i]->bv_len == 0 ) {
2711 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
2718 idx = p - left.bv_val;
2719 assert( idx < left.bv_len );
2721 if( idx >= left.bv_len ) {
2722 /* this shouldn't happen */
2729 if( sub->sa_any[i]->bv_len > left.bv_len ) {
2730 /* not enough left */
2735 match = strncmp( left.bv_val,
2736 sub->sa_any[i]->bv_val,
2737 sub->sa_any[i]->bv_len );
2745 left.bv_val += sub->sa_any[i]->bv_len;
2746 left.bv_len -= sub->sa_any[i]->bv_len;
2747 inlen -= sub->sa_any[i]->bv_len;
2753 return LDAP_SUCCESS;
2756 /* Index generation function */
2757 int caseExactIA5Indexer(
2762 struct berval *prefix,
2763 struct berval **values,
2764 struct berval ***keysp )
2768 struct berval **keys;
2769 HASH_CONTEXT HASHcontext;
2770 unsigned char HASHdigest[HASH_BYTES];
2771 struct berval digest;
2772 digest.bv_val = HASHdigest;
2773 digest.bv_len = sizeof(HASHdigest);
2775 /* we should have at least one value at this point */
2776 assert( values != NULL && values[0] != NULL );
2778 for( i=0; values[i] != NULL; i++ ) {
2779 /* just count them */
2782 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
2784 slen = strlen( syntax->ssyn_oid );
2785 mlen = strlen( mr->smr_oid );
2787 for( i=0; values[i] != NULL; i++ ) {
2788 struct berval *value = values[i];
2790 HASH_Init( &HASHcontext );
2791 if( prefix != NULL && prefix->bv_len > 0 ) {
2792 HASH_Update( &HASHcontext,
2793 prefix->bv_val, prefix->bv_len );
2795 HASH_Update( &HASHcontext,
2796 syntax->ssyn_oid, slen );
2797 HASH_Update( &HASHcontext,
2798 mr->smr_oid, mlen );
2799 HASH_Update( &HASHcontext,
2800 value->bv_val, value->bv_len );
2801 HASH_Final( HASHdigest, &HASHcontext );
2803 keys[i] = ber_bvdup( &digest );
2808 return LDAP_SUCCESS;
2811 /* Index generation function */
2812 int caseExactIA5Filter(
2817 struct berval *prefix,
2819 struct berval ***keysp )
2822 struct berval **keys;
2823 HASH_CONTEXT HASHcontext;
2824 unsigned char HASHdigest[HASH_BYTES];
2825 struct berval *value;
2826 struct berval digest;
2827 digest.bv_val = HASHdigest;
2828 digest.bv_len = sizeof(HASHdigest);
2830 slen = strlen( syntax->ssyn_oid );
2831 mlen = strlen( mr->smr_oid );
2833 value = (struct berval *) assertValue;
2835 keys = ch_malloc( sizeof( struct berval * ) * 2 );
2837 HASH_Init( &HASHcontext );
2838 if( prefix != NULL && prefix->bv_len > 0 ) {
2839 HASH_Update( &HASHcontext,
2840 prefix->bv_val, prefix->bv_len );
2842 HASH_Update( &HASHcontext,
2843 syntax->ssyn_oid, slen );
2844 HASH_Update( &HASHcontext,
2845 mr->smr_oid, mlen );
2846 HASH_Update( &HASHcontext,
2847 value->bv_val, value->bv_len );
2848 HASH_Final( HASHdigest, &HASHcontext );
2850 keys[0] = ber_bvdup( &digest );
2854 return LDAP_SUCCESS;
2857 /* Substrings Index generation function */
2858 int caseExactIA5SubstringsIndexer(
2863 struct berval *prefix,
2864 struct berval **values,
2865 struct berval ***keysp )
2869 struct berval **keys;
2870 HASH_CONTEXT HASHcontext;
2871 unsigned char HASHdigest[HASH_BYTES];
2872 struct berval digest;
2873 digest.bv_val = HASHdigest;
2874 digest.bv_len = sizeof(HASHdigest);
2876 /* we should have at least one value at this point */
2877 assert( values != NULL && values[0] != NULL );
2880 for( i=0; values[i] != NULL; i++ ) {
2881 /* count number of indices to generate */
2882 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
2886 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2887 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2888 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2889 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2891 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2895 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2896 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2897 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2901 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2902 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2903 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2904 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2906 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2912 /* no keys to generate */
2914 return LDAP_SUCCESS;
2917 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2919 slen = strlen( syntax->ssyn_oid );
2920 mlen = strlen( mr->smr_oid );
2923 for( i=0; values[i] != NULL; i++ ) {
2925 struct berval *value;
2928 if( value->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2930 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2931 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2933 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2934 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2936 for( j=0; j<max; j++ ) {
2937 HASH_Init( &HASHcontext );
2938 if( prefix != NULL && prefix->bv_len > 0 ) {
2939 HASH_Update( &HASHcontext,
2940 prefix->bv_val, prefix->bv_len );
2943 HASH_Update( &HASHcontext,
2944 &pre, sizeof( pre ) );
2945 HASH_Update( &HASHcontext,
2946 syntax->ssyn_oid, slen );
2947 HASH_Update( &HASHcontext,
2948 mr->smr_oid, mlen );
2949 HASH_Update( &HASHcontext,
2951 SLAP_INDEX_SUBSTR_MAXLEN );
2952 HASH_Final( HASHdigest, &HASHcontext );
2954 keys[nkeys++] = ber_bvdup( &digest );
2958 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2959 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2961 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2964 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2965 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2966 HASH_Init( &HASHcontext );
2967 if( prefix != NULL && prefix->bv_len > 0 ) {
2968 HASH_Update( &HASHcontext,
2969 prefix->bv_val, prefix->bv_len );
2971 HASH_Update( &HASHcontext,
2972 &pre, sizeof( pre ) );
2973 HASH_Update( &HASHcontext,
2974 syntax->ssyn_oid, slen );
2975 HASH_Update( &HASHcontext,
2976 mr->smr_oid, mlen );
2977 HASH_Update( &HASHcontext,
2979 HASH_Final( HASHdigest, &HASHcontext );
2981 keys[nkeys++] = ber_bvdup( &digest );
2984 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2985 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2986 HASH_Init( &HASHcontext );
2987 if( prefix != NULL && prefix->bv_len > 0 ) {
2988 HASH_Update( &HASHcontext,
2989 prefix->bv_val, prefix->bv_len );
2991 HASH_Update( &HASHcontext,
2992 &pre, sizeof( pre ) );
2993 HASH_Update( &HASHcontext,
2994 syntax->ssyn_oid, slen );
2995 HASH_Update( &HASHcontext,
2996 mr->smr_oid, mlen );
2997 HASH_Update( &HASHcontext,
2998 &value->bv_val[value->bv_len-j], j );
2999 HASH_Final( HASHdigest, &HASHcontext );
3001 keys[nkeys++] = ber_bvdup( &digest );
3015 return LDAP_SUCCESS;
3018 int caseExactIA5SubstringsFilter(
3023 struct berval *prefix,
3025 struct berval ***keysp )
3027 SubstringsAssertion *sa = assertValue;
3029 ber_len_t nkeys = 0;
3030 size_t slen, mlen, klen;
3031 struct berval **keys;
3032 HASH_CONTEXT HASHcontext;
3033 unsigned char HASHdigest[HASH_BYTES];
3034 struct berval *value;
3035 struct berval digest;
3037 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
3038 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3043 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
3045 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3046 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3047 /* don't bother accounting for stepping */
3048 nkeys += sa->sa_any[i]->bv_len -
3049 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3054 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
3055 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3062 return LDAP_SUCCESS;
3065 digest.bv_val = HASHdigest;
3066 digest.bv_len = sizeof(HASHdigest);
3068 slen = strlen( syntax->ssyn_oid );
3069 mlen = strlen( mr->smr_oid );
3071 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3074 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
3075 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3077 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3078 value = sa->sa_initial;
3080 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3081 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3083 HASH_Init( &HASHcontext );
3084 if( prefix != NULL && prefix->bv_len > 0 ) {
3085 HASH_Update( &HASHcontext,
3086 prefix->bv_val, prefix->bv_len );
3088 HASH_Update( &HASHcontext,
3089 &pre, sizeof( pre ) );
3090 HASH_Update( &HASHcontext,
3091 syntax->ssyn_oid, slen );
3092 HASH_Update( &HASHcontext,
3093 mr->smr_oid, mlen );
3094 HASH_Update( &HASHcontext,
3095 value->bv_val, klen );
3096 HASH_Final( HASHdigest, &HASHcontext );
3098 keys[nkeys++] = ber_bvdup( &digest );
3101 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
3103 pre = SLAP_INDEX_SUBSTR_PREFIX;
3104 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3106 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3107 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3111 value = sa->sa_any[i];
3114 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3115 j += SLAP_INDEX_SUBSTR_STEP )
3117 HASH_Init( &HASHcontext );
3118 if( prefix != NULL && prefix->bv_len > 0 ) {
3119 HASH_Update( &HASHcontext,
3120 prefix->bv_val, prefix->bv_len );
3122 HASH_Update( &HASHcontext,
3123 &pre, sizeof( pre ) );
3124 HASH_Update( &HASHcontext,
3125 syntax->ssyn_oid, slen );
3126 HASH_Update( &HASHcontext,
3127 mr->smr_oid, mlen );
3128 HASH_Update( &HASHcontext,
3129 &value->bv_val[j], klen );
3130 HASH_Final( HASHdigest, &HASHcontext );
3132 keys[nkeys++] = ber_bvdup( &digest );
3137 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
3138 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3140 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3141 value = sa->sa_final;
3143 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3144 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3146 HASH_Init( &HASHcontext );
3147 if( prefix != NULL && prefix->bv_len > 0 ) {
3148 HASH_Update( &HASHcontext,
3149 prefix->bv_val, prefix->bv_len );
3151 HASH_Update( &HASHcontext,
3152 &pre, sizeof( pre ) );
3153 HASH_Update( &HASHcontext,
3154 syntax->ssyn_oid, slen );
3155 HASH_Update( &HASHcontext,
3156 mr->smr_oid, mlen );
3157 HASH_Update( &HASHcontext,
3158 &value->bv_val[value->bv_len-klen], klen );
3159 HASH_Final( HASHdigest, &HASHcontext );
3161 keys[nkeys++] = ber_bvdup( &digest );
3172 return LDAP_SUCCESS;
3181 struct berval *value,
3182 void *assertedValue )
3184 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
3186 if( match == 0 && value->bv_len ) {
3187 match = strncasecmp( value->bv_val,
3188 ((struct berval *) assertedValue)->bv_val,
3193 return LDAP_SUCCESS;
3197 caseIgnoreIA5SubstringsMatch(
3202 struct berval *value,
3203 void *assertedValue )
3206 SubstringsAssertion *sub = assertedValue;
3207 struct berval left = *value;
3211 /* Add up asserted input length */
3212 if( sub->sa_initial ) {
3213 inlen += sub->sa_initial->bv_len;
3216 for(i=0; sub->sa_any[i] != NULL; i++) {
3217 inlen += sub->sa_any[i]->bv_len;
3220 if( sub->sa_final ) {
3221 inlen += sub->sa_final->bv_len;
3224 if( sub->sa_initial ) {
3225 if( inlen > left.bv_len ) {
3230 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
3231 sub->sa_initial->bv_len );
3237 left.bv_val += sub->sa_initial->bv_len;
3238 left.bv_len -= sub->sa_initial->bv_len;
3239 inlen -= sub->sa_initial->bv_len;
3242 if( sub->sa_final ) {
3243 if( inlen > left.bv_len ) {
3248 match = strncasecmp( sub->sa_final->bv_val,
3249 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
3250 sub->sa_final->bv_len );
3256 left.bv_len -= sub->sa_final->bv_len;
3257 inlen -= sub->sa_final->bv_len;
3261 for(i=0; sub->sa_any[i]; i++) {
3266 if( inlen > left.bv_len ) {
3267 /* not enough length */
3272 if( sub->sa_any[i]->bv_len == 0 ) {
3276 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
3283 idx = p - left.bv_val;
3284 assert( idx < left.bv_len );
3286 if( idx >= left.bv_len ) {
3287 /* this shouldn't happen */
3294 if( sub->sa_any[i]->bv_len > left.bv_len ) {
3295 /* not enough left */
3300 match = strncasecmp( left.bv_val,
3301 sub->sa_any[i]->bv_val,
3302 sub->sa_any[i]->bv_len );
3311 left.bv_val += sub->sa_any[i]->bv_len;
3312 left.bv_len -= sub->sa_any[i]->bv_len;
3313 inlen -= sub->sa_any[i]->bv_len;
3319 return LDAP_SUCCESS;
3322 /* Index generation function */
3323 int caseIgnoreIA5Indexer(
3328 struct berval *prefix,
3329 struct berval **values,
3330 struct berval ***keysp )
3334 struct berval **keys;
3335 HASH_CONTEXT HASHcontext;
3336 unsigned char HASHdigest[HASH_BYTES];
3337 struct berval digest;
3338 digest.bv_val = HASHdigest;
3339 digest.bv_len = sizeof(HASHdigest);
3341 /* we should have at least one value at this point */
3342 assert( values != NULL && values[0] != NULL );
3344 for( i=0; values[i] != NULL; i++ ) {
3345 /* just count them */
3348 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
3350 slen = strlen( syntax->ssyn_oid );
3351 mlen = strlen( mr->smr_oid );
3353 for( i=0; values[i] != NULL; i++ ) {
3354 struct berval *value = ber_bvdup( values[i] );
3355 ldap_pvt_str2upper( value->bv_val );
3357 HASH_Init( &HASHcontext );
3358 if( prefix != NULL && prefix->bv_len > 0 ) {
3359 HASH_Update( &HASHcontext,
3360 prefix->bv_val, prefix->bv_len );
3362 HASH_Update( &HASHcontext,
3363 syntax->ssyn_oid, slen );
3364 HASH_Update( &HASHcontext,
3365 mr->smr_oid, mlen );
3366 HASH_Update( &HASHcontext,
3367 value->bv_val, value->bv_len );
3368 HASH_Final( HASHdigest, &HASHcontext );
3370 ber_bvfree( value );
3372 keys[i] = ber_bvdup( &digest );
3377 return LDAP_SUCCESS;
3380 /* Index generation function */
3381 int caseIgnoreIA5Filter(
3386 struct berval *prefix,
3388 struct berval ***keysp )
3391 struct berval **keys;
3392 HASH_CONTEXT HASHcontext;
3393 unsigned char HASHdigest[HASH_BYTES];
3394 struct berval *value;
3395 struct berval digest;
3396 digest.bv_val = HASHdigest;
3397 digest.bv_len = sizeof(HASHdigest);
3399 slen = strlen( syntax->ssyn_oid );
3400 mlen = strlen( mr->smr_oid );
3402 value = ber_bvdup( (struct berval *) assertValue );
3403 ldap_pvt_str2upper( value->bv_val );
3405 keys = ch_malloc( sizeof( struct berval * ) * 2 );
3407 HASH_Init( &HASHcontext );
3408 if( prefix != NULL && prefix->bv_len > 0 ) {
3409 HASH_Update( &HASHcontext,
3410 prefix->bv_val, prefix->bv_len );
3412 HASH_Update( &HASHcontext,
3413 syntax->ssyn_oid, slen );
3414 HASH_Update( &HASHcontext,
3415 mr->smr_oid, mlen );
3416 HASH_Update( &HASHcontext,
3417 value->bv_val, value->bv_len );
3418 HASH_Final( HASHdigest, &HASHcontext );
3420 keys[0] = ber_bvdup( &digest );
3423 ber_bvfree( value );
3427 return LDAP_SUCCESS;
3430 /* Substrings Index generation function */
3431 int caseIgnoreIA5SubstringsIndexer(
3436 struct berval *prefix,
3437 struct berval **values,
3438 struct berval ***keysp )
3442 struct berval **keys;
3443 HASH_CONTEXT HASHcontext;
3444 unsigned char HASHdigest[HASH_BYTES];
3445 struct berval digest;
3446 digest.bv_val = HASHdigest;
3447 digest.bv_len = sizeof(HASHdigest);
3449 /* we should have at least one value at this point */
3450 assert( values != NULL && values[0] != NULL );
3453 for( i=0; values[i] != NULL; i++ ) {
3454 /* count number of indices to generate */
3455 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
3459 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3460 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3461 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3462 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3464 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3468 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
3469 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3470 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3474 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3475 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3476 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3477 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3479 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3485 /* no keys to generate */
3487 return LDAP_SUCCESS;
3490 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3492 slen = strlen( syntax->ssyn_oid );
3493 mlen = strlen( mr->smr_oid );
3496 for( i=0; values[i] != NULL; i++ ) {
3498 struct berval *value;
3500 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
3502 value = ber_bvdup( values[i] );
3503 ldap_pvt_str2upper( value->bv_val );
3505 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
3506 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
3508 char pre = SLAP_INDEX_SUBSTR_PREFIX;
3509 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
3511 for( j=0; j<max; j++ ) {
3512 HASH_Init( &HASHcontext );
3513 if( prefix != NULL && prefix->bv_len > 0 ) {
3514 HASH_Update( &HASHcontext,
3515 prefix->bv_val, prefix->bv_len );
3518 HASH_Update( &HASHcontext,
3519 &pre, sizeof( pre ) );
3520 HASH_Update( &HASHcontext,
3521 syntax->ssyn_oid, slen );
3522 HASH_Update( &HASHcontext,
3523 mr->smr_oid, mlen );
3524 HASH_Update( &HASHcontext,
3526 SLAP_INDEX_SUBSTR_MAXLEN );
3527 HASH_Final( HASHdigest, &HASHcontext );
3529 keys[nkeys++] = ber_bvdup( &digest );
3533 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3534 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3536 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
3539 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3540 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3541 HASH_Init( &HASHcontext );
3542 if( prefix != NULL && prefix->bv_len > 0 ) {
3543 HASH_Update( &HASHcontext,
3544 prefix->bv_val, prefix->bv_len );
3546 HASH_Update( &HASHcontext,
3547 &pre, sizeof( pre ) );
3548 HASH_Update( &HASHcontext,
3549 syntax->ssyn_oid, slen );
3550 HASH_Update( &HASHcontext,
3551 mr->smr_oid, mlen );
3552 HASH_Update( &HASHcontext,
3554 HASH_Final( HASHdigest, &HASHcontext );
3556 keys[nkeys++] = ber_bvdup( &digest );
3559 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3560 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3561 HASH_Init( &HASHcontext );
3562 if( prefix != NULL && prefix->bv_len > 0 ) {
3563 HASH_Update( &HASHcontext,
3564 prefix->bv_val, prefix->bv_len );
3566 HASH_Update( &HASHcontext,
3567 &pre, sizeof( pre ) );
3568 HASH_Update( &HASHcontext,
3569 syntax->ssyn_oid, slen );
3570 HASH_Update( &HASHcontext,
3571 mr->smr_oid, mlen );
3572 HASH_Update( &HASHcontext,
3573 &value->bv_val[value->bv_len-j], j );
3574 HASH_Final( HASHdigest, &HASHcontext );
3576 keys[nkeys++] = ber_bvdup( &digest );
3581 ber_bvfree( value );
3592 return LDAP_SUCCESS;
3595 int caseIgnoreIA5SubstringsFilter(
3600 struct berval *prefix,
3602 struct berval ***keysp )
3604 SubstringsAssertion *sa = assertValue;
3606 ber_len_t nkeys = 0;
3607 size_t slen, mlen, klen;
3608 struct berval **keys;
3609 HASH_CONTEXT HASHcontext;
3610 unsigned char HASHdigest[HASH_BYTES];
3611 struct berval *value;
3612 struct berval digest;
3614 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3615 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3620 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3622 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3623 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3624 /* don't bother accounting for stepping */
3625 nkeys += sa->sa_any[i]->bv_len -
3626 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3631 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3632 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3639 return LDAP_SUCCESS;
3642 digest.bv_val = HASHdigest;
3643 digest.bv_len = sizeof(HASHdigest);
3645 slen = strlen( syntax->ssyn_oid );
3646 mlen = strlen( mr->smr_oid );
3648 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3651 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3652 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3654 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3655 value = ber_bvdup( sa->sa_initial );
3656 ldap_pvt_str2upper( value->bv_val );
3658 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3659 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3661 HASH_Init( &HASHcontext );
3662 if( prefix != NULL && prefix->bv_len > 0 ) {
3663 HASH_Update( &HASHcontext,
3664 prefix->bv_val, prefix->bv_len );
3666 HASH_Update( &HASHcontext,
3667 &pre, sizeof( pre ) );
3668 HASH_Update( &HASHcontext,
3669 syntax->ssyn_oid, slen );
3670 HASH_Update( &HASHcontext,
3671 mr->smr_oid, mlen );
3672 HASH_Update( &HASHcontext,
3673 value->bv_val, klen );
3674 HASH_Final( HASHdigest, &HASHcontext );
3676 ber_bvfree( value );
3677 keys[nkeys++] = ber_bvdup( &digest );
3680 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3682 pre = SLAP_INDEX_SUBSTR_PREFIX;
3683 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3685 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3686 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3690 value = ber_bvdup( sa->sa_any[i] );
3691 ldap_pvt_str2upper( value->bv_val );
3694 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3695 j += SLAP_INDEX_SUBSTR_STEP )
3697 HASH_Init( &HASHcontext );
3698 if( prefix != NULL && prefix->bv_len > 0 ) {
3699 HASH_Update( &HASHcontext,
3700 prefix->bv_val, prefix->bv_len );
3702 HASH_Update( &HASHcontext,
3703 &pre, sizeof( pre ) );
3704 HASH_Update( &HASHcontext,
3705 syntax->ssyn_oid, slen );
3706 HASH_Update( &HASHcontext,
3707 mr->smr_oid, mlen );
3708 HASH_Update( &HASHcontext,
3709 &value->bv_val[j], klen );
3710 HASH_Final( HASHdigest, &HASHcontext );
3712 keys[nkeys++] = ber_bvdup( &digest );
3715 ber_bvfree( value );
3719 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3720 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3722 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3723 value = ber_bvdup( sa->sa_final );
3724 ldap_pvt_str2upper( value->bv_val );
3726 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3727 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3729 HASH_Init( &HASHcontext );
3730 if( prefix != NULL && prefix->bv_len > 0 ) {
3731 HASH_Update( &HASHcontext,
3732 prefix->bv_val, prefix->bv_len );
3734 HASH_Update( &HASHcontext,
3735 &pre, sizeof( pre ) );
3736 HASH_Update( &HASHcontext,
3737 syntax->ssyn_oid, slen );
3738 HASH_Update( &HASHcontext,
3739 mr->smr_oid, mlen );
3740 HASH_Update( &HASHcontext,
3741 &value->bv_val[value->bv_len-klen], klen );
3742 HASH_Final( HASHdigest, &HASHcontext );
3744 ber_bvfree( value );
3745 keys[nkeys++] = ber_bvdup( &digest );
3756 return LDAP_SUCCESS;
3760 numericStringValidate(
3766 for(i=0; i < in->bv_len; i++) {
3767 if( !SLAP_NUMERIC(in->bv_val[i]) ) {
3768 return LDAP_INVALID_SYNTAX;
3772 return LDAP_SUCCESS;
3776 numericStringNormalize(
3779 struct berval **normalized )
3781 /* removal all spaces */
3782 struct berval *newval;
3785 newval = ch_malloc( sizeof( struct berval ) );
3786 newval->bv_val = ch_malloc( val->bv_len + 1 );
3792 if ( ASCII_SPACE( *p ) ) {
3793 /* Ignore whitespace */
3800 assert( newval->bv_val <= p );
3803 /* null terminate */
3806 newval->bv_len = q - newval->bv_val;
3807 *normalized = newval;
3809 return LDAP_SUCCESS;
3813 objectIdentifierFirstComponentMatch(
3818 struct berval *value,
3819 void *assertedValue )
3821 int rc = LDAP_SUCCESS;
3823 struct berval *asserted = (struct berval *) assertedValue;
3827 if( value->bv_len == 0 || value->bv_val[0] != '(' /*')'*/ ) {
3828 return LDAP_INVALID_SYNTAX;
3831 /* trim leading white space */
3832 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < value->bv_len; i++ ) {
3836 /* grab next word */
3837 oid.bv_val = &value->bv_val[i];
3838 oid.bv_len = value->bv_len - i;
3839 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < oid.bv_len; i++ ) {
3844 /* insert attributeTypes, objectclass check here */
3845 if( OID_LEADCHAR(asserted->bv_val[0]) ) {
3846 rc = objectIdentifierMatch( &match, flags, syntax, mr, &oid, asserted );
3849 char *stored = ch_malloc( oid.bv_len + 1 );
3850 AC_MEMCPY( stored, oid.bv_val, oid.bv_len );
3851 stored[oid.bv_len] = '\0';
3853 if ( !strcmp( syntax->ssyn_oid, SLAP_SYNTAX_MATCHINGRULES_OID ) ) {
3854 MatchingRule *asserted_mr = mr_find( asserted->bv_val );
3855 MatchingRule *stored_mr = mr_find( stored );
3857 if( asserted_mr == NULL ) {
3858 rc = SLAPD_COMPARE_UNDEFINED;
3860 match = asserted_mr != stored_mr;
3863 } else if ( !strcmp( syntax->ssyn_oid,
3864 SLAP_SYNTAX_ATTRIBUTETYPES_OID ) )
3866 AttributeType *asserted_at = at_find( asserted->bv_val );
3867 AttributeType *stored_at = at_find( stored );
3869 if( asserted_at == NULL ) {
3870 rc = SLAPD_COMPARE_UNDEFINED;
3872 match = asserted_at != stored_at;
3875 } else if ( !strcmp( syntax->ssyn_oid,
3876 SLAP_SYNTAX_OBJECTCLASSES_OID ) )
3878 ObjectClass *asserted_oc = oc_find( asserted->bv_val );
3879 ObjectClass *stored_oc = oc_find( stored );
3881 if( asserted_oc == NULL ) {
3882 rc = SLAPD_COMPARE_UNDEFINED;
3884 match = asserted_oc != stored_oc;
3892 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
3893 "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
3894 match, value->bv_val, asserted->bv_val ));
3896 Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
3897 "%d\n\t\"%s\"\n\t\"%s\"\n",
3898 match, value->bv_val, asserted->bv_val );
3902 if( rc == LDAP_SUCCESS ) *matchp = match;
3907 check_time_syntax (struct berval *val,
3911 static int ceiling[9] = { 99, 99, 11, 30, 23, 59, 59, 12, 59 };
3912 static int mdays[2][12] = {
3913 /* non-leap years */
3914 { 30, 27, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 },
3916 { 30, 28, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 }
3919 int part, c, tzoffset, leapyear = 0 ;
3921 if( val->bv_len == 0 ) {
3922 return LDAP_INVALID_SYNTAX;
3925 p = (char *)val->bv_val;
3926 e = p + val->bv_len;
3928 /* Ignore initial whitespace */
3929 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3933 if (e - p < 13 - (2 * start)) {
3934 return LDAP_INVALID_SYNTAX;
3937 for (part = 0; part < 9; part++) {
3941 for (part = start; part < 7; part++) {
3943 if ((part == 6) && (c == 'Z' || c == '+' || c == '-')) {
3950 return LDAP_INVALID_SYNTAX;
3952 if (c < 0 || c > 9) {
3953 return LDAP_INVALID_SYNTAX;
3959 return LDAP_INVALID_SYNTAX;
3961 if (c < 0 || c > 9) {
3962 return LDAP_INVALID_SYNTAX;
3967 if (part == 2 || part == 3) {
3970 if (parts[part] < 0) {
3971 return LDAP_INVALID_SYNTAX;
3973 if (parts[part] > ceiling[part]) {
3974 return LDAP_INVALID_SYNTAX;
3978 /* leapyear check for the Gregorian calendar (year>1581) */
3979 if (((parts[1] % 4 == 0) && (parts[1] != 0)) ||
3980 ((parts[0] % 4 == 0) && (parts[1] == 0)))
3985 if (parts[3] > mdays[leapyear][parts[2]]) {
3986 return LDAP_INVALID_SYNTAX;
3991 tzoffset = 0; /* UTC */
3992 } else if (c != '+' && c != '-') {
3993 return LDAP_INVALID_SYNTAX;
3997 } else /* c == '+' */ {
4002 return LDAP_INVALID_SYNTAX;
4005 for (part = 7; part < 9; part++) {
4007 if (c < 0 || c > 9) {
4008 return LDAP_INVALID_SYNTAX;
4013 if (c < 0 || c > 9) {
4014 return LDAP_INVALID_SYNTAX;
4018 if (parts[part] < 0 || parts[part] > ceiling[part]) {
4019 return LDAP_INVALID_SYNTAX;
4024 /* Ignore trailing whitespace */
4025 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
4029 return LDAP_INVALID_SYNTAX;
4032 switch ( tzoffset ) {
4033 case -1: /* negativ offset to UTC, ie west of Greenwich */
4034 parts[4] += parts[7];
4035 parts[5] += parts[8];
4036 for (part = 6; --part > 0; ) { /* offset is just hhmm, no seconds */
4040 c = mdays[leapyear][parts[2]];
4042 if (parts[part] > c) {
4043 parts[part] -= c + 1;
4048 case 1: /* positive offset to UTC, ie east of Greenwich */
4049 parts[4] -= parts[7];
4050 parts[5] -= parts[8];
4051 for (part = 6; --part > 0; ) {
4055 /* first arg to % needs to be non negativ */
4056 c = mdays[leapyear][(parts[2] - 1 + 12) % 12];
4058 if (parts[part] < 0) {
4059 parts[part] += c + 1;
4064 case 0: /* already UTC */
4068 return LDAP_SUCCESS;
4075 struct berval **normalized )
4080 rc = check_time_syntax(val, 1, parts);
4081 if (rc != LDAP_SUCCESS) {
4086 out = ch_malloc( sizeof(struct berval) );
4088 return LBER_ERROR_MEMORY;
4091 out->bv_val = ch_malloc( 14 );
4092 if ( out->bv_val == NULL ) {
4094 return LBER_ERROR_MEMORY;
4097 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ldZ",
4098 parts[1], parts[2] + 1, parts[3] + 1,
4099 parts[4], parts[5], parts[6] );
4103 return LDAP_SUCCESS;
4113 return check_time_syntax(in, 1, parts);
4117 generalizedTimeValidate(
4123 return check_time_syntax(in, 0, parts);
4127 generalizedTimeNormalize(
4130 struct berval **normalized )
4135 rc = check_time_syntax(val, 0, parts);
4136 if (rc != LDAP_SUCCESS) {
4141 out = ch_malloc( sizeof(struct berval) );
4143 return LBER_ERROR_MEMORY;
4146 out->bv_val = ch_malloc( 16 );
4147 if ( out->bv_val == NULL ) {
4149 return LBER_ERROR_MEMORY;
4152 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ld%02ldZ",
4153 parts[0], parts[1], parts[2] + 1, parts[3] + 1,
4154 parts[4], parts[5], parts[6] );
4158 return LDAP_SUCCESS;
4162 nisNetgroupTripleValidate(
4164 struct berval *val )
4169 if ( val->bv_len == 0 ) {
4170 return LDAP_INVALID_SYNTAX;
4173 p = (char *)val->bv_val;
4174 e = p + val->bv_len;
4177 /* syntax does not allow leading white space */
4178 /* Ignore initial whitespace */
4179 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
4184 if ( *p != '(' /*')'*/ ) {
4185 return LDAP_INVALID_SYNTAX;
4188 for ( p++; ( p < e ) && ( *p != ')' ); p++ ) {
4192 return LDAP_INVALID_SYNTAX;
4195 } else if ( !ATTR_CHAR( *p ) ) {
4196 return LDAP_INVALID_SYNTAX;
4200 if ( ( commas != 2 ) || ( *p != /*'('*/ ')' ) ) {
4201 return LDAP_INVALID_SYNTAX;
4207 /* syntax does not allow trailing white space */
4208 /* Ignore trailing whitespace */
4209 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
4215 return LDAP_INVALID_SYNTAX;
4218 return LDAP_SUCCESS;
4222 bootParameterValidate(
4224 struct berval *val )
4228 if ( val->bv_len == 0 ) {
4229 return LDAP_INVALID_SYNTAX;
4232 p = (char *)val->bv_val;
4233 e = p + val->bv_len;
4236 for (; ( p < e ) && ( *p != '=' ); p++ ) {
4237 if ( !ATTR_CHAR( *p ) ) {
4238 return LDAP_INVALID_SYNTAX;
4243 return LDAP_INVALID_SYNTAX;
4247 for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
4248 if ( !ATTR_CHAR( *p ) ) {
4249 return LDAP_INVALID_SYNTAX;
4254 return LDAP_INVALID_SYNTAX;
4258 for ( p++; p < e; p++ ) {
4259 if ( !ATTR_CHAR( *p ) ) {
4260 return LDAP_INVALID_SYNTAX;
4264 return LDAP_SUCCESS;
4267 struct syntax_defs_rec {
4270 slap_syntax_validate_func *sd_validate;
4271 slap_syntax_transform_func *sd_normalize;
4272 slap_syntax_transform_func *sd_pretty;
4273 #ifdef SLAPD_BINARY_CONVERSION
4274 slap_syntax_transform_func *sd_ber2str;
4275 slap_syntax_transform_func *sd_str2ber;
4279 #define X_BINARY "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
4280 #define X_NOT_H_R "X-NOT-HUMAN-READABLE 'TRUE' "
4282 struct syntax_defs_rec syntax_defs[] = {
4283 {"( 1.3.6.1.4.1.1466.115.121.1.1 DESC 'ACI Item' " X_BINARY X_NOT_H_R ")",
4284 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, NULL, NULL, NULL},
4285 {"( 1.3.6.1.4.1.1466.115.121.1.2 DESC 'Access Point' " X_NOT_H_R ")",
4286 0, NULL, NULL, NULL},
4287 {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )",
4288 0, NULL, NULL, NULL},
4289 {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' " X_NOT_H_R ")",
4290 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4291 {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' " X_NOT_H_R ")",
4292 SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4293 {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )",
4294 0, bitStringValidate, NULL, NULL },
4295 {"( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
4296 0, booleanValidate, NULL, NULL},
4297 {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' "
4298 X_BINARY X_NOT_H_R ")",
4299 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4300 {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'Certificate List' "
4301 X_BINARY X_NOT_H_R ")",
4302 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4303 {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'Certificate Pair' "
4304 X_BINARY X_NOT_H_R ")",
4305 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4306 {"( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )",
4307 0, countryStringValidate, IA5StringNormalize, NULL},
4308 {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'Distinguished Name' )",
4309 0, dnValidate, dnNormalize, dnPretty},
4310 {"( 1.3.6.1.4.1.1466.115.121.1.13 DESC 'Data Quality' )",
4311 0, NULL, NULL, NULL},
4312 {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )",
4313 0, NULL, NULL, NULL},
4314 {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )",
4315 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4316 {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )",
4317 0, NULL, NULL, NULL},
4318 {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )",
4319 0, NULL, NULL, NULL},
4320 {"( 1.3.6.1.4.1.1466.115.121.1.19 DESC 'DSA Quality' )",
4321 0, NULL, NULL, NULL},
4322 {"( 1.3.6.1.4.1.1466.115.121.1.20 DESC 'DSE Type' )",
4323 0, NULL, NULL, NULL},
4324 {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )",
4325 0, NULL, NULL, NULL},
4326 {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number' )",
4327 0, printablesStringValidate, IA5StringNormalize, NULL},
4328 {"( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' " X_NOT_H_R ")",
4329 SLAP_SYNTAX_BLOB, NULL, NULL, NULL},
4330 {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )",
4331 0, generalizedTimeValidate, generalizedTimeNormalize, NULL},
4332 {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )",
4333 0, NULL, NULL, NULL},
4334 {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )",
4335 0, IA5StringValidate, IA5StringNormalize, NULL},
4336 {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'Integer' )",
4337 0, integerValidate, integerNormalize, integerPretty},
4338 {"( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' " X_NOT_H_R ")",
4339 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4340 {"( 1.3.6.1.4.1.1466.115.121.1.29 DESC 'Master And Shadow Access Points' )",
4341 0, NULL, NULL, NULL},
4342 {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )",
4343 0, NULL, NULL, NULL},
4344 {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )",
4345 0, NULL, NULL, NULL},
4346 {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'Mail Preference' )",
4347 0, NULL, NULL, NULL},
4348 {"( 1.3.6.1.4.1.1466.115.121.1.33 DESC 'MHS OR Address' )",
4349 0, NULL, NULL, NULL},
4350 {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )",
4351 0, nameUIDValidate, nameUIDNormalize, NULL},
4352 {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )",
4353 0, NULL, NULL, NULL},
4354 {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )",
4355 0, numericStringValidate, numericStringNormalize, NULL},
4356 {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )",
4357 0, NULL, NULL, NULL},
4358 {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )",
4359 0, oidValidate, NULL, NULL},
4360 {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )",
4361 0, IA5StringValidate, IA5StringNormalize, NULL},
4362 {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )",
4363 0, blobValidate, NULL, NULL},
4364 {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )",
4365 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4366 {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'Protocol Information' )",
4367 0, NULL, NULL, NULL},
4368 {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'Presentation Address' )",
4369 0, NULL, NULL, NULL},
4370 {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )",
4371 0, printableStringValidate, IA5StringNormalize, NULL},
4372 {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'Supported Algorithm' "
4373 X_BINARY X_NOT_H_R ")",
4374 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4375 {"( 1.3.6.1.4.1.1466.115.121.1.50 DESC 'Telephone Number' )",
4376 0, printableStringValidate, IA5StringNormalize, NULL},
4377 {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )",
4378 0, NULL, NULL, NULL},
4379 {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )",
4380 0, printableStringValidate, IA5StringNormalize, NULL},
4381 {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )",
4382 0, utcTimeValidate, utcTimeNormalize, NULL},
4383 {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )",
4384 0, NULL, NULL, NULL},
4385 {"( 1.3.6.1.4.1.1466.115.121.1.55 DESC 'Modify Rights' )",
4386 0, NULL, NULL, NULL},
4387 {"( 1.3.6.1.4.1.1466.115.121.1.56 DESC 'LDAP Schema Definition' )",
4388 0, NULL, NULL, NULL},
4389 {"( 1.3.6.1.4.1.1466.115.121.1.57 DESC 'LDAP Schema Description' )",
4390 0, NULL, NULL, NULL},
4391 {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )",
4392 0, NULL, NULL, NULL},
4394 /* RFC 2307 NIS Syntaxes */
4395 {"( 1.3.6.1.1.1.0.0 DESC 'RFC2307 NIS Netgroup Triple' )",
4396 0, nisNetgroupTripleValidate, NULL, NULL},
4397 {"( 1.3.6.1.1.1.0.1 DESC 'RFC2307 Boot Parameter' )",
4398 0, bootParameterValidate, NULL, NULL},
4400 /* OpenLDAP Experimental Syntaxes */
4401 {"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
4402 0, UTF8StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
4404 {"( 1.3.6.1.4.1.4203.666.2.2 DESC 'OpenLDAP authPassword' )",
4405 0, NULL, NULL, NULL},
4407 /* OpenLDAP Void Syntax */
4408 {"( 1.3.6.1.4.1.4203.1.1.1 DESC 'OpenLDAP void' )" ,
4409 SLAP_SYNTAX_HIDE, inValidate, NULL, NULL},
4410 {NULL, 0, NULL, NULL, NULL}
4413 struct mrule_defs_rec {
4415 slap_mask_t mrd_usage;
4416 slap_mr_convert_func * mrd_convert;
4417 slap_mr_normalize_func * mrd_normalize;
4418 slap_mr_match_func * mrd_match;
4419 slap_mr_indexer_func * mrd_indexer;
4420 slap_mr_filter_func * mrd_filter;
4422 char * mrd_associated;
4426 * Other matching rules in X.520 that we do not use (yet):
4428 * 2.5.13.9 numericStringOrderingMatch
4429 * 2.5.13.15 integerOrderingMatch
4430 * 2.5.13.18 octetStringOrderingMatch
4431 * 2.5.13.19 octetStringSubstringsMatch
4432 * 2.5.13.25 uTCTimeMatch
4433 * 2.5.13.26 uTCTimeOrderingMatch
4434 * 2.5.13.31 directoryStringFirstComponentMatch
4435 * 2.5.13.32 wordMatch
4436 * 2.5.13.33 keywordMatch
4437 * 2.5.13.34 certificateExactMatch
4438 * 2.5.13.35 certificateMatch
4439 * 2.5.13.36 certificatePairExactMatch
4440 * 2.5.13.37 certificatePairMatch
4441 * 2.5.13.38 certificateListExactMatch
4442 * 2.5.13.39 certificateListMatch
4443 * 2.5.13.40 algorithmIdentifierMatch
4444 * 2.5.13.41 storedPrefixMatch
4445 * 2.5.13.42 attributeCertificateMatch
4446 * 2.5.13.43 readerAndKeyIDMatch
4447 * 2.5.13.44 attributeIntegrityMatch
4450 struct mrule_defs_rec mrule_defs[] = {
4452 * EQUALITY matching rules must be listed after associated APPROX
4453 * matching rules. So, we list all APPROX matching rules first.
4455 {"( " directoryStringApproxMatchOID " NAME 'directoryStringApproxMatch' "
4456 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4457 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4459 directoryStringApproxMatch,
4460 directoryStringApproxIndexer,
4461 directoryStringApproxFilter,
4464 {"( " IA5StringApproxMatchOID " NAME 'IA5StringApproxMatch' "
4465 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4466 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4468 IA5StringApproxMatch,
4469 IA5StringApproxIndexer,
4470 IA5StringApproxFilter,
4474 * Other matching rules
4477 {"( 2.5.13.0 NAME 'objectIdentifierMatch' "
4478 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4479 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4481 objectIdentifierMatch, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4484 {"( 2.5.13.1 NAME 'distinguishedNameMatch' "
4485 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
4486 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4488 dnMatch, dnIndexer, dnFilter,
4491 {"( 2.5.13.2 NAME 'caseIgnoreMatch' "
4492 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4493 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4495 caseIgnoreMatch, caseIgnoreIndexer, caseIgnoreFilter,
4496 directoryStringApproxMatchOID },
4498 {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' "
4499 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4502 caseIgnoreOrderingMatch, NULL, NULL,
4505 {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' "
4506 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4507 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4509 caseIgnoreSubstringsMatch,
4510 caseIgnoreSubstringsIndexer,
4511 caseIgnoreSubstringsFilter,
4514 {"( 2.5.13.5 NAME 'caseExactMatch' "
4515 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4516 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4518 caseExactMatch, caseExactIndexer, caseExactFilter,
4519 directoryStringApproxMatchOID },
4521 {"( 2.5.13.6 NAME 'caseExactOrderingMatch' "
4522 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4525 caseExactOrderingMatch, NULL, NULL,
4528 {"( 2.5.13.7 NAME 'caseExactSubstringsMatch' "
4529 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4530 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4532 caseExactSubstringsMatch,
4533 caseExactSubstringsIndexer,
4534 caseExactSubstringsFilter,
4537 {"( 2.5.13.8 NAME 'numericStringMatch' "
4538 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
4539 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4542 caseIgnoreIA5Indexer,
4543 caseIgnoreIA5Filter,
4546 {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' "
4547 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4548 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4550 caseIgnoreIA5SubstringsMatch,
4551 caseIgnoreIA5SubstringsIndexer,
4552 caseIgnoreIA5SubstringsFilter,
4555 {"( 2.5.13.11 NAME 'caseIgnoreListMatch' "
4556 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )",
4557 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4559 caseIgnoreListMatch, NULL, NULL,
4562 {"( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch' "
4563 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4564 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4566 caseIgnoreListSubstringsMatch, NULL, NULL,
4569 {"( 2.5.13.13 NAME 'booleanMatch' "
4570 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )",
4571 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4573 booleanMatch, NULL, NULL,
4576 {"( 2.5.13.14 NAME 'integerMatch' "
4577 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4578 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4580 integerMatch, integerIndexer, integerFilter,
4583 {"( 2.5.13.16 NAME 'bitStringMatch' "
4584 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )",
4585 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4587 bitStringMatch, NULL, NULL,
4590 {"( 2.5.13.17 NAME 'octetStringMatch' "
4591 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4592 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4594 octetStringMatch, octetStringIndexer, octetStringFilter,
4597 {"( 2.5.13.20 NAME 'telephoneNumberMatch' "
4598 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
4599 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4601 telephoneNumberMatch,
4602 telephoneNumberIndexer,
4603 telephoneNumberFilter,
4606 {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' "
4607 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4608 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4610 telephoneNumberSubstringsMatch,
4611 telephoneNumberSubstringsIndexer,
4612 telephoneNumberSubstringsFilter,
4615 {"( 2.5.13.22 NAME 'presentationAddressMatch' "
4616 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )",
4617 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4622 {"( 2.5.13.23 NAME 'uniqueMemberMatch' "
4623 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )",
4624 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4626 uniqueMemberMatch, NULL, NULL,
4629 {"( 2.5.13.24 NAME 'protocolInformationMatch' "
4630 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )",
4631 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4633 protocolInformationMatch, NULL, NULL,
4636 {"( 2.5.13.27 NAME 'generalizedTimeMatch' "
4637 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4638 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4640 generalizedTimeMatch, NULL, NULL,
4643 {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' "
4644 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4647 generalizedTimeOrderingMatch, NULL, NULL,
4650 {"( 2.5.13.29 NAME 'integerFirstComponentMatch' "
4651 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4652 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4654 integerFirstComponentMatch, NULL, NULL,
4657 {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' "
4658 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4659 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4661 objectIdentifierFirstComponentMatch, NULL, NULL,
4664 {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' "
4665 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4666 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4668 caseExactIA5Match, caseExactIA5Indexer, caseExactIA5Filter,
4669 IA5StringApproxMatchOID },
4671 {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' "
4672 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4673 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4675 caseIgnoreIA5Match, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4676 IA5StringApproxMatchOID },
4678 {"( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch' "
4679 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4682 caseIgnoreIA5SubstringsMatch,
4683 caseIgnoreIA5SubstringsIndexer,
4684 caseIgnoreIA5SubstringsFilter,
4687 {"( 1.3.6.1.4.1.4203.1.2.1 NAME 'caseExactIA5SubstringsMatch' "
4688 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4691 caseExactIA5SubstringsMatch,
4692 caseExactIA5SubstringsIndexer,
4693 caseExactIA5SubstringsFilter,
4696 {"( 1.3.6.1.4.1.4203.666.4.1 NAME 'authPasswordMatch' "
4697 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4700 authPasswordMatch, NULL, NULL,
4703 {"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
4704 "SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
4707 OpenLDAPaciMatch, NULL, NULL,
4710 {NULL, SLAP_MR_NONE, NULL, NULL, NULL, NULL}
4719 /* we should only be called once (from main) */
4720 assert( schema_init_done == 0 );
4722 for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
4723 res = register_syntax( syntax_defs[i].sd_desc,
4724 syntax_defs[i].sd_flags,
4725 syntax_defs[i].sd_validate,
4726 syntax_defs[i].sd_normalize,
4727 syntax_defs[i].sd_pretty
4728 #ifdef SLAPD_BINARY_CONVERSION
4730 syntax_defs[i].sd_ber2str,
4731 syntax_defs[i].sd_str2ber
4736 fprintf( stderr, "schema_init: Error registering syntax %s\n",
4737 syntax_defs[i].sd_desc );
4742 for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
4743 if( mrule_defs[i].mrd_usage == SLAP_MR_NONE ) {
4745 "schema_init: Ingoring unusable matching rule %s\n",
4746 mrule_defs[i].mrd_desc );
4750 res = register_matching_rule(
4751 mrule_defs[i].mrd_desc,
4752 mrule_defs[i].mrd_usage,
4753 mrule_defs[i].mrd_convert,
4754 mrule_defs[i].mrd_normalize,
4755 mrule_defs[i].mrd_match,
4756 mrule_defs[i].mrd_indexer,
4757 mrule_defs[i].mrd_filter,
4758 mrule_defs[i].mrd_associated );
4762 "schema_init: Error registering matching rule %s\n",
4763 mrule_defs[i].mrd_desc );
4767 schema_init_done = 1;
4768 return LDAP_SUCCESS;