#include "portable.h"
#include <stdio.h>
+#include <limits.h>
#include <ac/ctype.h>
+#include <ac/errno.h>
#include <ac/string.h>
#include <ac/socket.h>
/* recycled matching routines */
#define bitStringMatch octetStringMatch
-#define integerMatch caseIgnoreIA5Match
#define numericStringMatch caseIgnoreIA5Match
#define objectIdentifierMatch caseIgnoreIA5Match
#define telephoneNumberMatch caseIgnoreIA5Match
/* recycled indexing/filtering routines */
#define dnIndexer caseExactIgnoreIndexer
#define dnFilter caseExactIgnoreFilter
-#define integerIndexer caseIgnoreIA5Indexer
-#define integerFilter caseIgnoreIA5Filter
#define telephoneNumberIndexer caseIgnoreIA5Indexer
#define telephoneNumberFilter caseIgnoreIA5Filter
return LDAP_INVALID_SYNTAX;
}
+static int
+integerMatch(
+ int *matchp,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *value,
+ void *assertedValue )
+{
+ char *v, *av;
+ int vsign=0, avsign=0;
+ struct berval *asserted;
+ ber_len_t vlen, avlen;
+
+
+ /* Start off pessimistic */
+ *matchp = 1;
+
+ /* Skip past leading spaces/zeros, and get the sign of the *value number */
+ v = value->bv_val;
+ vlen = value->bv_len;
+ while( vlen ) {
+ if( ASCII_SPACE(*v) || ( *v == '0' )) {
+ /* empty -- skip spaces */
+ }
+ else if ( *v == '+' ) {
+ vsign = 1;
+ }
+ else if ( *v == '-' ) {
+ vsign = -1;
+ }
+ else if ( ASCII_DIGIT(*v) ) {
+ if ( vsign == 0 ) vsign = 1;
+ vsign *= 2;
+ break;
+ }
+ v++;
+ vlen--;
+ }
+
+ /* Skip past leading spaces/zeros, and get the sign of the *assertedValue
+ number */
+ asserted = (struct berval *) assertedValue;
+ av = asserted->bv_val;
+ avlen = asserted->bv_len;
+ while( avlen ) {
+ if( ASCII_SPACE(*av) || ( *av == '0' )) {
+ /* empty -- skip spaces */
+ }
+ else if ( *av == '+' ) {
+ avsign = 1;
+ }
+ else if ( *av == '-' ) {
+ avsign = -1;
+ }
+ else if ( ASCII_DIGIT(*av) ) {
+ if ( avsign == 0 ) avsign = 1;
+ avsign *= 2;
+ break;
+ }
+ av++;
+ avlen--;
+ }
+
+ /* The two ?sign vars are now one of :
+ -2 negative non-zero number
+ -1 -0 \
+ 0 0 collapse these three to 0
+ +1 +0 /
+ +2 positive non-zero number
+ */
+ if ( abs( vsign ) == 1 ) vsign = 0;
+ if ( abs( avsign ) == 1 ) avsign = 0;
+
+ if( vsign != avsign ) return LDAP_SUCCESS;
+
+ /* Check the significant digits */
+ while( vlen && avlen ) {
+ if( *v != *av ) break;
+ v++;
+ vlen--;
+ av++;
+ avlen--;
+ }
+
+ /* If all digits compared equal, the numbers are equal */
+ if(( vlen == 0 ) && ( avlen == 0 )) {
+ *matchp = 0;
+ }
+ return LDAP_SUCCESS;
+}
+
static int
integerValidate(
Syntax *syntax,
if( !val->bv_len ) return LDAP_INVALID_SYNTAX;
- if( val->bv_val[0] == '+' || val->bv_val[0] == '-' ) {
+ if(( val->bv_val[0] == '+' ) || ( val->bv_val[0] == '-' )) {
if( val->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
} else if( !ASCII_DIGIT(val->bv_val[0]) ) {
return LDAP_INVALID_SYNTAX;
}
- for(i=1; i < val->bv_len; i++) {
+ for( i=1; i < val->bv_len; i++ ) {
if( !ASCII_DIGIT(val->bv_val[i]) ) return LDAP_INVALID_SYNTAX;
}
struct berval *val,
struct berval **normalized )
{
- int negative;
- struct berval *newval;
char *p;
+ int negative=0;
+ struct berval *newval;
+ ber_len_t len;
+
p = val->bv_val;
+ len = val->bv_len;
+
+ /* Ignore leading spaces */
+ while ( len && ( *p == ' ' )) {
+ p++;
+ len--;
+ }
/* save sign */
- negative = ( *p == '-' );
- if( *p == '-' || *p == '+' ) p++;
+ if( len ) {
+ negative = ( *p == '-' );
+ if(( *p == '-' ) || ( *p == '+' )) {
+ p++;
+ len--;
+ }
+ }
/* Ignore leading zeros */
- while ( *p == '0' ) p++;
+ while ( len && ( *p == '0' )) {
+ p++;
+ len--;
+ }
newval = (struct berval *) ch_malloc( sizeof(struct berval) );
- if( *p == '\0' ) {
+ /* If there are no non-zero digits left, the number is zero, otherwise
+ allocate space for the number and copy it into the buffer */
+ if( len == 0 ) {
newval->bv_val = ch_strdup("0");
newval->bv_len = 1;
- goto done;
+ }
+ else {
+ newval->bv_len = len+negative;
+ newval->bv_val = ch_malloc( newval->bv_len );
+ if( negative ) {
+ newval->bv_val[0] = '-';
+ }
+ memcpy( newval->bv_val + negative, p, len );
}
- newval->bv_val = ch_malloc( val->bv_len + 1 );
- newval->bv_len = 0;
+ *normalized = newval;
+ return LDAP_SUCCESS;
+}
+
+/* Index generation function */
+int integerIndexer(
+ slap_mask_t use,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *prefix,
+ struct berval **values,
+ struct berval ***keysp )
+{
+ int i;
+ struct berval **keys;
+
+ /* we should have at least one value at this point */
+ assert( values != NULL && values[0] != NULL );
- if( negative ) {
- newval->bv_val[newval->bv_len++] = '-';
+ for( i=0; values[i] != NULL; i++ ) {
+ /* empty -- just count them */
}
- for( ; *p != '\0'; p++ ) {
- newval->bv_val[newval->bv_len++] = *p;
+ keys = ch_malloc( sizeof( struct berval * ) * (i+1) );
+
+ for( i=0; values[i] != NULL; i++ ) {
+ integerNormalize( syntax, values[i], &keys[i] );
}
-done:
- *normalized = newval;
+ keys[i] = NULL;
+ *keysp = keys;
+ return LDAP_SUCCESS;
+}
+
+/* Index generation function */
+int integerFilter(
+ slap_mask_t use,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *prefix,
+ void * assertValue,
+ struct berval ***keysp )
+{
+ struct berval **keys;
+
+ keys = ch_malloc( sizeof( struct berval * ) * 2 );
+ integerNormalize( syntax, assertValue, &keys[0] );
+ keys[1] = NULL;
+ *keysp = keys;
+
return LDAP_SUCCESS;
}
+
static int
countryStringValidate(
Syntax *syntax,
return rc;
}
+static int
+integerBitAndMatch(
+ int *matchp,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *value,
+ void *assertedValue )
+{
+ long lValue, lAssertedValue;
+
+ /* safe to assume integers are NUL terminated? */
+ lValue = strtoul(value->bv_val, NULL, 10);
+ if(( lValue == LONG_MIN || lValue == LONG_MAX) && errno == ERANGE )
+ return LDAP_CONSTRAINT_VIOLATION;
+
+ lAssertedValue = strtol(((struct berval *)assertedValue)->bv_val, NULL, 10);
+ if(( lAssertedValue == LONG_MIN || lAssertedValue == LONG_MAX) && errno == ERANGE )
+ return LDAP_CONSTRAINT_VIOLATION;
+
+ *matchp = (lValue & lAssertedValue);
+ return LDAP_SUCCESS;
+}
+
+static int
+integerBitOrMatch(
+ int *matchp,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *value,
+ void *assertedValue )
+{
+ long lValue, lAssertedValue;
+
+ /* safe to assume integers are NUL terminated? */
+ lValue = strtoul(value->bv_val, NULL, 10);
+ if(( lValue == LONG_MIN || lValue == LONG_MAX) && errno == ERANGE )
+ return LDAP_CONSTRAINT_VIOLATION;
+
+ lAssertedValue = strtol(((struct berval *)assertedValue)->bv_val, NULL, 10);
+ if(( lAssertedValue == LONG_MIN || lAssertedValue == LONG_MAX) && errno == ERANGE )
+ return LDAP_CONSTRAINT_VIOLATION;
+
+ *matchp = (lValue | lAssertedValue);
+ return LDAP_SUCCESS;
+}
+
+#ifdef HAVE_TLS
+#include <openssl/x509.h>
+#include <openssl/err.h>
+char digit[] = "0123456789";
+
+/*
+ * Next function returns a string representation of a ASN1_INTEGER.
+ * It works for unlimited lengths.
+ */
+
+static struct berval *
+asn1_integer2str(ASN1_INTEGER *a)
+{
+ char buf[256];
+ char *p;
+
+ /* We work backwards, make it fill from the end of buf */
+ p = buf + sizeof(buf) - 1;
+ *p = '\0';
+
+ if ( a == NULL || a->length == 0 ) {
+ *--p = '0';
+ } else {
+ int i;
+ int n = a->length;
+ int base = 0;
+ unsigned int *copy;
+
+ /* We want to preserve the original */
+ copy = ch_malloc(n*sizeof(unsigned int));
+ for (i = 0; i<n; i++) {
+ copy[i] = a->data[i];
+ }
+
+ /*
+ * base indicates the index of the most significant
+ * byte that might be nonzero. When it goes off the
+ * end, we now there is nothing left to do.
+ */
+ while (base < n) {
+ unsigned int carry;
+ unsigned int temp;
+
+ carry = 0;
+ for (i = base; i<n; i++ ) {
+ copy[i] += carry*256;
+ carry = copy[i] % 10;
+ copy[i] /= 10;
+ }
+ if (p <= buf+1) {
+ /*
+ * Way too large, we need to leave
+ * room for sign if negative
+ */
+ return NULL;
+ }
+ *--p = digit[carry];
+ if (copy[base] == 0)
+ base++;
+ }
+ free(copy);
+ }
+
+ if ( a->type == V_ASN1_NEG_INTEGER ) {
+ *--p = '-';
+ }
+
+ return ber_bvstrdup(p);
+}
+
+static struct berval *
+dn_openssl2ldap(X509_NAME *name)
+{
+ char issuer_dn[1024];
+ BIO *bio;
+
+ bio = BIO_new(BIO_s_mem());
+ if ( !bio ) {
+ fprintf(stderr, ERR_error_string(ERR_get_error(),NULL));
+ /* ERR_print_errors(bio_err); */
+ return NULL;
+ }
+ X509_NAME_print_ex(bio, name, 0, XN_FLAG_RFC2253);
+
+ BIO_gets(bio, issuer_dn, 1024);
+
+ BIO_free(bio);
+ return ber_bvstrdup(issuer_dn);
+}
+
+static int
+serial_and_issuer_parse(
+ struct berval *assertion,
+ struct berval **serial,
+ struct berval **issuer_dn
+)
+{
+ char *begin;
+ char *end;
+ char *p;
+ char *q;
+
+ begin = assertion->bv_val;
+ end = assertion->bv_val+assertion->bv_len-1;
+ for (p=begin; p<=end && *p != '$'; p++)
+ ;
+ if ( p > end )
+ return LDAP_INVALID_SYNTAX;
+
+ /* p now points at the $ sign, now use begin and end to delimit the
+ serial number */
+ while (ASCII_SPACE(*begin++))
+ ;
+ end = p;
+ while (ASCII_SPACE(*end--))
+ ;
+
+ q = ch_malloc( (end-begin+1)+1 );
+ AC_MEMCPY( q, begin, end-begin+1 );
+ q[end-begin+1] = '\0';
+ *serial = ber_bvstr(q);
+
+ /* now extract the issuer, remember p was at the dollar sign */
+ begin = p+1;
+ end = assertion->bv_val+assertion->bv_len-1;
+ while (ASCII_SPACE(*begin++))
+ ;
+ /* should we trim spaces at the end too? is it safe always? */
+
+ q = ch_malloc( (end-begin+1)+1 );
+ AC_MEMCPY( q, begin, end-begin+1 );
+ q[end-begin+1] = '\0';
+ *issuer_dn = ber_bvstr(q);
+
+ return LDAP_SUCCESS;
+}
+
+static int
+certificateExactMatch(
+ int *matchp,
+ slap_mask_t flags,
+ Syntax *syntax,
+ MatchingRule *mr,
+ struct berval *value,
+ void *assertedValue )
+{
+ X509 *xcert;
+ unsigned char *p = value->bv_val;
+ struct berval *serial;
+ struct berval *issuer_dn;
+ struct berval *asserted_serial;
+ struct berval *asserted_issuer_dn;
+ int ret;
+
+ xcert = d2i_X509(NULL, &p, value->bv_len);
+ if ( !xcert ) {
+ ERR_error_string(ERR_get_error(),NULL);
+ }
+
+ serial = asn1_integer2str(xcert->cert_info->serialNumber);
+ issuer_dn = dn_openssl2ldap(X509_get_issuer_name(xcert));
+
+ X509_free(xcert);
+
+ serial_and_issuer_parse(assertedValue,
+ &asserted_serial,
+ &asserted_issuer_dn);
+
+ ret = integerMatch(
+ matchp,
+ flags,
+ slap_schema.si_syn_integer,
+ slap_schema.si_mr_integerMatch,
+ serial,
+ asserted_serial);
+ if ( ret == LDAP_SUCCESS ) {
+ if ( *matchp == 0 ) {
+ ret = dnMatch(
+ matchp,
+ flags,
+ slap_schema.si_syn_distinguishedName,
+ slap_schema.si_mr_distinguishedNameMatch,
+ issuer_dn,
+ asserted_issuer_dn);
+ }
+ }
+
+ ber_bvfree(serial);
+ ber_bvfree(issuer_dn);
+ ber_bvfree(asserted_serial);
+ ber_bvfree(asserted_issuer_dn);
+
+ return ret;
+}
+#endif
+
static int
check_time_syntax (struct berval *val,
int start,
{"( 1.3.6.1.1.1.0.1 DESC 'RFC2307 Boot Parameter' )",
0, bootParameterValidate, NULL, NULL},
+#ifdef HAVE_TLS
+ /* From PKIX */
+ /* These OIDs are not published yet, but will be in the next
+ * I-D for PKIX LDAPv3 schema as have been advanced by David
+ * Chadwick in private mail.
+ */
+ {"( 1.2.826.0.1.3344810.7.1 DESC 'Serial Number and Issuer' )",
+ 0, NULL, NULL, NULL},
+#endif
+
/* OpenLDAP Experimental Syntaxes */
{"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
0, UTF8StringValidate /* THIS WILL CHANGE FOR NEW ACI SYNTAX */,
* 2.5.13.31 directoryStringFirstComponentMatch
* 2.5.13.32 wordMatch
* 2.5.13.33 keywordMatch
- * 2.5.13.34 certificateExactMatch
* 2.5.13.35 certificateMatch
* 2.5.13.36 certificatePairExactMatch
* 2.5.13.37 certificatePairMatch
objectIdentifierFirstComponentMatch, NULL, NULL,
NULL},
+#ifdef HAVE_TLS
+ {"( 2.5.13.34 NAME 'certificateExactMatch' "
+ "SYNTAX 1.2.826.0.1.3344810.7.1 )",
+ SLAP_MR_EQUALITY | SLAP_MR_EXT,
+ NULL, NULL,
+ certificateExactMatch, NULL, NULL,
+ NULL},
+#endif
+
{"( 1.3.6.1.4.1.1466.109.114.1 NAME 'caseExactIA5Match' "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.26 )",
SLAP_MR_EQUALITY | SLAP_MR_EXT,
OpenLDAPaciMatch, NULL, NULL,
NULL},
+ {"( 1.2.840.113556.1.4.803 NAME 'integerBitAndMatch' "
+ "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
+ SLAP_MR_EXT,
+ NULL, NULL,
+ integerBitAndMatch, NULL, NULL,
+ NULL},
+
+ {"( 1.2.840.113556.1.4.804 NAME 'integerBitOrMatch' "
+ "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 )",
+ SLAP_MR_EXT,
+ NULL, NULL,
+ integerBitOrMatch, NULL, NULL,
+ NULL},
+
{NULL, SLAP_MR_NONE, NULL, NULL, NULL, NULL}
};
projects / openldap / blobdiff