Back to index

openldap  2.4.31
Defines | Enumerations | Functions | Variables
schema_init.c File Reference
#include "portable.h"
#include <stdio.h>
#include <ac/ctype.h>
#include <ac/errno.h>
#include <ac/string.h>
#include <ac/socket.h>
#include "slap.h"
#include "../../libraries/liblber/lber-int.h"
#include "ldap_utf8.h"
#include "lutil.h"
#include "lutil_hash.h"

Go to the source code of this file.

Defines

#define HASH_BYTES   LUTIL_HASH_BYTES
#define HASH_CONTEXT   lutil_HASH_CTX
#define HASH_Init(c)   lutil_HASHInit(c)
#define HASH_Update(c, buf, len)   lutil_HASHUpdate(c,buf,len)
#define HASH_Final(d, c)   lutil_HASHFinal(d,c)
#define directoryStringApproxMatchOID   "1.3.6.1.4.1.4203.666.4.4"
#define directoryStringApproxMatch   approxMatch
#define directoryStringApproxIndexer   approxIndexer
#define directoryStringApproxFilter   approxFilter
#define IA5StringApproxMatchOID   "1.3.6.1.4.1.4203.666.4.5"
#define IA5StringApproxMatch   approxMatch
#define IA5StringApproxIndexer   approxIndexer
#define IA5StringApproxFilter   approxFilter
#define csnMatch   octetStringMatch
#define csnOrderingMatch   octetStringOrderingMatch
#define csnIndexer   generalizedTimeIndexer
#define csnFilter   generalizedTimeFilter
#define authzMatch   octetStringMatch
#define X509_PMI_SyntaxOID   "1.3.6.1.4.1.4203.666.11.10.2"
#define attributeCertificateSyntaxOID   X509_PMI_SyntaxOID ".1"
#define attributeCertificateExactAssertionSyntaxOID   X509_PMI_SyntaxOID ".2"
#define attributeCertificateAssertionSyntaxOID   X509_PMI_SyntaxOID ".3"
#define berValidate   blobValidate
#define SLAP_X509_OPTION   (LBER_CLASS_CONTEXT|LBER_CONSTRUCTED)
#define SLAPD_APPROX_DELIMITER   " "
#define SLAPD_APPROX_WORDLEN   1
#define INDEX_INTLEN_CHOP   7
#define INDEX_INTLEN_CHOPBYTES   3
#define SLAP_STRTOL(n, e, b)   strtol(n,e,b)
#define SLAP_LONG   long
#define SLAP_SN_BUFLEN   (64)
#define check_time_syntax(v, start, p, f)   (check_time_syntax)(v, p, f)
#define LENOF(s)   (sizeof(s)-1)
#define X_BINARY   "X-BINARY-TRANSFER-REQUIRED 'TRUE' "
#define X_NOT_H_R   "X-NOT-HUMAN-READABLE 'TRUE' "
#define subtreeSpecificationValidate   UTF8StringValidate /* FIXME */

Enumerations

enum  { SLAP_X509_V1 = 0, SLAP_X509_V2 = 1, SLAP_X509_V3 = 2 }
enum  { SLAP_TAG_UTCTIME = 0x17U, SLAP_TAG_GENERALIZEDTIME = 0x18U }
enum  { SLAP_X509_OPT_C_VERSION = SLAP_X509_OPTION + 0, SLAP_X509_OPT_C_ISSUERUNIQUEID = LBER_CLASS_CONTEXT + 1, SLAP_X509_OPT_C_SUBJECTUNIQUEID = LBER_CLASS_CONTEXT + 2, SLAP_X509_OPT_C_EXTENSIONS = SLAP_X509_OPTION + 3 }
enum  { SLAP_X509_OPT_CL_CRLEXTENSIONS = SLAP_X509_OPTION + 0 }
enum  {
  SLAP_X509_GN_OTHERNAME = SLAP_X509_OPTION + 0, SLAP_X509_GN_RFC822NAME = SLAP_X509_OPTION + 1, SLAP_X509_GN_DNSNAME = SLAP_X509_OPTION + 2, SLAP_X509_GN_X400ADDRESS = SLAP_X509_OPTION + 3,
  SLAP_X509_GN_DIRECTORYNAME = SLAP_X509_OPTION + 4, SLAP_X509_GN_EDIPARTYNAME = SLAP_X509_OPTION + 5, SLAP_X509_GN_URI = SLAP_X509_OPTION + 6, SLAP_X509_GN_IPADDRESS = SLAP_X509_OPTION + 7,
  SLAP_X509_GN_REGISTEREDID = SLAP_X509_OPTION + 8
}
enum  { SLAP_X509AC_V1 = 0, SLAP_X509AC_V2 = 1 }
enum  { SLAP_X509AC_ISSUER = SLAP_X509_OPTION + 0 }
enum  { start = 0 }

Functions

static int generalizedTimeValidate (Syntax *syntax, struct berval *in)
static int inValidate (Syntax *syntax, struct berval *in)
static int blobValidate (Syntax *syntax, struct berval *in)
static int sequenceValidate (Syntax *syntax, struct berval *in)
static int certificateValidate (Syntax *syntax, struct berval *in)
static int checkTime (struct berval *in, struct berval *out)
static int certificateListValidate (Syntax *syntax, struct berval *in)
static int attributeCertificateValidate (Syntax *syntax, struct berval *in)
int octetStringMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
int octetStringOrderingMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static void hashPreset (HASH_CONTEXT *HASHcontext, struct berval *prefix, char pre, Syntax *syntax, MatchingRule *mr)
static void hashIter (HASH_CONTEXT *HASHcontext, unsigned char *HASHdigest, unsigned char *value, int len)
int octetStringIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
int octetStringFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int octetStringSubstringsMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int octetStringSubstringsIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
static int octetStringSubstringsFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int bitStringValidate (Syntax *syntax, struct berval *in)
static int nameUIDValidate (Syntax *syntax, struct berval *in)
int nameUIDPretty (Syntax *syntax, struct berval *val, struct berval *out, void *ctx)
static int uniqueMemberNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int uniqueMemberMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int uniqueMemberIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
static int uniqueMemberFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int booleanValidate (Syntax *syntax, struct berval *in)
static int booleanMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int UTF8StringValidate (Syntax *syntax, struct berval *in)
static int UTF8StringNormalize (slap_mask_t use, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int directoryStringSubstringsMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int approxMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int approxIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
static int approxFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int telephoneNumberNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int postalAddressValidate (Syntax *syntax, struct berval *in)
static int postalAddressNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
int numericoidValidate (Syntax *syntax, struct berval *in)
static int integerValidate (Syntax *syntax, struct berval *in)
static int integerMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int integerVal2Key (struct berval *in, struct berval *key, struct berval *tmp, void *ctx)
static int integerIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
static int integerFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int countryStringValidate (Syntax *syntax, struct berval *val)
static int printableStringValidate (Syntax *syntax, struct berval *val)
static int printablesStringValidate (Syntax *syntax, struct berval *val)
static int IA5StringValidate (Syntax *syntax, struct berval *val)
static int IA5StringNormalize (slap_mask_t use, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int UUIDValidate (Syntax *syntax, struct berval *in)
static int UUIDPretty (Syntax *syntax, struct berval *in, struct berval *out, void *ctx)
int UUIDNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
int numericStringValidate (Syntax *syntax, struct berval *in)
static int numericStringNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int integerBitAndMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int integerBitOrMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
static int checkNum (struct berval *in, struct berval *out)
static int serialNumberAndIssuerCheck (struct berval *in, struct berval *sn, struct berval *is, void *ctx)
static int serialNumberAndIssuerValidate (Syntax *syntax, struct berval *in)
static int serialNumberAndIssuerPretty (Syntax *syntax, struct berval *in, struct berval *out, void *ctx)
static int slap_bin2hex (struct berval *in, struct berval *out, void *ctx)
static int serialNumberAndIssuerNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *in, struct berval *out, void *ctx)
static int certificateExactNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int issuerAndThisUpdateCheck (struct berval *in, struct berval *is, struct berval *tu, void *ctx)
static int issuerAndThisUpdateValidate (Syntax *syntax, struct berval *in)
static int issuerAndThisUpdatePretty (Syntax *syntax, struct berval *in, struct berval *out, void *ctx)
static int issuerAndThisUpdateNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *in, struct berval *out, void *ctx)
static int certificateListExactNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int serialNumberAndIssuerSerialCheck (struct berval *in, struct berval *sn, struct berval *is, struct berval *i_sn, void *ctx)
static int serialNumberAndIssuerSerialValidate (Syntax *syntax, struct berval *in)
static int serialNumberAndIssuerSerialPretty (Syntax *syntax, struct berval *in, struct berval *out, void *ctx)
static int serialNumberAndIssuerSerialNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *in, struct berval *out, void *ctx)
static int attributeCertificateExactNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int hexValidate (Syntax *syntax, struct berval *in)
static int hexNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int sidValidate (Syntax *syntax, struct berval *in)
static int sidNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int sidPretty (Syntax *syntax, struct berval *val, struct berval *out, void *ctx)
static int csnSidNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int csnValidate (Syntax *syntax, struct berval *in)
static int csnNormalize21 (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int csnNormalize23 (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int csnNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int csnPretty (Syntax *syntax, struct berval *val, struct berval *out, void *ctx)
static int check_time_syntax (struct berval *val, int start, int *parts, struct berval *fraction)
static int generalizedTimeNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
static int generalizedTimeOrderingMatch (int *matchp, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *value, void *assertedValue)
int generalizedTimeIndexer (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, BerVarray values, BerVarray *keysp, void *ctx)
int generalizedTimeFilter (slap_mask_t use, slap_mask_t flags, Syntax *syntax, MatchingRule *mr, struct berval *prefix, void *assertedValue, BerVarray *keysp, void *ctx)
static int deliveryMethodValidate (Syntax *syntax, struct berval *val)
static int nisNetgroupTripleValidate (Syntax *syntax, struct berval *val)
static int bootParameterValidate (Syntax *syntax, struct berval *val)
static int firstComponentNormalize (slap_mask_t usage, Syntax *syntax, MatchingRule *mr, struct berval *val, struct berval *normalized, void *ctx)
int slap_schema_init (void)
void schema_destroy (void)

Variables

unsigned int index_substr_if_minlen = SLAP_INDEX_SUBSTR_IF_MINLEN_DEFAULT
unsigned int index_substr_if_maxlen = SLAP_INDEX_SUBSTR_IF_MAXLEN_DEFAULT
unsigned int index_substr_any_len = SLAP_INDEX_SUBSTR_ANY_LEN_DEFAULT
unsigned int index_substr_any_step = SLAP_INDEX_SUBSTR_ANY_STEP_DEFAULT
unsigned int index_intlen = SLAP_INDEX_INTLEN_DEFAULT
unsigned int index_intlen_strlen
ldap_pvt_thread_mutex_t ad_index_mutex
ldap_pvt_thread_mutex_t ad_undef_mutex
ldap_pvt_thread_mutex_t oc_undef_mutex
static char * country_gen_syn []
static slap_syntax_defs_rec syntax_defs []
char * csnSIDMatchSyntaxes []
char * certificateExactMatchSyntaxes []
char * certificateListExactMatchSyntaxes []
char * attributeCertificateExactMatchSyntaxes []
char * directoryStringSyntaxes []
char * integerFirstComponentMatchSyntaxes []
char * objectIdentifierFirstComponentMatchSyntaxes []
static slap_mrule_defs_rec mrule_defs []

Define Documentation

Definition at line 155 of file schema_init.c.

Definition at line 154 of file schema_init.c.

Definition at line 153 of file schema_init.c.

Definition at line 130 of file schema_init.c.

#define berValidate   blobValidate

Definition at line 201 of file schema_init.c.

#define check_time_syntax (   v,
  start,
  p,
  f 
)    (check_time_syntax)(v, p, f)

Definition at line 5423 of file schema_init.c.

Definition at line 128 of file schema_init.c.

Definition at line 127 of file schema_init.c.

#define csnMatch   octetStringMatch

Definition at line 125 of file schema_init.c.

Definition at line 126 of file schema_init.c.

Definition at line 118 of file schema_init.c.

Definition at line 117 of file schema_init.c.

Definition at line 116 of file schema_init.c.

#define directoryStringApproxMatchOID   "1.3.6.1.4.1.4203.666.4.4"

Definition at line 115 of file schema_init.c.

Definition at line 108 of file schema_init.c.

#define HASH_CONTEXT   lutil_HASH_CTX

Definition at line 109 of file schema_init.c.

#define HASH_Final (   d,
  c 
)    lutil_HASHFinal(d,c)

Definition at line 112 of file schema_init.c.

#define HASH_Init (   c)    lutil_HASHInit(c)

Definition at line 110 of file schema_init.c.

#define HASH_Update (   c,
  buf,
  len 
)    lutil_HASHUpdate(c,buf,len)

Definition at line 111 of file schema_init.c.

Definition at line 122 of file schema_init.c.

Definition at line 121 of file schema_init.c.

Definition at line 120 of file schema_init.c.

#define IA5StringApproxMatchOID   "1.3.6.1.4.1.4203.666.4.5"

Definition at line 119 of file schema_init.c.

#define INDEX_INTLEN_CHOP   7

Definition at line 2515 of file schema_init.c.

#define INDEX_INTLEN_CHOPBYTES   3

Definition at line 2516 of file schema_init.c.

#define LENOF (   s)    (sizeof(s)-1)
#define SLAP_LONG   long

Definition at line 3058 of file schema_init.c.

#define SLAP_SN_BUFLEN   (64)

Definition at line 3519 of file schema_init.c.

#define SLAP_STRTOL (   n,
  e,
  b 
)    strtol(n,e,b)

Definition at line 3057 of file schema_init.c.

Definition at line 228 of file schema_init.c.

#define SLAPD_APPROX_DELIMITER   " "

Definition at line 2002 of file schema_init.c.

#define SLAPD_APPROX_WORDLEN   1

Definition at line 2003 of file schema_init.c.

#define X509_PMI_SyntaxOID   "1.3.6.1.4.1.4203.666.11.10.2"

Definition at line 152 of file schema_init.c.

#define X_BINARY   "X-BINARY-TRANSFER-REQUIRED 'TRUE' "

Definition at line 6112 of file schema_init.c.

#define X_NOT_H_R   "X-NOT-HUMAN-READABLE 'TRUE' "

Definition at line 6113 of file schema_init.c.


Enumeration Type Documentation

anonymous enum
Enumerator:
SLAP_X509_V1 
SLAP_X509_V2 
SLAP_X509_V3 

Definition at line 216 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_TAG_UTCTIME 
SLAP_TAG_GENERALIZEDTIME 

Definition at line 222 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_X509_OPT_C_VERSION 
SLAP_X509_OPT_C_ISSUERUNIQUEID 
SLAP_X509_OPT_C_SUBJECTUNIQUEID 
SLAP_X509_OPT_C_EXTENSIONS 

Definition at line 230 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_X509_OPT_CL_CRLEXTENSIONS 

Definition at line 237 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_X509_GN_OTHERNAME 
SLAP_X509_GN_RFC822NAME 
SLAP_X509_GN_DNSNAME 
SLAP_X509_GN_X400ADDRESS 
SLAP_X509_GN_DIRECTORYNAME 
SLAP_X509_GN_EDIPARTYNAME 
SLAP_X509_GN_URI 
SLAP_X509_GN_IPADDRESS 
SLAP_X509_GN_REGISTEREDID 

Definition at line 253 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_X509AC_V1 
SLAP_X509AC_V2 

Definition at line 266 of file schema_init.c.

anonymous enum
Enumerator:
SLAP_X509AC_ISSUER 

Definition at line 271 of file schema_init.c.

anonymous enum
Enumerator:
start 

Definition at line 5424 of file schema_init.c.

{ start = 0 };

Function Documentation

static int approxFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
) [static]

Definition at line 2175 of file schema_init.c.

{
       char *c;
       int i, count, len;
       struct berval *val;
       BerVarray keys;

       /* Yes, this is necessary */
       val = UTF8bvnormalize( ((struct berval *)assertedValue),
              NULL, LDAP_UTF8_APPROX, NULL );
       if( val == NULL || BER_BVISNULL( val ) ) {
              keys = (struct berval *)ch_malloc( sizeof(struct berval) );
              BER_BVZERO( &keys[0] );
              *keysp = keys;
              ber_bvfree( val );
              return LDAP_SUCCESS;
       }

       /* Isolate how many words there are. There will be a key for each */
       for( count = 0,c = val->bv_val; *c; c++) {
              len = strcspn(c, SLAPD_APPROX_DELIMITER);
              if( len >= SLAPD_APPROX_WORDLEN ) count++;
              c+= len;
              if (*c == '\0') break;
              *c = '\0';
       }

       /* Allocate storage for new keys */
       keys = (struct berval *)ch_malloc( (count + 1) * sizeof(struct berval) );

       /* Get a phonetic copy of each word */
       for( c = val->bv_val, i = 0; i < count; c += len + 1 ) {
              len = strlen(c);
              if( len < SLAPD_APPROX_WORDLEN ) continue;
              ber_str2bv( phonetic( c ), 0, 0, &keys[i] );
              i++;
       }

       ber_bvfree( val );

       BER_BVZERO( &keys[count] );
       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int approxIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
) [static]

Definition at line 2116 of file schema_init.c.

{
       char *c;
       int i,j, len, wordcount, keycount=0;
       struct berval *newkeys;
       BerVarray keys=NULL;

       for( j = 0; !BER_BVISNULL( &values[j] ); j++ ) {
              struct berval val = BER_BVNULL;
              /* Yes, this is necessary */
              UTF8bvnormalize( &values[j], &val, LDAP_UTF8_APPROX, NULL );
              assert( !BER_BVISNULL( &val ) );

              /* Isolate how many words there are. There will be a key for each */
              for( wordcount = 0, c = val.bv_val; *c; c++) {
                     len = strcspn(c, SLAPD_APPROX_DELIMITER);
                     if( len >= SLAPD_APPROX_WORDLEN ) wordcount++;
                     c+= len;
                     if (*c == '\0') break;
                     *c = '\0';
              }

              /* Allocate/increase storage to account for new keys */
              newkeys = (struct berval *)ch_malloc( (keycount + wordcount + 1) 
                     * sizeof(struct berval) );
              AC_MEMCPY( newkeys, keys, keycount * sizeof(struct berval) );
              if( keys ) ch_free( keys );
              keys = newkeys;

              /* Get a phonetic copy of each word */
              for( c = val.bv_val, i = 0; i < wordcount; c += len + 1 ) {
                     len = strlen( c );
                     if( len < SLAPD_APPROX_WORDLEN ) continue;
                     ber_str2bv( phonetic( c ), 0, 0, &keys[keycount] );
                     if( keys[keycount].bv_len ) {
                            keycount++;
                     } else {
                            ch_free( keys[keycount].bv_val );
                     }
                     i++;
              }

              ber_memfree( val.bv_val );
       }
       BER_BVZERO( &keys[keycount] );
       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int approxMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 2007 of file schema_init.c.

{
       struct berval *nval, *assertv;
       char *val, **values, **words, *c;
       int i, count, len, nextchunk=0, nextavail=0;

       /* Yes, this is necessary */
       nval = UTF8bvnormalize( value, NULL, LDAP_UTF8_APPROX, NULL );
       if( nval == NULL ) {
              *matchp = 1;
              return LDAP_SUCCESS;
       }

       /* Yes, this is necessary */
       assertv = UTF8bvnormalize( ((struct berval *)assertedValue),
              NULL, LDAP_UTF8_APPROX, NULL );
       if( assertv == NULL ) {
              ber_bvfree( nval );
              *matchp = 1;
              return LDAP_SUCCESS;
       }

       /* Isolate how many words there are */
       for ( c = nval->bv_val, count = 1; *c; c++ ) {
              c = strpbrk( c, SLAPD_APPROX_DELIMITER );
              if ( c == NULL ) break;
              *c = '\0';
              count++;
       }

       /* Get a phonetic copy of each word */
       words = (char **)ch_malloc( count * sizeof(char *) );
       values = (char **)ch_malloc( count * sizeof(char *) );
       for ( c = nval->bv_val, i = 0;  i < count; i++, c += strlen(c) + 1 ) {
              words[i] = c;
              values[i] = phonetic(c);
       }

       /* Work through the asserted value's words, to see if at least some
        * of the words are there, in the same order. */
       len = 0;
       while ( (ber_len_t) nextchunk < assertv->bv_len ) {
              len = strcspn( assertv->bv_val + nextchunk, SLAPD_APPROX_DELIMITER);
              if( len == 0 ) {
                     nextchunk++;
                     continue;
              }
#if defined(SLAPD_APPROX_INITIALS)
              else if( len == 1 ) {
                     /* Single letter words need to at least match one word's initial */
                     for( i=nextavail; i<count; i++ )
                            if( !strncasecmp( assertv->bv_val + nextchunk, words[i], 1 )) {
                                   nextavail=i+1;
                                   break;
                            }
              }
#endif
              else {
                     /* Isolate the next word in the asserted value and phonetic it */
                     assertv->bv_val[nextchunk+len] = '\0';
                     val = phonetic( assertv->bv_val + nextchunk );

                     /* See if this phonetic chunk is in the remaining words of *value */
                     for( i=nextavail; i<count; i++ ){
                            if( !strcmp( val, values[i] ) ){
                                   nextavail = i+1;
                                   break;
                            }
                     }
                     ch_free( val );
              }

              /* This chunk in the asserted value was NOT within the *value. */
              if( i >= count ) {
                     nextavail=-1;
                     break;
              }

              /* Go on to the next word in the asserted value */
              nextchunk += len+1;
       }

       /* If some of the words were seen, call it a match */
       if( nextavail > 0 ) {
              *matchp = 0;
       }
       else {
              *matchp = 1;
       }

       /* Cleanup allocs */
       ber_bvfree( assertv );
       for( i=0; i<count; i++ ) {
              ch_free( values[i] );
       }
       ch_free( values );
       ch_free( words );
       ber_bvfree( nval );

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int attributeCertificateExactNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 4763 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len;
       char issuer_serialbuf[SLAP_SN_BUFLEN], serialbuf[SLAP_SN_BUFLEN];
       struct berval sn, i_sn, sn2 = BER_BVNULL, i_sn2 = BER_BVNULL;
       struct berval issuer_dn = BER_BVNULL, bvdn;
       char *p;
       int rc = LDAP_INVALID_SYNTAX;

       if ( BER_BVISEMPTY( val ) ) {
              return rc;
       }

       if ( SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX(usage) ) {
              return serialNumberAndIssuerSerialNormalize( 0, NULL, NULL, val, normalized, ctx );
       }

       assert( SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX(usage) != 0 );

       ber_init2( ber, val, LBER_USE_DER );
       tag = ber_skip_tag( ber, &len );   /* Signed Sequence */
       tag = ber_skip_tag( ber, &len );   /* Sequence */
       tag = ber_skip_tag( ber, &len );   /* (Mandatory) version; must be v2(1) */
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Holder Sequence */
       ber_skip_data( ber, len );

       /* Issuer */
       tag = ber_skip_tag( ber, &len );   /* Sequence */
                                          /* issuerName (GeneralNames sequence; optional)? */
       tag = ber_skip_tag( ber, &len );   /* baseCertificateID (sequence; optional)? */
       tag = ber_skip_tag( ber, &len );   /* GeneralNames (sequence) */
       tag = ber_skip_tag( ber, &len );   /* directoryName (we only accept this form of GeneralName) */
       if ( tag != SLAP_X509_GN_DIRECTORYNAME ) { 
              return LDAP_INVALID_SYNTAX; 
       }
       tag = ber_peek_tag( ber, &len );   /* sequence of RDN */
       len = ber_ptrlen( ber );
       bvdn.bv_val = val->bv_val + len;
       bvdn.bv_len = val->bv_len - len;
       rc = dnX509normalize( &bvdn, &issuer_dn );
       if ( rc != LDAP_SUCCESS ) goto done;
       
       tag = ber_skip_tag( ber, &len );   /* sequence of RDN */
       ber_skip_data( ber, len ); 
       tag = ber_skip_tag( ber, &len );   /* serial number */
       if ( tag != LBER_INTEGER ) {
              rc = LDAP_INVALID_SYNTAX; 
              goto done;
       }
       i_sn.bv_val = (char *)ber->ber_ptr;
       i_sn.bv_len = len;
       i_sn2.bv_val = issuer_serialbuf;
       i_sn2.bv_len = sizeof(issuer_serialbuf);
       if ( slap_bin2hex( &i_sn, &i_sn2, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }
       ber_skip_data( ber, len );

                                          /* issuerUID (bitstring; optional)? */
                                          /* objectDigestInfo (sequence; optional)? */

       tag = ber_skip_tag( ber, &len );   /* Signature (sequence) */
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* serial number */ 
       if ( tag != LBER_INTEGER ) {
              rc = LDAP_INVALID_SYNTAX; 
              goto done;
       }
       sn.bv_val = (char *)ber->ber_ptr;
       sn.bv_len = len;
       sn2.bv_val = serialbuf;
       sn2.bv_len = sizeof(serialbuf);
       if ( slap_bin2hex( &sn, &sn2, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }
       ber_skip_data( ber, len );

       normalized->bv_len = STRLENOF( "{ serialNumber , issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"\" }, serial  } } }" )
              + sn2.bv_len + issuer_dn.bv_len + i_sn2.bv_len;
       normalized->bv_val = ch_malloc( normalized->bv_len + 1 );

       p = normalized->bv_val;

       p = lutil_strcopy( p, "{ serialNumber " );
       p = lutil_strbvcopy( p, &sn2 );
       p = lutil_strcopy( p, ", issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"" );
       p = lutil_strbvcopy( p, &issuer_dn );
       p = lutil_strcopy( p, "\" }, serial " );
       p = lutil_strbvcopy( p, &i_sn2 );
       p = lutil_strcopy( p, " } } }" );

       Debug( LDAP_DEBUG_TRACE, "attributeCertificateExactNormalize: %s\n",
              normalized->bv_val, NULL, NULL );

       rc = LDAP_SUCCESS;

done:
       if ( issuer_dn.bv_val ) ber_memfree( issuer_dn.bv_val );
       if ( i_sn2.bv_val != issuer_serialbuf ) ber_memfree_x( i_sn2.bv_val, ctx );
       if ( sn2.bv_val != serialbuf ) ber_memfree_x( sn2.bv_val, ctx );

       return rc;
}

Here is the call graph for this function:

static int attributeCertificateValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 470 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len;
       ber_int_t version;
       int cont = 0;

       ber_init2( ber, in, LBER_USE_DER );
       
       tag = ber_skip_tag( ber, &len );   /* Signed wrapper */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;

       tag = ber_skip_tag( ber, &len );   /* Sequence */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;

       tag = ber_peek_tag( ber, &len );   /* Version */
       if ( tag != LBER_INTEGER ) return LDAP_INVALID_SYNTAX;
       tag = ber_get_int( ber, &version );       /* X.509 only allows v2 */
       if ( version != SLAP_X509AC_V2 ) return LDAP_INVALID_SYNTAX;

       tag = ber_skip_tag( ber, &len );   /* Holder */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* Issuer */
       if ( tag != SLAP_X509AC_ISSUER ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* Signature */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* Serial number */
       if ( tag != LBER_INTEGER ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* AttCertValidityPeriod */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* Attributes */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_peek_tag( ber, &len );

       if ( tag == LBER_BITSTRING ) {     /* issuerUniqueID */
              tag = ber_skip_tag( ber, &len );
              ber_skip_data( ber, len );
              tag = ber_peek_tag( ber, &len );
       }

       if ( tag == LBER_SEQUENCE ) {      /* extensions or signatureAlgorithm */
              tag = ber_skip_tag( ber, &len );
              ber_skip_data( ber, len );
              cont++;
              tag = ber_peek_tag( ber, &len );
       }

       if ( tag == LBER_SEQUENCE ) {      /* signatureAlgorithm */
              tag = ber_skip_tag( ber, &len );
              ber_skip_data( ber, len );
              cont++;
              tag = ber_peek_tag( ber, &len );
       }

       if ( tag == LBER_BITSTRING ) {     /* Signature */
              tag = ber_skip_tag( ber, &len );
              ber_skip_data( ber, len );
              cont++;
              tag = ber_peek_tag( ber, &len );
       }

       /* Must be at end now */
       if ( len != 0 || tag != LBER_DEFAULT || cont < 2 ) return LDAP_INVALID_SYNTAX;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int bitStringValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 1132 of file schema_init.c.

{
       ber_len_t i;

       /* very unforgiving validation, requires no normalization
        * before simplistic matching
        */
       if( in->bv_len < 3 ) {
              return LDAP_INVALID_SYNTAX;
       }

       /* RFC 4517 Section 3.3.2 Bit String:
        *     BitString    = SQUOTE *binary-digit SQUOTE "B"
        *     binary-digit = "0" / "1"
        *
        * where SQUOTE [RFC4512] is
        *     SQUOTE  = %x27 ; single quote ("'")
        *
        * Example: '0101111101'B
        */
       
       if( in->bv_val[0] != '\'' ||
              in->bv_val[in->bv_len - 2] != '\'' ||
              in->bv_val[in->bv_len - 1] != 'B' )
       {
              return LDAP_INVALID_SYNTAX;
       }

       for( i = in->bv_len - 3; i > 0; i-- ) {
              if( in->bv_val[i] != '0' && in->bv_val[i] != '1' ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

static int blobValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 193 of file schema_init.c.

{
       /* any value allowed */
       return LDAP_SUCCESS;
}
static int booleanMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 1648 of file schema_init.c.

{
       /* simplistic matching allowed by rigid validation */
       struct berval *asserted = (struct berval *) assertedValue;
       *matchp = (int) asserted->bv_len - (int) value->bv_len;
       return LDAP_SUCCESS;
}
static int booleanValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 1626 of file schema_init.c.

{
       /* very unforgiving validation, requires no normalization
        * before simplistic matching
        */

       if( in->bv_len == 4 ) {
              if( bvmatch( in, &slap_true_bv ) ) {
                     return LDAP_SUCCESS;
              }
       } else if( in->bv_len == 5 ) {
              if( bvmatch( in, &slap_false_bv ) ) {
                     return LDAP_SUCCESS;
              }
       }

       return LDAP_INVALID_SYNTAX;
}
static int bootParameterValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 5998 of file schema_init.c.

{
       char *p, *e;

       if ( BER_BVISEMPTY( val ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       p = (char *)val->bv_val;
       e = p + val->bv_len;

       /* key */
       for (; ( p < e ) && ( *p != '=' ); p++ ) {
              if ( !AD_CHAR( *p ) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       if ( *p != '=' ) {
              return LDAP_INVALID_SYNTAX;
       }

       /* server */
       for ( p++; ( p < e ) && ( *p != ':' ); p++ ) {
              if ( !AD_CHAR( *p ) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       if ( *p != ':' ) {
              return LDAP_INVALID_SYNTAX;
       }

       /* path */
       for ( p++; p < e; p++ ) {
              if ( !SLAP_PRINTABLE( *p ) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}
static int certificateExactNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 3613 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len;
       ber_int_t i;
       char serialbuf2[SLAP_SN_BUFLEN];
       struct berval sn, sn2 = BER_BVNULL;
       struct berval issuer_dn = BER_BVNULL, bvdn;
       char *p;
       int rc = LDAP_INVALID_SYNTAX;

       assert( val != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> certificateExactNormalize: <%p, %lu>\n",
              val->bv_val, val->bv_len, 0 );

       if ( BER_BVISEMPTY( val ) ) goto done;

       if ( SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX(usage) ) {
              return serialNumberAndIssuerNormalize( 0, NULL, NULL, val, normalized, ctx );
       }

       assert( SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX(usage) != 0 );

       ber_init2( ber, val, LBER_USE_DER );
       tag = ber_skip_tag( ber, &len );   /* Signed Sequence */
       tag = ber_skip_tag( ber, &len );   /* Sequence */
       tag = ber_peek_tag( ber, &len );   /* Optional version? */
       if ( tag == SLAP_X509_OPT_C_VERSION ) {
              tag = ber_skip_tag( ber, &len );
              tag = ber_get_int( ber, &i );      /* version */
       }

       /* NOTE: move the test here from certificateValidate,
        * so that we can validate certs with serial longer
        * than sizeof(ber_int_t) */
       tag = ber_skip_tag( ber, &len );   /* serial */
       sn.bv_len = len;
       sn.bv_val = (char *)ber->ber_ptr;
       sn2.bv_val = serialbuf2;
       sn2.bv_len = sizeof(serialbuf2);
       if ( slap_bin2hex( &sn, &sn2, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* SignatureAlg */
       ber_skip_data( ber, len );
       tag = ber_peek_tag( ber, &len );   /* IssuerDN */
       len = ber_ptrlen( ber );
       bvdn.bv_val = val->bv_val + len;
       bvdn.bv_len = val->bv_len - len;

       rc = dnX509normalize( &bvdn, &issuer_dn );
       if ( rc != LDAP_SUCCESS ) goto done;

       normalized->bv_len = STRLENOF( "{ serialNumber , issuer rdnSequence:\"\" }" )
              + sn2.bv_len + issuer_dn.bv_len;
       normalized->bv_val = ch_malloc( normalized->bv_len + 1 );

       p = normalized->bv_val;

       p = lutil_strcopy( p, "{ serialNumber " /*}*/ );
       p = lutil_strbvcopy( p, &sn2 );
       p = lutil_strcopy( p, ", issuer rdnSequence:\"" );
       p = lutil_strbvcopy( p, &issuer_dn );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       rc = LDAP_SUCCESS;

done:
       Debug( LDAP_DEBUG_TRACE, "<<< certificateExactNormalize: <%p, %lu> => <%s>\n",
              val->bv_val, val->bv_len, rc == LDAP_SUCCESS ? normalized->bv_val : "(err)" );

       if ( issuer_dn.bv_val ) ber_memfree( issuer_dn.bv_val );
       if ( sn2.bv_val != serialbuf2 ) ber_memfree_x( sn2.bv_val, ctx );

       return rc;
}

Here is the call graph for this function:

static int certificateListExactNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 4100 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len;
       ber_int_t version;
       struct berval issuer_dn = BER_BVNULL, bvdn,
              thisUpdate, bvtu;
       char *p, tubuf[STRLENOF("YYYYmmddHHMMSSZ") + 1];
       int rc = LDAP_INVALID_SYNTAX;

       assert( val != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> certificateListExactNormalize: <%p, %lu>\n",
              val->bv_val, val->bv_len, 0 );

       if ( BER_BVISEMPTY( val ) ) goto done;

       if ( SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX(usage) ) {
              return issuerAndThisUpdateNormalize( 0, NULL, NULL, val, normalized, ctx );
       }

       assert( SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX(usage) != 0 );

       ber_init2( ber, val, LBER_USE_DER );
       tag = ber_skip_tag( ber, &len );   /* Signed wrapper */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       tag = ber_skip_tag( ber, &len );   /* Sequence */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       tag = ber_peek_tag( ber, &len );
       /* Optional version */
       if ( tag == LBER_INTEGER ) {
              tag = ber_get_int( ber, &version );
              assert( tag == LBER_INTEGER );
              if ( version != SLAP_X509_V2 ) return LDAP_INVALID_SYNTAX;
       }
       tag = ber_skip_tag( ber, &len );   /* Signature Algorithm */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );

       tag = ber_peek_tag( ber, &len );   /* IssuerDN */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       len = ber_ptrlen( ber );
       bvdn.bv_val = val->bv_val + len;
       bvdn.bv_len = val->bv_len - len;
       tag = ber_skip_tag( ber, &len );
       ber_skip_data( ber, len );

       tag = ber_skip_tag( ber, &len );   /* thisUpdate */
       /* Time is a CHOICE { UTCTime, GeneralizedTime } */
       if ( tag != SLAP_TAG_UTCTIME && tag != SLAP_TAG_GENERALIZEDTIME ) return LDAP_INVALID_SYNTAX;
       bvtu.bv_val = (char *)ber->ber_ptr;
       bvtu.bv_len = len;

       rc = dnX509normalize( &bvdn, &issuer_dn );
       if ( rc != LDAP_SUCCESS ) goto done;

       thisUpdate.bv_val = tubuf;
       thisUpdate.bv_len = sizeof(tubuf);
       if ( checkTime( &bvtu, &thisUpdate ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }

       normalized->bv_len = STRLENOF( "{ issuer rdnSequence:\"\", thisUpdate \"\" }" )
              + issuer_dn.bv_len + thisUpdate.bv_len;
       normalized->bv_val = ch_malloc( normalized->bv_len + 1 );

       p = normalized->bv_val;

       p = lutil_strcopy( p, "{ issuer rdnSequence:\"" );
       p = lutil_strbvcopy( p, &issuer_dn );
       p = lutil_strcopy( p, "\", thisUpdate \"" );
       p = lutil_strbvcopy( p, &thisUpdate );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       rc = LDAP_SUCCESS;

done:
       Debug( LDAP_DEBUG_TRACE, "<<< certificateListExactNormalize: <%p, %lu> => <%s>\n",
              val->bv_val, val->bv_len, rc == LDAP_SUCCESS ? normalized->bv_val : "(err)" );

       if ( issuer_dn.bv_val ) ber_memfree( issuer_dn.bv_val );

       return rc;
}

Here is the call graph for this function:

static int certificateListValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 353 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len, wrapper_len;
       char *wrapper_start;
       int wrapper_ok = 0;
       ber_int_t version = SLAP_X509_V1;
       struct berval bvdn, bvtu;

       ber_init2( ber, in, LBER_USE_DER );
       tag = ber_skip_tag( ber, &wrapper_len );  /* Signed wrapper */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       wrapper_start = ber->ber_ptr;
       tag = ber_skip_tag( ber, &len );   /* Sequence */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       tag = ber_peek_tag( ber, &len );
       /* Optional version */
       if ( tag == LBER_INTEGER ) {
              tag = ber_get_int( ber, &version );
              assert( tag == LBER_INTEGER );
              if ( version != SLAP_X509_V2 ) return LDAP_INVALID_SYNTAX;
       }
       tag = ber_skip_tag( ber, &len );   /* Signature Algorithm */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_peek_tag( ber, &len );   /* Issuer DN */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       len = ber_ptrlen( ber );
       bvdn.bv_val = in->bv_val + len;
       bvdn.bv_len = in->bv_len - len;
       tag = ber_skip_tag( ber, &len );
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* thisUpdate */
       /* Time is a CHOICE { UTCTime, GeneralizedTime } */
       if ( tag != SLAP_TAG_UTCTIME && tag != SLAP_TAG_GENERALIZEDTIME ) return LDAP_INVALID_SYNTAX;
       bvtu.bv_val = (char *)ber->ber_ptr;
       bvtu.bv_len = len;
       ber_skip_data( ber, len );
       /* Optional nextUpdate */
       tag = ber_skip_tag( ber, &len );
       if ( tag == SLAP_TAG_UTCTIME || tag == SLAP_TAG_GENERALIZEDTIME ) {
              ber_skip_data( ber, len );
              tag = ber_skip_tag( ber, &len );
       }
       /* revokedCertificates - Sequence of Sequence, Optional */
       if ( tag == LBER_SEQUENCE ) {
              ber_len_t seqlen;
              ber_tag_t stag;
              stag = ber_peek_tag( ber, &seqlen );
              if ( stag == LBER_SEQUENCE || !len ) {
                     /* RFC5280 requires non-empty, but X.509(2005) allows empty. */
                     if ( len )
                            ber_skip_data( ber, len );
                     tag = ber_skip_tag( ber, &len );
              }
       }
       /* Optional Extensions - Sequence of Sequence */
       if ( tag == SLAP_X509_OPT_CL_CRLEXTENSIONS ) { /* ? */
              ber_len_t seqlen;
              if ( version != SLAP_X509_V2 ) return LDAP_INVALID_SYNTAX;
              tag = ber_peek_tag( ber, &seqlen );
              if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
              ber_skip_data( ber, len );
              tag = ber_skip_tag( ber, &len );
       }
       /* signatureAlgorithm */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );
       /* Signature */
       if ( tag != LBER_BITSTRING ) return LDAP_INVALID_SYNTAX; 
       ber_skip_data( ber, len );
       if ( ber->ber_ptr == wrapper_start + wrapper_len ) wrapper_ok = 1;
       tag = ber_skip_tag( ber, &len );
       /* Must be at end now */
       /* NOTE: OpenSSL tolerates CL with garbage past the end */
       if ( len || tag != LBER_DEFAULT ) {
              struct berval issuer_dn = BER_BVNULL, thisUpdate;
              char tubuf[STRLENOF("YYYYmmddHHMMSSZ") + 1];
              int rc;

              if ( ! wrapper_ok ) {
                     return LDAP_INVALID_SYNTAX;
              }

              rc = dnX509normalize( &bvdn, &issuer_dn );
              if ( rc != LDAP_SUCCESS ) {
                     rc = LDAP_INVALID_SYNTAX;
                     goto done;
              }

              thisUpdate.bv_val = tubuf;
              thisUpdate.bv_len = sizeof(tubuf); 
              if ( checkTime( &bvtu, &thisUpdate ) ) {
                     rc = LDAP_INVALID_SYNTAX;
                     goto done;
              }

              Debug( LDAP_DEBUG_ANY,
                     "certificateListValidate issuer=\"%s\", thisUpdate=%s: extra cruft past end of certificateList\n",
                     issuer_dn.bv_val, thisUpdate.bv_val, 0 );

done:;
              if ( ! BER_BVISNULL( &issuer_dn ) ) {
                     ber_memfree( issuer_dn.bv_val );
              }

              return rc;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int certificateValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 277 of file schema_init.c.

{
       BerElementBuffer berbuf;
       BerElement *ber = (BerElement *)&berbuf;
       ber_tag_t tag;
       ber_len_t len;
       ber_int_t version = SLAP_X509_V1;

       ber_init2( ber, in, LBER_USE_DER );
       tag = ber_skip_tag( ber, &len );   /* Signed wrapper */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       tag = ber_skip_tag( ber, &len );   /* Sequence */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       tag = ber_peek_tag( ber, &len );
       /* Optional version */
       if ( tag == SLAP_X509_OPT_C_VERSION ) {
              tag = ber_skip_tag( ber, &len );
              tag = ber_get_int( ber, &version );
              if ( tag != LBER_INTEGER ) return LDAP_INVALID_SYNTAX;
       }
       /* NOTE: don't try to parse Serial, because it might be longer
        * than sizeof(ber_int_t); deferred to certificateExactNormalize() */
       tag = ber_skip_tag( ber, &len );   /* Serial */
       if ( tag != LBER_INTEGER ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Signature Algorithm */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Issuer DN */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Validity */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Subject DN */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );   /* Subject PublicKeyInfo */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );
       if ( tag == SLAP_X509_OPT_C_ISSUERUNIQUEID ) {   /* issuerUniqueID */
              if ( version < SLAP_X509_V2 ) return LDAP_INVALID_SYNTAX;
              ber_skip_data( ber, len );
              tag = ber_skip_tag( ber, &len );
       }
       if ( tag == SLAP_X509_OPT_C_SUBJECTUNIQUEID ) {  /* subjectUniqueID */
              if ( version < SLAP_X509_V2 ) return LDAP_INVALID_SYNTAX;
              ber_skip_data( ber, len );
              tag = ber_skip_tag( ber, &len );
       }
       if ( tag == SLAP_X509_OPT_C_EXTENSIONS ) {       /* Extensions */
              if ( version < SLAP_X509_V3 ) return LDAP_INVALID_SYNTAX;
              tag = ber_skip_tag( ber, &len );
              if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
              ber_skip_data( ber, len );
              tag = ber_skip_tag( ber, &len );
       }
       /* signatureAlgorithm */
       if ( tag != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );
       /* Signature */
       if ( tag != LBER_BITSTRING ) return LDAP_INVALID_SYNTAX; 
       ber_skip_data( ber, len );
       tag = ber_skip_tag( ber, &len );
       /* Must be at end now */
       if ( len || tag != LBER_DEFAULT ) return LDAP_INVALID_SYNTAX;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int check_time_syntax ( struct berval val,
int  start,
int parts,
struct berval fraction 
) [static]

Definition at line 5428 of file schema_init.c.

{
       /*
        * start=0 GeneralizedTime YYYYmmddHH[MM[SS]][(./,)d...](Z|(+/-)HH[MM])
        * start=1 UTCTime         YYmmddHHMM[SS][Z|(+/-)HHMM]
        * GeneralizedTime supports leap seconds, UTCTime does not.
        */
       static const int ceiling[9] = { 100, 100, 12, 31, 24, 60, 60, 24, 60 };
       static const int mdays[2][12] = {
              /* non-leap years */
              { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 },
              /* leap years */
              { 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 }
       };
       char *p, *e;
       int part, c, c1, c2, tzoffset, leapyear = 0;

       p = val->bv_val;
       e = p + val->bv_len;

#ifdef SUPPORT_OBSOLETE_UTC_SYNTAX
       parts[0] = 20; /* century - any multiple of 4 from 04 to 96 */
#endif
       for (part = start; part < 7 && p < e; part++) {
              c1 = *p;
              if (!ASCII_DIGIT(c1)) {
                     break;
              }
              p++;
              if (p == e) {
                     return LDAP_INVALID_SYNTAX;
              }
              c = *p++;
              if (!ASCII_DIGIT(c)) {
                     return LDAP_INVALID_SYNTAX;
              }
              c += c1 * 10 - '0' * 11;
              if ((part | 1) == 3) {
                     --c;
                     if (c < 0) {
                            return LDAP_INVALID_SYNTAX;
                     }
              }
              if (c >= ceiling[part]) {
                     if (! (c == 60 && part == 6 && start == 0))
                            return LDAP_INVALID_SYNTAX;
              }
              parts[part] = c;
       }
       if (part < 5 + start) {
              return LDAP_INVALID_SYNTAX;
       }
       for (; part < 9; part++) {
              parts[part] = 0;
       }

       /* leapyear check for the Gregorian calendar (year>1581) */
       if (parts[parts[1] == 0 ? 0 : 1] % 4 == 0) {
              leapyear = 1;
       }

       if (parts[3] >= mdays[leapyear][parts[2]]) {
              return LDAP_INVALID_SYNTAX;
       }

       if (start == 0) {
              fraction->bv_val = p;
              fraction->bv_len = 0;
              if (p < e && (*p == '.' || *p == ',')) {
                     char *end_num;
                     while (++p < e && ASCII_DIGIT(*p)) {
                            /* EMTPY */;
                     }
                     if (p - fraction->bv_val == 1) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     for (end_num = p; end_num[-1] == '0'; --end_num) {
                            /* EMPTY */;
                     }
                     c = end_num - fraction->bv_val;
                     if (c != 1) fraction->bv_len = c;
              }
       }

       if (p == e) {
              /* no time zone */
              return start == 0 ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
       }

       tzoffset = *p++;
       switch (tzoffset) {
       default:
              return LDAP_INVALID_SYNTAX;
       case 'Z':
              /* UTC */
              break;
       case '+':
       case '-':
              for (part = 7; part < 9 && p < e; part++) {
                     c1 = *p;
                     if (!ASCII_DIGIT(c1)) {
                            break;
                     }
                     p++;
                     if (p == e) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     c2 = *p++;
                     if (!ASCII_DIGIT(c2)) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     parts[part] = c1 * 10 + c2 - '0' * 11;
                     if (parts[part] >= ceiling[part]) {
                            return LDAP_INVALID_SYNTAX;
                     }
              }
              if (part < 8 + start) {
                     return LDAP_INVALID_SYNTAX;
              }

              if (tzoffset == '-') {
                     /* negative offset to UTC, ie west of Greenwich */
                     parts[4] += parts[7];
                     parts[5] += parts[8];
                     /* offset is just hhmm, no seconds */
                     for (part = 6; --part >= 0; ) {
                            if (part != 3) {
                                   c = ceiling[part];
                            } else {
                                   c = mdays[leapyear][parts[2]];
                            }
                            if (parts[part] >= c) {
                                   if (part == 0) {
                                          return LDAP_INVALID_SYNTAX;
                                   }
                                   parts[part] -= c;
                                   parts[part - 1]++;
                                   continue;
                            } else if (part != 5) {
                                   break;
                            }
                     }
              } else {
                     /* positive offset to UTC, ie east of Greenwich */
                     parts[4] -= parts[7];
                     parts[5] -= parts[8];
                     for (part = 6; --part >= 0; ) {
                            if (parts[part] < 0) {
                                   if (part == 0) {
                                          return LDAP_INVALID_SYNTAX;
                                   }
                                   if (part != 3) {
                                          c = ceiling[part];
                                   } else {
                                          /* make first arg to % non-negative */
                                          c = mdays[leapyear][(parts[2] - 1 + 12) % 12];
                                   }
                                   parts[part] += c;
                                   parts[part - 1]--;
                                   continue;
                            } else if (part != 5) {
                                   break;
                            }
                     }
              }
       }

       return p != e ? LDAP_INVALID_SYNTAX : LDAP_SUCCESS;
}
static int checkNum ( struct berval in,
struct berval out 
) [static]

Definition at line 3122 of file schema_init.c.

{
       /* parse serialNumber */
       ber_len_t neg = 0, extra = 0;
       char first = '\0';

       out->bv_val = in->bv_val;
       out->bv_len = 0;

       if ( out->bv_val[0] == '-' ) {
              neg++;
              out->bv_len++;
       }

       if ( strncasecmp( out->bv_val, "0x", STRLENOF("0x") ) == 0 ) {
              first = out->bv_val[2];
              extra = 2;

              out->bv_len += STRLENOF("0x");
              for ( ; out->bv_len < in->bv_len; out->bv_len++ ) {
                     if ( !ASCII_HEX( out->bv_val[out->bv_len] ) ) break;
              }

       } else if ( out->bv_val[0] == '\'' ) {
              first = out->bv_val[1];
              extra = 3;

              out->bv_len += STRLENOF("'");

              for ( ; out->bv_len < in->bv_len; out->bv_len++ ) {
                     if ( !ASCII_HEX( out->bv_val[out->bv_len] ) ) break;
              }
              if ( strncmp( &out->bv_val[out->bv_len], "'H", STRLENOF("'H") ) != 0 ) {
                     return -1;
              }
              out->bv_len += STRLENOF("'H");

       } else {
              first = out->bv_val[0];
              for ( ; out->bv_len < in->bv_len; out->bv_len++ ) {
                     if ( !ASCII_DIGIT( out->bv_val[out->bv_len] ) ) break;
              }
       }

       if ( !( out->bv_len > neg ) ) {
              return -1;
       }

       if ( ( out->bv_len > extra + 1 + neg ) && ( first == '0' ) ) {
              return -1;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int checkTime ( struct berval in,
struct berval out 
) [static]

Definition at line 3704 of file schema_init.c.

{
       int rc;
       ber_len_t i;
       char buf[STRLENOF("YYYYmmddHHMMSSZ") + 1];
       struct berval bv;

       assert( in != NULL );
       assert( !BER_BVISNULL( in ) );
       assert( !BER_BVISEMPTY( in ) );

       if ( in->bv_len < STRLENOF( "YYmmddHHMMSSZ" ) ) {
              return -1;
       }

       if ( out != NULL ) {
              assert( !BER_BVISNULL( out ) );
              assert( out->bv_len >= sizeof( buf ) );
              bv.bv_val = out->bv_val;

       } else {
              bv.bv_val = buf;
       }

       for ( i = 0; i < STRLENOF( "YYYYmmddHHMMSS" ); i++ ) {
              if ( !ASCII_DIGIT( in->bv_val[i] ) ) break;
       }

       if ( in->bv_val[i] != 'Z' ) {
              return -1;
       }
       i++;

       if ( i != in->bv_len ) {
              return -1;
       }

       if ( i == STRLENOF( "YYYYmmddHHMMSSZ" ) ) {
              lutil_strncopy( bv.bv_val, in->bv_val, i );
              bv.bv_len = i;
              
       } else if ( i == STRLENOF( "YYmmddHHMMSSZ" ) ) {
              char *p = bv.bv_val;
              if ( in->bv_val[0] < '7' ) {
                     p = lutil_strcopy( p, "20" );

              } else {
                     p = lutil_strcopy( p, "19" );
              }
              lutil_strncopy( p, in->bv_val, i );
              bv.bv_len = 2 + i;

       } else {
              return -1;
       }

       rc = generalizedTimeValidate( NULL, &bv );
       if ( rc == LDAP_SUCCESS && out != NULL ) {
              if ( out->bv_len > bv.bv_len ) {
                     out->bv_val[ bv.bv_len ] = '\0';
              }
              out->bv_len = bv.bv_len;
       }

       return rc != LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int countryStringValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 2697 of file schema_init.c.

{
       if( val->bv_len != 2 ) return LDAP_INVALID_SYNTAX;

       if( !SLAP_PRINTABLE(val->bv_val[0]) ) {
              return LDAP_INVALID_SYNTAX;
       }
       if( !SLAP_PRINTABLE(val->bv_val[1]) ) {
              return LDAP_INVALID_SYNTAX;
       }

       return LDAP_SUCCESS;
}
static int csnNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 5321 of file schema_init.c.

{
       struct berval cnt, sid, mod;
       char          *ptr;
       ber_len_t     i;

       assert( val != NULL );
       assert( normalized != NULL );

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) != 0 );

       if ( BER_BVISEMPTY( val ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( val->bv_len == STRLENOF( "YYYYmmddHHMMSSZ#SSSSSS#ID#ssssss" ) ) {
              /* Openldap <= 2.3 */

              return csnNormalize23( usage, syntax, mr, val, normalized, ctx );
       }

       if ( val->bv_len == STRLENOF( "YYYYmmddHH:MM:SSZ#0xSSSS#I#ssss" ) ) {
              /* Openldap 2.1 */

              return csnNormalize21( usage, syntax, mr, val, normalized, ctx );
       }

       if ( val->bv_len != STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#SID#ssssss" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       ptr = ber_bvchr( val, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( ptr - val->bv_val != STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_val = ptr + 1;
       cnt.bv_len = val->bv_len - ( cnt.bv_val - val->bv_val );

       ptr = ber_bvchr( &cnt, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( ptr - cnt.bv_val != STRLENOF( "000000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       sid.bv_val = ptr + 1;
       sid.bv_len = val->bv_len - ( sid.bv_val - val->bv_val );
              
       ptr = ber_bvchr( &sid, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       sid.bv_len = ptr - sid.bv_val;
       if ( sid.bv_len != STRLENOF( "000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       mod.bv_val = ptr + 1;
       mod.bv_len = val->bv_len - ( mod.bv_val - val->bv_val );

       if ( mod.bv_len != STRLENOF( "000000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       ber_dupbv_x( normalized, val, ctx );

       for ( i = STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#" );
              i < normalized->bv_len; i++ )
       {
              /* assume it's already validated that's all hex digits */
              normalized->bv_val[ i ] = TOLOWER( normalized->bv_val[ i ] );
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int csnNormalize21 ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 5122 of file schema_init.c.

{
       struct berval gt, cnt, sid, mod;
       struct berval bv;
       char          buf[ STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#SID#ssssss" ) + 1 ];
       char          *ptr;
       ber_len_t     i;

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) != 0 );
       assert( !BER_BVISEMPTY( val ) );

       gt = *val;

       ptr = ber_bvchr( &gt, '#' );
       if ( ptr == NULL || ptr == &gt.bv_val[gt.bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       gt.bv_len = ptr - gt.bv_val;
       if ( gt.bv_len != STRLENOF( "YYYYmmddHH:MM:SSZ" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( gt.bv_val[ 10 ] != ':' || gt.bv_val[ 13 ] != ':' ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_val = ptr + 1;
       cnt.bv_len = val->bv_len - ( cnt.bv_val - val->bv_val );

       ptr = ber_bvchr( &cnt, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_len = ptr - cnt.bv_val;
       if ( cnt.bv_len != STRLENOF( "0x0000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( strncmp( cnt.bv_val, "0x", STRLENOF( "0x" ) ) != 0 ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_val += STRLENOF( "0x" );
       cnt.bv_len -= STRLENOF( "0x" );

       sid.bv_val = ptr + 1;
       sid.bv_len = val->bv_len - ( sid.bv_val - val->bv_val );
              
       ptr = ber_bvchr( &sid, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       sid.bv_len = ptr - sid.bv_val;
       if ( sid.bv_len != STRLENOF( "0" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       mod.bv_val = ptr + 1;
       mod.bv_len = val->bv_len - ( mod.bv_val - val->bv_val );
       if ( mod.bv_len != STRLENOF( "0000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#SID#ssssss" );
       bv.bv_val = buf;

       ptr = bv.bv_val;
       ptr = lutil_strncopy( ptr, gt.bv_val, STRLENOF( "YYYYmmddHH" ) );
       ptr = lutil_strncopy( ptr, &gt.bv_val[ STRLENOF( "YYYYmmddHH:" ) ],
              STRLENOF( "MM" ) );
       ptr = lutil_strncopy( ptr, &gt.bv_val[ STRLENOF( "YYYYmmddHH:MM:" ) ],
              STRLENOF( "SS" ) );
       ptr = lutil_strcopy( ptr, ".000000Z#00" );
       ptr = lutil_strbvcopy( ptr, &cnt );
       *ptr++ = '#';
       *ptr++ = '0';
       *ptr++ = '0';
       *ptr++ = sid.bv_val[ 0 ];
       *ptr++ = '#';
       *ptr++ = '0';
       *ptr++ = '0';
       for ( i = 0; i < mod.bv_len; i++ ) {
              *ptr++ = TOLOWER( mod.bv_val[ i ] );
       }
       *ptr = '\0';

       assert( ptr == &bv.bv_val[bv.bv_len] );

       if ( csnValidate( syntax, &bv ) != LDAP_SUCCESS ) {
              return LDAP_INVALID_SYNTAX;
       }

       ber_dupbv_x( normalized, &bv, ctx );

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int csnNormalize23 ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 5230 of file schema_init.c.

{
       struct berval gt, cnt, sid, mod;
       struct berval bv;
       char          buf[ STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#SID#ssssss" ) + 1 ];
       char          *ptr;
       ber_len_t     i;

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) != 0 );
       assert( !BER_BVISEMPTY( val ) );

       gt = *val;

       ptr = ber_bvchr( &gt, '#' );
       if ( ptr == NULL || ptr == &gt.bv_val[gt.bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       gt.bv_len = ptr - gt.bv_val;
       if ( gt.bv_len != STRLENOF( "YYYYmmddHHMMSSZ" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_val = ptr + 1;
       cnt.bv_len = val->bv_len - ( cnt.bv_val - val->bv_val );

       ptr = ber_bvchr( &cnt, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       cnt.bv_len = ptr - cnt.bv_val;
       if ( cnt.bv_len != STRLENOF( "000000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       sid.bv_val = ptr + 1;
       sid.bv_len = val->bv_len - ( sid.bv_val - val->bv_val );
              
       ptr = ber_bvchr( &sid, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       sid.bv_len = ptr - sid.bv_val;
       if ( sid.bv_len != STRLENOF( "00" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       mod.bv_val = ptr + 1;
       mod.bv_len = val->bv_len - ( mod.bv_val - val->bv_val );
       if ( mod.bv_len != STRLENOF( "000000" ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ#SSSSSS#SID#ssssss" );
       bv.bv_val = buf;

       ptr = bv.bv_val;
       ptr = lutil_strncopy( ptr, gt.bv_val, gt.bv_len - 1 );
       ptr = lutil_strcopy( ptr, ".000000Z#" );
       ptr = lutil_strbvcopy( ptr, &cnt );
       *ptr++ = '#';
       *ptr++ = '0';
       for ( i = 0; i < sid.bv_len; i++ ) {
              *ptr++ = TOLOWER( sid.bv_val[ i ] );
       }
       *ptr++ = '#';
       for ( i = 0; i < mod.bv_len; i++ ) {
              *ptr++ = TOLOWER( mod.bv_val[ i ] );
       }
       *ptr = '\0';

       assert( ptr == &bv.bv_val[bv.bv_len] );
       if ( csnValidate( syntax, &bv ) != LDAP_SUCCESS ) {
              return LDAP_INVALID_SYNTAX;
       }

       ber_dupbv_x( normalized, &bv, ctx );

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int csnPretty ( Syntax syntax,
struct berval val,
struct berval out,
void ctx 
) [static]

Definition at line 5412 of file schema_init.c.

{
       return csnNormalize( SLAP_MR_VALUE_OF_SYNTAX, NULL, NULL, val, out, ctx );
}

Here is the call graph for this function:

static int csnSidNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 4977 of file schema_init.c.

{
       struct berval bv;
       char          *ptr,
                     buf[ 4 ];


       if ( BER_BVISEMPTY( val ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       if ( SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX(usage) ) {
              return sidNormalize( 0, NULL, NULL, val, normalized, ctx );
       }

       assert( SLAP_MR_IS_VALUE_OF_ATTRIBUTE_SYNTAX(usage) != 0 );

       ptr = ber_bvchr( val, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_val = ptr + 1;
       bv.bv_len = val->bv_len - ( ptr + 1 - val->bv_val );

       ptr = ber_bvchr( &bv, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_val = ptr + 1;
       bv.bv_len = val->bv_len - ( ptr + 1 - val->bv_val );
              
       ptr = ber_bvchr( &bv, '#' );
       if ( ptr == NULL || ptr == &val->bv_val[val->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = ptr - bv.bv_val;

       if ( bv.bv_len == 2 ) {
              /* OpenLDAP 2.3 SID */
              buf[ 0 ] = '0';
              buf[ 1 ] = bv.bv_val[ 0 ];
              buf[ 2 ] = bv.bv_val[ 1 ];
              buf[ 3 ] = '\0';

              bv.bv_val = buf;
              bv.bv_len = 3;
       }

       return sidNormalize( 0, NULL, NULL, &bv, normalized, ctx );
}

Here is the call graph for this function:

static int csnValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 5038 of file schema_init.c.

{
       struct berval bv;
       char          *ptr;
       int           rc;

       assert( in != NULL );
       assert( !BER_BVISNULL( in ) );

       if ( BER_BVISEMPTY( in ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv = *in;

       ptr = ber_bvchr( &bv, '#' );
       if ( ptr == NULL || ptr == &bv.bv_val[bv.bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = ptr - bv.bv_val;
       if ( bv.bv_len != STRLENOF( "YYYYmmddHHMMSS.uuuuuuZ" ) &&
              bv.bv_len != STRLENOF( "YYYYmmddHHMMSSZ" ) )
       {
              return LDAP_INVALID_SYNTAX;
       }

       rc = generalizedTimeValidate( NULL, &bv );
       if ( rc != LDAP_SUCCESS ) {
              return rc;
       }

       bv.bv_val = ptr + 1;
       bv.bv_len = in->bv_len - ( bv.bv_val - in->bv_val );

       ptr = ber_bvchr( &bv, '#' );
       if ( ptr == NULL || ptr == &in->bv_val[in->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = ptr - bv.bv_val;
       if ( bv.bv_len != 6 ) {
              return LDAP_INVALID_SYNTAX;
       }

       rc = hexValidate( NULL, &bv );
       if ( rc != LDAP_SUCCESS ) {
              return rc;
       }

       bv.bv_val = ptr + 1;
       bv.bv_len = in->bv_len - ( bv.bv_val - in->bv_val );

       ptr = ber_bvchr( &bv, '#' );
       if ( ptr == NULL || ptr == &in->bv_val[in->bv_len] ) {
              return LDAP_INVALID_SYNTAX;
       }

       bv.bv_len = ptr - bv.bv_val;
       if ( bv.bv_len == 2 ) {
              /* tolerate old 2-digit replica-id */
              rc = hexValidate( NULL, &bv );

       } else {
              rc = sidValidate( NULL, &bv );
       }
       if ( rc != LDAP_SUCCESS ) {
              return rc;
       }

       bv.bv_val = ptr + 1;
       bv.bv_len = in->bv_len - ( bv.bv_val - in->bv_val );

       if ( bv.bv_len != 6 ) {
              return LDAP_INVALID_SYNTAX;
       }

       return hexValidate( NULL, &bv );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int deliveryMethodValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 5821 of file schema_init.c.

{
#undef LENOF
#define LENOF(s) (sizeof(s)-1)
       struct berval tmp = *val;
       /*
     * DeliveryMethod = pdm *( WSP DOLLAR WSP DeliveryMethod )
        *     pdm = "any" / "mhs" / "physical" / "telex" / "teletex" /
        *            "g3fax" / "g4fax" / "ia5" / "videotex" / "telephone"
        */
again:
       if( tmp.bv_len < 3 ) return LDAP_INVALID_SYNTAX;

       switch( tmp.bv_val[0] ) {
       case 'a':
       case 'A':
              if(( tmp.bv_len >= LENOF("any") ) &&
                     ( strncasecmp(tmp.bv_val, "any", LENOF("any")) == 0 ))
              {
                     tmp.bv_len -= LENOF("any");
                     tmp.bv_val += LENOF("any");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 'm':
       case 'M':
              if(( tmp.bv_len >= LENOF("mhs") ) &&
                     ( strncasecmp(tmp.bv_val, "mhs", LENOF("mhs")) == 0 ))
              {
                     tmp.bv_len -= LENOF("mhs");
                     tmp.bv_val += LENOF("mhs");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 'p':
       case 'P':
              if(( tmp.bv_len >= LENOF("physical") ) &&
                     ( strncasecmp(tmp.bv_val, "physical", LENOF("physical")) == 0 ))
              {
                     tmp.bv_len -= LENOF("physical");
                     tmp.bv_val += LENOF("physical");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 't':
       case 'T': /* telex or teletex or telephone */
              if(( tmp.bv_len >= LENOF("telex") ) &&
                     ( strncasecmp(tmp.bv_val, "telex", LENOF("telex")) == 0 ))
              {
                     tmp.bv_len -= LENOF("telex");
                     tmp.bv_val += LENOF("telex");
                     break;
              }
              if(( tmp.bv_len >= LENOF("teletex") ) &&
                     ( strncasecmp(tmp.bv_val, "teletex", LENOF("teletex")) == 0 ))
              {
                     tmp.bv_len -= LENOF("teletex");
                     tmp.bv_val += LENOF("teletex");
                     break;
              }
              if(( tmp.bv_len >= LENOF("telephone") ) &&
                     ( strncasecmp(tmp.bv_val, "telephone", LENOF("telephone")) == 0 ))
              {
                     tmp.bv_len -= LENOF("telephone");
                     tmp.bv_val += LENOF("telephone");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 'g':
       case 'G': /* g3fax or g4fax */
              if(( tmp.bv_len >= LENOF("g3fax") ) && (
                     ( strncasecmp(tmp.bv_val, "g3fax", LENOF("g3fax")) == 0 ) ||
                     ( strncasecmp(tmp.bv_val, "g4fax", LENOF("g4fax")) == 0 )))
              {
                     tmp.bv_len -= LENOF("g3fax");
                     tmp.bv_val += LENOF("g3fax");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 'i':
       case 'I':
              if(( tmp.bv_len >= LENOF("ia5") ) &&
                     ( strncasecmp(tmp.bv_val, "ia5", LENOF("ia5")) == 0 ))
              {
                     tmp.bv_len -= LENOF("ia5");
                     tmp.bv_val += LENOF("ia5");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       case 'v':
       case 'V':
              if(( tmp.bv_len >= LENOF("videotex") ) &&
                     ( strncasecmp(tmp.bv_val, "videotex", LENOF("videotex")) == 0 ))
              {
                     tmp.bv_len -= LENOF("videotex");
                     tmp.bv_val += LENOF("videotex");
                     break;
              }
              return LDAP_INVALID_SYNTAX;

       default:
              return LDAP_INVALID_SYNTAX;
       }

       if( BER_BVISEMPTY( &tmp ) ) return LDAP_SUCCESS;

       while( !BER_BVISEMPTY( &tmp ) && ( tmp.bv_val[0] == ' ' ) ) {
              tmp.bv_len++;
              tmp.bv_val--;
       }
       if( !BER_BVISEMPTY( &tmp ) && ( tmp.bv_val[0] == '$' ) ) {
              tmp.bv_len++;
              tmp.bv_val--;
       } else {
              return LDAP_INVALID_SYNTAX;
       }
       while( !BER_BVISEMPTY( &tmp ) && ( tmp.bv_val[0] == ' ' ) ) {
              tmp.bv_len++;
              tmp.bv_val--;
       }

       goto again;
}

Here is the call graph for this function:

static int directoryStringSubstringsMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 1868 of file schema_init.c.

{
       int match = 0;
       SubstringsAssertion *sub = assertedValue;
       struct berval left = *value;
       ber_len_t i;
       int priorspace=0;

       if ( !BER_BVISNULL( &sub->sa_initial ) ) {
              if ( sub->sa_initial.bv_len > left.bv_len ) {
                     /* not enough left */
                     match = 1;
                     goto done;
              }

              match = memcmp( sub->sa_initial.bv_val, left.bv_val,
                     sub->sa_initial.bv_len );

              if ( match != 0 ) {
                     goto done;
              }

              left.bv_val += sub->sa_initial.bv_len;
              left.bv_len -= sub->sa_initial.bv_len;

              priorspace = ASCII_SPACE(
                     sub->sa_initial.bv_val[sub->sa_initial.bv_len] );
       }

       if ( sub->sa_any ) {
              for ( i = 0; !BER_BVISNULL( &sub->sa_any[i] ); i++ ) {
                     ber_len_t idx;
                     char *p;

                     if( priorspace && !BER_BVISEMPTY( &sub->sa_any[i] ) 
                            && ASCII_SPACE( sub->sa_any[i].bv_val[0] ))
                     { 
                            /* allow next space to match */
                            left.bv_val--;
                            left.bv_len++;
                     }
                     priorspace=0;

retry:
                     if ( BER_BVISEMPTY( &sub->sa_any[i] ) ) {
                            continue;
                     }

                     if ( sub->sa_any[i].bv_len > left.bv_len ) {
                            /* not enough left */
                            match = 1;
                            goto done;
                     }

                     p = memchr( left.bv_val, *sub->sa_any[i].bv_val, left.bv_len );

                     if( p == NULL ) {
                            match = 1;
                            goto done;
                     }

                     idx = p - left.bv_val;

                     if ( idx >= left.bv_len ) {
                            /* this shouldn't happen */
                            return LDAP_OTHER;
                     }

                     left.bv_val = p;
                     left.bv_len -= idx;

                     if ( sub->sa_any[i].bv_len > left.bv_len ) {
                            /* not enough left */
                            match = 1;
                            goto done;
                     }

                     match = memcmp( left.bv_val,
                            sub->sa_any[i].bv_val,
                            sub->sa_any[i].bv_len );

                     if ( match != 0 ) {
                            left.bv_val++;
                            left.bv_len--;
                            goto retry;
                     }

                     left.bv_val += sub->sa_any[i].bv_len;
                     left.bv_len -= sub->sa_any[i].bv_len;

                     priorspace = ASCII_SPACE(
                            sub->sa_any[i].bv_val[sub->sa_any[i].bv_len] );
              }
       }

       if ( !BER_BVISNULL( &sub->sa_final ) ) {
              if( priorspace && !BER_BVISEMPTY( &sub->sa_final ) 
                     && ASCII_SPACE( sub->sa_final.bv_val[0] ))
              { 
                     /* allow next space to match */
                     left.bv_val--;
                     left.bv_len++;
              }

              if ( sub->sa_final.bv_len > left.bv_len ) {
                     /* not enough left */
                     match = 1;
                     goto done;
              }

              match = memcmp( sub->sa_final.bv_val,
                     &left.bv_val[left.bv_len - sub->sa_final.bv_len],
                     sub->sa_final.bv_len );

              if ( match != 0 ) {
                     goto done;
              }
       }

done:
       *matchp = match;
       return LDAP_SUCCESS;
}
static int firstComponentNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 6044 of file schema_init.c.

{
       int rc;
       struct berval comp;
       ber_len_t len;

       if( SLAP_MR_IS_VALUE_OF_ASSERTION_SYNTAX( usage )) {
              ber_dupbv_x( normalized, val, ctx );
              return LDAP_SUCCESS;
       }

       if( val->bv_len < 3 ) return LDAP_INVALID_SYNTAX;

       if( ! ( val->bv_val[0] == '(' /*')'*/
                     && val->bv_val[val->bv_len - 1] == /*'('*/ ')' )
              && ! ( val->bv_val[0] == '{' /*'}'*/
                     && val->bv_val[val->bv_len - 1] == /*'('*/ '}' ) )
       {
              return LDAP_INVALID_SYNTAX;
       }

       /* trim leading white space */
       for( len=1;
              len < val->bv_len && ASCII_SPACE(val->bv_val[len]);
              len++ )
       {
              /* empty */
       }

       /* grab next word */
       comp.bv_val = &val->bv_val[len];
       len = val->bv_len - len - STRLENOF(/*"{"*/ "}");
       for( comp.bv_len = 0;
              !ASCII_SPACE(comp.bv_val[comp.bv_len]) && comp.bv_len < len;
              comp.bv_len++ )
       {
              /* empty */
       }

       if( mr == slap_schema.si_mr_objectIdentifierFirstComponentMatch ) {
              rc = numericoidValidate( NULL, &comp );
       } else if( mr == slap_schema.si_mr_integerFirstComponentMatch ) {
              rc = integerValidate( NULL, &comp );
       } else {
              rc = LDAP_INVALID_SYNTAX;
       }
       

       if( rc == LDAP_SUCCESS ) {
              ber_dupbv_x( normalized, &comp, ctx );
       }

       return rc;
}

Here is the call graph for this function:

int generalizedTimeFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
)

Definition at line 5773 of file schema_init.c.

{
       BerVarray keys;
       char tmp[5];
       BerValue bvtmp; /* 40 bit index */
       BerValue *value = (BerValue *) assertedValue;
       struct lutil_tm tm;
       struct lutil_timet tt;
       
       bvtmp.bv_len = sizeof(tmp);
       bvtmp.bv_val = tmp;
       /* GeneralizedTime YYYYmmddHH[MM[SS]][(./,)d...](Z|(+/-)HH[MM]) */
       /* Use 40 bits of time for key */
       if ( value->bv_val && value->bv_len >= 10 &&
              lutil_parsetime( value->bv_val, &tm ) == 0 ) {

              lutil_tm2time( &tm, &tt );
              tmp[0] = tt.tt_gsec & 0xff;
              tmp[4] = tt.tt_sec & 0xff;
              tt.tt_sec >>= 8;
              tmp[3] = tt.tt_sec & 0xff;
              tt.tt_sec >>= 8;
              tmp[2] = tt.tt_sec & 0xff;
              tt.tt_sec >>= 8;
              tmp[1] = tt.tt_sec & 0xff;

              keys = slap_sl_malloc( sizeof( struct berval ) * 2, ctx );
              ber_dupbv_x(keys, &bvtmp, ctx );
              keys[1].bv_val = NULL;
              keys[1].bv_len = 0;
       } else {
              keys = NULL;
       }

       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

int generalizedTimeIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
)

Definition at line 5717 of file schema_init.c.

{
       int i, j;
       BerVarray keys;
       char tmp[5];
       BerValue bvtmp; /* 40 bit index */
       struct lutil_tm tm;
       struct lutil_timet tt;

       bvtmp.bv_len = sizeof(tmp);
       bvtmp.bv_val = tmp;
       for( i=0; values[i].bv_val != NULL; i++ ) {
              /* just count them */
       }

       /* we should have at least one value at this point */
       assert( i > 0 );

       keys = slap_sl_malloc( sizeof( struct berval ) * (i+1), ctx );

       /* GeneralizedTime YYYYmmddHH[MM[SS]][(./,)d...](Z|(+/-)HH[MM]) */
       for( i=0, j=0; values[i].bv_val != NULL; i++ ) {
              assert(values[i].bv_val != NULL && values[i].bv_len >= 10);
              /* Use 40 bits of time for key */
              if ( lutil_parsetime( values[i].bv_val, &tm ) == 0 ) {
                     lutil_tm2time( &tm, &tt );
                     tmp[0] = tt.tt_gsec & 0xff;
                     tmp[4] = tt.tt_sec & 0xff;
                     tt.tt_sec >>= 8;
                     tmp[3] = tt.tt_sec & 0xff;
                     tt.tt_sec >>= 8;
                     tmp[2] = tt.tt_sec & 0xff;
                     tt.tt_sec >>= 8;
                     tmp[1] = tt.tt_sec & 0xff;
                     
                     ber_dupbv_x(&keys[j++], &bvtmp, ctx );
              }
       }

       keys[j].bv_val = NULL;
       keys[j].bv_len = 0;

       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int generalizedTimeNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 5653 of file schema_init.c.

{
       int parts[9], rc;
       unsigned int len;
       struct berval fraction;

       rc = check_time_syntax(val, 0, parts, &fraction);
       if (rc != LDAP_SUCCESS) {
              return rc;
       }

       len = STRLENOF("YYYYmmddHHMMSSZ") + fraction.bv_len;
       normalized->bv_val = slap_sl_malloc( len + 1, ctx );
       if ( BER_BVISNULL( normalized ) ) {
              return LBER_ERROR_MEMORY;
       }

       sprintf( normalized->bv_val, "%02d%02d%02d%02d%02d%02d%02d",
              parts[0], parts[1], parts[2] + 1, parts[3] + 1,
              parts[4], parts[5], parts[6] );
       if ( !BER_BVISEMPTY( &fraction ) ) {
              memcpy( normalized->bv_val + STRLENOF("YYYYmmddHHMMSSZ")-1,
                     fraction.bv_val, fraction.bv_len );
              normalized->bv_val[STRLENOF("YYYYmmddHHMMSSZ")-1] = '.';
       }
       strcpy( normalized->bv_val + len-1, "Z" );
       normalized->bv_len = len;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int generalizedTimeOrderingMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 5691 of file schema_init.c.

{
       struct berval *asserted = (struct berval *) assertedValue;
       ber_len_t v_len  = value->bv_len;
       ber_len_t av_len = asserted->bv_len;

       /* ignore trailing 'Z' when comparing */
       int match = memcmp( value->bv_val, asserted->bv_val,
              (v_len < av_len ? v_len : av_len) - 1 );
       if ( match == 0 ) match = v_len - av_len;

       /* If used in extensible match filter, match if value < asserted */
       if ( flags & SLAP_MR_EXT )
              match = (match >= 0);

       *matchp = match;
       return LDAP_SUCCESS;
}
static int generalizedTimeValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 5643 of file schema_init.c.

{
       int parts[9];
       struct berval fraction;
       return check_time_syntax(in, 0, parts, &fraction);
}

Here is the caller graph for this function:

static void hashIter ( HASH_CONTEXT HASHcontext,
unsigned char *  HASHdigest,
unsigned char *  value,
int  len 
) [static]

Definition at line 621 of file schema_init.c.

{
       HASH_CONTEXT ctx = *HASHcontext;
       HASH_Update( &ctx, value, len );
       HASH_Final( HASHdigest, &ctx );
}

Here is the caller graph for this function:

static void hashPreset ( HASH_CONTEXT HASHcontext,
struct berval prefix,
char  pre,
Syntax syntax,
MatchingRule mr 
) [static]

Definition at line 601 of file schema_init.c.

{
       HASH_Init(HASHcontext);
       if(prefix && prefix->bv_len > 0) {
              HASH_Update(HASHcontext,
                     (unsigned char *)prefix->bv_val, prefix->bv_len);
       }
       if(pre) HASH_Update(HASHcontext, (unsigned char*)&pre, sizeof(pre));
       HASH_Update(HASHcontext, (unsigned char*)syntax->ssyn_oid, syntax->ssyn_oidlen);
       HASH_Update(HASHcontext, (unsigned char*)mr->smr_oid, mr->smr_oidlen);
       return;
}

Here is the caller graph for this function:

static int hexNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 4902 of file schema_init.c.

{
       ber_len_t     i;

       assert( val != NULL );
       assert( normalized != NULL );

       ber_dupbv_x( normalized, val, ctx );

       for ( i = 0; i < normalized->bv_len; i++ ) {
              if ( !ASCII_HEX( normalized->bv_val[ i ] ) ) {
                     ber_memfree_x( normalized->bv_val, ctx );
                     BER_BVZERO( normalized );
                     return LDAP_INVALID_SYNTAX;
              }

              normalized->bv_val[ i ] = TOLOWER( normalized->bv_val[ i ] );
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int hexValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 4881 of file schema_init.c.

{
       ber_len_t     i;

       assert( in != NULL );
       assert( !BER_BVISNULL( in ) );

       for ( i = 0; i < in->bv_len; i++ ) {
              if ( !ASCII_HEX( in->bv_val[ i ] ) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

static int IA5StringNormalize ( slap_mask_t  use,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 2780 of file schema_init.c.

{
       char *p, *q;
       int casefold = !SLAP_MR_ASSOCIATED( mr,
              slap_schema.si_mr_caseExactIA5Match );

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( use ) != 0 );

       p = val->bv_val;

       /* Ignore initial whitespace */
       while ( ASCII_SPACE( *p ) ) p++;

       normalized->bv_len = val->bv_len - ( p - val->bv_val );
       normalized->bv_val = slap_sl_malloc( normalized->bv_len + 1, ctx );
       AC_MEMCPY( normalized->bv_val, p, normalized->bv_len );
       normalized->bv_val[normalized->bv_len] = '\0';

       p = q = normalized->bv_val;

       while ( *p ) {
              if ( ASCII_SPACE( *p ) ) {
                     *q++ = *p++;

                     /* Ignore the extra whitespace */
                     while ( ASCII_SPACE( *p ) ) {
                            p++;
                     }

              } else if ( casefold ) {
                     /* Most IA5 rules require casefolding */
                     *q++ = TOLOWER(*p); p++;

              } else {
                     *q++ = *p++;
              }
       }

       assert( normalized->bv_val <= p );
       assert( q <= p );

       /*
        * If the string ended in space, backup the pointer one
        * position.  One is enough because the above loop collapsed
        * all whitespace to a single space.
        */
       if ( q > normalized->bv_val && ASCII_SPACE( q[-1] ) ) --q;

       /* null terminate */
       *q = '\0';

       normalized->bv_len = q - normalized->bv_val;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int IA5StringValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 2764 of file schema_init.c.

{
       ber_len_t i;

       for(i=0; i < val->bv_len; i++) {
              if( !LDAP_ASCII(val->bv_val[i]) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}
static int integerBitAndMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 3062 of file schema_init.c.

{
       SLAP_LONG lValue, lAssertedValue;

       errno = 0;
       /* safe to assume integers are NUL terminated? */
       lValue = SLAP_STRTOL(value->bv_val, NULL, 10);
       if( errno == ERANGE )
       {
              return LDAP_CONSTRAINT_VIOLATION;
       }

       lAssertedValue = SLAP_STRTOL(((struct berval *)assertedValue)->bv_val,
              NULL, 10);
       if( errno == ERANGE )
       {
              return LDAP_CONSTRAINT_VIOLATION;
       }

       *matchp = ((lValue & lAssertedValue) == lAssertedValue) ? 0 : 1;
       return LDAP_SUCCESS;
}
static int integerBitOrMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 3092 of file schema_init.c.

{
       SLAP_LONG lValue, lAssertedValue;

       errno = 0;
       /* safe to assume integers are NUL terminated? */
       lValue = SLAP_STRTOL(value->bv_val, NULL, 10);
       if( errno == ERANGE )
       {
              return LDAP_CONSTRAINT_VIOLATION;
       }

       lAssertedValue = SLAP_STRTOL( ((struct berval *)assertedValue)->bv_val,
              NULL, 10);
       if( errno == ERANGE )
       {
              return LDAP_CONSTRAINT_VIOLATION;
       }

       *matchp = ((lValue & lAssertedValue) != 0) ? 0 : -1;
       return LDAP_SUCCESS;
}
static int integerFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
) [static]

Definition at line 2652 of file schema_init.c.

{
       char ibuf[64];
       struct berval iv;
       BerVarray keys;
       struct berval *value;
       int rc;

       value = (struct berval *) assertedValue;

       keys = slap_sl_malloc( sizeof( struct berval ) * 2, ctx );

       keys[0].bv_len = index_intlen;
       keys[0].bv_val = slap_sl_malloc( index_intlen, ctx );
       keys[1].bv_len = 0;
       keys[1].bv_val = NULL;

       iv.bv_len = value->bv_len < index_intlen_strlen + INDEX_INTLEN_CHOP-1
              ? value->bv_len : index_intlen_strlen + INDEX_INTLEN_CHOP-1;
       if ( iv.bv_len > (int) sizeof(ibuf) ) {
              iv.bv_val = slap_sl_malloc( iv.bv_len, ctx );
       } else {
              iv.bv_val = ibuf;
              iv.bv_len = sizeof(ibuf);
       }

       rc = integerVal2Key( value, keys, &iv, ctx );
       if ( rc == 0 )
              *keysp = keys;

       if ( iv.bv_val != ibuf ) {
              slap_sl_free( iv.bv_val, ctx );
       }
       return rc;
}

Here is the call graph for this function:

static int integerIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
) [static]

Definition at line 2586 of file schema_init.c.

{
       char ibuf[64];
       struct berval itmp;
       BerVarray keys;
       ber_len_t vlen;
       int i, rc;
       unsigned maxstrlen = index_intlen_strlen + INDEX_INTLEN_CHOP-1;

       /* count the values and find max needed length */
       vlen = 0;
       for( i = 0; !BER_BVISNULL( &values[i] ); i++ ) {
              if ( vlen < values[i].bv_len )
                     vlen = values[i].bv_len;
       }
       if ( vlen > maxstrlen )
              vlen = maxstrlen;

       /* we should have at least one value at this point */
       assert( i > 0 );

       keys = slap_sl_malloc( sizeof( struct berval ) * (i+1), ctx );
       for ( i = 0; !BER_BVISNULL( &values[i] ); i++ ) {
              keys[i].bv_len = index_intlen;
              keys[i].bv_val = slap_sl_malloc( index_intlen, ctx );
       }
       keys[i].bv_len = 0;
       keys[i].bv_val = NULL;

       if ( vlen > sizeof(ibuf) ) {
              itmp.bv_val = slap_sl_malloc( vlen, ctx );
       } else {
              itmp.bv_val = ibuf;
       }
       itmp.bv_len = sizeof(ibuf);

       for ( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
              if ( itmp.bv_val != ibuf ) {
                     itmp.bv_len = values[i].bv_len;
                     if ( itmp.bv_len <= sizeof(ibuf) )
                            itmp.bv_len = sizeof(ibuf);
                     else if ( itmp.bv_len > maxstrlen )
                            itmp.bv_len = maxstrlen;
              }
              rc = integerVal2Key( &values[i], &keys[i], &itmp, ctx );
              if ( rc )
                     goto func_leave;
       }
       *keysp = keys;
func_leave:
       if ( itmp.bv_val != ibuf ) {
              slap_sl_free( itmp.bv_val, ctx );
       }
       return rc;
}

Here is the call graph for this function:

static int integerMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 2467 of file schema_init.c.

{
       struct berval *asserted = (struct berval *) assertedValue;
       int vsign = 1, asign = 1;   /* default sign = '+' */
       struct berval v, a;
       int match;

       v = *value;
       if( v.bv_val[0] == '-' ) {
              vsign = -1;
              v.bv_val++;
              v.bv_len--;
       }

       if( BER_BVISEMPTY( &v ) ) vsign = 0;

       a = *asserted;
       if( a.bv_val[0] == '-' ) {
              asign = -1;
              a.bv_val++;
              a.bv_len--;
       }

       if( BER_BVISEMPTY( &a ) ) vsign = 0;

       match = vsign - asign;
       if( match == 0 ) {
              match = ( v.bv_len != a.bv_len
                     ? ( v.bv_len < a.bv_len ? -1 : 1 )
                     : memcmp( v.bv_val, a.bv_val, v.bv_len ));
              if( vsign < 0 ) match = -match;
       }

       /* Ordering rule used in extensible match filter? */
       if ( (flags & SLAP_MR_EXT) && (mr->smr_usage & SLAP_MR_ORDERING) )
              match = (match >= 0);

       *matchp = match;
       return LDAP_SUCCESS;
}
static int integerVal2Key ( struct berval in,
struct berval key,
struct berval tmp,
void ctx 
) [static]

Definition at line 2519 of file schema_init.c.

{
       /* Integer index key format, designed for memcmp to collate correctly:
        * if too large: one's complement sign*<approx exponent=chopped bytes>,
        * two's complement value (sign-extended or chopped as needed),
        * however in first byte above, the top <number of exponent-bytes + 1>
        * bits are the inverse sign and next bit is the sign as delimiter.
        */
       ber_slen_t k = index_intlen_strlen;
       ber_len_t chop = 0;
       unsigned signmask = ~0x7fU;
       unsigned char lenbuf[sizeof(k) + 2], *lenp, neg = 0xff;
       struct berval val = *in, itmp = *tmp;

       if ( val.bv_val[0] != '-' ) {
              neg = 0;
              --k;
       }

       /* Chop least significant digits, increase length instead */
       if ( val.bv_len > (ber_len_t) k ) {
              chop = (val.bv_len-k+2)/INDEX_INTLEN_CHOP; /* 2 fewer digits */
              val.bv_len -= chop * INDEX_INTLEN_CHOP;   /* #digits chopped */
              chop *= INDEX_INTLEN_CHOPBYTES;           /* #bytes added */
       }

       if ( lutil_str2bin( &val, &itmp, ctx )) {
              return LDAP_INVALID_SYNTAX;
       }

       /* Omit leading sign byte */
       if ( itmp.bv_val[0] == neg ) {
              itmp.bv_val++;
              itmp.bv_len--;
       }

       k = (ber_slen_t) index_intlen - (ber_slen_t) (itmp.bv_len + chop);
       if ( k > 0 ) {
              assert( chop == 0 );
              memset( key->bv_val, neg, k );     /* sign-extend */
       } else if ( k != 0 || ((itmp.bv_val[0] ^ neg) & 0xc0) ) {
              /* Got exponent -k, or no room for 2 sign bits */
              lenp = lenbuf + sizeof(lenbuf);
              chop = - (ber_len_t) k;
              do {
                     *--lenp = ((unsigned char) chop & 0xff) ^ neg;
                     signmask >>= 1;
              } while ( (chop >>= 8) != 0 || (signmask >> 1) & (*lenp ^ neg) );
              /* With n bytes in lenbuf, the top n+1 bits of (signmask&0xff)
               * are 1, and the top n+2 bits of lenp[0] are the sign bit. */
              k = (lenbuf + sizeof(lenbuf)) - lenp;
              if ( k > (ber_slen_t) index_intlen )
                     k = index_intlen;
              memcpy( key->bv_val, lenp, k );
              itmp.bv_len = index_intlen - k;
       }
       memcpy( key->bv_val + k, itmp.bv_val, itmp.bv_len );
       key->bv_val[0] ^= (unsigned char) signmask & 0xff; /* invert sign */
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int integerValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 2428 of file schema_init.c.

{
       ber_len_t i;
       struct berval val = *in;

       if ( BER_BVISEMPTY( &val ) ) return LDAP_INVALID_SYNTAX;

       if ( val.bv_val[0] == '-' ) {
              val.bv_len--;
              val.bv_val++;

              if( BER_BVISEMPTY( &val ) ) { /* bare "-" */
                     return LDAP_INVALID_SYNTAX;
              }

              if( val.bv_val[0] == '0' ) { /* "-0" */
                     return LDAP_INVALID_SYNTAX;
              }

       } else if ( val.bv_val[0] == '0' ) {
              if( val.bv_len > 1 ) { /* "0<more>" */
                     return LDAP_INVALID_SYNTAX;
              }

              return LDAP_SUCCESS;
       }

       for( i=0; i < val.bv_len; i++ ) {
              if( !ASCII_DIGIT(val.bv_val[i]) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

static int inValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 184 of file schema_init.c.

{
       /* no value allowed */
       return LDAP_INVALID_SYNTAX;
}
static int issuerAndThisUpdateCheck ( struct berval in,
struct berval is,
struct berval tu,
void ctx 
) [static]

Definition at line 3772 of file schema_init.c.

{
       int numdquotes = 0;
       struct berval x = *in;
       struct berval ni = BER_BVNULL;
       /* Parse GSER format */ 
       enum {
              HAVE_NONE = 0x0,
              HAVE_ISSUER = 0x1,
              HAVE_THISUPDATE = 0x2,
              HAVE_ALL = ( HAVE_ISSUER | HAVE_THISUPDATE )
       } have = HAVE_NONE;


       if ( in->bv_len < STRLENOF( "{issuer \"\",thisUpdate \"YYMMDDhhmmssZ\"}" ) ) return LDAP_INVALID_SYNTAX;

       if ( in->bv_val[0] != '{' && in->bv_val[in->bv_len-1] != '}' ) {
              return LDAP_INVALID_SYNTAX;
       }

       x.bv_val++;
       x.bv_len -= STRLENOF("{}");

       do {
              /* eat leading spaces */
              for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                     /* empty */;
              }

              /* should be at issuer or thisUpdate */
              if ( strncasecmp( x.bv_val, "issuer", STRLENOF("issuer") ) == 0 ) {
                     if ( have & HAVE_ISSUER ) return LDAP_INVALID_SYNTAX;

                     /* parse issuer */
                     x.bv_val += STRLENOF("issuer");
                     x.bv_len -= STRLENOF("issuer");

                     if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     /* For backward compatibility, this part is optional */
                     if ( strncasecmp( x.bv_val, "rdnSequence:", STRLENOF("rdnSequence:") ) != 0 ) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     x.bv_val += STRLENOF("rdnSequence:");
                     x.bv_len -= STRLENOF("rdnSequence:");

                     if ( x.bv_val[0] != '"' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     is->bv_val = x.bv_val;
                     is->bv_len = 0;

                     for ( ; is->bv_len < x.bv_len; ) {
                            if ( is->bv_val[is->bv_len] != '"' ) {
                                   is->bv_len++;
                                   continue;
                            }
                            if ( is->bv_val[is->bv_len+1] == '"' ) {
                                   /* double dquote */
                                   is->bv_len += 2;
                                   continue;
                            }
                            break;
                     }
                     x.bv_val += is->bv_len + 1;
                     x.bv_len -= is->bv_len + 1;

                     have |= HAVE_ISSUER;

              } else if ( strncasecmp( x.bv_val, "thisUpdate", STRLENOF("thisUpdate") ) == 0 )
              {
                     if ( have & HAVE_THISUPDATE ) return LDAP_INVALID_SYNTAX;

                     /* parse thisUpdate */
                     x.bv_val += STRLENOF("thisUpdate");
                     x.bv_len -= STRLENOF("thisUpdate");

                     if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( x.bv_val[0] != '"' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     tu->bv_val = x.bv_val;
                     tu->bv_len = 0;

                     for ( ; tu->bv_len < x.bv_len; tu->bv_len++ ) {
                            if ( tu->bv_val[tu->bv_len] == '"' ) {
                                   break;
                            }
                     }
                     x.bv_val += tu->bv_len + 1;
                     x.bv_len -= tu->bv_len + 1;

                     have |= HAVE_THISUPDATE;

              } else {
                     return LDAP_INVALID_SYNTAX;
              }

              /* eat leading spaces */
              for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                     /* empty */;
              }

              if ( have == HAVE_ALL ) {
                     break;
              }

              if ( x.bv_val[0] != ',' ) {
                     return LDAP_INVALID_SYNTAX;
              }

              x.bv_val++;
              x.bv_len--;
       } while ( 1 );

       /* should have no characters left... */
       if ( x.bv_len ) return LDAP_INVALID_SYNTAX;

       if ( numdquotes == 0 ) {
              ber_dupbv_x( &ni, is, ctx );

       } else {
              ber_len_t src, dst;

              ni.bv_len = is->bv_len - numdquotes;
              ni.bv_val = ber_memalloc_x( ni.bv_len + 1, ctx );
              for ( src = 0, dst = 0; src < is->bv_len; src++, dst++ ) {
                     if ( is->bv_val[src] == '"' ) {
                            src++;
                     }
                     ni.bv_val[dst] = is->bv_val[src];
              }
              ni.bv_val[dst] = '\0';
       }
              
       *is = ni;

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int issuerAndThisUpdateNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 4034 of file schema_init.c.

{
       struct berval i, ni, tu, tu2;
       char sbuf[STRLENOF("YYYYmmddHHMMSSZ") + 1];
       char *p;
       int rc;

       assert( in != NULL );
       assert( out != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> issuerAndThisUpdateNormalize: <%s>\n",
              in->bv_val, 0, 0 );

       rc = issuerAndThisUpdateCheck( in, &i, &tu, ctx );
       if ( rc ) {
              return rc;
       }

       rc = dnNormalize( usage, syntax, mr, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       tu2.bv_val = sbuf;
       tu2.bv_len = sizeof( sbuf );
       if ( rc || checkTime( &tu, &tu2 ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       out->bv_len = STRLENOF( "{ issuer rdnSequence:\"\", thisUpdate \"\" }" )
              + ni.bv_len + tu2.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto func_leave;
       }

       p = out->bv_val;

       p = lutil_strcopy( p, "{ issuer rdnSequence:\"" /*}*/ );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, "\", thisUpdate \"" );
       p = lutil_strbvcopy( p, &tu2 );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       assert( p == &out->bv_val[out->bv_len] );

func_leave:
       Debug( LDAP_DEBUG_TRACE, "<<< issuerAndThisUpdateNormalize: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       slap_sl_free( ni.bv_val, ctx );

       return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int issuerAndThisUpdatePretty ( Syntax syntax,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 3970 of file schema_init.c.

{
       int rc;
       struct berval i, tu, ni = BER_BVNULL;
       char *p;

       assert( in != NULL );
       assert( out != NULL );

       BER_BVZERO( out );

       Debug( LDAP_DEBUG_TRACE, ">>> issuerAndThisUpdatePretty: <%s>\n",
              in->bv_val, 0, 0 );

       rc = issuerAndThisUpdateCheck( in, &i, &tu, ctx );
       if ( rc ) {
              goto done;
       }

       rc = dnPretty( syntax, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       if ( rc || checkTime( &tu, NULL ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }

       /* make room */
       out->bv_len = STRLENOF("{ issuer rdnSequence:\"\", thisUpdate \"\" }")
              + ni.bv_len + tu.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto done;
       }

       p = out->bv_val;
       p = lutil_strcopy( p, "{ issuer rdnSequence:\"" /*}*/ );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, "\", thisUpdate \"" );
       p = lutil_strbvcopy( p, &tu );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       assert( p == &out->bv_val[out->bv_len] );

done:;
       Debug( LDAP_DEBUG_TRACE, "<<< issuerAndThisUpdatePretty: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       slap_sl_free( ni.bv_val, ctx );

       return rc; 
}

Here is the call graph for this function:

static int issuerAndThisUpdateValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 3934 of file schema_init.c.

{
       int rc;
       struct berval i, tu;

       Debug( LDAP_DEBUG_TRACE, ">>> issuerAndThisUpdateValidate: <%s>\n",
              in->bv_val, 0, 0 );

       rc = issuerAndThisUpdateCheck( in, &i, &tu, NULL );
       if ( rc ) {
              goto done;
       }

       /* validate DN -- doesn't handle double dquote */ 
       rc = dnValidate( NULL, &i );
       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;

       } else if ( checkTime( &tu, NULL ) ) {
              rc = LDAP_INVALID_SYNTAX;
       }

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, NULL );
       }

       Debug( LDAP_DEBUG_TRACE, "<<< issuerAndThisUpdateValidate: <%s> err=%d\n",
              in->bv_val, rc, 0 );

done:;
       return rc;
}

Here is the call graph for this function:

int nameUIDPretty ( Syntax syntax,
struct berval val,
struct berval out,
void ctx 
)

Definition at line 1309 of file schema_init.c.

{
       assert( val != NULL );
       assert( out != NULL );


       Debug( LDAP_DEBUG_TRACE, ">>> nameUIDPretty: <%s>\n", val->bv_val, 0, 0 );

       if( BER_BVISEMPTY( val ) ) {
              ber_dupbv_x( out, val, ctx );

       } else if ( val->bv_len > SLAP_LDAPDN_MAXLEN ) {
              return LDAP_INVALID_SYNTAX;

       } else {
              int           rc;
              struct berval dnval = *val;
              struct berval uidval = BER_BVNULL;

              uidval.bv_val = strrchr( val->bv_val, '#' );
              if ( !BER_BVISNULL( &uidval ) ) {
                     uidval.bv_val++;
                     uidval.bv_len = val->bv_len - ( uidval.bv_val - val->bv_val );

                     rc = bitStringValidate( NULL, &uidval );

                     if ( rc == LDAP_SUCCESS ) {
                            ber_dupbv_x( &dnval, val, ctx );
                            uidval.bv_val--;
                            dnval.bv_len -= ++uidval.bv_len;
                            dnval.bv_val[dnval.bv_len] = '\0';

                     } else {
                            BER_BVZERO( &uidval );
                     }
              }

              rc = dnPretty( syntax, &dnval, out, ctx );
              if ( dnval.bv_val != val->bv_val ) {
                     slap_sl_free( dnval.bv_val, ctx );
              }
              if( rc != LDAP_SUCCESS ) {
                     return rc;
              }

              if( !BER_BVISNULL( &uidval ) ) {
                     char   *tmp;

                     tmp = slap_sl_realloc( out->bv_val, out->bv_len 
                            + uidval.bv_len + 1,
                            ctx );
                     if( tmp == NULL ) {
                            ber_memfree_x( out->bv_val, ctx );
                            return LDAP_OTHER;
                     }
                     out->bv_val = tmp;
                     memcpy( out->bv_val + out->bv_len, uidval.bv_val, uidval.bv_len );
                     out->bv_len += uidval.bv_len;
                     out->bv_val[out->bv_len] = '\0';
              }
       }

       Debug( LDAP_DEBUG_TRACE, "<<< nameUIDPretty: <%s>\n", out->bv_val, 0, 0 );

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int nameUIDValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 1275 of file schema_init.c.

{
       int rc;
       struct berval dn, uid;

       if( BER_BVISEMPTY( in ) ) return LDAP_SUCCESS;

       ber_dupbv( &dn, in );
       if( !dn.bv_val ) return LDAP_OTHER;

       /* if there's a "#", try bitStringValidate()... */
       uid.bv_val = strrchr( dn.bv_val, '#' );
       if ( !BER_BVISNULL( &uid ) ) {
              uid.bv_val++;
              uid.bv_len = dn.bv_len - ( uid.bv_val - dn.bv_val );

              rc = bitStringValidate( NULL, &uid );
              if ( rc == LDAP_SUCCESS ) {
                     /* in case of success, trim the UID,
                      * otherwise treat it as part of the DN */
                     dn.bv_len -= uid.bv_len + 1;
                     uid.bv_val[-1] = '\0';
              }
       }

       rc = dnValidate( NULL, &dn );

       ber_memfree( dn.bv_val );
       return rc;
}

Here is the call graph for this function:

static int nisNetgroupTripleValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 5954 of file schema_init.c.

{
       char *p, *e;
       int commas = 0;

       if ( BER_BVISEMPTY( val ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       p = (char *)val->bv_val;
       e = p + val->bv_len;

       if ( *p != '(' /*')'*/ ) {
              return LDAP_INVALID_SYNTAX;
       }

       for ( p++; ( p < e ) && ( *p != /*'('*/ ')' ); p++ ) {
              if ( *p == ',' ) {
                     commas++;
                     if ( commas > 2 ) {
                            return LDAP_INVALID_SYNTAX;
                     }

              } else if ( !AD_CHAR( *p ) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       if ( ( commas != 2 ) || ( *p != /*'('*/ ')' ) ) {
              return LDAP_INVALID_SYNTAX;
       }

       p++;

       if (p != e) {
              return LDAP_INVALID_SYNTAX;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

int numericoidValidate ( Syntax syntax,
struct berval in 
)

Definition at line 2384 of file schema_init.c.

{
       struct berval val = *in;

       if( BER_BVISEMPTY( &val ) ) {
              /* disallow empty strings */
              return LDAP_INVALID_SYNTAX;
       }

       while( OID_LEADCHAR( val.bv_val[0] ) ) {
              if ( val.bv_len == 1 ) {
                     return LDAP_SUCCESS;
              }

              if ( val.bv_val[0] == '0' && !OID_SEPARATOR( val.bv_val[1] )) {
                     break;
              }

              val.bv_val++;
              val.bv_len--;

              while ( OID_LEADCHAR( val.bv_val[0] )) {
                     val.bv_val++;
                     val.bv_len--;

                     if ( val.bv_len == 0 ) {
                            return LDAP_SUCCESS;
                     }
              }

              if( !OID_SEPARATOR( val.bv_val[0] )) {
                     break;
              }

              val.bv_val++;
              val.bv_len--;
       }

       return LDAP_INVALID_SYNTAX;
}

Here is the caller graph for this function:

static int numericStringNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 3004 of file schema_init.c.

{
       /* removal all spaces */
       char *p, *q;

       assert( !BER_BVISEMPTY( val ) );

       normalized->bv_val = slap_sl_malloc( val->bv_len + 1, ctx );

       p = val->bv_val;
       q = normalized->bv_val;

       while ( *p ) {
              if ( ASCII_SPACE( *p ) ) {
                     /* Ignore whitespace */
                     p++;
              } else {
                     *q++ = *p++;
              }
       }

       /* we should have copied no more than is in val */
       assert( (q - normalized->bv_val) <= (p - val->bv_val) );

       /* null terminate */
       *q = '\0';

       normalized->bv_len = q - normalized->bv_val;

       if( BER_BVISEMPTY( normalized ) ) {
              normalized->bv_val = slap_sl_realloc( normalized->bv_val, 2, ctx );
              normalized->bv_val[0] = ' ';
              normalized->bv_val[1] = '\0';
              normalized->bv_len = 1;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

int numericStringValidate ( Syntax syntax,
struct berval in 
)

Definition at line 2986 of file schema_init.c.

{
       ber_len_t i;

       if( BER_BVISEMPTY( in ) ) return LDAP_INVALID_SYNTAX;

       for(i=0; i < in->bv_len; i++) {
              if( !SLAP_NUMERIC(in->bv_val[i]) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int octetStringFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
)

Definition at line 679 of file schema_init.c.

{
       size_t slen, mlen;
       BerVarray keys;
       HASH_CONTEXT HASHcontext;
       unsigned char HASHdigest[HASH_BYTES];
       struct berval *value = (struct berval *) assertedValue;
       struct berval digest;
       digest.bv_val = (char *)HASHdigest;
       digest.bv_len = sizeof(HASHdigest);

       slen = syntax->ssyn_oidlen;
       mlen = mr->smr_oidlen;

       keys = slap_sl_malloc( sizeof( struct berval ) * 2, ctx );

       hashPreset( &HASHcontext, prefix, 0, syntax, mr );
       hashIter( &HASHcontext, HASHdigest,
              (unsigned char *)value->bv_val, value->bv_len );

       ber_dupbv_x( keys, &digest, ctx );
       BER_BVZERO( &keys[1] );

       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int octetStringIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
)

Definition at line 633 of file schema_init.c.

{
       int i;
       size_t slen, mlen;
       BerVarray keys;
       HASH_CONTEXT HASHcontext;
       unsigned char HASHdigest[HASH_BYTES];
       struct berval digest;
       digest.bv_val = (char *)HASHdigest;
       digest.bv_len = sizeof(HASHdigest);

       for( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
              /* just count them */
       }

       /* we should have at least one value at this point */
       assert( i > 0 );

       keys = slap_sl_malloc( sizeof( struct berval ) * (i+1), ctx );

       slen = syntax->ssyn_oidlen;
       mlen = mr->smr_oidlen;

       hashPreset( &HASHcontext, prefix, 0, syntax, mr);
       for( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
              hashIter( &HASHcontext, HASHdigest,
                     (unsigned char *)values[i].bv_val, values[i].bv_len );
              ber_dupbv_x( &keys[i], &digest, ctx );
       }

       BER_BVZERO( &keys[i] );

       *keysp = keys;

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

int octetStringMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
)

Definition at line 552 of file schema_init.c.

{
       struct berval *asserted = (struct berval *) assertedValue;
       ber_slen_t d = (ber_slen_t) value->bv_len - (ber_slen_t) asserted->bv_len;

       /* For speed, order first by length, then by contents */
       *matchp = d ? (sizeof(d) == sizeof(int) ? d : d < 0 ? -1 : 1)
              : memcmp( value->bv_val, asserted->bv_val, value->bv_len );

       return LDAP_SUCCESS;
}
int octetStringOrderingMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
)

Definition at line 571 of file schema_init.c.

{
       struct berval *asserted = (struct berval *) assertedValue;
       ber_len_t v_len  = value->bv_len;
       ber_len_t av_len = asserted->bv_len;

       int match = memcmp( value->bv_val, asserted->bv_val,
              (v_len < av_len ? v_len : av_len) );

       if( match == 0 )
              match = sizeof(v_len) == sizeof(int)
                     ? (int) v_len - (int) av_len
                     : v_len < av_len ? -1 : v_len > av_len;

       /* If used in extensible match filter, match if value < asserted */
       if ( flags & SLAP_MR_EXT )
              match = (match >= 0);

       *matchp = match;
       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

static int octetStringSubstringsFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
) [static]

Definition at line 961 of file schema_init.c.

{
       SubstringsAssertion *sa;
       char pre;
       ber_len_t nkeys = 0;
       size_t slen, mlen, klen;
       BerVarray keys;
       HASH_CONTEXT HASHcontext;
       unsigned char HASHdigest[HASH_BYTES];
       struct berval *value;
       struct berval digest;

       sa = (SubstringsAssertion *) assertedValue;

       if( flags & SLAP_INDEX_SUBSTR_INITIAL &&
              !BER_BVISNULL( &sa->sa_initial ) &&
              sa->sa_initial.bv_len >= index_substr_if_minlen )
       {
              nkeys++;
              if ( sa->sa_initial.bv_len > index_substr_if_maxlen &&
                     ( flags & SLAP_INDEX_SUBSTR_ANY ))
              {
                     nkeys += 1 + (sa->sa_initial.bv_len - index_substr_if_maxlen) / index_substr_any_step;
              }
       }

       if ( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
              ber_len_t i;
              for( i=0; !BER_BVISNULL( &sa->sa_any[i] ); i++ ) {
                     if( sa->sa_any[i].bv_len >= index_substr_any_len ) {
                            /* don't bother accounting with stepping */
                            nkeys += sa->sa_any[i].bv_len -
                                   ( index_substr_any_len - 1 );
                     }
              }
       }

       if( flags & SLAP_INDEX_SUBSTR_FINAL &&
              !BER_BVISNULL( &sa->sa_final ) &&
              sa->sa_final.bv_len >= index_substr_if_minlen )
       {
              nkeys++;
              if ( sa->sa_final.bv_len > index_substr_if_maxlen &&
                     ( flags & SLAP_INDEX_SUBSTR_ANY ))
              {
                     nkeys += 1 + (sa->sa_final.bv_len - index_substr_if_maxlen) / index_substr_any_step;
              }
       }

       if( nkeys == 0 ) {
              *keysp = NULL;
              return LDAP_SUCCESS;
       }

       digest.bv_val = (char *)HASHdigest;
       digest.bv_len = sizeof(HASHdigest);

       slen = syntax->ssyn_oidlen;
       mlen = mr->smr_oidlen;

       keys = slap_sl_malloc( sizeof( struct berval ) * (nkeys+1), ctx );
       nkeys = 0;

       if( flags & SLAP_INDEX_SUBSTR_INITIAL &&
              !BER_BVISNULL( &sa->sa_initial ) &&
              sa->sa_initial.bv_len >= index_substr_if_minlen )
       {
              pre = SLAP_INDEX_SUBSTR_INITIAL_PREFIX;
              value = &sa->sa_initial;

              klen = index_substr_if_maxlen < value->bv_len
                     ? index_substr_if_maxlen : value->bv_len;

              hashPreset( &HASHcontext, prefix, pre, syntax, mr );
              hashIter( &HASHcontext, HASHdigest,
                     (unsigned char *)value->bv_val, klen );
              ber_dupbv_x( &keys[nkeys++], &digest, ctx );

              /* If initial is too long and we have subany indexed, use it
               * to match the excess...
               */
              if (value->bv_len > index_substr_if_maxlen && (flags & SLAP_INDEX_SUBSTR_ANY))
              {
                     ber_len_t j;
                     pre = SLAP_INDEX_SUBSTR_PREFIX;
                     hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                     for ( j=index_substr_if_maxlen-1; j <= value->bv_len - index_substr_any_len; j+=index_substr_any_step )
                     {
                            hashIter( &HASHcontext, HASHdigest,
                                   (unsigned char *)&value->bv_val[j], index_substr_any_len );
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }
              }
       }

       if( flags & SLAP_INDEX_SUBSTR_ANY && sa->sa_any != NULL ) {
              ber_len_t i, j;
              pre = SLAP_INDEX_SUBSTR_PREFIX;
              klen = index_substr_any_len;

              for( i=0; !BER_BVISNULL( &sa->sa_any[i] ); i++ ) {
                     if( sa->sa_any[i].bv_len < index_substr_any_len ) {
                            continue;
                     }

                     value = &sa->sa_any[i];

                     hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                     for(j=0;
                            j <= value->bv_len - index_substr_any_len;
                            j += index_substr_any_step )
                     {
                            hashIter( &HASHcontext, HASHdigest,
                                   (unsigned char *)&value->bv_val[j], klen ); 
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }
              }
       }

       if( flags & SLAP_INDEX_SUBSTR_FINAL &&
              !BER_BVISNULL( &sa->sa_final ) &&
              sa->sa_final.bv_len >= index_substr_if_minlen )
       {
              pre = SLAP_INDEX_SUBSTR_FINAL_PREFIX;
              value = &sa->sa_final;

              klen = index_substr_if_maxlen < value->bv_len
                     ? index_substr_if_maxlen : value->bv_len;

              hashPreset( &HASHcontext, prefix, pre, syntax, mr );
              hashIter( &HASHcontext, HASHdigest,
                     (unsigned char *)&value->bv_val[value->bv_len-klen], klen );
              ber_dupbv_x( &keys[nkeys++], &digest, ctx );

              /* If final is too long and we have subany indexed, use it
               * to match the excess...
               */
              if (value->bv_len > index_substr_if_maxlen && (flags & SLAP_INDEX_SUBSTR_ANY))
              {
                     ber_len_t j;
                     pre = SLAP_INDEX_SUBSTR_PREFIX;
                     hashPreset( &HASHcontext, prefix, pre, syntax, mr);
                     for ( j=0; j <= value->bv_len - index_substr_if_maxlen; j+=index_substr_any_step )
                     {
                            hashIter( &HASHcontext, HASHdigest,
                                   (unsigned char *)&value->bv_val[j], index_substr_any_len );
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }
              }
       }

       if( nkeys > 0 ) {
              BER_BVZERO( &keys[nkeys] );
              *keysp = keys;
       } else {
              ch_free( keys );
              *keysp = NULL;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int octetStringSubstringsIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
) [static]

Definition at line 841 of file schema_init.c.

{
       ber_len_t i, nkeys;
       size_t slen, mlen;
       BerVarray keys;

       HASH_CONTEXT HCany, HCini, HCfin;
       unsigned char HASHdigest[HASH_BYTES];
       struct berval digest;
       digest.bv_val = (char *)HASHdigest;
       digest.bv_len = sizeof(HASHdigest);

       nkeys = 0;

       for ( i = 0; !BER_BVISNULL( &values[i] ); i++ ) {
              /* count number of indices to generate */
              if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
                     if( values[i].bv_len >= index_substr_if_maxlen ) {
                            nkeys += index_substr_if_maxlen -
                                   (index_substr_if_minlen - 1);
                     } else if( values[i].bv_len >= index_substr_if_minlen ) {
                            nkeys += values[i].bv_len - (index_substr_if_minlen - 1);
                     }
              }

              if( flags & SLAP_INDEX_SUBSTR_ANY ) {
                     if( values[i].bv_len >= index_substr_any_len ) {
                            nkeys += values[i].bv_len - (index_substr_any_len - 1);
                     }
              }

              if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
                     if( values[i].bv_len >= index_substr_if_maxlen ) {
                            nkeys += index_substr_if_maxlen -
                                   (index_substr_if_minlen - 1);
                     } else if( values[i].bv_len >= index_substr_if_minlen ) {
                            nkeys += values[i].bv_len - (index_substr_if_minlen - 1);
                     }
              }
       }

       if( nkeys == 0 ) {
              /* no keys to generate */
              *keysp = NULL;
              return LDAP_SUCCESS;
       }

       keys = slap_sl_malloc( sizeof( struct berval ) * (nkeys+1), ctx );

       slen = syntax->ssyn_oidlen;
       mlen = mr->smr_oidlen;

       if ( flags & SLAP_INDEX_SUBSTR_ANY )
              hashPreset( &HCany, prefix, SLAP_INDEX_SUBSTR_PREFIX, syntax, mr );
       if( flags & SLAP_INDEX_SUBSTR_INITIAL )
              hashPreset( &HCini, prefix, SLAP_INDEX_SUBSTR_INITIAL_PREFIX, syntax, mr );
       if( flags & SLAP_INDEX_SUBSTR_FINAL )
              hashPreset( &HCfin, prefix, SLAP_INDEX_SUBSTR_FINAL_PREFIX, syntax, mr );

       nkeys = 0;
       for ( i = 0; !BER_BVISNULL( &values[i] ); i++ ) {
              ber_len_t j,max;

              if( ( flags & SLAP_INDEX_SUBSTR_ANY ) &&
                     ( values[i].bv_len >= index_substr_any_len ) )
              {
                     max = values[i].bv_len - (index_substr_any_len - 1);

                     for( j=0; j<max; j++ ) {
                            hashIter( &HCany, HASHdigest,
                                   (unsigned char *)&values[i].bv_val[j],
                                   index_substr_any_len );
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }
              }

              /* skip if too short */ 
              if( values[i].bv_len < index_substr_if_minlen ) continue;

              max = index_substr_if_maxlen < values[i].bv_len
                     ? index_substr_if_maxlen : values[i].bv_len;

              for( j=index_substr_if_minlen; j<=max; j++ ) {

                     if( flags & SLAP_INDEX_SUBSTR_INITIAL ) {
                            hashIter( &HCini, HASHdigest,
                                   (unsigned char *)values[i].bv_val, j );
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }

                     if( flags & SLAP_INDEX_SUBSTR_FINAL ) {
                            hashIter( &HCfin, HASHdigest,
                                   (unsigned char *)&values[i].bv_val[values[i].bv_len-j], j );
                            ber_dupbv_x( &keys[nkeys++], &digest, ctx );
                     }

              }
       }

       if( nkeys > 0 ) {
              BER_BVZERO( &keys[nkeys] );
              *keysp = keys;
       } else {
              ch_free( keys );
              *keysp = NULL;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int octetStringSubstringsMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 716 of file schema_init.c.

{
       int match = 0;
       SubstringsAssertion *sub = assertedValue;
       struct berval left = *value;
       int i;
       ber_len_t inlen = 0;

       /* Add up asserted input length */
       if ( !BER_BVISNULL( &sub->sa_initial ) ) {
              inlen += sub->sa_initial.bv_len;
       }
       if ( sub->sa_any ) {
              for ( i = 0; !BER_BVISNULL( &sub->sa_any[i] ); i++ ) {
                     inlen += sub->sa_any[i].bv_len;
              }
       }
       if ( !BER_BVISNULL( &sub->sa_final ) ) {
              inlen += sub->sa_final.bv_len;
       }

       if ( !BER_BVISNULL( &sub->sa_initial ) ) {
              if ( inlen > left.bv_len ) {
                     match = 1;
                     goto done;
              }

              match = memcmp( sub->sa_initial.bv_val, left.bv_val,
                     sub->sa_initial.bv_len );

              if ( match != 0 ) {
                     goto done;
              }

              left.bv_val += sub->sa_initial.bv_len;
              left.bv_len -= sub->sa_initial.bv_len;
              inlen -= sub->sa_initial.bv_len;
       }

       if ( !BER_BVISNULL( &sub->sa_final ) ) {
              if ( inlen > left.bv_len ) {
                     match = 1;
                     goto done;
              }

              match = memcmp( sub->sa_final.bv_val,
                     &left.bv_val[left.bv_len - sub->sa_final.bv_len],
                     sub->sa_final.bv_len );

              if ( match != 0 ) {
                     goto done;
              }

              left.bv_len -= sub->sa_final.bv_len;
              inlen -= sub->sa_final.bv_len;
       }

       if ( sub->sa_any ) {
              for ( i = 0; !BER_BVISNULL( &sub->sa_any[i] ); i++ ) {
                     ber_len_t idx;
                     char *p;

retry:
                     if ( inlen > left.bv_len ) {
                            /* not enough length */
                            match = 1;
                            goto done;
                     }

                     if ( BER_BVISEMPTY( &sub->sa_any[i] ) ) {
                            continue;
                     }

                     p = memchr( left.bv_val, *sub->sa_any[i].bv_val, left.bv_len );

                     if( p == NULL ) {
                            match = 1;
                            goto done;
                     }

                     idx = p - left.bv_val;

                     if ( idx >= left.bv_len ) {
                            /* this shouldn't happen */
                            return LDAP_OTHER;
                     }

                     left.bv_val = p;
                     left.bv_len -= idx;

                     if ( sub->sa_any[i].bv_len > left.bv_len ) {
                            /* not enough left */
                            match = 1;
                            goto done;
                     }

                     match = memcmp( left.bv_val,
                            sub->sa_any[i].bv_val,
                            sub->sa_any[i].bv_len );

                     if ( match != 0 ) {
                            left.bv_val++;
                            left.bv_len--;
                            goto retry;
                     }

                     left.bv_val += sub->sa_any[i].bv_len;
                     left.bv_len -= sub->sa_any[i].bv_len;
                     inlen -= sub->sa_any[i].bv_len;
              }
       }

done:
       *matchp = match;
       return LDAP_SUCCESS;
}
static int postalAddressNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 2299 of file schema_init.c.

{
       BerVarray lines = NULL, nlines = NULL;
       ber_len_t l, c;
       int rc = LDAP_SUCCESS;
       MatchingRule *xmr = NULL;
       char *p;

       if ( SLAP_MR_ASSOCIATED( mr, slap_schema.si_mr_caseIgnoreListMatch ) ) {
              xmr = slap_schema.si_mr_caseIgnoreMatch;

       } else {
              xmr = slap_schema.si_mr_caseExactMatch;
       }

       for ( l = 0, c = 0; c < val->bv_len; c++ ) {
              if ( val->bv_val[c] == '$' ) {
                     l++;
              }
       }

       lines = slap_sl_calloc( sizeof( struct berval ), 2 * ( l + 2 ), ctx );
       nlines = &lines[l + 2];

       lines[0].bv_val = val->bv_val;
       for ( l = 0, c = 0; c < val->bv_len; c++ ) {
              if ( val->bv_val[c] == '$' ) {
                     lines[l].bv_len = &val->bv_val[c] - lines[l].bv_val;
                     l++;
                     lines[l].bv_val = &val->bv_val[c + 1];
              }
       }
       lines[l].bv_len = &val->bv_val[c] - lines[l].bv_val;

       normalized->bv_len = c = l;

       for ( l = 0; l <= c; l++ ) {
              /* NOTE: we directly normalize each line,
               * without unescaping the values, since the special
               * values '\24' ('$') and '\5C' ('\') are not affected
               * by normalization */
              if ( !lines[l].bv_len ) {
                     nlines[l].bv_len = 0;
                     nlines[l].bv_val = NULL;
                     continue;
              }
              rc = UTF8StringNormalize( usage, NULL, xmr, &lines[l], &nlines[l], ctx );
              if ( rc != LDAP_SUCCESS ) {
                     rc = LDAP_INVALID_SYNTAX;
                     goto done;
              }

              normalized->bv_len += nlines[l].bv_len;
       }

       normalized->bv_val = slap_sl_malloc( normalized->bv_len + 1, ctx );

       p = normalized->bv_val;
       for ( l = 0; l <= c ; l++ ) {
              p = lutil_strbvcopy( p, &nlines[l] );
              *p++ = '$';
       }
       *--p = '\0';

       assert( p == &normalized->bv_val[normalized->bv_len] );

done:;
       if ( nlines != NULL ) {
              for ( l = 0; !BER_BVISNULL( &nlines[ l ] ); l++ ) {
                     slap_sl_free( nlines[l].bv_val, ctx );
              }

              slap_sl_free( lines, ctx );
       }

       return rc;
}

Here is the call graph for this function:

static int postalAddressValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 2267 of file schema_init.c.

{
       struct berval bv = *in;
       ber_len_t c;

       for ( c = 0; c < in->bv_len; c++ ) {
              if ( in->bv_val[c] == '\\' ) {
                     c++;
                     if ( strncasecmp( &in->bv_val[c], "24", STRLENOF( "24" ) ) != 0
                            && strncasecmp( &in->bv_val[c], "5C", STRLENOF( "5C" ) ) != 0 )
                     {
                            return LDAP_INVALID_SYNTAX;
                     }
                     continue;
              }

              if ( in->bv_val[c] == '$' ) {
                     bv.bv_len = &in->bv_val[c] - bv.bv_val;
                     if ( UTF8StringValidate( NULL, &bv ) != LDAP_SUCCESS ) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     bv.bv_val = &in->bv_val[c] + 1;
              }
       }

       bv.bv_len = &in->bv_val[c] - bv.bv_val;
       return UTF8StringValidate( NULL, &bv );
}

Here is the call graph for this function:

static int printablesStringValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 2732 of file schema_init.c.

{
       ber_len_t i, len;

       if( BER_BVISEMPTY( val ) ) return LDAP_INVALID_SYNTAX;

       for(i=0,len=0; i < val->bv_len; i++) {
              int c = val->bv_val[i];

              if( c == '$' ) {
                     if( len == 0 ) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     len = 0;

              } else if ( SLAP_PRINTABLE(c) ) {
                     len++;
              } else {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       if( len == 0 ) {
              return LDAP_INVALID_SYNTAX;
       }

       return LDAP_SUCCESS;
}
static int printableStringValidate ( Syntax syntax,
struct berval val 
) [static]

Definition at line 2714 of file schema_init.c.

{
       ber_len_t i;

       if( BER_BVISEMPTY( val ) ) return LDAP_INVALID_SYNTAX;

       for(i=0; i < val->bv_len; i++) {
              if( !SLAP_PRINTABLE(val->bv_val[i]) ) {
                     return LDAP_INVALID_SYNTAX;
              }
       }

       return LDAP_SUCCESS;
}

Definition at line 6847 of file schema_init.c.

{
       oidm_destroy();
       oc_destroy();
       at_destroy();
       mr_destroy();
       mru_destroy();
       syn_destroy();

       if( schema_init_done ) {
              ldap_pvt_thread_mutex_destroy( &ad_index_mutex );
              ldap_pvt_thread_mutex_destroy( &ad_undef_mutex );
              ldap_pvt_thread_mutex_destroy( &oc_undef_mutex );
       }
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sequenceValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 204 of file schema_init.c.

{
       if ( in->bv_len < 2 ) return LDAP_INVALID_SYNTAX;
       if ( in->bv_val[0] != LBER_SEQUENCE ) return LDAP_INVALID_SYNTAX;

       return LDAP_SUCCESS;
}
static int serialNumberAndIssuerCheck ( struct berval in,
struct berval sn,
struct berval is,
void ctx 
) [static]

Definition at line 3178 of file schema_init.c.

{
       ber_len_t n;

       if( in->bv_len < 3 ) return LDAP_INVALID_SYNTAX;

       if( in->bv_val[0] != '{' && in->bv_val[in->bv_len-1] != '}' ) {
              /* Parse old format */
              is->bv_val = ber_bvchr( in, '$' );
              if( BER_BVISNULL( is ) ) return LDAP_INVALID_SYNTAX;

              sn->bv_val = in->bv_val;
              sn->bv_len = is->bv_val - in->bv_val;

              is->bv_val++;
              is->bv_len = in->bv_len - (sn->bv_len + 1);

              /* eat leading zeros */
              for( n=0; n < (sn->bv_len-1); n++ ) {
                     if( sn->bv_val[n] != '0' ) break;
              }
              sn->bv_val += n;
              sn->bv_len -= n;

              for( n=0; n < sn->bv_len; n++ ) {
                     if( !ASCII_DIGIT(sn->bv_val[n]) ) return LDAP_INVALID_SYNTAX;
              }

       } else {
              /* Parse GSER format */ 
              enum {
                     HAVE_NONE = 0x0,
                     HAVE_ISSUER = 0x1,
                     HAVE_SN = 0x2,
                     HAVE_ALL = ( HAVE_ISSUER | HAVE_SN )
              } have = HAVE_NONE;

              int numdquotes = 0;
              struct berval x = *in;
              struct berval ni;
              x.bv_val++;
              x.bv_len -= 2;

              do {
                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     /* should be at issuer or serialNumber NamedValue */
                     if ( strncasecmp( x.bv_val, "issuer", STRLENOF("issuer") ) == 0 ) {
                            if ( have & HAVE_ISSUER ) return LDAP_INVALID_SYNTAX;

                            /* parse issuer */
                            x.bv_val += STRLENOF("issuer");
                            x.bv_len -= STRLENOF("issuer");

                            if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                            x.bv_val++;
                            x.bv_len--;

                            /* eat leading spaces */
                            for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                   /* empty */;
                            }

                            /* For backward compatibility, this part is optional */
                            if ( strncasecmp( x.bv_val, "rdnSequence:", STRLENOF("rdnSequence:") ) == 0 ) {
                                   x.bv_val += STRLENOF("rdnSequence:");
                                   x.bv_len -= STRLENOF("rdnSequence:");
                            }

                            if ( x.bv_val[0] != '"' ) return LDAP_INVALID_SYNTAX;
                            x.bv_val++;
                            x.bv_len--;

                            is->bv_val = x.bv_val;
                            is->bv_len = 0;

                            for ( ; is->bv_len < x.bv_len; ) {
                                   if ( is->bv_val[is->bv_len] != '"' ) {
                                          is->bv_len++;
                                          continue;
                                   }
                                   if ( is->bv_val[is->bv_len+1] == '"' ) {
                                          /* double dquote */
                                          is->bv_len += 2;
                                          continue;
                                   }
                                   break;
                            }
                            x.bv_val += is->bv_len + 1;
                            x.bv_len -= is->bv_len + 1;

                            have |= HAVE_ISSUER;

                     } else if ( strncasecmp( x.bv_val, "serialNumber", STRLENOF("serialNumber") ) == 0 )
                     {
                            if ( have & HAVE_SN ) return LDAP_INVALID_SYNTAX;

                            /* parse serialNumber */
                            x.bv_val += STRLENOF("serialNumber");
                            x.bv_len -= STRLENOF("serialNumber");

                            if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                            x.bv_val++;
                            x.bv_len--;

                            /* eat leading spaces */
                            for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                   /* empty */;
                            }

                            if ( checkNum( &x, sn ) ) {
                                   return LDAP_INVALID_SYNTAX;
                            }

                            x.bv_val += sn->bv_len;
                            x.bv_len -= sn->bv_len;

                            have |= HAVE_SN;

                     } else {
                            return LDAP_INVALID_SYNTAX;
                     }

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( have == HAVE_ALL ) {
                            break;
                     }

                     if ( x.bv_val[0] != ',' ) {
                            return LDAP_INVALID_SYNTAX;
                     }

                     x.bv_val++;
                     x.bv_len--;
              } while ( 1 );

              /* should have no characters left... */
              if ( x.bv_len ) return LDAP_INVALID_SYNTAX;

              if ( numdquotes == 0 ) {
                     ber_dupbv_x( &ni, is, ctx );

              } else {
                     ber_len_t src, dst;

                     ni.bv_len = is->bv_len - numdquotes;
                     ni.bv_val = ber_memalloc_x( ni.bv_len + 1, ctx );
                     for ( src = 0, dst = 0; src < is->bv_len; src++, dst++ ) {
                            if ( is->bv_val[src] == '"' ) {
                                   src++;
                            }
                            ni.bv_val[dst] = is->bv_val[src];
                     }
                     ni.bv_val[dst] = '\0';
              }
                     
              *is = ni;
       }

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int serialNumberAndIssuerNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 3528 of file schema_init.c.

{
       struct berval sn, sn2, sn3, i, ni;
       char sbuf2[SLAP_SN_BUFLEN];
       char sbuf3[SLAP_SN_BUFLEN];
       char *p;
       int rc;

       assert( in != NULL );
       assert( out != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerNormalize: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerCheck( in, &sn, &i, ctx );
       if ( rc ) {
              return rc;
       }

       rc = dnNormalize( usage, syntax, mr, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       if ( rc ) {
              return LDAP_INVALID_SYNTAX;
       }

       /* Convert sn to canonical hex */
       sn2.bv_val = sbuf2;
       if ( sn.bv_len > sizeof( sbuf2 ) ) {
              sn2.bv_val = slap_sl_malloc( sn.bv_len, ctx );
       }
       sn2.bv_len = sn.bv_len;
       sn3.bv_val = sbuf3;
       sn3.bv_len = sizeof(sbuf3);
       if ( lutil_str2bin( &sn, &sn2, ctx ) || slap_bin2hex( &sn2, &sn3, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

       out->bv_len = STRLENOF( "{ serialNumber , issuer rdnSequence:\"\" }" )
              + sn3.bv_len + ni.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );
       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto func_leave;
       }

       p = out->bv_val;

       p = lutil_strcopy( p, "{ serialNumber " /*}*/ );
       p = lutil_strbvcopy( p, &sn3 );
       p = lutil_strcopy( p, ", issuer rdnSequence:\"" );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       assert( p == &out->bv_val[out->bv_len] );

func_leave:
       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerNormalize: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       if ( sn2.bv_val != sbuf2 ) {
              slap_sl_free( sn2.bv_val, ctx );
       }

       if ( sn3.bv_val != sbuf3 ) {
              slap_sl_free( sn3.bv_val, ctx );
       }

       slap_sl_free( ni.bv_val, ctx );

       return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int serialNumberAndIssuerPretty ( Syntax syntax,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 3385 of file schema_init.c.

{
       int rc;
       struct berval sn, i, ni = BER_BVNULL;
       char *p;

       assert( in != NULL );
       assert( out != NULL );

       BER_BVZERO( out );

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerPretty: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerCheck( in, &sn, &i, ctx );
       if ( rc ) {
              goto done;
       }

       rc = dnPretty( syntax, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }

       /* make room from sn + "$" */
       out->bv_len = STRLENOF("{ serialNumber , issuer rdnSequence:\"\" }")
              + sn.bv_len + ni.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto done;
       }

       p = out->bv_val;
       p = lutil_strcopy( p, "{ serialNumber " /*}*/ );
       p = lutil_strbvcopy( p, &sn );
       p = lutil_strcopy( p, ", issuer rdnSequence:\"" );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, /*{*/ "\" }" );

       assert( p == &out->bv_val[out->bv_len] );

done:;
       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerPretty: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       slap_sl_free( ni.bv_val, ctx );

       return LDAP_SUCCESS; 
}

Here is the call graph for this function:

static int serialNumberAndIssuerSerialCheck ( struct berval in,
struct berval sn,
struct berval is,
struct berval i_sn,
void ctx 
) [static]

Definition at line 4260 of file schema_init.c.

{
       /* Parse GSER format */ 
       enum {
              HAVE_NONE = 0x0,
              HAVE_SN = 0x1,
              HAVE_ISSUER = 0x2,
              HAVE_ALL = ( HAVE_SN | HAVE_ISSUER )
       } have = HAVE_NONE, have2 = HAVE_NONE;
       int numdquotes = 0;
       struct berval x = *in;
       struct berval ni;

       if ( in->bv_len < 3 ) return LDAP_INVALID_SYNTAX;

       /* no old format */
       if ( in->bv_val[0] != '{' && in->bv_val[in->bv_len-1] != '}' ) return LDAP_INVALID_SYNTAX;

       x.bv_val++;
       x.bv_len -= 2;

       do {

              /* eat leading spaces */
              for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                     /* empty */;
              }

              /* should be at issuer or serialNumber NamedValue */
              if ( strncasecmp( x.bv_val, "issuer", STRLENOF("issuer") ) == 0 ) {
                     if ( have & HAVE_ISSUER ) {
                            return LDAP_INVALID_SYNTAX;
                     }

                     /* parse IssuerSerial */
                     x.bv_val += STRLENOF("issuer");
                     x.bv_len -= STRLENOF("issuer");

                     if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( x.bv_val[0] != '{' /*}*/ ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( strncasecmp( x.bv_val, "baseCertificateID ", STRLENOF("baseCertificateID ") ) != 0 ) {
                            return LDAP_INVALID_SYNTAX;
                     }
                     x.bv_val += STRLENOF("baseCertificateID ");
                     x.bv_len -= STRLENOF("baseCertificateID ");

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( x.bv_val[0] != '{' /*}*/ ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     do {
                            /* eat leading spaces */
                            for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                   /* empty */;
                            }

                            /* parse issuer of baseCertificateID */
                            if ( strncasecmp( x.bv_val, "issuer ", STRLENOF("issuer ") ) == 0 ) {
                                   if ( have2 & HAVE_ISSUER ) {
                                          return LDAP_INVALID_SYNTAX;
                                   }

                                   x.bv_val += STRLENOF("issuer ");
                                   x.bv_len -= STRLENOF("issuer ");

                                   /* eat leading spaces */
                                   for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                          /* empty */;
                                   }

                                   if ( x.bv_val[0] != '{' /*}*/ ) return LDAP_INVALID_SYNTAX;
                                   x.bv_val++;
                                   x.bv_len--;

                                   /* eat leading spaces */
                                   for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                          /* empty */;
                                   }

                                   if ( strncasecmp( x.bv_val, "directoryName:rdnSequence:", STRLENOF("directoryName:rdnSequence:") ) != 0 ) {
                                          return LDAP_INVALID_SYNTAX;
                                   }
                                   x.bv_val += STRLENOF("directoryName:rdnSequence:");
                                   x.bv_len -= STRLENOF("directoryName:rdnSequence:");

                                   if ( x.bv_val[0] != '"' ) return LDAP_INVALID_SYNTAX;
                                   x.bv_val++;
                                   x.bv_len--;

                                   is->bv_val = x.bv_val;
                                   is->bv_len = 0;

                                   for ( ; is->bv_len < x.bv_len; ) {
                                          if ( is->bv_val[is->bv_len] != '"' ) {
                                                 is->bv_len++;
                                                 continue;
                                          }
                                          if ( is->bv_val[is->bv_len + 1] == '"' ) {
                                                 /* double dquote */
                                                 is->bv_len += 2;
                                                 continue;
                                          }
                                          break;
                                   }
                                   x.bv_val += is->bv_len + 1;
                                   x.bv_len -= is->bv_len + 1;

                                   /* eat leading spaces */
                                   for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                          /* empty */;
                                   }

                                   if ( x.bv_val[0] != /*{*/ '}' ) return LDAP_INVALID_SYNTAX;
                                   x.bv_val++;
                                   x.bv_len--;

                                   have2 |= HAVE_ISSUER;

                            } else if ( strncasecmp( x.bv_val, "serial ", STRLENOF("serial ") ) == 0 ) {
                                   if ( have2 & HAVE_SN ) {
                                          return LDAP_INVALID_SYNTAX;
                                   }

                                   x.bv_val += STRLENOF("serial ");
                                   x.bv_len -= STRLENOF("serial ");

                                   /* eat leading spaces */
                                   for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len--) {
                                          /* empty */;
                                   }

                                   if ( checkNum( &x, i_sn ) ) {
                                          return LDAP_INVALID_SYNTAX;
                                   }

                                   x.bv_val += i_sn->bv_len;
                                   x.bv_len -= i_sn->bv_len;

                                   have2 |= HAVE_SN;

                            } else {
                                   return LDAP_INVALID_SYNTAX;
                            }

                            /* eat leading spaces */
                            for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                                   /* empty */;
                            }

                            if ( have2 == HAVE_ALL ) {
                                   break;
                            }

                            if ( x.bv_val[0] != ',' ) return LDAP_INVALID_SYNTAX;
                            x.bv_val++;
                            x.bv_len--;
                     } while ( 1 );

                     if ( x.bv_val[0] != /*{*/ '}' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }

                     if ( x.bv_val[0] != /*{*/ '}' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     have |= HAVE_ISSUER;

              } else if ( strncasecmp( x.bv_val, "serialNumber", STRLENOF("serialNumber") ) == 0 ) {
                     if ( have & HAVE_SN ) {
                            return LDAP_INVALID_SYNTAX;
                     }

                     /* parse serialNumber */
                     x.bv_val += STRLENOF("serialNumber");
                     x.bv_len -= STRLENOF("serialNumber");

                     if ( x.bv_val[0] != ' ' ) return LDAP_INVALID_SYNTAX;
                     x.bv_val++;
                     x.bv_len--;

                     /* eat leading spaces */
                     for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                            /* empty */;
                     }
                     
                     if ( checkNum( &x, sn ) ) {
                            return LDAP_INVALID_SYNTAX;
                     }

                     x.bv_val += sn->bv_len;
                     x.bv_len -= sn->bv_len;

                     have |= HAVE_SN;

              } else {
                     return LDAP_INVALID_SYNTAX;
              }

              /* eat spaces */
              for ( ; (x.bv_val[0] == ' ') && x.bv_len; x.bv_val++, x.bv_len-- ) {
                     /* empty */;
              }

              if ( have == HAVE_ALL ) {
                     break;
              }

              if ( x.bv_val[0] != ',' ) {
                     return LDAP_INVALID_SYNTAX;
              }
              x.bv_val++ ;
              x.bv_len--;
       } while ( 1 );

       /* should have no characters left... */
       if( x.bv_len ) return LDAP_INVALID_SYNTAX;

       if ( numdquotes == 0 ) {
              ber_dupbv_x( &ni, is, ctx );

       } else {
              ber_len_t src, dst;

              ni.bv_len = is->bv_len - numdquotes;
              ni.bv_val = ber_memalloc_x( ni.bv_len + 1, ctx );
              for ( src = 0, dst = 0; src < is->bv_len; src++, dst++ ) {
                     if ( is->bv_val[src] == '"' ) {
                            src++;
                     }
                     ni.bv_val[dst] = is->bv_val[src];
              }
              ni.bv_val[dst] = '\0';
       }

       *is = ni;

       /* need to handle double dquotes here */
       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int serialNumberAndIssuerSerialNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 4640 of file schema_init.c.

{
       struct berval i, ni = BER_BVNULL,
              sn, sn2 = BER_BVNULL, sn3 = BER_BVNULL,
              i_sn, i_sn2 = BER_BVNULL, i_sn3 = BER_BVNULL;
       char sbuf2[SLAP_SN_BUFLEN], i_sbuf2[SLAP_SN_BUFLEN],
              sbuf3[SLAP_SN_BUFLEN], i_sbuf3[SLAP_SN_BUFLEN];
       char *p;
       int rc;

       assert( in != NULL );
       assert( out != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerSerialNormalize: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerSerialCheck( in, &sn, &i, &i_sn, ctx );
       if ( rc ) {
              goto func_leave;
       }

       rc = dnNormalize( usage, syntax, mr, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

       /* Convert sn to canonical hex */
       sn2.bv_val = sbuf2;
       sn2.bv_len = sn.bv_len;
       if ( sn.bv_len > sizeof( sbuf2 ) ) {
              sn2.bv_val = slap_sl_malloc( sn.bv_len, ctx );
       }
       if ( lutil_str2bin( &sn, &sn2, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

        /* Convert i_sn to canonical hex */
       i_sn2.bv_val = i_sbuf2;
       i_sn2.bv_len = i_sn.bv_len;
       if ( i_sn.bv_len > sizeof( i_sbuf2 ) ) {
              i_sn2.bv_val = slap_sl_malloc( i_sn.bv_len, ctx );
       }
       if ( lutil_str2bin( &i_sn, &i_sn2, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

       sn3.bv_val = sbuf3;
       sn3.bv_len = sizeof(sbuf3);
       if ( slap_bin2hex( &sn2, &sn3, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

       i_sn3.bv_val = i_sbuf3;
       i_sn3.bv_len = sizeof(i_sbuf3);
       if ( slap_bin2hex( &i_sn2, &i_sn3, ctx ) ) {
              rc = LDAP_INVALID_SYNTAX;
              goto func_leave;
       }

       out->bv_len = STRLENOF("{ serialNumber , issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"\" }, serial  } } }")
              + sn3.bv_len + ni.bv_len + i_sn3.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto func_leave;
       }

       p = out->bv_val;

       p = lutil_strcopy( p, "{ serialNumber " );
       p = lutil_strbvcopy( p, &sn3 );
       p = lutil_strcopy( p, ", issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"" );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, "\" }, serial " );
       p = lutil_strbvcopy( p, &i_sn3 );
       p = lutil_strcopy( p, " } } }" );

       assert( p == &out->bv_val[out->bv_len] );

func_leave:
       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerSerialNormalize: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       if ( sn2.bv_val != sbuf2 ) {
              slap_sl_free( sn2.bv_val, ctx );
       }

       if ( i_sn2.bv_val != i_sbuf2 ) {
              slap_sl_free( i_sn2.bv_val, ctx );
       }

       if ( sn3.bv_val != sbuf3 ) {
              slap_sl_free( sn3.bv_val, ctx );
       }

       if ( i_sn3.bv_val != i_sbuf3 ) {
              slap_sl_free( i_sn3.bv_val, ctx );
       }

       slap_sl_free( ni.bv_val, ctx );

       return rc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int serialNumberAndIssuerSerialPretty ( Syntax syntax,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 4568 of file schema_init.c.

{
       struct berval sn, i, i_sn, ni = BER_BVNULL;
       char *p;
       int rc;

       assert( in != NULL );
       assert( out != NULL );

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerSerialPretty: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerSerialCheck( in, &sn, &i, &i_sn, ctx );
       if ( rc ) {
              goto done;
       }

       rc = dnPretty( syntax, &i, &ni, ctx );

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, ctx );
       }

       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;
              goto done;
       }

       /* make room from sn + "$" */
       out->bv_len = STRLENOF("{ serialNumber , issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"\" }, serial  } } }")
              + sn.bv_len + ni.bv_len + i_sn.bv_len;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       if ( out->bv_val == NULL ) {
              out->bv_len = 0;
              rc = LDAP_OTHER;
              goto done;
       }

       p = out->bv_val;
       p = lutil_strcopy( p, "{ serialNumber " );
       p = lutil_strbvcopy( p, &sn );
       p = lutil_strcopy( p, ", issuer { baseCertificateID { issuer { directoryName:rdnSequence:\"" );
       p = lutil_strbvcopy( p, &ni );
       p = lutil_strcopy( p, "\" }, serial " );
       p = lutil_strbvcopy( p, &i_sn );
       p = lutil_strcopy( p, " } } }" );

       assert( p == &out->bv_val[out->bv_len] );

done:;
       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerSerialPretty: <%s> => <%s>\n",
              in->bv_val, rc == LDAP_SUCCESS ? out->bv_val : "(err)", 0 );

       slap_sl_free( ni.bv_val, ctx );

       return rc; 
}

Here is the call graph for this function:

static int serialNumberAndIssuerSerialValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 4534 of file schema_init.c.

{
       int rc;
       struct berval sn, i, i_sn;

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerSerialValidate: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerSerialCheck( in, &sn, &i, &i_sn, NULL );
       if ( rc ) {
              goto done;
       }

       /* validate DN -- doesn't handle double dquote */ 
       rc = dnValidate( NULL, &i );
       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;
       }

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, NULL );
       }

done:;
       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerSerialValidate: <%s> err=%d\n",
              in->bv_val, rc, 0 );

       return rc;
}

Here is the call graph for this function:

static int serialNumberAndIssuerValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 3352 of file schema_init.c.

{
       int rc;
       struct berval sn, i;

       Debug( LDAP_DEBUG_TRACE, ">>> serialNumberAndIssuerValidate: <%s>\n",
              in->bv_val, 0, 0 );

       rc = serialNumberAndIssuerCheck( in, &sn, &i, NULL );
       if ( rc ) {
              goto done;
       }

       /* validate DN -- doesn't handle double dquote */ 
       rc = dnValidate( NULL, &i );
       if ( rc ) {
              rc = LDAP_INVALID_SYNTAX;
       }

       if ( in->bv_val[0] == '{' && in->bv_val[in->bv_len-1] == '}' ) {
              slap_sl_free( i.bv_val, NULL );
       }

       Debug( LDAP_DEBUG_TRACE, "<<< serialNumberAndIssuerValidate: <%s> err=%d\n",
              in->bv_val, rc, 0 );

done:;
       return rc;
}

Here is the call graph for this function:

static int sidNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 4948 of file schema_init.c.

{
       if ( val->bv_len != 3 ) {
              return LDAP_INVALID_SYNTAX;
       }

       return hexNormalize( 0, NULL, NULL, val, normalized, ctx );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int sidPretty ( Syntax syntax,
struct berval val,
struct berval out,
void ctx 
) [static]

Definition at line 4964 of file schema_init.c.

{
       return sidNormalize( SLAP_MR_VALUE_OF_SYNTAX, NULL, NULL, val, out, ctx );
}

Here is the call graph for this function:

static int sidValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 4931 of file schema_init.c.

{
       assert( in != NULL );
       assert( !BER_BVISNULL( in ) );

       if ( in->bv_len != 3 ) {
              return LDAP_INVALID_SYNTAX;
       }

       return hexValidate( NULL, in );
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int slap_bin2hex ( struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 3449 of file schema_init.c.

{      
       /* Use hex format. '123456789abcdef'H */
       unsigned char *ptr, zero = '\0';
       char *sptr;
       int first;
       ber_len_t i, len, nlen;

       assert( in != NULL );
       assert( !BER_BVISNULL( in ) );
       assert( out != NULL );
       assert( !BER_BVISNULL( out ) );

       ptr = (unsigned char *)in->bv_val;
       len = in->bv_len;

       /* Check for minimal encodings */
       if ( len > 1 ) {
              if ( ptr[0] & 0x80 ) {
                     if ( ( ptr[0] == 0xff ) && ( ptr[1] & 0x80 ) ) {
                            return -1;
                     }

              } else if ( ptr[0] == 0 ) {
                     if ( !( ptr[1] & 0x80 ) ) {
                            return -1;
                     }
                     len--;
                     ptr++;
              }

       } else if ( len == 0 ) {
              /* FIXME: this should not be possible,
               * since a value of zero would have length 1 */
              len = 1;
              ptr = &zero;
       }

       first = !( ptr[0] & 0xf0U );
       nlen = len * 2 - first + STRLENOF("''H"); /* quotes, H */
       if ( nlen >= out->bv_len ) {
              out->bv_val = slap_sl_malloc( nlen + 1, ctx );
       }
       sptr = out->bv_val;
       *sptr++ = '\'';
       i = 0;
       if ( first ) {
              sprintf( sptr, "%01X", ( ptr[0] & 0x0fU ) );
              sptr++;
              i = 1;
       }
       for ( ; i < len; i++ ) {
              sprintf( sptr, "%02X", ptr[i] );
              sptr += 2;
       }
       *sptr++ = '\'';
       *sptr++ = 'H';
       *sptr = '\0';

       assert( sptr == &out->bv_val[nlen] );

       out->bv_len = nlen;

       return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Definition at line 6803 of file schema_init.c.

{
       int           res;
       int           i;

       /* we should only be called once (from main) */
       assert( schema_init_done == 0 );

       for ( i=0; syntax_defs[i].sd_desc != NULL; i++ ) {
              res = register_syntax( &syntax_defs[i] );

              if ( res ) {
                     fprintf( stderr, "slap_schema_init: Error registering syntax %s\n",
                             syntax_defs[i].sd_desc );
                     return LDAP_OTHER;
              }
       }

       for ( i=0; mrule_defs[i].mrd_desc != NULL; i++ ) {
              if( mrule_defs[i].mrd_usage == SLAP_MR_NONE &&
                     mrule_defs[i].mrd_compat_syntaxes == NULL )
              {
                     fprintf( stderr,
                            "slap_schema_init: Ignoring unusable matching rule %s\n",
                             mrule_defs[i].mrd_desc );
                     continue;
              }

              res = register_matching_rule( &mrule_defs[i] );

              if ( res ) {
                     fprintf( stderr,
                            "slap_schema_init: Error registering matching rule %s\n",
                             mrule_defs[i].mrd_desc );
                     return LDAP_OTHER;
              }
       }

       res = slap_schema_load();
       schema_init_done = 1;
       return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int telephoneNumberNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 2231 of file schema_init.c.

{
       char *p, *q;

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) != 0 );

       /* validator should have refused an empty string */
       assert( !BER_BVISEMPTY( val ) );

       q = normalized->bv_val = slap_sl_malloc( val->bv_len + 1, ctx );

       for( p = val->bv_val; *p; p++ ) {
              if ( ! ( ASCII_SPACE( *p ) || *p == '-' )) {
                     *q++ = *p;
              }
       }
       *q = '\0';

       normalized->bv_len = q - normalized->bv_val;

       if( BER_BVISEMPTY( normalized ) ) {
              slap_sl_free( normalized->bv_val, ctx );
              BER_BVZERO( normalized );
              return LDAP_INVALID_SYNTAX;
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int uniqueMemberFilter ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
void assertedValue,
BerVarray keysp,
void ctx 
) [static]

Definition at line 1584 of file schema_init.c.

{
       struct berval *asserted = (struct berval *) assertedValue;
       struct berval assertedDN = *asserted;
       struct berval assertedUID = BER_BVNULL;

       if ( !BER_BVISEMPTY( asserted ) ) {
              assertedUID.bv_val = strrchr( assertedDN.bv_val, '#' );
              if ( !BER_BVISNULL( &assertedUID ) ) {
                     assertedUID.bv_val++;
                     assertedUID.bv_len = assertedDN.bv_len
                            - ( assertedUID.bv_val - assertedDN.bv_val );

                     if ( bitStringValidate( NULL, &assertedUID ) == LDAP_SUCCESS ) {
                            assertedDN.bv_len -= assertedUID.bv_len + 1;

                     } else {
                            BER_BVZERO( &assertedUID );
                     }
              }
       }

       return octetStringFilter( use, flags, syntax, mr, prefix,
              &assertedDN, keysp, ctx );
}

Here is the call graph for this function:

static int uniqueMemberIndexer ( slap_mask_t  use,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval prefix,
BerVarray  values,
BerVarray keysp,
void ctx 
) [static]

Definition at line 1532 of file schema_init.c.

{
       BerVarray dnvalues;
       int rc;
       int i;
       for( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
              /* just count them */                 
       }
       assert( i > 0 );

       dnvalues = slap_sl_malloc( sizeof( struct berval ) * (i+1), ctx );

       for( i=0; !BER_BVISNULL( &values[i] ); i++ ) {
              struct berval assertedDN = values[i];
              struct berval assertedUID = BER_BVNULL;

              if ( !BER_BVISEMPTY( &assertedDN ) ) {
                     assertedUID.bv_val = strrchr( assertedDN.bv_val, '#' );
                     if ( !BER_BVISNULL( &assertedUID ) ) {
                            assertedUID.bv_val++;
                            assertedUID.bv_len = assertedDN.bv_len
                                   - ( assertedUID.bv_val - assertedDN.bv_val );
       
                            if ( bitStringValidate( NULL, &assertedUID ) == LDAP_SUCCESS ) {
                                   assertedDN.bv_len -= assertedUID.bv_len + 1;

                            } else {
                                   BER_BVZERO( &assertedUID );
                            }
                     }
              }

              dnvalues[i] = assertedDN;
       }
       BER_BVZERO( &dnvalues[i] );

       rc = octetStringIndexer( use, flags, syntax, mr, prefix,
              dnvalues, keysp, ctx );

       slap_sl_free( dnvalues, ctx );
       return rc;
}

Here is the call graph for this function:

static int uniqueMemberMatch ( int matchp,
slap_mask_t  flags,
Syntax syntax,
MatchingRule mr,
struct berval value,
void assertedValue 
) [static]

Definition at line 1454 of file schema_init.c.

{
       int match;
       struct berval *asserted = (struct berval *) assertedValue;
       struct berval assertedDN = *asserted;
       struct berval assertedUID = BER_BVNULL;
       struct berval valueDN = *value;
       struct berval valueUID = BER_BVNULL;
       int approx = ((flags & SLAP_MR_EQUALITY_APPROX) == SLAP_MR_EQUALITY_APPROX);

       if ( !BER_BVISEMPTY( asserted ) ) {
              assertedUID.bv_val = strrchr( assertedDN.bv_val, '#' );
              if ( !BER_BVISNULL( &assertedUID ) ) {
                     assertedUID.bv_val++;
                     assertedUID.bv_len = assertedDN.bv_len
                            - ( assertedUID.bv_val - assertedDN.bv_val );

                     if ( bitStringValidate( NULL, &assertedUID ) == LDAP_SUCCESS ) {
                            assertedDN.bv_len -= assertedUID.bv_len + 1;

                     } else {
                            BER_BVZERO( &assertedUID );
                     }
              }
       }

       if ( !BER_BVISEMPTY( value ) ) {

              valueUID.bv_val = strrchr( valueDN.bv_val, '#' );
              if ( !BER_BVISNULL( &valueUID ) ) {
                     valueUID.bv_val++;
                     valueUID.bv_len = valueDN.bv_len
                            - ( valueUID.bv_val - valueDN.bv_val );

                     if ( bitStringValidate( NULL, &valueUID ) == LDAP_SUCCESS ) {
                            valueDN.bv_len -= valueUID.bv_len + 1;

                     } else {
                            BER_BVZERO( &valueUID );
                     }
              }
       }

       if( valueUID.bv_len && assertedUID.bv_len ) {
              ber_slen_t d;
              d = (ber_slen_t) valueUID.bv_len - (ber_slen_t) assertedUID.bv_len;
              if ( d ) {
                     *matchp = sizeof(d) == sizeof(int) ? d : d < 0 ? -1 : 1;
                     return LDAP_SUCCESS;
              }

              match = memcmp( valueUID.bv_val, assertedUID.bv_val, valueUID.bv_len );
              if( match ) {
                     *matchp = match;
                     return LDAP_SUCCESS;
              }

       } else if ( !approx && valueUID.bv_len ) {
              match = -1;
              *matchp = match;
              return LDAP_SUCCESS;

       } else if ( !approx && assertedUID.bv_len ) {
              match = 1;
              *matchp = match;
              return LDAP_SUCCESS;
       }

       return dnMatch( matchp, flags, syntax, mr, &valueDN, &assertedDN );
}

Here is the call graph for this function:

static int uniqueMemberNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 1381 of file schema_init.c.

{
       struct berval out;
       int rc;

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( usage ) != 0 );

       ber_dupbv_x( &out, val, ctx );
       if ( BER_BVISEMPTY( &out ) ) {
              *normalized = out;

       } else {
              struct berval uid = BER_BVNULL;

              uid.bv_val = strrchr( out.bv_val, '#' );
              if ( !BER_BVISNULL( &uid ) ) {
                     uid.bv_val++;
                     uid.bv_len = out.bv_len - ( uid.bv_val - out.bv_val );

                     rc = bitStringValidate( NULL, &uid );
                     if ( rc == LDAP_SUCCESS ) {
                            uid.bv_val[-1] = '\0';
                            out.bv_len -= uid.bv_len + 1;
                     } else {
                            BER_BVZERO( &uid );
                     }
              }

              rc = dnNormalize( 0, NULL, NULL, &out, normalized, ctx );

              if( rc != LDAP_SUCCESS ) {
                     slap_sl_free( out.bv_val, ctx );
                     return LDAP_INVALID_SYNTAX;
              }

              if( !BER_BVISNULL( &uid ) ) {
                     char   *tmp;

                     tmp = ch_realloc( normalized->bv_val,
                            normalized->bv_len + uid.bv_len
                            + STRLENOF("#") + 1 );
                     if ( tmp == NULL ) {
                            ber_memfree_x( normalized->bv_val, ctx );
                            return LDAP_OTHER;
                     }

                     normalized->bv_val = tmp;

                     /* insert the separator */
                     normalized->bv_val[normalized->bv_len++] = '#';

                     /* append the UID */
                     AC_MEMCPY( &normalized->bv_val[normalized->bv_len],
                            uid.bv_val, uid.bv_len );
                     normalized->bv_len += uid.bv_len;

                     /* terminate */
                     normalized->bv_val[normalized->bv_len] = '\0';
              }

              slap_sl_free( out.bv_val, ctx );
       }

       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int UTF8StringNormalize ( slap_mask_t  use,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
) [static]

Definition at line 1793 of file schema_init.c.

{
       struct berval tmp, nvalue;
       int flags, wasspace;
       ber_len_t i;

       assert( SLAP_MR_IS_VALUE_OF_SYNTAX( use ) != 0 );

       if( BER_BVISNULL( val ) ) {
              /* assume we're dealing with a syntax (e.g., UTF8String)
               * which allows empty strings
               */
              BER_BVZERO( normalized );
              return LDAP_SUCCESS;
       }

       flags = SLAP_MR_ASSOCIATED( mr, slap_schema.si_mr_caseExactMatch )
              ? LDAP_UTF8_NOCASEFOLD : LDAP_UTF8_CASEFOLD;
       flags |= ( ( use & SLAP_MR_EQUALITY_APPROX ) == SLAP_MR_EQUALITY_APPROX )
              ? LDAP_UTF8_APPROX : 0;

       val = UTF8bvnormalize( val, &tmp, flags, ctx );
       /* out of memory or syntax error, the former is unlikely */
       if( val == NULL ) {
              return LDAP_INVALID_SYNTAX;
       }
       
       /* collapse spaces (in place) */
       nvalue.bv_len = 0;
       nvalue.bv_val = tmp.bv_val;

       /* trim leading spaces? */
       wasspace = !((( use & SLAP_MR_SUBSTR_ANY ) == SLAP_MR_SUBSTR_ANY ) ||
              (( use & SLAP_MR_SUBSTR_FINAL ) == SLAP_MR_SUBSTR_FINAL ));

       for( i = 0; i < tmp.bv_len; i++) {
              if ( ASCII_SPACE( tmp.bv_val[i] )) {
                     if( wasspace++ == 0 ) {
                            /* trim repeated spaces */
                            nvalue.bv_val[nvalue.bv_len++] = tmp.bv_val[i];
                     }
              } else {
                     wasspace = 0;
                     nvalue.bv_val[nvalue.bv_len++] = tmp.bv_val[i];
              }
       }

       if( !BER_BVISEMPTY( &nvalue ) ) {
              /* trim trailing space? */
              if( wasspace && (
                     (( use & SLAP_MR_SUBSTR_INITIAL ) != SLAP_MR_SUBSTR_INITIAL ) &&
                     ( use & SLAP_MR_SUBSTR_ANY ) != SLAP_MR_SUBSTR_ANY ))
              {
                     --nvalue.bv_len;
              }
              nvalue.bv_val[nvalue.bv_len] = '\0';

       } else if ( tmp.bv_len )  {
              /* string of all spaces is treated as one space */
              nvalue.bv_val[0] = ' ';
              nvalue.bv_val[1] = '\0';
              nvalue.bv_len = 1;
       }      /* should never be entered with 0-length val */

       *normalized = nvalue;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

Here is the caller graph for this function:

static int UTF8StringValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 1734 of file schema_init.c.

{
       ber_len_t count;
       int len;
       unsigned char *u = (unsigned char *)in->bv_val;

       if( BER_BVISEMPTY( in ) && syntax == slap_schema.si_syn_directoryString ) {
              /* directory strings cannot be empty */
              return LDAP_INVALID_SYNTAX;
       }

       for( count = in->bv_len; count > 0; count -= len, u += len ) {
              /* get the length indicated by the first byte */
              len = LDAP_UTF8_CHARLEN2( u, len );

              /* very basic checks */
              switch( len ) {
                     case 6:
                            if( (u[5] & 0xC0) != 0x80 ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                     case 5:
                            if( (u[4] & 0xC0) != 0x80 ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                     case 4:
                            if( (u[3] & 0xC0) != 0x80 ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                     case 3:
                            if( (u[2] & 0xC0 )!= 0x80 ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                     case 2:
                            if( (u[1] & 0xC0) != 0x80 ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                     case 1:
                            /* CHARLEN already validated it */
                            break;
                     default:
                            return LDAP_INVALID_SYNTAX;
              }

              /* make sure len corresponds with the offset
                     to the next character */
              if( LDAP_UTF8_OFFSET( (char *)u ) != len ) return LDAP_INVALID_SYNTAX;
       }

       if( count != 0 ) {
              return LDAP_INVALID_SYNTAX;
       }

       return LDAP_SUCCESS;
}

Here is the caller graph for this function:

int UUIDNormalize ( slap_mask_t  usage,
Syntax syntax,
MatchingRule mr,
struct berval val,
struct berval normalized,
void ctx 
)

Definition at line 2923 of file schema_init.c.

{
       unsigned char octet = '\0';
       int i;
       int j;

       if ( SLAP_MR_IS_DENORMALIZE( usage ) ) {
              /* NOTE: must be a normalized UUID */
              assert( val->bv_len == 16 );

              normalized->bv_val = slap_sl_malloc( LDAP_LUTIL_UUIDSTR_BUFSIZE, ctx );
              normalized->bv_len = lutil_uuidstr_from_normalized( val->bv_val,
                     val->bv_len, normalized->bv_val, LDAP_LUTIL_UUIDSTR_BUFSIZE );
              assert( normalized->bv_len == STRLENOF( "BADBADBA-DBAD-0123-4567-BADBADBADBAD" ) );

              return LDAP_SUCCESS;
       }

       normalized->bv_len = 16;
       normalized->bv_val = slap_sl_malloc( normalized->bv_len + 1, ctx );

       for( i=0, j=0; i<36; i++ ) {
              unsigned char nibble;
              if( val->bv_val[i] == '-' ) {
                     continue;

              } else if( ASCII_DIGIT( val->bv_val[i] ) ) {
                     nibble = val->bv_val[i] - '0';

              } else if( ASCII_HEXLOWER( val->bv_val[i] ) ) {
                     nibble = val->bv_val[i] - ('a'-10);

              } else if( ASCII_HEXUPPER( val->bv_val[i] ) ) {
                     nibble = val->bv_val[i] - ('A'-10);

              } else {
                     slap_sl_free( normalized->bv_val, ctx );
                     BER_BVZERO( normalized );
                     return LDAP_INVALID_SYNTAX;
              }

              if( j & 1 ) {
                     octet |= nibble;
                     normalized->bv_val[j>>1] = octet;
              } else {
                     octet = nibble << 4;
              }
              j++;
       }

       normalized->bv_val[normalized->bv_len] = 0;
       return LDAP_SUCCESS;
}

Here is the call graph for this function:

static int UUIDPretty ( Syntax syntax,
struct berval in,
struct berval out,
void ctx 
) [static]

Definition at line 2873 of file schema_init.c.

{
       int i;
       int rc=LDAP_INVALID_SYNTAX;

       assert( in != NULL );
       assert( out != NULL );

       if( in->bv_len != 36 ) return LDAP_INVALID_SYNTAX;

       out->bv_len = 36;
       out->bv_val = slap_sl_malloc( out->bv_len + 1, ctx );

       for( i=0; i<36; i++ ) {
              switch(i) {
                     case 8:
                     case 13:
                     case 18:
                     case 23:
                            if( in->bv_val[i] != '-' ) {
                                   goto handle_error;
                            }
                            out->bv_val[i] = '-';
                            break;

                     default:
                            if( !ASCII_HEX( in->bv_val[i]) ) {
                                   goto handle_error;
                            }
                            out->bv_val[i] = TOLOWER( in->bv_val[i] );
              }
       }

       rc = LDAP_SUCCESS;
       out->bv_val[ out->bv_len ] = '\0';

       if( 0 ) {
handle_error:
              slap_sl_free( out->bv_val, ctx );
              out->bv_val = NULL;
       }

       return rc;
}

Here is the call graph for this function:

static int UUIDValidate ( Syntax syntax,
struct berval in 
) [static]

Definition at line 2843 of file schema_init.c.

{
       int i;
       if( in->bv_len != 36 ) {
              return LDAP_INVALID_SYNTAX;
       }

       for( i=0; i<36; i++ ) {
              switch(i) {
                     case 8:
                     case 13:
                     case 18:
                     case 23:
                            if( in->bv_val[i] != '-' ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
                            break;
                     default:
                            if( !ASCII_HEX( in->bv_val[i]) ) {
                                   return LDAP_INVALID_SYNTAX;
                            }
              }
       }
       
       return LDAP_SUCCESS;
}

Variable Documentation

Definition at line 167 of file schema_init.c.

Definition at line 168 of file schema_init.c.

Initial value:

Definition at line 6327 of file schema_init.c.

Initial value:
 {
       "1.3.6.1.4.1.1466.115.121.1.8" ,
       NULL
}

Definition at line 6319 of file schema_init.c.

Initial value:
 {
       "1.3.6.1.4.1.1466.115.121.1.9" ,
       NULL
}

Definition at line 6323 of file schema_init.c.

char* country_gen_syn[] [static]
Initial value:
 {
       "1.3.6.1.4.1.1466.115.121.1.15",   
       "1.3.6.1.4.1.1466.115.121.1.26",   
       "1.3.6.1.4.1.1466.115.121.1.44",   
       NULL
}

Definition at line 6105 of file schema_init.c.

Initial value:
 {
       "1.3.6.1.4.1.4203.666.11.2.1" ,
       NULL
}

Definition at line