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 presentationAddressMatch NULL
75 #define protocolInformationMatch NULL
76 #define integerFirstComponentMatch NULL
78 #define OpenLDAPaciMatch NULL
79 #define authPasswordMatch NULL
81 /* recycled indexing/filtering routines */
82 #define dnIndexer caseIgnoreIndexer
83 #define dnFilter caseIgnoreFilter
84 #define integerIndexer caseIgnoreIA5Indexer
85 #define integerFilter caseIgnoreIA5Filter
87 static char *strcasechr( const char *str, int c )
89 char *lower = strchr( str, TOLOWER(c) );
90 char *upper = strchr( str, TOUPPER(c) );
92 if( lower && upper ) {
93 return lower < upper ? lower : upper;
107 struct berval *value,
108 void *assertedValue )
110 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
113 match = memcmp( value->bv_val,
114 ((struct berval *) assertedValue)->bv_val,
122 /* Index generation function */
123 int octetStringIndexer(
128 struct berval *prefix,
129 struct berval **values,
130 struct berval ***keysp )
134 struct berval **keys;
135 HASH_CONTEXT HASHcontext;
136 unsigned char HASHdigest[HASH_BYTES];
137 struct berval digest;
138 digest.bv_val = HASHdigest;
139 digest.bv_len = sizeof(HASHdigest);
141 /* we should have at least one value at this point */
142 assert( values != NULL && values[0] != NULL );
144 for( i=0; values[i] != NULL; i++ ) {
145 /* just count them */
148 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
150 slen = strlen( syntax->ssyn_oid );
151 mlen = strlen( mr->smr_oid );
153 for( i=0; values[i] != NULL; i++ ) {
154 HASH_Init( &HASHcontext );
155 if( prefix != NULL && prefix->bv_len > 0 ) {
156 HASH_Update( &HASHcontext,
157 prefix->bv_val, prefix->bv_len );
159 HASH_Update( &HASHcontext,
160 syntax->ssyn_oid, slen );
161 HASH_Update( &HASHcontext,
163 HASH_Update( &HASHcontext,
164 values[i]->bv_val, values[i]->bv_len );
165 HASH_Final( HASHdigest, &HASHcontext );
167 keys[i] = ber_bvdup( &digest );
177 /* Index generation function */
178 int octetStringFilter(
183 struct berval *prefix,
185 struct berval ***keysp )
188 struct berval **keys;
189 HASH_CONTEXT HASHcontext;
190 unsigned char HASHdigest[HASH_BYTES];
191 struct berval *value = (struct berval *) assertValue;
192 struct berval digest;
193 digest.bv_val = HASHdigest;
194 digest.bv_len = sizeof(HASHdigest);
196 slen = strlen( syntax->ssyn_oid );
197 mlen = strlen( mr->smr_oid );
199 keys = ch_malloc( sizeof( struct berval * ) * 2 );
201 HASH_Init( &HASHcontext );
202 if( prefix != NULL && prefix->bv_len > 0 ) {
203 HASH_Update( &HASHcontext,
204 prefix->bv_val, prefix->bv_len );
206 HASH_Update( &HASHcontext,
207 syntax->ssyn_oid, slen );
208 HASH_Update( &HASHcontext,
210 HASH_Update( &HASHcontext,
211 value->bv_val, value->bv_len );
212 HASH_Final( HASHdigest, &HASHcontext );
214 keys[0] = ber_bvdup( &digest );
230 if( in->bv_len == 0 ) return LDAP_SUCCESS;
232 dn = ch_strdup( in->bv_val );
234 rc = dn_validate( dn ) == NULL
235 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
245 struct berval **normalized )
249 if ( val->bv_len != 0 ) {
251 #ifdef USE_DN_NORMALIZE
252 out = ber_bvstr( UTF8normalize( val->bv_val, UTF8_CASEFOLD ) );
254 out = ber_bvdup( val );
255 ldap_pvt_str2upper( out->bv_val );
257 dn = dn_validate( out->bv_val );
261 return LDAP_INVALID_SYNTAX;
265 out->bv_len = strlen( dn );
267 out = ber_bvdup( val );
280 struct berval *value,
281 void *assertedValue )
284 struct berval *asserted = (struct berval *) assertedValue;
286 match = value->bv_len - asserted->bv_len;
289 #ifdef USE_DN_NORMALIZE
290 match = strcmp( value->bv_val, asserted->bv_val );
292 match = strcasecmp( value->bv_val, asserted->bv_val );
297 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
298 "dnMatch: %d\n %s\n %s\n", match,
299 value->bv_val, asserted->bv_val ));
301 Debug( LDAP_DEBUG_ARGS, "dnMatch %d\n\t\"%s\"\n\t\"%s\"\n",
302 match, value->bv_val, asserted->bv_val );
318 if( in->bv_len == 0 ) return LDAP_SUCCESS;
320 dn = ber_bvdup( in );
322 if( dn->bv_val[dn->bv_len-1] == '\'' ) {
323 /* assume presence of optional UID */
326 for(i=dn->bv_len-2; i>2; i--) {
327 if( dn->bv_val[i] != '0' && dn->bv_val[i] != '1' ) {
331 if( dn->bv_val[i] != '\'' ) {
332 return LDAP_INVALID_SYNTAX;
334 if( dn->bv_val[i-1] != 'B' ) {
335 return LDAP_INVALID_SYNTAX;
337 if( dn->bv_val[i-2] != '#' ) {
338 return LDAP_INVALID_SYNTAX;
341 /* trim the UID to allow use of dn_validate */
342 dn->bv_val[i-2] = '\0';
345 rc = dn_validate( dn->bv_val ) == NULL
346 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
356 struct berval **normalized )
358 struct berval *out = ber_bvdup( val );
360 if( out->bv_len != 0 ) {
364 ber_len_t uidlen = 0;
366 if( out->bv_val[out->bv_len-1] == '\'' ) {
367 /* assume presence of optional UID */
368 uid = strrchr( out->bv_val, '#' );
372 return LDAP_INVALID_SYNTAX;
375 uidlen = out->bv_len - (out->bv_val - uid);
376 /* temporarily trim the UID */
380 #ifdef USE_DN_NORMALIZE
381 dn = dn_normalize( out->bv_val );
383 dn = dn_validate( out->bv_val );
388 return LDAP_INVALID_SYNTAX;
394 /* restore the separator */
397 SAFEMEMCPY( &dn[dnlen], uid, uidlen );
401 out->bv_len = dnlen + uidlen;
413 /* any value allowed */
422 /* any value allowed */
433 /* very unforgiving validation, requires no normalization
434 * before simplistic matching
436 if( in->bv_len < 3 ) {
437 return LDAP_INVALID_SYNTAX;
439 if( in->bv_val[0] != 'B' ||
440 in->bv_val[1] != '\'' ||
441 in->bv_val[in->bv_len-1] != '\'' )
443 return LDAP_INVALID_SYNTAX;
446 for( i=in->bv_len-2; i>1; i-- ) {
447 if( in->bv_val[i] != '0' && in->bv_val[i] != '1' ) {
448 return LDAP_INVALID_SYNTAX;
456 * Handling boolean syntax and matching is quite rigid.
457 * A more flexible approach would be to allow a variety
458 * of strings to be normalized and prettied into TRUE
466 /* very unforgiving validation, requires no normalization
467 * before simplistic matching
470 if( in->bv_len == 4 ) {
471 if( !memcmp( in->bv_val, "TRUE", 4 ) ) {
474 } else if( in->bv_len == 5 ) {
475 if( !memcmp( in->bv_val, "FALSE", 5 ) ) {
480 return LDAP_INVALID_SYNTAX;
489 struct berval *value,
490 void *assertedValue )
492 /* simplistic matching allowed by rigid validation */
493 struct berval *asserted = (struct berval *) assertedValue;
494 *matchp = value->bv_len != asserted->bv_len;
501 struct berval *right,
502 struct berval *left )
506 ldap_unicode_t ru, lu;
507 ldap_unicode_t ruu, luu;
510 r < right->bv_len && l < left->bv_len;
514 * XXYYZ: we convert to ucs4 even though -llunicode
515 * expects ucs2 in an unsigned long
517 ru = ldap_utf8_to_ucs4( &right->bv_val[r] );
518 if( ru == LDAP_UCS4_INVALID ) {
522 lu = ldap_utf8_to_ucs4( &left->bv_val[l] );
523 if( lu == LDAP_UCS4_INVALID ) {
527 ruu = uctoupper( ru );
528 luu = uctoupper( lu );
532 } else if( luu > ruu ) {
536 rlen = LDAP_UTF8_CHARLEN( &right->bv_val[r] );
537 llen = LDAP_UTF8_CHARLEN( &left->bv_val[l] );
540 if( r < right->bv_len ) {
545 if( l < left->bv_len ) {
553 /* case insensitive UTF8 strncmp with offset for second string */
556 struct berval *right,
564 ldap_unicode_t ru, lu;
565 ldap_unicode_t ruu, luu;
567 rslen = len < right->bv_len ? len : right->bv_len;
568 lslen = len + offset < left->bv_len ? len : left->bv_len;
570 for( r = 0, l = offset;
571 r < rslen && l < lslen;
575 * XXYYZ: we convert to ucs4 even though -llunicode
576 * expects ucs2 in an unsigned long
578 ru = ldap_utf8_to_ucs4( &right->bv_val[r] );
579 if( ru == LDAP_UCS4_INVALID ) {
583 lu = ldap_utf8_to_ucs4( &left->bv_val[l] );
584 if( lu == LDAP_UCS4_INVALID ) {
588 ruu = uctoupper( ru );
589 luu = uctoupper( lu );
593 } else if( luu > ruu ) {
597 rlen = LDAP_UTF8_CHARLEN( &right->bv_val[r] );
598 llen = LDAP_UTF8_CHARLEN( &left->bv_val[l] );
614 static char *UTF8casechr( const char *str, const char *c )
616 char *p, *lower, *upper;
617 ldap_ucs4_t tch, ch = ldap_utf8_to_ucs4(c);
619 tch = uctolower ( ch );
620 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
621 if( ldap_utf8_to_ucs4( p ) == tch ) {
625 lower = *p != '\0' ? p : NULL;
627 tch = uctoupper ( ch );
628 for( p = (char *) str; *p != '\0'; LDAP_UTF8_INCR(p) ) {
629 if( ldap_utf8_to_ucs4( p ) == tch ) {
633 upper = *p != '\0' ? p : NULL;
635 if( lower && upper ) {
636 return lower < upper ? lower : upper;
637 } else if ( lower ) {
652 unsigned char *u = in->bv_val;
654 if( !in->bv_len ) return LDAP_INVALID_SYNTAX;
656 for( count = in->bv_len; count > 0; count-=len, u+=len ) {
657 /* get the length indicated by the first byte */
658 len = LDAP_UTF8_CHARLEN( u );
660 /* should not be zero */
661 if( len == 0 ) return LDAP_INVALID_SYNTAX;
663 /* make sure len corresponds with the offset
664 to the next character */
665 if( LDAP_UTF8_OFFSET( u ) != len ) return LDAP_INVALID_SYNTAX;
668 if( count != 0 ) return LDAP_INVALID_SYNTAX;
677 struct berval **normalized )
679 struct berval *newval;
682 newval = ch_malloc( sizeof( struct berval ) );
686 /* Ignore initial whitespace */
687 while ( ldap_utf8_isspace( p ) ) {
693 return LDAP_INVALID_SYNTAX;
696 newval->bv_val = ch_strdup( p );
697 p = q = newval->bv_val;
703 if ( ldap_utf8_isspace( p ) ) {
704 len = LDAP_UTF8_COPY(q,p);
709 /* Ignore the extra whitespace */
710 while ( ldap_utf8_isspace( p ) ) {
714 len = LDAP_UTF8_COPY(q,p);
721 assert( *newval->bv_val );
722 assert( newval->bv_val < p );
725 /* cannot start with a space */
726 assert( !ldap_utf8_isspace(newval->bv_val) );
729 * If the string ended in space, backup the pointer one
730 * position. One is enough because the above loop collapsed
731 * all whitespace to a single space.
738 /* cannot end with a space */
739 assert( !ldap_utf8_isspace( LDAP_UTF8_PREV(q) ) );
744 newval->bv_len = q - newval->bv_val;
745 *normalized = newval;
750 #if defined(SLAPD_APPROX_MULTISTRING)
752 #if defined(SLAPD_APPROX_INITIALS)
753 #define SLAPD_APPROX_DELIMITER "._ "
754 #define SLAPD_APPROX_WORDLEN 2
756 #define SLAPD_APPROX_DELIMITER " "
757 #define SLAPD_APPROX_WORDLEN 1
766 struct berval *value,
767 void *assertedValue )
769 char *val, *assertv, **values, **words, *c;
770 int i, count, len, nextchunk=0, nextavail=0;
773 /* Isolate how many words there are */
774 val = ch_strdup( value->bv_val );
775 for( c=val,count=1; *c; c++ ) {
776 c = strpbrk( c, SLAPD_APPROX_DELIMITER );
777 if ( c == NULL ) break;
782 /* Get a phonetic copy of each word */
783 words = (char **)ch_malloc( count * sizeof(char *) );
784 values = (char **)ch_malloc( count * sizeof(char *) );
785 for( c=val,i=0; i<count; i++,c+=strlen(c)+1 ) {
787 values[i] = phonetic(c);
791 /* Work through the asserted value's words, to see if at least some
792 of the words are there, in the same order. */
793 assertv = ch_strdup( ((struct berval *)assertedValue)->bv_val );
795 while ( nextchunk < ((struct berval *)assertedValue)->bv_len ) {
796 len = strcspn( assertv + nextchunk, SLAPD_APPROX_DELIMITER);
801 #if defined(SLAPD_APPROX_INITIALS)
802 else if( len == 1 ) {
803 /* Single letter words need to at least match one word's initial */
804 for( i=nextavail; i<count; i++ )
805 if( !strncasecmp( assertv+nextchunk, words[i], 1 )) {
812 /* Isolate the next word in the asserted value and phonetic it */
813 assertv[nextchunk+len] = '\0';
814 val = phonetic( assertv + nextchunk );
816 /* See if this phonetic chunk is in the remaining words of *value */
817 for( i=nextavail; i<count; i++ ){
818 if( !strcmp( val, values[i] ) ){
825 /* This chunk in the asserted value was NOT within the *value. */
831 /* Go on to the next word in the asserted value */
835 /* If some of the words were seen, call it a match */
836 if( nextavail > 0 ) {
845 for( i=0; i<count; i++ ) {
846 ch_free( values[i] );
862 struct berval *prefix,
863 struct berval **values,
864 struct berval ***keysp )
867 int i,j, len, wordcount, keycount=0;
868 struct berval **newkeys, **keys=NULL;
871 for( j=0; values[j] != NULL; j++ ) {
873 /* Isolate how many words there are. There will be a key for each */
874 val = ch_strdup( values[j]->bv_val );
875 for( wordcount=0,c=val; *c; c++) {
876 len = strcspn(c, SLAPD_APPROX_DELIMITER);
877 if( len >= SLAPD_APPROX_WORDLEN ) wordcount++;
879 if (*c == '\0') break;
883 /* Allocate/increase storage to account for new keys */
884 newkeys = (struct berval **)ch_malloc( (keycount + wordcount + 1)
885 * sizeof(struct berval *) );
886 memcpy( newkeys, keys, keycount * sizeof(struct berval *) );
887 if( keys ) ch_free( keys );
890 /* Get a phonetic copy of each word */
891 for( c=val,i=0; i<wordcount; c+=len+1 ) {
893 if( len < SLAPD_APPROX_WORDLEN ) continue;
894 keys[keycount] = (struct berval *)ch_malloc( sizeof(struct berval) );
895 keys[keycount]->bv_val = phonetic( c );
896 keys[keycount]->bv_len = strlen( keys[keycount]->bv_val );
903 keys[keycount] = NULL;
916 struct berval *prefix,
918 struct berval ***keysp )
922 struct berval **keys;
925 /* Isolate how many words there are. There will be a key for each */
926 val = ch_strdup( ((struct berval *)assertValue)->bv_val );
927 for( count=0,c=val; *c; c++) {
928 len = strcspn(c, SLAPD_APPROX_DELIMITER);
929 if( len >= SLAPD_APPROX_WORDLEN ) count++;
931 if (*c == '\0') break;
935 /* Allocate storage for new keys */
936 keys = (struct berval **)ch_malloc( (count + 1) * sizeof(struct berval *) );
938 /* Get a phonetic copy of each word */
939 for( c=val,i=0; i<count; c+=len+1 ) {
941 if( len < SLAPD_APPROX_WORDLEN ) continue;
942 keys[i] = (struct berval *)ch_malloc( sizeof(struct berval) );
943 keys[i]->bv_val = phonetic( c );
944 keys[i]->bv_len = strlen( keys[i]->bv_val );
958 /* No other form of Approximate Matching is defined */
966 struct berval *value,
967 void *assertedValue )
969 char *vapprox, *avapprox;
971 vapprox = phonetic( value->bv_val );
972 avapprox = phonetic( ((struct berval *)assertedValue)->bv_val);
974 *matchp = strcmp( vapprox, avapprox );
988 struct berval *prefix,
989 struct berval **values,
990 struct berval ***keysp )
993 struct berval **keys;
996 for( i=0; values[i] != NULL; i++ ) {
997 /* just count them */
1001 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * (i+1) );
1003 /* Copy each value and run it through phonetic() */
1004 for( i=0; values[i] != NULL; i++ ) {
1005 keys[i] = ch_malloc( sizeof( struct berval * ) );
1006 keys[i]->bv_val = phonetic( values[i]->bv_val );
1007 keys[i]->bv_len = strlen( keys[i]->bv_val );
1012 return LDAP_SUCCESS;
1022 struct berval *prefix,
1024 struct berval ***keysp )
1026 struct berval **keys;
1029 keys = (struct berval **)ch_malloc( sizeof( struct berval * ) * 2 );
1031 /* Copy the value and run it through phonetic() */
1032 keys[0] = ch_malloc( sizeof( struct berval * ) );
1033 keys[0]->bv_val = phonetic( ((struct berval *)assertValue)->bv_val );
1034 keys[0]->bv_len = strlen( keys[0]->bv_val );
1038 return LDAP_SUCCESS;
1049 struct berval *value,
1050 void *assertedValue )
1052 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
1055 match = strncmp( value->bv_val,
1056 ((struct berval *) assertedValue)->bv_val,
1061 return LDAP_SUCCESS;
1065 caseExactSubstringsMatch(
1070 struct berval *value,
1071 void *assertedValue )
1074 SubstringsAssertion *sub = assertedValue;
1075 struct berval left = *value;
1079 /* Add up asserted input length */
1080 if( sub->sa_initial ) {
1081 inlen += sub->sa_initial->bv_len;
1084 for(i=0; sub->sa_any[i] != NULL; i++) {
1085 inlen += sub->sa_any[i]->bv_len;
1088 if( sub->sa_final ) {
1089 inlen += sub->sa_final->bv_len;
1092 if( sub->sa_initial ) {
1093 if( inlen > left.bv_len ) {
1098 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
1099 sub->sa_initial->bv_len );
1105 left.bv_val += sub->sa_initial->bv_len;
1106 left.bv_len -= sub->sa_initial->bv_len;
1107 inlen -= sub->sa_initial->bv_len;
1110 if( sub->sa_final ) {
1111 if( inlen > left.bv_len ) {
1116 match = strncmp( sub->sa_final->bv_val,
1117 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1118 sub->sa_final->bv_len );
1124 left.bv_len -= sub->sa_final->bv_len;
1125 inlen -= sub->sa_final->bv_len;
1129 for(i=0; sub->sa_any[i]; i++) {
1134 if( inlen > left.bv_len ) {
1135 /* not enough length */
1140 if( sub->sa_any[i]->bv_len == 0 ) {
1144 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
1151 idx = p - left.bv_val;
1152 assert( idx < left.bv_len );
1154 if( idx >= left.bv_len ) {
1155 /* this shouldn't happen */
1162 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1163 /* not enough left */
1168 match = strncmp( left.bv_val,
1169 sub->sa_any[i]->bv_val,
1170 sub->sa_any[i]->bv_len );
1178 left.bv_val += sub->sa_any[i]->bv_len;
1179 left.bv_len -= sub->sa_any[i]->bv_len;
1180 inlen -= sub->sa_any[i]->bv_len;
1186 return LDAP_SUCCESS;
1189 /* Index generation function */
1190 int caseExactIndexer(
1195 struct berval *prefix,
1196 struct berval **values,
1197 struct berval ***keysp )
1201 struct berval **keys;
1202 HASH_CONTEXT HASHcontext;
1203 unsigned char HASHdigest[HASH_BYTES];
1204 struct berval digest;
1205 digest.bv_val = HASHdigest;
1206 digest.bv_len = sizeof(HASHdigest);
1208 /* we should have at least one value at this point */
1209 assert( values != NULL && values[0] != NULL );
1211 for( i=0; values[i] != NULL; i++ ) {
1212 /* just count them */
1215 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1217 slen = strlen( syntax->ssyn_oid );
1218 mlen = strlen( mr->smr_oid );
1220 for( i=0; values[i] != NULL; i++ ) {
1221 struct berval *value;
1223 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_NOCASEFOLD ) );
1228 HASH_Init( &HASHcontext );
1229 if( prefix != NULL && prefix->bv_len > 0 ) {
1230 HASH_Update( &HASHcontext,
1231 prefix->bv_val, prefix->bv_len );
1233 HASH_Update( &HASHcontext,
1234 syntax->ssyn_oid, slen );
1235 HASH_Update( &HASHcontext,
1236 mr->smr_oid, mlen );
1237 HASH_Update( &HASHcontext,
1238 value->bv_val, value->bv_len );
1239 HASH_Final( HASHdigest, &HASHcontext );
1242 ber_bvfree( value );
1245 keys[i] = ber_bvdup( &digest );
1250 return LDAP_SUCCESS;
1253 /* Index generation function */
1254 int caseExactFilter(
1259 struct berval *prefix,
1261 struct berval ***keysp )
1264 struct berval **keys;
1265 HASH_CONTEXT HASHcontext;
1266 unsigned char HASHdigest[HASH_BYTES];
1267 struct berval *value;
1268 struct berval digest;
1269 digest.bv_val = HASHdigest;
1270 digest.bv_len = sizeof(HASHdigest);
1272 slen = strlen( syntax->ssyn_oid );
1273 mlen = strlen( mr->smr_oid );
1276 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val, UTF8_NOCASEFOLD ) );
1278 value = (struct berval *) assertValue;
1281 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1283 HASH_Init( &HASHcontext );
1284 if( prefix != NULL && prefix->bv_len > 0 ) {
1285 HASH_Update( &HASHcontext,
1286 prefix->bv_val, prefix->bv_len );
1288 HASH_Update( &HASHcontext,
1289 syntax->ssyn_oid, slen );
1290 HASH_Update( &HASHcontext,
1291 mr->smr_oid, mlen );
1292 HASH_Update( &HASHcontext,
1293 value->bv_val, value->bv_len );
1294 HASH_Final( HASHdigest, &HASHcontext );
1296 keys[0] = ber_bvdup( &digest );
1300 ber_bvfree( value );
1304 return LDAP_SUCCESS;
1307 /* Substrings Index generation function */
1308 int caseExactSubstringsIndexer(
1313 struct berval *prefix,
1314 struct berval **values,
1315 struct berval ***keysp )
1319 struct berval **keys;
1320 HASH_CONTEXT HASHcontext;
1321 unsigned char HASHdigest[HASH_BYTES];
1322 struct berval digest;
1323 digest.bv_val = HASHdigest;
1324 digest.bv_len = sizeof(HASHdigest);
1326 /* we should have at least one value at this point */
1327 assert( values != NULL && values[0] != NULL );
1330 for( i=0; values[i] != NULL; i++ ) {
1331 /* count number of indices to generate */
1332 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1336 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1337 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1338 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1339 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1341 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1345 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1346 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1347 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1351 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1352 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1353 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1354 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1356 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1362 /* no keys to generate */
1364 return LDAP_SUCCESS;
1367 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1369 slen = strlen( syntax->ssyn_oid );
1370 mlen = strlen( mr->smr_oid );
1373 for( i=0; values[i] != NULL; i++ ) {
1375 struct berval *value;
1377 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
1380 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_NOCASEFOLD ) );
1385 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
1386 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
1388 char pre = SLAP_INDEX_SUBSTR_PREFIX;
1389 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
1391 for( j=0; j<max; j++ ) {
1392 HASH_Init( &HASHcontext );
1393 if( prefix != NULL && prefix->bv_len > 0 ) {
1394 HASH_Update( &HASHcontext,
1395 prefix->bv_val, prefix->bv_len );
1398 HASH_Update( &HASHcontext,
1399 &pre, sizeof( pre ) );
1400 HASH_Update( &HASHcontext,
1401 syntax->ssyn_oid, slen );
1402 HASH_Update( &HASHcontext,
1403 mr->smr_oid, mlen );
1404 HASH_Update( &HASHcontext,
1406 SLAP_INDEX_SUBSTR_MAXLEN );
1407 HASH_Final( HASHdigest, &HASHcontext );
1409 keys[nkeys++] = ber_bvdup( &digest );
1413 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1414 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1416 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
1419 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1420 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1421 HASH_Init( &HASHcontext );
1422 if( prefix != NULL && prefix->bv_len > 0 ) {
1423 HASH_Update( &HASHcontext,
1424 prefix->bv_val, prefix->bv_len );
1426 HASH_Update( &HASHcontext,
1427 &pre, sizeof( pre ) );
1428 HASH_Update( &HASHcontext,
1429 syntax->ssyn_oid, slen );
1430 HASH_Update( &HASHcontext,
1431 mr->smr_oid, mlen );
1432 HASH_Update( &HASHcontext,
1434 HASH_Final( HASHdigest, &HASHcontext );
1436 keys[nkeys++] = ber_bvdup( &digest );
1439 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1440 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1441 HASH_Init( &HASHcontext );
1442 if( prefix != NULL && prefix->bv_len > 0 ) {
1443 HASH_Update( &HASHcontext,
1444 prefix->bv_val, prefix->bv_len );
1446 HASH_Update( &HASHcontext,
1447 &pre, sizeof( pre ) );
1448 HASH_Update( &HASHcontext,
1449 syntax->ssyn_oid, slen );
1450 HASH_Update( &HASHcontext,
1451 mr->smr_oid, mlen );
1452 HASH_Update( &HASHcontext,
1453 &value->bv_val[value->bv_len-j], j );
1454 HASH_Final( HASHdigest, &HASHcontext );
1456 keys[nkeys++] = ber_bvdup( &digest );
1462 ber_bvfree( value );
1475 return LDAP_SUCCESS;
1478 int caseExactSubstringsFilter(
1483 struct berval *prefix,
1485 struct berval ***keysp )
1487 SubstringsAssertion *sa = assertValue;
1489 ber_len_t nkeys = 0;
1490 size_t slen, mlen, klen;
1491 struct berval **keys;
1492 HASH_CONTEXT HASHcontext;
1493 unsigned char HASHdigest[HASH_BYTES];
1494 struct berval *value;
1495 struct berval digest;
1497 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1498 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1503 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1505 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1506 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1507 /* don't bother accounting for stepping */
1508 nkeys += sa->sa_any[i]->bv_len -
1509 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1514 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1515 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1522 return LDAP_SUCCESS;
1525 digest.bv_val = HASHdigest;
1526 digest.bv_len = sizeof(HASHdigest);
1528 slen = strlen( syntax->ssyn_oid );
1529 mlen = strlen( mr->smr_oid );
1531 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
1534 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
1535 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1537 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
1539 value = ber_bvstr( UTF8normalize( sa->sa_initial->bv_val, UTF8_NOCASEFOLD ) );
1541 value = sa->sa_initial;
1544 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1545 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1547 HASH_Init( &HASHcontext );
1548 if( prefix != NULL && prefix->bv_len > 0 ) {
1549 HASH_Update( &HASHcontext,
1550 prefix->bv_val, prefix->bv_len );
1552 HASH_Update( &HASHcontext,
1553 &pre, sizeof( pre ) );
1554 HASH_Update( &HASHcontext,
1555 syntax->ssyn_oid, slen );
1556 HASH_Update( &HASHcontext,
1557 mr->smr_oid, mlen );
1558 HASH_Update( &HASHcontext,
1559 value->bv_val, klen );
1560 HASH_Final( HASHdigest, &HASHcontext );
1563 ber_bvfree( value );
1565 keys[nkeys++] = ber_bvdup( &digest );
1568 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
1570 pre = SLAP_INDEX_SUBSTR_PREFIX;
1571 klen = SLAP_INDEX_SUBSTR_MAXLEN;
1573 for( i=0; sa->sa_any[i] != NULL; i++ ) {
1574 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
1579 value = ber_bvstr( UTF8normalize( sa->sa_any[i]->bv_val, UTF8_NOCASEFOLD ) );
1581 value = sa->sa_any[i];
1585 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
1586 j += SLAP_INDEX_SUBSTR_STEP )
1588 HASH_Init( &HASHcontext );
1589 if( prefix != NULL && prefix->bv_len > 0 ) {
1590 HASH_Update( &HASHcontext,
1591 prefix->bv_val, prefix->bv_len );
1593 HASH_Update( &HASHcontext,
1594 &pre, sizeof( pre ) );
1595 HASH_Update( &HASHcontext,
1596 syntax->ssyn_oid, slen );
1597 HASH_Update( &HASHcontext,
1598 mr->smr_oid, mlen );
1599 HASH_Update( &HASHcontext,
1600 &value->bv_val[j], klen );
1601 HASH_Final( HASHdigest, &HASHcontext );
1603 keys[nkeys++] = ber_bvdup( &digest );
1607 ber_bvfree( value );
1612 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
1613 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
1615 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
1617 value = ber_bvstr( UTF8normalize( sa->sa_final->bv_val, UTF8_NOCASEFOLD ) );
1619 value = sa->sa_final;
1622 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
1623 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
1625 HASH_Init( &HASHcontext );
1626 if( prefix != NULL && prefix->bv_len > 0 ) {
1627 HASH_Update( &HASHcontext,
1628 prefix->bv_val, prefix->bv_len );
1630 HASH_Update( &HASHcontext,
1631 &pre, sizeof( pre ) );
1632 HASH_Update( &HASHcontext,
1633 syntax->ssyn_oid, slen );
1634 HASH_Update( &HASHcontext,
1635 mr->smr_oid, mlen );
1636 HASH_Update( &HASHcontext,
1637 &value->bv_val[value->bv_len-klen], klen );
1638 HASH_Final( HASHdigest, &HASHcontext );
1641 ber_bvfree( value );
1643 keys[nkeys++] = ber_bvdup( &digest );
1654 return LDAP_SUCCESS;
1663 struct berval *value,
1664 void *assertedValue )
1667 *matchp = UTF8casecmp( value, (struct berval *) assertedValue );
1669 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
1672 match = strncasecmp( value->bv_val,
1673 ((struct berval *) assertedValue)->bv_val,
1679 return LDAP_SUCCESS;
1683 caseIgnoreSubstringsMatch(
1688 struct berval *value,
1689 void *assertedValue )
1692 SubstringsAssertion *sub = assertedValue;
1693 struct berval left = *value;
1697 /* Add up asserted input length */
1698 if( sub->sa_initial ) {
1699 inlen += sub->sa_initial->bv_len;
1702 for(i=0; sub->sa_any[i] != NULL; i++) {
1703 inlen += sub->sa_any[i]->bv_len;
1706 if( sub->sa_final ) {
1707 inlen += sub->sa_final->bv_len;
1710 if( sub->sa_initial ) {
1711 if( inlen > left.bv_len ) {
1717 match = UTF8oncasecmp( sub->sa_initial, &left,
1718 sub->sa_initial->bv_len, 0 );
1720 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
1721 sub->sa_initial->bv_len );
1728 left.bv_val += sub->sa_initial->bv_len;
1729 left.bv_len -= sub->sa_initial->bv_len;
1730 inlen -= sub->sa_initial->bv_len;
1733 if( sub->sa_final ) {
1734 if( inlen > left.bv_len ) {
1740 match = UTF8oncasecmp( sub->sa_final, &left,
1741 sub->sa_final->bv_len,
1742 left.bv_len - sub->sa_final->bv_len );
1744 match = strncasecmp( sub->sa_final->bv_val,
1745 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
1746 sub->sa_final->bv_len );
1753 left.bv_len -= sub->sa_final->bv_len;
1754 inlen -= sub->sa_final->bv_len;
1758 for(i=0; sub->sa_any[i]; i++) {
1763 if( inlen > left.bv_len ) {
1764 /* not enough length */
1769 if( sub->sa_any[i]->bv_len == 0 ) {
1774 p = UTF8casechr( left.bv_val, sub->sa_any[i]->bv_val );
1776 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
1784 idx = p - left.bv_val;
1785 assert( idx < left.bv_len );
1787 if( idx >= left.bv_len ) {
1788 /* this shouldn't happen */
1795 if( sub->sa_any[i]->bv_len > left.bv_len ) {
1796 /* not enough left */
1802 match = UTF8oncasecmp( &left, sub->sa_any[i],
1803 sub->sa_any[i]->bv_len, 0 );
1806 int len = LDAP_UTF8_CHARLEN( left.bv_val );
1812 match = strncasecmp( left.bv_val,
1813 sub->sa_any[i]->bv_val,
1814 sub->sa_any[i]->bv_len );
1824 left.bv_val += sub->sa_any[i]->bv_len;
1825 left.bv_len -= sub->sa_any[i]->bv_len;
1826 inlen -= sub->sa_any[i]->bv_len;
1832 return LDAP_SUCCESS;
1835 /* Index generation function */
1836 int caseIgnoreIndexer(
1841 struct berval *prefix,
1842 struct berval **values,
1843 struct berval ***keysp )
1847 struct berval **keys;
1848 HASH_CONTEXT HASHcontext;
1849 unsigned char HASHdigest[HASH_BYTES];
1850 struct berval digest;
1851 digest.bv_val = HASHdigest;
1852 digest.bv_len = sizeof(HASHdigest);
1854 /* we should have at least one value at this point */
1855 assert( values != NULL && values[0] != NULL );
1857 for( i=0; values[i] != NULL; i++ ) {
1858 /* just count them */
1861 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
1863 slen = strlen( syntax->ssyn_oid );
1864 mlen = strlen( mr->smr_oid );
1866 for( i=0; values[i] != NULL; i++ ) {
1867 struct berval *value;
1869 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
1871 value = ber_bvdup( values[i] );
1872 ldap_pvt_str2upper( value->bv_val );
1874 HASH_Init( &HASHcontext );
1875 if( prefix != NULL && prefix->bv_len > 0 ) {
1876 HASH_Update( &HASHcontext,
1877 prefix->bv_val, prefix->bv_len );
1879 HASH_Update( &HASHcontext,
1880 syntax->ssyn_oid, slen );
1881 HASH_Update( &HASHcontext,
1882 mr->smr_oid, mlen );
1883 HASH_Update( &HASHcontext,
1884 value->bv_val, value->bv_len );
1885 HASH_Final( HASHdigest, &HASHcontext );
1887 ber_bvfree( value );
1889 keys[i] = ber_bvdup( &digest );
1894 return LDAP_SUCCESS;
1897 /* Index generation function */
1898 int caseIgnoreFilter(
1903 struct berval *prefix,
1905 struct berval ***keysp )
1908 struct berval **keys;
1909 HASH_CONTEXT HASHcontext;
1910 unsigned char HASHdigest[HASH_BYTES];
1911 struct berval *value;
1912 struct berval digest;
1913 digest.bv_val = HASHdigest;
1914 digest.bv_len = sizeof(HASHdigest);
1916 slen = strlen( syntax->ssyn_oid );
1917 mlen = strlen( mr->smr_oid );
1920 value = ber_bvstr( UTF8normalize( ((struct berval *) assertValue)->bv_val, UTF8_CASEFOLD ) );
1922 value = ber_bvdup( (struct berval *) assertValue );
1923 ldap_pvt_str2upper( value->bv_val );
1926 keys = ch_malloc( sizeof( struct berval * ) * 2 );
1928 HASH_Init( &HASHcontext );
1929 if( prefix != NULL && prefix->bv_len > 0 ) {
1930 HASH_Update( &HASHcontext,
1931 prefix->bv_val, prefix->bv_len );
1933 HASH_Update( &HASHcontext,
1934 syntax->ssyn_oid, slen );
1935 HASH_Update( &HASHcontext,
1936 mr->smr_oid, mlen );
1937 HASH_Update( &HASHcontext,
1938 value->bv_val, value->bv_len );
1939 HASH_Final( HASHdigest, &HASHcontext );
1941 keys[0] = ber_bvdup( &digest );
1944 ber_bvfree( value );
1948 return LDAP_SUCCESS;
1951 /* Substrings Index generation function */
1952 int caseIgnoreSubstringsIndexer(
1957 struct berval *prefix,
1958 struct berval **values,
1959 struct berval ***keysp )
1963 struct berval **keys;
1964 HASH_CONTEXT HASHcontext;
1965 unsigned char HASHdigest[HASH_BYTES];
1966 struct berval digest;
1967 digest.bv_val = HASHdigest;
1968 digest.bv_len = sizeof(HASHdigest);
1970 /* we should have at least one value at this point */
1971 assert( values != NULL && values[0] != NULL );
1974 for( i=0; values[i] != NULL; i++ ) {
1975 /* count number of indices to generate */
1976 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
1980 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
1981 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1982 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1983 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
1985 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
1989 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
1990 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1991 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
1995 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
1996 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
1997 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
1998 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2000 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2006 /* no keys to generate */
2008 return LDAP_SUCCESS;
2011 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2013 slen = strlen( syntax->ssyn_oid );
2014 mlen = strlen( mr->smr_oid );
2017 for( i=0; values[i] != NULL; i++ ) {
2019 struct berval *value;
2021 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2024 value = ber_bvstr( UTF8normalize( values[i]->bv_val, UTF8_CASEFOLD ) );
2026 value = ber_bvdup( values[i] );
2027 ldap_pvt_str2upper( value->bv_val );
2030 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2031 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2033 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2034 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2036 for( j=0; j<max; j++ ) {
2037 HASH_Init( &HASHcontext );
2038 if( prefix != NULL && prefix->bv_len > 0 ) {
2039 HASH_Update( &HASHcontext,
2040 prefix->bv_val, prefix->bv_len );
2043 HASH_Update( &HASHcontext,
2044 &pre, sizeof( pre ) );
2045 HASH_Update( &HASHcontext,
2046 syntax->ssyn_oid, slen );
2047 HASH_Update( &HASHcontext,
2048 mr->smr_oid, mlen );
2049 HASH_Update( &HASHcontext,
2051 SLAP_INDEX_SUBSTR_MAXLEN );
2052 HASH_Final( HASHdigest, &HASHcontext );
2054 keys[nkeys++] = ber_bvdup( &digest );
2058 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2059 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2061 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2064 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2065 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2066 HASH_Init( &HASHcontext );
2067 if( prefix != NULL && prefix->bv_len > 0 ) {
2068 HASH_Update( &HASHcontext,
2069 prefix->bv_val, prefix->bv_len );
2071 HASH_Update( &HASHcontext,
2072 &pre, sizeof( pre ) );
2073 HASH_Update( &HASHcontext,
2074 syntax->ssyn_oid, slen );
2075 HASH_Update( &HASHcontext,
2076 mr->smr_oid, mlen );
2077 HASH_Update( &HASHcontext,
2079 HASH_Final( HASHdigest, &HASHcontext );
2081 keys[nkeys++] = ber_bvdup( &digest );
2084 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2085 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2086 HASH_Init( &HASHcontext );
2087 if( prefix != NULL && prefix->bv_len > 0 ) {
2088 HASH_Update( &HASHcontext,
2089 prefix->bv_val, prefix->bv_len );
2091 HASH_Update( &HASHcontext,
2092 &pre, sizeof( pre ) );
2093 HASH_Update( &HASHcontext,
2094 syntax->ssyn_oid, slen );
2095 HASH_Update( &HASHcontext,
2096 mr->smr_oid, mlen );
2097 HASH_Update( &HASHcontext,
2098 &value->bv_val[value->bv_len-j], j );
2099 HASH_Final( HASHdigest, &HASHcontext );
2101 keys[nkeys++] = ber_bvdup( &digest );
2106 ber_bvfree( value );
2117 return LDAP_SUCCESS;
2120 int caseIgnoreSubstringsFilter(
2125 struct berval *prefix,
2127 struct berval ***keysp )
2129 SubstringsAssertion *sa = assertValue;
2131 ber_len_t nkeys = 0;
2132 size_t slen, mlen, klen;
2133 struct berval **keys;
2134 HASH_CONTEXT HASHcontext;
2135 unsigned char HASHdigest[HASH_BYTES];
2136 struct berval *value;
2137 struct berval digest;
2139 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2140 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2145 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2147 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2148 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2149 /* don't bother accounting for stepping */
2150 nkeys += sa->sa_any[i]->bv_len -
2151 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2156 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2157 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2164 return LDAP_SUCCESS;
2167 digest.bv_val = HASHdigest;
2168 digest.bv_len = sizeof(HASHdigest);
2170 slen = strlen( syntax->ssyn_oid );
2171 mlen = strlen( mr->smr_oid );
2173 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2176 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
2177 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2179 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2181 value = ber_bvstr( UTF8normalize( sa->sa_initial->bv_val, UTF8_CASEFOLD ) );
2183 value = ber_bvdup( sa->sa_initial );
2184 ldap_pvt_str2upper( value->bv_val );
2187 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2188 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2190 HASH_Init( &HASHcontext );
2191 if( prefix != NULL && prefix->bv_len > 0 ) {
2192 HASH_Update( &HASHcontext,
2193 prefix->bv_val, prefix->bv_len );
2195 HASH_Update( &HASHcontext,
2196 &pre, sizeof( pre ) );
2197 HASH_Update( &HASHcontext,
2198 syntax->ssyn_oid, slen );
2199 HASH_Update( &HASHcontext,
2200 mr->smr_oid, mlen );
2201 HASH_Update( &HASHcontext,
2202 value->bv_val, klen );
2203 HASH_Final( HASHdigest, &HASHcontext );
2205 ber_bvfree( value );
2206 keys[nkeys++] = ber_bvdup( &digest );
2209 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
2211 pre = SLAP_INDEX_SUBSTR_PREFIX;
2212 klen = SLAP_INDEX_SUBSTR_MAXLEN;
2214 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2215 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
2220 value = ber_bvstr( UTF8normalize( sa->sa_any[i]->bv_val, UTF8_CASEFOLD ) );
2222 value = ber_bvdup( sa->sa_any[i] );
2223 ldap_pvt_str2upper( value->bv_val );
2227 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
2228 j += SLAP_INDEX_SUBSTR_STEP )
2230 HASH_Init( &HASHcontext );
2231 if( prefix != NULL && prefix->bv_len > 0 ) {
2232 HASH_Update( &HASHcontext,
2233 prefix->bv_val, prefix->bv_len );
2235 HASH_Update( &HASHcontext,
2236 &pre, sizeof( pre ) );
2237 HASH_Update( &HASHcontext,
2238 syntax->ssyn_oid, slen );
2239 HASH_Update( &HASHcontext,
2240 mr->smr_oid, mlen );
2241 HASH_Update( &HASHcontext,
2242 &value->bv_val[j], klen );
2243 HASH_Final( HASHdigest, &HASHcontext );
2245 keys[nkeys++] = ber_bvdup( &digest );
2248 ber_bvfree( value );
2252 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
2253 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2255 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2257 value = ber_bvstr( UTF8normalize( sa->sa_final->bv_val, UTF8_CASEFOLD ) );
2259 value = ber_bvdup( sa->sa_final );
2260 ldap_pvt_str2upper( value->bv_val );
2263 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2264 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2266 HASH_Init( &HASHcontext );
2267 if( prefix != NULL && prefix->bv_len > 0 ) {
2268 HASH_Update( &HASHcontext,
2269 prefix->bv_val, prefix->bv_len );
2271 HASH_Update( &HASHcontext,
2272 &pre, sizeof( pre ) );
2273 HASH_Update( &HASHcontext,
2274 syntax->ssyn_oid, slen );
2275 HASH_Update( &HASHcontext,
2276 mr->smr_oid, mlen );
2277 HASH_Update( &HASHcontext,
2278 &value->bv_val[value->bv_len-klen], klen );
2279 HASH_Final( HASHdigest, &HASHcontext );
2281 ber_bvfree( value );
2282 keys[nkeys++] = ber_bvdup( &digest );
2293 return LDAP_SUCCESS;
2299 struct berval *val )
2303 if( val->bv_len == 0 ) {
2304 /* disallow empty strings */
2305 return LDAP_INVALID_SYNTAX;
2308 if( OID_LEADCHAR(val->bv_val[0]) ) {
2310 for(i=1; i < val->bv_len; i++) {
2311 if( OID_SEPARATOR( val->bv_val[i] ) ) {
2312 if( dot++ ) return 1;
2313 } else if ( OID_CHAR( val->bv_val[i] ) ) {
2316 return LDAP_INVALID_SYNTAX;
2320 return !dot ? LDAP_SUCCESS : LDAP_INVALID_SYNTAX;
2322 } else if( DESC_LEADCHAR(val->bv_val[0]) ) {
2323 for(i=1; i < val->bv_len; i++) {
2324 if( !DESC_CHAR(val->bv_val[i] ) ) {
2325 return LDAP_INVALID_SYNTAX;
2329 return LDAP_SUCCESS;
2332 return LDAP_INVALID_SYNTAX;
2338 struct berval *val )
2342 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2344 if( val->bv_val[0] == '+' || val->bv_val[0] == '-' ) {
2345 if( val->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
2346 } else if( !ASCII_DIGIT(val->bv_val[0]) ) {
2347 return LDAP_INVALID_SYNTAX;
2350 for(i=1; i < val->bv_len; i++) {
2351 if( !ASCII_DIGIT(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2354 return LDAP_SUCCESS;
2361 struct berval **normalized )
2364 struct berval *newval;
2370 negative = ( *p == '-' );
2371 if( *p == '-' || *p == '+' ) p++;
2373 /* Ignore leading zeros */
2374 while ( *p == '0' ) p++;
2376 newval = (struct berval *) ch_malloc( sizeof(struct berval) );
2379 newval->bv_val = ch_strdup("0");
2384 newval->bv_val = ch_malloc( val->bv_len + 1 );
2388 newval->bv_val[newval->bv_len++] = '-';
2391 for( ; *p != '\0'; p++ ) {
2392 newval->bv_val[newval->bv_len++] = *p;
2396 *normalized = newval;
2397 return LDAP_SUCCESS;
2401 countryStringValidate(
2403 struct berval *val )
2407 if( val->bv_len != 2 ) return LDAP_INVALID_SYNTAX;
2409 if( !SLAP_PRINTABLE(val->bv_val[0]) ) {
2410 return LDAP_INVALID_SYNTAX;
2412 if( !SLAP_PRINTABLE(val->bv_val[1]) ) {
2413 return LDAP_INVALID_SYNTAX;
2416 return LDAP_SUCCESS;
2420 printableStringValidate(
2422 struct berval *val )
2426 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2428 for(i=0; i < val->bv_len; i++) {
2429 if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
2430 return LDAP_INVALID_SYNTAX;
2434 return LDAP_SUCCESS;
2438 printablesStringValidate(
2440 struct berval *val )
2444 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2446 for(i=0; i < val->bv_len; i++) {
2447 if( !SLAP_PRINTABLES(val->bv_val[i]) ) {
2448 return LDAP_INVALID_SYNTAX;
2452 return LDAP_SUCCESS;
2458 struct berval *val )
2462 if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
2464 for(i=0; i < val->bv_len; i++) {
2465 if( !isascii(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
2468 return LDAP_SUCCESS;
2475 struct berval **normalized )
2477 struct berval *newval;
2480 newval = ch_malloc( sizeof( struct berval ) );
2484 /* Ignore initial whitespace */
2485 while ( ASCII_SPACE( *p ) ) {
2491 return LDAP_INVALID_SYNTAX;
2494 newval->bv_val = ch_strdup( p );
2495 p = q = newval->bv_val;
2498 if ( ASCII_SPACE( *p ) ) {
2501 /* Ignore the extra whitespace */
2502 while ( ASCII_SPACE( *p ) ) {
2510 assert( *newval->bv_val );
2511 assert( newval->bv_val < p );
2514 /* cannot start with a space */
2515 assert( !ASCII_SPACE(*newval->bv_val) );
2518 * If the string ended in space, backup the pointer one
2519 * position. One is enough because the above loop collapsed
2520 * all whitespace to a single space.
2523 if ( ASCII_SPACE( q[-1] ) ) {
2527 /* cannot end with a space */
2528 assert( !ASCII_SPACE( q[-1] ) );
2530 /* null terminate */
2533 newval->bv_len = q - newval->bv_val;
2534 *normalized = newval;
2536 return LDAP_SUCCESS;
2545 struct berval *value,
2546 void *assertedValue )
2548 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
2551 match = strncmp( value->bv_val,
2552 ((struct berval *) assertedValue)->bv_val,
2557 return LDAP_SUCCESS;
2561 caseExactIA5SubstringsMatch(
2566 struct berval *value,
2567 void *assertedValue )
2570 SubstringsAssertion *sub = assertedValue;
2571 struct berval left = *value;
2575 /* Add up asserted input length */
2576 if( sub->sa_initial ) {
2577 inlen += sub->sa_initial->bv_len;
2580 for(i=0; sub->sa_any[i] != NULL; i++) {
2581 inlen += sub->sa_any[i]->bv_len;
2584 if( sub->sa_final ) {
2585 inlen += sub->sa_final->bv_len;
2588 if( sub->sa_initial ) {
2589 if( inlen > left.bv_len ) {
2594 match = strncmp( sub->sa_initial->bv_val, left.bv_val,
2595 sub->sa_initial->bv_len );
2601 left.bv_val += sub->sa_initial->bv_len;
2602 left.bv_len -= sub->sa_initial->bv_len;
2603 inlen -= sub->sa_initial->bv_len;
2606 if( sub->sa_final ) {
2607 if( inlen > left.bv_len ) {
2612 match = strncmp( sub->sa_final->bv_val,
2613 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
2614 sub->sa_final->bv_len );
2620 left.bv_len -= sub->sa_final->bv_len;
2621 inlen -= sub->sa_final->bv_len;
2625 for(i=0; sub->sa_any[i]; i++) {
2630 if( inlen > left.bv_len ) {
2631 /* not enough length */
2636 if( sub->sa_any[i]->bv_len == 0 ) {
2640 p = strchr( left.bv_val, *sub->sa_any[i]->bv_val );
2647 idx = p - left.bv_val;
2648 assert( idx < left.bv_len );
2650 if( idx >= left.bv_len ) {
2651 /* this shouldn't happen */
2658 if( sub->sa_any[i]->bv_len > left.bv_len ) {
2659 /* not enough left */
2664 match = strncmp( left.bv_val,
2665 sub->sa_any[i]->bv_val,
2666 sub->sa_any[i]->bv_len );
2674 left.bv_val += sub->sa_any[i]->bv_len;
2675 left.bv_len -= sub->sa_any[i]->bv_len;
2676 inlen -= sub->sa_any[i]->bv_len;
2682 return LDAP_SUCCESS;
2685 /* Index generation function */
2686 int caseExactIA5Indexer(
2691 struct berval *prefix,
2692 struct berval **values,
2693 struct berval ***keysp )
2697 struct berval **keys;
2698 HASH_CONTEXT HASHcontext;
2699 unsigned char HASHdigest[HASH_BYTES];
2700 struct berval digest;
2701 digest.bv_val = HASHdigest;
2702 digest.bv_len = sizeof(HASHdigest);
2704 /* we should have at least one value at this point */
2705 assert( values != NULL && values[0] != NULL );
2707 for( i=0; values[i] != NULL; i++ ) {
2708 /* just count them */
2711 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
2713 slen = strlen( syntax->ssyn_oid );
2714 mlen = strlen( mr->smr_oid );
2716 for( i=0; values[i] != NULL; i++ ) {
2717 struct berval *value = values[i];
2719 HASH_Init( &HASHcontext );
2720 if( prefix != NULL && prefix->bv_len > 0 ) {
2721 HASH_Update( &HASHcontext,
2722 prefix->bv_val, prefix->bv_len );
2724 HASH_Update( &HASHcontext,
2725 syntax->ssyn_oid, slen );
2726 HASH_Update( &HASHcontext,
2727 mr->smr_oid, mlen );
2728 HASH_Update( &HASHcontext,
2729 value->bv_val, value->bv_len );
2730 HASH_Final( HASHdigest, &HASHcontext );
2732 keys[i] = ber_bvdup( &digest );
2737 return LDAP_SUCCESS;
2740 /* Index generation function */
2741 int caseExactIA5Filter(
2746 struct berval *prefix,
2748 struct berval ***keysp )
2751 struct berval **keys;
2752 HASH_CONTEXT HASHcontext;
2753 unsigned char HASHdigest[HASH_BYTES];
2754 struct berval *value;
2755 struct berval digest;
2756 digest.bv_val = HASHdigest;
2757 digest.bv_len = sizeof(HASHdigest);
2759 slen = strlen( syntax->ssyn_oid );
2760 mlen = strlen( mr->smr_oid );
2762 value = (struct berval *) assertValue;
2764 keys = ch_malloc( sizeof( struct berval * ) * 2 );
2766 HASH_Init( &HASHcontext );
2767 if( prefix != NULL && prefix->bv_len > 0 ) {
2768 HASH_Update( &HASHcontext,
2769 prefix->bv_val, prefix->bv_len );
2771 HASH_Update( &HASHcontext,
2772 syntax->ssyn_oid, slen );
2773 HASH_Update( &HASHcontext,
2774 mr->smr_oid, mlen );
2775 HASH_Update( &HASHcontext,
2776 value->bv_val, value->bv_len );
2777 HASH_Final( HASHdigest, &HASHcontext );
2779 keys[0] = ber_bvdup( &digest );
2783 return LDAP_SUCCESS;
2786 /* Substrings Index generation function */
2787 int caseExactIA5SubstringsIndexer(
2792 struct berval *prefix,
2793 struct berval **values,
2794 struct berval ***keysp )
2798 struct berval **keys;
2799 HASH_CONTEXT HASHcontext;
2800 unsigned char HASHdigest[HASH_BYTES];
2801 struct berval digest;
2802 digest.bv_val = HASHdigest;
2803 digest.bv_len = sizeof(HASHdigest);
2805 /* we should have at least one value at this point */
2806 assert( values != NULL && values[0] != NULL );
2809 for( i=0; values[i] != NULL; i++ ) {
2810 /* count number of indices to generate */
2811 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
2815 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2816 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2817 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2818 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2820 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2824 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
2825 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2826 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2830 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2831 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2832 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
2833 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
2835 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
2841 /* no keys to generate */
2843 return LDAP_SUCCESS;
2846 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
2848 slen = strlen( syntax->ssyn_oid );
2849 mlen = strlen( mr->smr_oid );
2852 for( i=0; values[i] != NULL; i++ ) {
2854 struct berval *value;
2857 if( value->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
2859 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
2860 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
2862 char pre = SLAP_INDEX_SUBSTR_PREFIX;
2863 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
2865 for( j=0; j<max; j++ ) {
2866 HASH_Init( &HASHcontext );
2867 if( prefix != NULL && prefix->bv_len > 0 ) {
2868 HASH_Update( &HASHcontext,
2869 prefix->bv_val, prefix->bv_len );
2872 HASH_Update( &HASHcontext,
2873 &pre, sizeof( pre ) );
2874 HASH_Update( &HASHcontext,
2875 syntax->ssyn_oid, slen );
2876 HASH_Update( &HASHcontext,
2877 mr->smr_oid, mlen );
2878 HASH_Update( &HASHcontext,
2880 SLAP_INDEX_SUBSTR_MAXLEN );
2881 HASH_Final( HASHdigest, &HASHcontext );
2883 keys[nkeys++] = ber_bvdup( &digest );
2887 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
2888 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
2890 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
2893 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
2894 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
2895 HASH_Init( &HASHcontext );
2896 if( prefix != NULL && prefix->bv_len > 0 ) {
2897 HASH_Update( &HASHcontext,
2898 prefix->bv_val, prefix->bv_len );
2900 HASH_Update( &HASHcontext,
2901 &pre, sizeof( pre ) );
2902 HASH_Update( &HASHcontext,
2903 syntax->ssyn_oid, slen );
2904 HASH_Update( &HASHcontext,
2905 mr->smr_oid, mlen );
2906 HASH_Update( &HASHcontext,
2908 HASH_Final( HASHdigest, &HASHcontext );
2910 keys[nkeys++] = ber_bvdup( &digest );
2913 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
2914 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
2915 HASH_Init( &HASHcontext );
2916 if( prefix != NULL && prefix->bv_len > 0 ) {
2917 HASH_Update( &HASHcontext,
2918 prefix->bv_val, prefix->bv_len );
2920 HASH_Update( &HASHcontext,
2921 &pre, sizeof( pre ) );
2922 HASH_Update( &HASHcontext,
2923 syntax->ssyn_oid, slen );
2924 HASH_Update( &HASHcontext,
2925 mr->smr_oid, mlen );
2926 HASH_Update( &HASHcontext,
2927 &value->bv_val[value->bv_len-j], j );
2928 HASH_Final( HASHdigest, &HASHcontext );
2930 keys[nkeys++] = ber_bvdup( &digest );
2944 return LDAP_SUCCESS;
2947 int caseExactIA5SubstringsFilter(
2952 struct berval *prefix,
2954 struct berval ***keysp )
2956 SubstringsAssertion *sa = assertValue;
2958 ber_len_t nkeys = 0;
2959 size_t slen, mlen, klen;
2960 struct berval **keys;
2961 HASH_CONTEXT HASHcontext;
2962 unsigned char HASHdigest[HASH_BYTES];
2963 struct berval *value;
2964 struct berval digest;
2966 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
2967 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2972 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
2974 for( i=0; sa->sa_any[i] != NULL; i++ ) {
2975 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
2976 /* don't bother accounting for stepping */
2977 nkeys += sa->sa_any[i]->bv_len -
2978 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
2983 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
2984 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
2991 return LDAP_SUCCESS;
2994 digest.bv_val = HASHdigest;
2995 digest.bv_len = sizeof(HASHdigest);
2997 slen = strlen( syntax->ssyn_oid );
2998 mlen = strlen( mr->smr_oid );
3000 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3003 if( flags & SLAP_INDEX_SUBSTR_INITIAL && sa->sa_initial != NULL &&
3004 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3006 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3007 value = sa->sa_initial;
3009 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3010 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3012 HASH_Init( &HASHcontext );
3013 if( prefix != NULL && prefix->bv_len > 0 ) {
3014 HASH_Update( &HASHcontext,
3015 prefix->bv_val, prefix->bv_len );
3017 HASH_Update( &HASHcontext,
3018 &pre, sizeof( pre ) );
3019 HASH_Update( &HASHcontext,
3020 syntax->ssyn_oid, slen );
3021 HASH_Update( &HASHcontext,
3022 mr->smr_oid, mlen );
3023 HASH_Update( &HASHcontext,
3024 value->bv_val, klen );
3025 HASH_Final( HASHdigest, &HASHcontext );
3027 keys[nkeys++] = ber_bvdup( &digest );
3030 if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
3032 pre = SLAP_INDEX_SUBSTR_PREFIX;
3033 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3035 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3036 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3040 value = sa->sa_any[i];
3043 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3044 j += SLAP_INDEX_SUBSTR_STEP )
3046 HASH_Init( &HASHcontext );
3047 if( prefix != NULL && prefix->bv_len > 0 ) {
3048 HASH_Update( &HASHcontext,
3049 prefix->bv_val, prefix->bv_len );
3051 HASH_Update( &HASHcontext,
3052 &pre, sizeof( pre ) );
3053 HASH_Update( &HASHcontext,
3054 syntax->ssyn_oid, slen );
3055 HASH_Update( &HASHcontext,
3056 mr->smr_oid, mlen );
3057 HASH_Update( &HASHcontext,
3058 &value->bv_val[j], klen );
3059 HASH_Final( HASHdigest, &HASHcontext );
3061 keys[nkeys++] = ber_bvdup( &digest );
3066 if( flags & SLAP_INDEX_SUBSTR_FINAL && sa->sa_final != NULL &&
3067 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3069 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3070 value = sa->sa_final;
3072 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3073 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3075 HASH_Init( &HASHcontext );
3076 if( prefix != NULL && prefix->bv_len > 0 ) {
3077 HASH_Update( &HASHcontext,
3078 prefix->bv_val, prefix->bv_len );
3080 HASH_Update( &HASHcontext,
3081 &pre, sizeof( pre ) );
3082 HASH_Update( &HASHcontext,
3083 syntax->ssyn_oid, slen );
3084 HASH_Update( &HASHcontext,
3085 mr->smr_oid, mlen );
3086 HASH_Update( &HASHcontext,
3087 &value->bv_val[value->bv_len-klen], klen );
3088 HASH_Final( HASHdigest, &HASHcontext );
3090 keys[nkeys++] = ber_bvdup( &digest );
3101 return LDAP_SUCCESS;
3110 struct berval *value,
3111 void *assertedValue )
3113 int match = value->bv_len - ((struct berval *) assertedValue)->bv_len;
3115 if( match == 0 && value->bv_len ) {
3116 match = strncasecmp( value->bv_val,
3117 ((struct berval *) assertedValue)->bv_val,
3122 return LDAP_SUCCESS;
3126 caseIgnoreIA5SubstringsMatch(
3131 struct berval *value,
3132 void *assertedValue )
3135 SubstringsAssertion *sub = assertedValue;
3136 struct berval left = *value;
3140 /* Add up asserted input length */
3141 if( sub->sa_initial ) {
3142 inlen += sub->sa_initial->bv_len;
3145 for(i=0; sub->sa_any[i] != NULL; i++) {
3146 inlen += sub->sa_any[i]->bv_len;
3149 if( sub->sa_final ) {
3150 inlen += sub->sa_final->bv_len;
3153 if( sub->sa_initial ) {
3154 if( inlen > left.bv_len ) {
3159 match = strncasecmp( sub->sa_initial->bv_val, left.bv_val,
3160 sub->sa_initial->bv_len );
3166 left.bv_val += sub->sa_initial->bv_len;
3167 left.bv_len -= sub->sa_initial->bv_len;
3168 inlen -= sub->sa_initial->bv_len;
3171 if( sub->sa_final ) {
3172 if( inlen > left.bv_len ) {
3177 match = strncasecmp( sub->sa_final->bv_val,
3178 &left.bv_val[left.bv_len - sub->sa_final->bv_len],
3179 sub->sa_final->bv_len );
3185 left.bv_len -= sub->sa_final->bv_len;
3186 inlen -= sub->sa_final->bv_len;
3190 for(i=0; sub->sa_any[i]; i++) {
3195 if( inlen > left.bv_len ) {
3196 /* not enough length */
3201 if( sub->sa_any[i]->bv_len == 0 ) {
3205 p = strcasechr( left.bv_val, *sub->sa_any[i]->bv_val );
3212 idx = p - left.bv_val;
3213 assert( idx < left.bv_len );
3215 if( idx >= left.bv_len ) {
3216 /* this shouldn't happen */
3223 if( sub->sa_any[i]->bv_len > left.bv_len ) {
3224 /* not enough left */
3229 match = strncasecmp( left.bv_val,
3230 sub->sa_any[i]->bv_val,
3231 sub->sa_any[i]->bv_len );
3240 left.bv_val += sub->sa_any[i]->bv_len;
3241 left.bv_len -= sub->sa_any[i]->bv_len;
3242 inlen -= sub->sa_any[i]->bv_len;
3248 return LDAP_SUCCESS;
3251 /* Index generation function */
3252 int caseIgnoreIA5Indexer(
3257 struct berval *prefix,
3258 struct berval **values,
3259 struct berval ***keysp )
3263 struct berval **keys;
3264 HASH_CONTEXT HASHcontext;
3265 unsigned char HASHdigest[HASH_BYTES];
3266 struct berval digest;
3267 digest.bv_val = HASHdigest;
3268 digest.bv_len = sizeof(HASHdigest);
3270 /* we should have at least one value at this point */
3271 assert( values != NULL && values[0] != NULL );
3273 for( i=0; values[i] != NULL; i++ ) {
3274 /* just count them */
3277 keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
3279 slen = strlen( syntax->ssyn_oid );
3280 mlen = strlen( mr->smr_oid );
3282 for( i=0; values[i] != NULL; i++ ) {
3283 struct berval *value = ber_bvdup( values[i] );
3284 ldap_pvt_str2upper( value->bv_val );
3286 HASH_Init( &HASHcontext );
3287 if( prefix != NULL && prefix->bv_len > 0 ) {
3288 HASH_Update( &HASHcontext,
3289 prefix->bv_val, prefix->bv_len );
3291 HASH_Update( &HASHcontext,
3292 syntax->ssyn_oid, slen );
3293 HASH_Update( &HASHcontext,
3294 mr->smr_oid, mlen );
3295 HASH_Update( &HASHcontext,
3296 value->bv_val, value->bv_len );
3297 HASH_Final( HASHdigest, &HASHcontext );
3299 ber_bvfree( value );
3301 keys[i] = ber_bvdup( &digest );
3306 return LDAP_SUCCESS;
3309 /* Index generation function */
3310 int caseIgnoreIA5Filter(
3315 struct berval *prefix,
3317 struct berval ***keysp )
3320 struct berval **keys;
3321 HASH_CONTEXT HASHcontext;
3322 unsigned char HASHdigest[HASH_BYTES];
3323 struct berval *value;
3324 struct berval digest;
3325 digest.bv_val = HASHdigest;
3326 digest.bv_len = sizeof(HASHdigest);
3328 slen = strlen( syntax->ssyn_oid );
3329 mlen = strlen( mr->smr_oid );
3331 value = ber_bvdup( (struct berval *) assertValue );
3332 ldap_pvt_str2upper( value->bv_val );
3334 keys = ch_malloc( sizeof( struct berval * ) * 2 );
3336 HASH_Init( &HASHcontext );
3337 if( prefix != NULL && prefix->bv_len > 0 ) {
3338 HASH_Update( &HASHcontext,
3339 prefix->bv_val, prefix->bv_len );
3341 HASH_Update( &HASHcontext,
3342 syntax->ssyn_oid, slen );
3343 HASH_Update( &HASHcontext,
3344 mr->smr_oid, mlen );
3345 HASH_Update( &HASHcontext,
3346 value->bv_val, value->bv_len );
3347 HASH_Final( HASHdigest, &HASHcontext );
3349 keys[0] = ber_bvdup( &digest );
3352 ber_bvfree( value );
3356 return LDAP_SUCCESS;
3359 /* Substrings Index generation function */
3360 int caseIgnoreIA5SubstringsIndexer(
3365 struct berval *prefix,
3366 struct berval **values,
3367 struct berval ***keysp )
3371 struct berval **keys;
3372 HASH_CONTEXT HASHcontext;
3373 unsigned char HASHdigest[HASH_BYTES];
3374 struct berval digest;
3375 digest.bv_val = HASHdigest;
3376 digest.bv_len = sizeof(HASHdigest);
3378 /* we should have at least one value at this point */
3379 assert( values != NULL && values[0] != NULL );
3382 for( i=0; values[i] != NULL; i++ ) {
3383 /* count number of indices to generate */
3384 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) {
3388 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3389 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3390 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3391 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3393 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3397 if( flags & SLAP_INDEX_SUBSTR_ANY ) {
3398 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3399 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3403 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3404 if( values[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3405 nkeys += SLAP_INDEX_SUBSTR_MAXLEN -
3406 ( SLAP_INDEX_SUBSTR_MINLEN - 1);
3408 nkeys += values[i]->bv_len - ( SLAP_INDEX_SUBSTR_MINLEN - 1 );
3414 /* no keys to generate */
3416 return LDAP_SUCCESS;
3419 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3421 slen = strlen( syntax->ssyn_oid );
3422 mlen = strlen( mr->smr_oid );
3425 for( i=0; values[i] != NULL; i++ ) {
3427 struct berval *value;
3429 if( values[i]->bv_len < SLAP_INDEX_SUBSTR_MINLEN ) continue;
3431 value = ber_bvdup( values[i] );
3432 ldap_pvt_str2upper( value->bv_val );
3434 if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
3435 ( value->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) )
3437 char pre = SLAP_INDEX_SUBSTR_PREFIX;
3438 max = value->bv_len - ( SLAP_INDEX_SUBSTR_MAXLEN - 1);
3440 for( j=0; j<max; j++ ) {
3441 HASH_Init( &HASHcontext );
3442 if( prefix != NULL && prefix->bv_len > 0 ) {
3443 HASH_Update( &HASHcontext,
3444 prefix->bv_val, prefix->bv_len );
3447 HASH_Update( &HASHcontext,
3448 &pre, sizeof( pre ) );
3449 HASH_Update( &HASHcontext,
3450 syntax->ssyn_oid, slen );
3451 HASH_Update( &HASHcontext,
3452 mr->smr_oid, mlen );
3453 HASH_Update( &HASHcontext,
3455 SLAP_INDEX_SUBSTR_MAXLEN );
3456 HASH_Final( HASHdigest, &HASHcontext );
3458 keys[nkeys++] = ber_bvdup( &digest );
3462 max = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3463 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3465 for( j=SLAP_INDEX_SUBSTR_MINLEN; j<=max; j++ ) {
3468 if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
3469 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3470 HASH_Init( &HASHcontext );
3471 if( prefix != NULL && prefix->bv_len > 0 ) {
3472 HASH_Update( &HASHcontext,
3473 prefix->bv_val, prefix->bv_len );
3475 HASH_Update( &HASHcontext,
3476 &pre, sizeof( pre ) );
3477 HASH_Update( &HASHcontext,
3478 syntax->ssyn_oid, slen );
3479 HASH_Update( &HASHcontext,
3480 mr->smr_oid, mlen );
3481 HASH_Update( &HASHcontext,
3483 HASH_Final( HASHdigest, &HASHcontext );
3485 keys[nkeys++] = ber_bvdup( &digest );
3488 if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
3489 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3490 HASH_Init( &HASHcontext );
3491 if( prefix != NULL && prefix->bv_len > 0 ) {
3492 HASH_Update( &HASHcontext,
3493 prefix->bv_val, prefix->bv_len );
3495 HASH_Update( &HASHcontext,
3496 &pre, sizeof( pre ) );
3497 HASH_Update( &HASHcontext,
3498 syntax->ssyn_oid, slen );
3499 HASH_Update( &HASHcontext,
3500 mr->smr_oid, mlen );
3501 HASH_Update( &HASHcontext,
3502 &value->bv_val[value->bv_len-j], j );
3503 HASH_Final( HASHdigest, &HASHcontext );
3505 keys[nkeys++] = ber_bvdup( &digest );
3510 ber_bvfree( value );
3521 return LDAP_SUCCESS;
3524 int caseIgnoreIA5SubstringsFilter(
3529 struct berval *prefix,
3531 struct berval ***keysp )
3533 SubstringsAssertion *sa = assertValue;
3535 ber_len_t nkeys = 0;
3536 size_t slen, mlen, klen;
3537 struct berval **keys;
3538 HASH_CONTEXT HASHcontext;
3539 unsigned char HASHdigest[HASH_BYTES];
3540 struct berval *value;
3541 struct berval digest;
3543 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3544 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3549 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3551 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3552 if( sa->sa_any[i]->bv_len >= SLAP_INDEX_SUBSTR_MAXLEN ) {
3553 /* don't bother accounting for stepping */
3554 nkeys += sa->sa_any[i]->bv_len -
3555 ( SLAP_INDEX_SUBSTR_MAXLEN - 1 );
3560 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3561 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3568 return LDAP_SUCCESS;
3571 digest.bv_val = HASHdigest;
3572 digest.bv_len = sizeof(HASHdigest);
3574 slen = strlen( syntax->ssyn_oid );
3575 mlen = strlen( mr->smr_oid );
3577 keys = ch_malloc( sizeof( struct berval * ) * (nkeys+1) );
3580 if((flags & SLAP_INDEX_SUBSTR_INITIAL) && sa->sa_initial != NULL &&
3581 sa->sa_initial->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3583 pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
3584 value = ber_bvdup( sa->sa_initial );
3585 ldap_pvt_str2upper( value->bv_val );
3587 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3588 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3590 HASH_Init( &HASHcontext );
3591 if( prefix != NULL && prefix->bv_len > 0 ) {
3592 HASH_Update( &HASHcontext,
3593 prefix->bv_val, prefix->bv_len );
3595 HASH_Update( &HASHcontext,
3596 &pre, sizeof( pre ) );
3597 HASH_Update( &HASHcontext,
3598 syntax->ssyn_oid, slen );
3599 HASH_Update( &HASHcontext,
3600 mr->smr_oid, mlen );
3601 HASH_Update( &HASHcontext,
3602 value->bv_val, klen );
3603 HASH_Final( HASHdigest, &HASHcontext );
3605 ber_bvfree( value );
3606 keys[nkeys++] = ber_bvdup( &digest );
3609 if((flags & SLAP_INDEX_SUBSTR_ANY) && sa->sa_any != NULL ) {
3611 pre = SLAP_INDEX_SUBSTR_PREFIX;
3612 klen = SLAP_INDEX_SUBSTR_MAXLEN;
3614 for( i=0; sa->sa_any[i] != NULL; i++ ) {
3615 if( sa->sa_any[i]->bv_len < SLAP_INDEX_SUBSTR_MAXLEN ) {
3619 value = ber_bvdup( sa->sa_any[i] );
3620 ldap_pvt_str2upper( value->bv_val );
3623 j <= value->bv_len - SLAP_INDEX_SUBSTR_MAXLEN;
3624 j += SLAP_INDEX_SUBSTR_STEP )
3626 HASH_Init( &HASHcontext );
3627 if( prefix != NULL && prefix->bv_len > 0 ) {
3628 HASH_Update( &HASHcontext,
3629 prefix->bv_val, prefix->bv_len );
3631 HASH_Update( &HASHcontext,
3632 &pre, sizeof( pre ) );
3633 HASH_Update( &HASHcontext,
3634 syntax->ssyn_oid, slen );
3635 HASH_Update( &HASHcontext,
3636 mr->smr_oid, mlen );
3637 HASH_Update( &HASHcontext,
3638 &value->bv_val[j], klen );
3639 HASH_Final( HASHdigest, &HASHcontext );
3641 keys[nkeys++] = ber_bvdup( &digest );
3644 ber_bvfree( value );
3648 if((flags & SLAP_INDEX_SUBSTR_FINAL) && sa->sa_final != NULL &&
3649 sa->sa_final->bv_len >= SLAP_INDEX_SUBSTR_MINLEN )
3651 pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
3652 value = ber_bvdup( sa->sa_final );
3653 ldap_pvt_str2upper( value->bv_val );
3655 klen = SLAP_INDEX_SUBSTR_MAXLEN < value->bv_len
3656 ? SLAP_INDEX_SUBSTR_MAXLEN : value->bv_len;
3658 HASH_Init( &HASHcontext );
3659 if( prefix != NULL && prefix->bv_len > 0 ) {
3660 HASH_Update( &HASHcontext,
3661 prefix->bv_val, prefix->bv_len );
3663 HASH_Update( &HASHcontext,
3664 &pre, sizeof( pre ) );
3665 HASH_Update( &HASHcontext,
3666 syntax->ssyn_oid, slen );
3667 HASH_Update( &HASHcontext,
3668 mr->smr_oid, mlen );
3669 HASH_Update( &HASHcontext,
3670 &value->bv_val[value->bv_len-klen], klen );
3671 HASH_Final( HASHdigest, &HASHcontext );
3673 ber_bvfree( value );
3674 keys[nkeys++] = ber_bvdup( &digest );
3685 return LDAP_SUCCESS;
3689 numericStringValidate(
3695 /* disallow empty numeric strings */
3697 for(i=0; i < in->bv_len; i++) {
3698 if( !SLAP_NUMERIC(in->bv_val[i]) ) {
3699 return LDAP_INVALID_SYNTAX;
3703 return LDAP_SUCCESS;
3707 numericStringNormalize(
3710 struct berval **normalized )
3712 /* removal all spaces */
3713 struct berval *newval;
3716 newval = ch_malloc( sizeof( struct berval ) );
3717 newval->bv_val = ch_malloc( val->bv_len + 1 );
3723 if ( ASCII_SPACE( *p ) ) {
3724 /* Ignore whitespace */
3731 assert( newval->bv_val < p );
3734 /* null terminate */
3737 newval->bv_len = q - newval->bv_val;
3738 *normalized = newval;
3740 return LDAP_SUCCESS;
3744 objectIdentifierFirstComponentMatch(
3749 struct berval *value,
3750 void *assertedValue )
3752 int rc = LDAP_SUCCESS;
3754 struct berval *asserted = (struct berval *) assertedValue;
3758 if( value->bv_len == 0 || value->bv_val[0] != '(' /*')'*/ ) {
3759 return LDAP_INVALID_SYNTAX;
3762 /* trim leading white space */
3763 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < value->bv_len; i++ ) {
3767 /* grab next word */
3768 oid.bv_val = &value->bv_val[i];
3769 oid.bv_len = value->bv_len - i;
3770 for( i=1; ASCII_SPACE(value->bv_val[i]) && i < oid.bv_len; i++ ) {
3775 /* insert attributeTypes, objectclass check here */
3776 if( OID_LEADCHAR(asserted->bv_val[0]) ) {
3777 rc = objectIdentifierMatch( &match, flags, syntax, mr, &oid, asserted );
3780 char *stored = ch_malloc( oid.bv_len + 1 );
3781 AC_MEMCPY( stored, oid.bv_val, oid.bv_len );
3782 stored[oid.bv_len] = '\0';
3784 if ( !strcmp( syntax->ssyn_oid, SLAP_SYNTAX_MATCHINGRULES_OID ) ) {
3785 MatchingRule *asserted_mr = mr_find( asserted->bv_val );
3786 MatchingRule *stored_mr = mr_find( stored );
3788 if( asserted_mr == NULL ) {
3789 rc = SLAPD_COMPARE_UNDEFINED;
3791 match = asserted_mr != stored_mr;
3794 } else if ( !strcmp( syntax->ssyn_oid,
3795 SLAP_SYNTAX_ATTRIBUTETYPES_OID ) )
3797 AttributeType *asserted_at = at_find( asserted->bv_val );
3798 AttributeType *stored_at = at_find( stored );
3800 if( asserted_at == NULL ) {
3801 rc = SLAPD_COMPARE_UNDEFINED;
3803 match = asserted_at != stored_at;
3806 } else if ( !strcmp( syntax->ssyn_oid,
3807 SLAP_SYNTAX_OBJECTCLASSES_OID ) )
3809 ObjectClass *asserted_oc = oc_find( asserted->bv_val );
3810 ObjectClass *stored_oc = oc_find( stored );
3812 if( asserted_oc == NULL ) {
3813 rc = SLAPD_COMPARE_UNDEFINED;
3815 match = asserted_oc != stored_oc;
3823 LDAP_LOG(( "schema", LDAP_LEVEL_ENTRY,
3824 "objectIdentifierFirstComponentMatch: %d\n %s\n %s\n",
3825 match, value->bv_val, asserted->bv_val ));
3827 Debug( LDAP_DEBUG_ARGS, "objectIdentifierFirstComponentMatch "
3828 "%d\n\t\"%s\"\n\t\"%s\"\n",
3829 match, value->bv_val, asserted->bv_val );
3833 if( rc == LDAP_SUCCESS ) *matchp = match;
3838 check_time_syntax (struct berval *val,
3842 static int ceiling[9] = { 99, 99, 11, 30, 23, 59, 59, 12, 59 };
3843 static int mdays[2][12] = {
3844 /* non-leap years */
3845 { 30, 27, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 },
3847 { 30, 28, 30, 29, 30, 29, 30, 30, 29, 30, 29, 30 }
3850 int part, c, tzoffset, leapyear = 0 ;
3852 if( val->bv_len == 0 ) {
3853 return LDAP_INVALID_SYNTAX;
3856 p = (char *)val->bv_val;
3857 e = p + val->bv_len;
3859 /* Ignore initial whitespace */
3860 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3864 if (e - p < 13 - (2 * start)) {
3865 return LDAP_INVALID_SYNTAX;
3868 for (part = 0; part < 9; part++) {
3872 for (part = start; part < 7; part++) {
3874 if ((part == 6) && (c == 'Z' || c == '+' || c == '-')) {
3881 return LDAP_INVALID_SYNTAX;
3883 if (c < 0 || c > 9) {
3884 return LDAP_INVALID_SYNTAX;
3890 return LDAP_INVALID_SYNTAX;
3892 if (c < 0 || c > 9) {
3893 return LDAP_INVALID_SYNTAX;
3898 if (part == 2 || part == 3) {
3901 if (parts[part] < 0) {
3902 return LDAP_INVALID_SYNTAX;
3904 if (parts[part] > ceiling[part]) {
3905 return LDAP_INVALID_SYNTAX;
3909 /* leapyear check for the Gregorian calendar (year>1581) */
3910 if (((parts[1] % 4 == 0) && (parts[1] != 0)) ||
3911 ((parts[0] % 4 == 0) && (parts[1] == 0)))
3916 if (parts[3] > mdays[leapyear][parts[2]]) {
3917 return LDAP_INVALID_SYNTAX;
3922 tzoffset = 0; /* UTC */
3923 } else if (c != '+' && c != '-') {
3924 return LDAP_INVALID_SYNTAX;
3928 } else /* c == '+' */ {
3933 return LDAP_INVALID_SYNTAX;
3936 for (part = 7; part < 9; part++) {
3938 if (c < 0 || c > 9) {
3939 return LDAP_INVALID_SYNTAX;
3944 if (c < 0 || c > 9) {
3945 return LDAP_INVALID_SYNTAX;
3949 if (parts[part] < 0 || parts[part] > ceiling[part]) {
3950 return LDAP_INVALID_SYNTAX;
3955 /* Ignore trailing whitespace */
3956 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
3960 return LDAP_INVALID_SYNTAX;
3963 switch ( tzoffset ) {
3964 case -1: /* negativ offset to UTC, ie west of Greenwich */
3965 parts[4] += parts[7];
3966 parts[5] += parts[8];
3967 for (part = 6; --part > 0; ) { /* offset is just hhmm, no seconds */
3971 c = mdays[leapyear][parts[2]];
3973 if (parts[part] > c) {
3974 parts[part] -= c + 1;
3979 case 1: /* positive offset to UTC, ie east of Greenwich */
3980 parts[4] -= parts[7];
3981 parts[5] -= parts[8];
3982 for (part = 6; --part > 0; ) {
3986 /* first arg to % needs to be non negativ */
3987 c = mdays[leapyear][(parts[2] - 1 + 12) % 12];
3989 if (parts[part] < 0) {
3990 parts[part] += c + 1;
3995 case 0: /* already UTC */
3999 return LDAP_SUCCESS;
4006 struct berval **normalized )
4011 rc = check_time_syntax(val, 1, parts);
4012 if (rc != LDAP_SUCCESS) {
4017 out = ch_malloc( sizeof(struct berval) );
4019 return LBER_ERROR_MEMORY;
4022 out->bv_val = ch_malloc( 14 );
4023 if ( out->bv_val == NULL ) {
4025 return LBER_ERROR_MEMORY;
4028 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ldZ",
4029 parts[1], parts[2] + 1, parts[3] + 1,
4030 parts[4], parts[5], parts[6] );
4034 return LDAP_SUCCESS;
4044 return check_time_syntax(in, 1, parts);
4048 generalizedTimeValidate(
4054 return check_time_syntax(in, 0, parts);
4058 generalizedTimeNormalize(
4061 struct berval **normalized )
4066 rc = check_time_syntax(val, 0, parts);
4067 if (rc != LDAP_SUCCESS) {
4072 out = ch_malloc( sizeof(struct berval) );
4074 return LBER_ERROR_MEMORY;
4077 out->bv_val = ch_malloc( 16 );
4078 if ( out->bv_val == NULL ) {
4080 return LBER_ERROR_MEMORY;
4083 sprintf( out->bv_val, "%02ld%02ld%02ld%02ld%02ld%02ld%02ldZ",
4084 parts[0], parts[1], parts[2] + 1, parts[3] + 1,
4085 parts[4], parts[5], parts[6] );
4089 return LDAP_SUCCESS;
4093 nisNetgroupTripleValidate(
4095 struct berval *val )
4100 if ( val->bv_len == 0 ) {
4101 return LDAP_INVALID_SYNTAX;
4104 p = (char *)val->bv_val;
4105 e = p + val->bv_len;
4108 /* syntax does not allow leading white space */
4109 /* Ignore initial whitespace */
4110 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
4115 if ( *p != '(' /*')'*/ ) {
4116 return LDAP_INVALID_SYNTAX;
4119 for ( p++; ( p < e ) && ( *p != ')' ); p++ ) {
4123 return LDAP_INVALID_SYNTAX;
4126 } else if ( !ATTR_CHAR( *p ) ) {
4127 return LDAP_INVALID_SYNTAX;
4131 if ( ( commas != 2 ) || ( *p != /*'('*/ ')' ) ) {
4132 return LDAP_INVALID_SYNTAX;
4138 /* syntax does not allow trailing white space */
4139 /* Ignore trailing whitespace */
4140 while ( ( p < e ) && ASCII_SPACE( *p ) ) {
4146 return LDAP_INVALID_SYNTAX;
4149 return LDAP_SUCCESS;
4153 bootParameterValidate(
4155 struct berval *val )
4159 if ( val->bv_len == 0 ) {
4160 return LDAP_INVALID_SYNTAX;
4163 p = (char *)val->bv_val;
4164 e = p + val->bv_len;
4167 for (; ( p < e ) && ( *p != '=' ); p++ ) {
4168 if ( !ATTR_CHAR( *p ) ) {
4169 return LDAP_INVALID_SYNTAX;
4174 return LDAP_INVALID_SYNTAX;
4178 for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
4179 if ( !ATTR_CHAR( *p ) ) {
4180 return LDAP_INVALID_SYNTAX;
4185 return LDAP_INVALID_SYNTAX;
4189 for ( p++; p < e; p++ ) {
4190 if ( !ATTR_CHAR( *p ) ) {
4191 return LDAP_INVALID_SYNTAX;
4195 return LDAP_SUCCESS;
4198 struct syntax_defs_rec {
4201 slap_syntax_validate_func *sd_validate;
4202 slap_syntax_transform_func *sd_normalize;
4203 slap_syntax_transform_func *sd_pretty;
4204 #ifdef SLAPD_BINARY_CONVERSION
4205 slap_syntax_transform_func *sd_ber2str;
4206 slap_syntax_transform_func *sd_str2ber;
4210 #define X_BINARY "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
4211 #define X_NOT_H_R "X-NOT-HUMAN-READABLE 'TRUE' "
4213 struct syntax_defs_rec syntax_defs[] = {
4214 {"( 1.3.6.1.4.1.1466.115.121.1.1 DESC 'ACI Item' " X_BINARY X_NOT_H_R ")",
4215 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, NULL, NULL, NULL},
4216 {"( 1.3.6.1.4.1.1466.115.121.1.2 DESC 'Access Point' " X_NOT_H_R ")",
4217 0, NULL, NULL, NULL},
4218 {"( 1.3.6.1.4.1.1466.115.121.1.3 DESC 'Attribute Type Description' )",
4219 0, NULL, NULL, NULL},
4220 {"( 1.3.6.1.4.1.1466.115.121.1.4 DESC 'Audio' " X_NOT_H_R ")",
4221 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4222 {"( 1.3.6.1.4.1.1466.115.121.1.5 DESC 'Binary' " X_NOT_H_R ")",
4223 SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4224 {"( 1.3.6.1.4.1.1466.115.121.1.6 DESC 'Bit String' )",
4225 0, bitStringValidate, NULL, NULL },
4226 {"( 1.3.6.1.4.1.1466.115.121.1.7 DESC 'Boolean' )",
4227 0, booleanValidate, NULL, NULL},
4228 {"( 1.3.6.1.4.1.1466.115.121.1.8 DESC 'Certificate' "
4229 X_BINARY X_NOT_H_R ")",
4230 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4231 {"( 1.3.6.1.4.1.1466.115.121.1.9 DESC 'Certificate List' "
4232 X_BINARY X_NOT_H_R ")",
4233 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4234 {"( 1.3.6.1.4.1.1466.115.121.1.10 DESC 'Certificate Pair' "
4235 X_BINARY X_NOT_H_R ")",
4236 SLAP_SYNTAX_BINARY|SLAP_SYNTAX_BER, berValidate, NULL, NULL},
4237 {"( 1.3.6.1.4.1.1466.115.121.1.11 DESC 'Country String' )",
4238 0, countryStringValidate, IA5StringNormalize, NULL},
4239 {"( 1.3.6.1.4.1.1466.115.121.1.12 DESC 'Distinguished Name' )",
4240 0, dnValidate, dnNormalize, dnPretty},
4241 {"( 1.3.6.1.4.1.1466.115.121.1.13 DESC 'Data Quality' )",
4242 0, NULL, NULL, NULL},
4243 {"( 1.3.6.1.4.1.1466.115.121.1.14 DESC 'Delivery Method' )",
4244 0, NULL, NULL, NULL},
4245 {"( 1.3.6.1.4.1.1466.115.121.1.15 DESC 'Directory String' )",
4246 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4247 {"( 1.3.6.1.4.1.1466.115.121.1.16 DESC 'DIT Content Rule Description' )",
4248 0, NULL, NULL, NULL},
4249 {"( 1.3.6.1.4.1.1466.115.121.1.17 DESC 'DIT Structure Rule Description' )",
4250 0, NULL, NULL, NULL},
4251 {"( 1.3.6.1.4.1.1466.115.121.1.19 DESC 'DSA Quality' )",
4252 0, NULL, NULL, NULL},
4253 {"( 1.3.6.1.4.1.1466.115.121.1.20 DESC 'DSE Type' )",
4254 0, NULL, NULL, NULL},
4255 {"( 1.3.6.1.4.1.1466.115.121.1.21 DESC 'Enhanced Guide' )",
4256 0, NULL, NULL, NULL},
4257 {"( 1.3.6.1.4.1.1466.115.121.1.22 DESC 'Facsimile Telephone Number' )",
4258 0, printablesStringValidate, IA5StringNormalize, NULL},
4259 {"( 1.3.6.1.4.1.1466.115.121.1.23 DESC 'Fax' " X_NOT_H_R ")",
4260 SLAP_SYNTAX_BLOB, NULL, NULL, NULL},
4261 {"( 1.3.6.1.4.1.1466.115.121.1.24 DESC 'Generalized Time' )",
4262 0, generalizedTimeValidate, generalizedTimeNormalize, NULL},
4263 {"( 1.3.6.1.4.1.1466.115.121.1.25 DESC 'Guide' )",
4264 0, NULL, NULL, NULL},
4265 {"( 1.3.6.1.4.1.1466.115.121.1.26 DESC 'IA5 String' )",
4266 0, IA5StringValidate, IA5StringNormalize, NULL},
4267 {"( 1.3.6.1.4.1.1466.115.121.1.27 DESC 'Integer' )",
4268 0, integerValidate, integerNormalize, integerPretty},
4269 {"( 1.3.6.1.4.1.1466.115.121.1.28 DESC 'JPEG' " X_NOT_H_R ")",
4270 SLAP_SYNTAX_BLOB, blobValidate, NULL, NULL},
4271 {"( 1.3.6.1.4.1.1466.115.121.1.29 DESC 'Master And Shadow Access Points' )",
4272 0, NULL, NULL, NULL},
4273 {"( 1.3.6.1.4.1.1466.115.121.1.30 DESC 'Matching Rule Description' )",
4274 0, NULL, NULL, NULL},
4275 {"( 1.3.6.1.4.1.1466.115.121.1.31 DESC 'Matching Rule Use Description' )",
4276 0, NULL, NULL, NULL},
4277 {"( 1.3.6.1.4.1.1466.115.121.1.32 DESC 'Mail Preference' )",
4278 0, NULL, NULL, NULL},
4279 {"( 1.3.6.1.4.1.1466.115.121.1.33 DESC 'MHS OR Address' )",
4280 0, NULL, NULL, NULL},
4281 {"( 1.3.6.1.4.1.1466.115.121.1.34 DESC 'Name And Optional UID' )",
4282 0, nameUIDValidate, nameUIDNormalize, NULL},
4283 {"( 1.3.6.1.4.1.1466.115.121.1.35 DESC 'Name Form Description' )",
4284 0, NULL, NULL, NULL},
4285 {"( 1.3.6.1.4.1.1466.115.121.1.36 DESC 'Numeric String' )",
4286 0, numericStringValidate, numericStringNormalize, NULL},
4287 {"( 1.3.6.1.4.1.1466.115.121.1.37 DESC 'Object Class Description' )",
4288 0, NULL, NULL, NULL},
4289 {"( 1.3.6.1.4.1.1466.115.121.1.38 DESC 'OID' )",
4290 0, oidValidate, NULL, NULL},
4291 {"( 1.3.6.1.4.1.1466.115.121.1.39 DESC 'Other Mailbox' )",
4292 0, IA5StringValidate, IA5StringNormalize, NULL},
4293 {"( 1.3.6.1.4.1.1466.115.121.1.40 DESC 'Octet String' )",
4294 0, blobValidate, NULL, NULL},
4295 {"( 1.3.6.1.4.1.1466.115.121.1.41 DESC 'Postal Address' )",
4296 0, UTF8StringValidate, UTF8StringNormalize, NULL},
4297 {"( 1.3.6.1.4.1.1466.115.121.1.42 DESC 'Protocol Information' )",
4298 0, NULL, NULL, NULL},
4299 {"( 1.3.6.1.4.1.1466.115.121.1.43 DESC 'Presentation Address' )",
4300 0, NULL, NULL, NULL},
4301 {"( 1.3.6.1.4.1.1466.115.121.1.44 DESC 'Printable String' )",
4302 0, printableStringValidate, IA5StringNormalize, NULL},
4303 {"( 1.3.6.1.4.1.1466.115.121.1.49 DESC 'Supported Algorithm' "
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.50 DESC 'Telephone Number' )",
4307 0, printableStringValidate, IA5StringNormalize, NULL},
4308 {"( 1.3.6.1.4.1.1466.115.121.1.51 DESC 'Teletex Terminal Identifier' )",
4309 0, NULL, NULL, NULL},
4310 {"( 1.3.6.1.4.1.1466.115.121.1.52 DESC 'Telex Number' )",
4311 0, printableStringValidate, IA5StringNormalize, NULL},
4312 {"( 1.3.6.1.4.1.1466.115.121.1.53 DESC 'UTC Time' )",
4313 0, utcTimeValidate, utcTimeNormalize, NULL},
4314 {"( 1.3.6.1.4.1.1466.115.121.1.54 DESC 'LDAP Syntax Description' )",
4315 0, NULL, NULL, NULL},
4316 {"( 1.3.6.1.4.1.1466.115.121.1.55 DESC 'Modify Rights' )",
4317 0, NULL, NULL, NULL},
4318 {"( 1.3.6.1.4.1.1466.115.121.1.56 DESC 'LDAP Schema Definition' )",
4319 0, NULL, NULL, NULL},
4320 {"( 1.3.6.1.4.1.1466.115.121.1.57 DESC 'LDAP Schema Description' )",
4321 0, NULL, NULL, NULL},
4322 {"( 1.3.6.1.4.1.1466.115.121.1.58 DESC 'Substring Assertion' )",
4323 0, NULL, NULL, NULL},
4325 /* RFC 2307 NIS Syntaxes */
4326 {"( 1.3.6.1.1.1.0.0 DESC 'RFC2307 NIS Netgroup Triple' )",
4327 0, nisNetgroupTripleValidate, NULL, NULL},
4328 {"( 1.3.6.1.1.1.0.1 DESC 'RFC2307 Boot Parameter' )",
4329 0, bootParameterValidate, NULL, NULL},
4331 /* OpenLDAP Experimental Syntaxes */
4332 {"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
4333 0, IA5StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
4335 {"( 1.3.6.1.4.1.4203.666.2.2 DESC 'OpenLDAP authPassword' )",
4336 0, NULL, NULL, NULL},
4338 /* OpenLDAP Void Syntax */
4339 {"( 1.3.6.1.4.1.4203.1.1.1 DESC 'OpenLDAP void' )" ,
4340 SLAP_SYNTAX_HIDE, inValidate, NULL, NULL},
4341 {NULL, 0, NULL, NULL, NULL}
4344 struct mrule_defs_rec {
4346 slap_mask_t mrd_usage;
4347 slap_mr_convert_func * mrd_convert;
4348 slap_mr_normalize_func * mrd_normalize;
4349 slap_mr_match_func * mrd_match;
4350 slap_mr_indexer_func * mrd_indexer;
4351 slap_mr_filter_func * mrd_filter;
4353 char * mrd_associated;
4357 * Other matching rules in X.520 that we do not use (yet):
4359 * 2.5.13.9 numericStringOrderingMatch
4360 * 2.5.13.15 integerOrderingMatch
4361 * 2.5.13.18 octetStringOrderingMatch
4362 * 2.5.13.19 octetStringSubstringsMatch
4363 * 2.5.13.25 uTCTimeMatch
4364 * 2.5.13.26 uTCTimeOrderingMatch
4365 * 2.5.13.31 directoryStringFirstComponentMatch
4366 * 2.5.13.32 wordMatch
4367 * 2.5.13.33 keywordMatch
4368 * 2.5.13.34 certificateExactMatch
4369 * 2.5.13.35 certificateMatch
4370 * 2.5.13.36 certificatePairExactMatch
4371 * 2.5.13.37 certificatePairMatch
4372 * 2.5.13.38 certificateListExactMatch
4373 * 2.5.13.39 certificateListMatch
4374 * 2.5.13.40 algorithmIdentifierMatch
4375 * 2.5.13.41 storedPrefixMatch
4376 * 2.5.13.42 attributeCertificateMatch
4377 * 2.5.13.43 readerAndKeyIDMatch
4378 * 2.5.13.44 attributeIntegrityMatch
4381 struct mrule_defs_rec mrule_defs[] = {
4383 * EQUALITY matching rules must be listed after associated APPROX
4384 * matching rules. So, we list all APPROX matching rules first.
4386 {"( " directoryStringApproxMatchOID " NAME 'directoryStringApproxMatch' "
4387 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4388 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4390 directoryStringApproxMatch,
4391 directoryStringApproxIndexer,
4392 directoryStringApproxFilter,
4395 {"( " IA5StringApproxMatchOID " NAME 'IA5StringApproxMatch' "
4396 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4397 SLAP_MR_EQUALITY_APPROX | SLAP_MR_EXT,
4399 IA5StringApproxMatch,
4400 IA5StringApproxIndexer,
4401 IA5StringApproxFilter,
4405 * Other matching rules
4408 {"( 2.5.13.0 NAME 'objectIdentifierMatch' "
4409 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4410 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4412 objectIdentifierMatch, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4415 {"( 2.5.13.1 NAME 'distinguishedNameMatch' "
4416 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 )",
4417 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4419 dnMatch, dnIndexer, dnFilter,
4422 {"( 2.5.13.2 NAME 'caseIgnoreMatch' "
4423 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4424 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4426 caseIgnoreMatch, caseIgnoreIndexer, caseIgnoreFilter,
4427 directoryStringApproxMatchOID },
4429 {"( 2.5.13.3 NAME 'caseIgnoreOrderingMatch' "
4430 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4433 caseIgnoreOrderingMatch, NULL, NULL,
4436 {"( 2.5.13.4 NAME 'caseIgnoreSubstringsMatch' "
4437 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4438 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4440 caseIgnoreSubstringsMatch,
4441 caseIgnoreSubstringsIndexer,
4442 caseIgnoreSubstringsFilter,
4445 {"( 2.5.13.5 NAME 'caseExactMatch' "
4446 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4447 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4449 caseExactMatch, caseExactIndexer, caseExactFilter,
4450 directoryStringApproxMatchOID },
4452 {"( 2.5.13.6 NAME 'caseExactOrderingMatch' "
4453 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
4456 caseExactOrderingMatch, NULL, NULL,
4459 {"( 2.5.13.7 NAME 'caseExactSubstringsMatch' "
4460 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4461 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4463 caseExactSubstringsMatch,
4464 caseExactSubstringsIndexer,
4465 caseExactSubstringsFilter,
4468 {"( 2.5.13.8 NAME 'numericStringMatch' "
4469 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.36 )",
4470 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4473 caseIgnoreIA5Indexer,
4474 caseIgnoreIA5Filter,
4477 {"( 2.5.13.10 NAME 'numericStringSubstringsMatch' "
4478 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4479 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4481 caseIgnoreIA5SubstringsMatch,
4482 caseIgnoreIA5SubstringsIndexer,
4483 caseIgnoreIA5SubstringsFilter,
4486 {"( 2.5.13.11 NAME 'caseIgnoreListMatch' "
4487 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.41 )",
4488 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4490 caseIgnoreListMatch, NULL, NULL,
4493 {"( 2.5.13.12 NAME 'caseIgnoreListSubstringsMatch' "
4494 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4495 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4497 caseIgnoreListSubstringsMatch, NULL, NULL,
4500 {"( 2.5.13.13 NAME 'booleanMatch' "
4501 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 )",
4502 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4504 booleanMatch, NULL, NULL,
4507 {"( 2.5.13.14 NAME 'integerMatch' "
4508 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4509 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4511 integerMatch, integerIndexer, integerFilter,
4514 {"( 2.5.13.16 NAME 'bitStringMatch' "
4515 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.6 )",
4516 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4518 bitStringMatch, NULL, NULL,
4521 {"( 2.5.13.17 NAME 'octetStringMatch' "
4522 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4523 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4525 octetStringMatch, octetStringIndexer, octetStringFilter,
4528 {"( 2.5.13.20 NAME 'telephoneNumberMatch' "
4529 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.50 )",
4530 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4532 telephoneNumberMatch, NULL, NULL,
4535 {"( 2.5.13.21 NAME 'telephoneNumberSubstringsMatch' "
4536 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.58 )",
4537 SLAP_MR_SUBSTR | SLAP_MR_EXT,
4539 telephoneNumberSubstringsMatch, NULL, NULL,
4542 {"( 2.5.13.22 NAME 'presentationAddressMatch' "
4543 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.43 )",
4544 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4546 presentationAddressMatch, NULL, NULL,
4549 {"( 2.5.13.23 NAME 'uniqueMemberMatch' "
4550 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.34 )",
4551 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4553 uniqueMemberMatch, NULL, NULL,
4556 {"( 2.5.13.24 NAME 'protocolInformationMatch' "
4557 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.42 )",
4558 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4560 protocolInformationMatch, NULL, NULL,
4563 {"( 2.5.13.27 NAME 'generalizedTimeMatch' "
4564 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4565 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4567 generalizedTimeMatch, NULL, NULL,
4570 {"( 2.5.13.28 NAME 'generalizedTimeOrderingMatch' "
4571 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 )",
4574 generalizedTimeOrderingMatch, NULL, NULL,
4577 {"( 2.5.13.29 NAME 'integerFirstComponentMatch' "
4578 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
4579 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4581 integerFirstComponentMatch, NULL, NULL,
4584 {"( 2.5.13.30 NAME 'objectIdentifierFirstComponentMatch' "
4585 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 )",
4586 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4588 objectIdentifierFirstComponentMatch, NULL, NULL,
4591 {"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' "
4592 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4593 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4595 caseExactIA5Match, caseExactIA5Indexer, caseExactIA5Filter,
4596 IA5StringApproxMatchOID },
4598 {"( 1.3.6.1.4.1.1466.109.114.2 NAME 'caseIgnoreIA5Match' "
4599 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4600 SLAP_MR_EQUALITY | SLAP_MR_EXT,
4602 caseIgnoreIA5Match, caseIgnoreIA5Indexer, caseIgnoreIA5Filter,
4603 IA5StringApproxMatchOID },
4605 {"( 1.3.6.1.4.1.1466.109.114.3 NAME 'caseIgnoreIA5SubstringsMatch' "
4606 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4609 caseIgnoreIA5SubstringsMatch,
4610 caseIgnoreIA5SubstringsIndexer,
4611 caseIgnoreIA5SubstringsFilter,
4614 {"( 1.3.6.1.4.1.4203.1.2.1 NAME 'caseExactIA5SubstringsMatch' "
4615 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
4618 caseExactIA5SubstringsMatch,
4619 caseExactIA5SubstringsIndexer,
4620 caseExactIA5SubstringsFilter,
4623 {"( 1.3.6.1.4.1.4203.666.4.1 NAME 'authPasswordMatch' "
4624 "SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 )",
4627 authPasswordMatch, NULL, NULL,
4630 {"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
4631 "SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
4634 OpenLDAPaciMatch, NULL, NULL,
4637 {NULL, SLAP_MR_NONE, NULL, NULL, NULL, NULL}
4646 /* we should only be called once (from main) */
4647 assert( schema_init_done == 0 );
4649 for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
4650 res = register_syntax( syntax_defs[i].sd_desc,
4651 syntax_defs[i].sd_flags,
4652 syntax_defs[i].sd_validate,
4653 syntax_defs[i].sd_normalize,
4654 syntax_defs[i].sd_pretty
4655 #ifdef SLAPD_BINARY_CONVERSION
4657 syntax_defs[i].sd_ber2str,
4658 syntax_defs[i].sd_str2ber
4663 fprintf( stderr, "schema_init: Error registering syntax %s\n",
4664 syntax_defs[i].sd_desc );
4669 for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
4670 if( mrule_defs[i].mrd_usage == SLAP_MR_NONE ) {
4672 "schema_init: Ingoring unusable matching rule %s\n",
4673 mrule_defs[i].mrd_desc );
4677 res = register_matching_rule(
4678 mrule_defs[i].mrd_desc,
4679 mrule_defs[i].mrd_usage,
4680 mrule_defs[i].mrd_convert,
4681 mrule_defs[i].mrd_normalize,
4682 mrule_defs[i].mrd_match,
4683 mrule_defs[i].mrd_indexer,
4684 mrule_defs[i].mrd_filter,
4685 mrule_defs[i].mrd_associated );
4689 "schema_init: Error registering matching rule %s\n",
4690 mrule_defs[i].mrd_desc );
4694 schema_init_done = 1;
4695 return LDAP_SUCCESS;