git.sur5r.net Git - openldap/blob - servers/slapd/value.c

   1 /* value.c - routines for dealing with values */
   2 /* $OpenLDAP$ */
   3 /*
   4  * Copyright 1998-2000 The OpenLDAP Foundation, All Rights Reserved.
   5  * COPYING RESTRICTIONS APPLY, see COPYRIGHT file
   6  */
   7
   8 #include "portable.h"
   9
  10 #include <stdio.h>
  11
  12 #include <ac/ctype.h>
  13 #include <ac/socket.h>
  14 #include <ac/string.h>
  15 #include <ac/time.h>
  16
  17 #include <sys/stat.h>
  18
  19 #include "slap.h"
  20
  21 int
  22 value_add(
  23     struct berval       ***vals,
  24     struct berval       **addvals
  25 )
  26 {
  27         int     n, nn, i, j;
  28
  29         for ( nn = 0; addvals != NULL && addvals[nn] != NULL; nn++ )
  30                 ;       /* NULL */
  31
  32         if ( *vals == NULL ) {
  33                 *vals = (struct berval **) ch_malloc( (nn + 1)
  34                     * sizeof(struct berval *) );
  35                 n = 0;
  36         } else {
  37                 for ( n = 0; (*vals)[n] != NULL; n++ )
  38                         ;       /* NULL */
  39                 *vals = (struct berval **) ch_realloc( (char *) *vals,
  40                     (n + nn + 1) * sizeof(struct berval *) );
  41         }
  42
  43         for ( i = 0, j = 0; i < nn; i++ ) {
  44                 if ( addvals[i]->bv_len > 0 ) {
  45                         (*vals)[n + j] = ber_bvdup( addvals[i] );
  46                         if( (*vals)[n + j++] == NULL ) break;
  47                 }
  48         }
  49         (*vals)[n + j] = NULL;
  50
  51         return( 0 );
  52 }
  53
  54 #ifdef SLAPD_SCHEMA_NOT_COMPAT
  55         /* not yet implemented */
  56 #else
  57 int
  58 value_add_fast(
  59     struct berval       ***vals,
  60     struct berval       **addvals,
  61     int                 nvals,
  62     int                 naddvals,
  63     int                 *maxvals
  64 )
  65 {
  66         int     need, i, j;
  67
  68         if ( *maxvals == 0 ) {
  69                 *maxvals = 1;
  70         }
  71         need = nvals + naddvals + 1;
  72         while ( *maxvals < need ) {
  73                 *maxvals *= 2;
  74                 *vals = (struct berval **) ch_realloc( (char *) *vals,
  75                     *maxvals * sizeof(struct berval *) );
  76         }
  77
  78         for ( i = 0, j = 0; i < naddvals; i++ ) {
  79                 if ( addvals[i]->bv_len > 0 ) {
  80                         (*vals)[nvals + j] = ber_bvdup( addvals[i] );
  81                         if( (*vals)[nvals + j] != NULL ) j++;
  82                 }
  83         }
  84         (*vals)[nvals + j] = NULL;
  85
  86         return( 0 );
  87 }
  88 #endif
  89
  90 #ifdef SLAPD_SCHEMA_NOT_COMPAT
  91 int
  92 value_normalize(
  93         AttributeDescription *ad,
  94         unsigned usage,
  95         struct berval *val,
  96         char **text )
  97 {
  98         /* not yet implemented */
  99         return LDAP_SUCCESS;
 100 }
 101
 102 #else
 103 void
 104 value_normalize(
 105     char        *s,
 106     int         syntax
 107 )
 108 {
 109         char    *d, *save;
 110
 111         if ( ! (syntax & SYNTAX_CIS) ) {
 112                 return;
 113         }
 114
 115         if ( syntax & SYNTAX_DN ) {
 116                 (void) dn_normalize( s );
 117                 return;
 118         }
 119
 120         save = s;
 121         for ( d = s; *s; s++ ) {
 122                 if ( (syntax & SYNTAX_TEL) && (*s == ' ' || *s == '-') ) {
 123                         continue;
 124                 }
 125                 *d++ = TOUPPER( (unsigned char) *s );
 126         }
 127         *d = '\0';
 128 }
 129 #endif
 130
 131 #ifdef SLAPD_SCHEMA_NOT_COMPAT
 132         /* not yet implemented */
 133 #else
 134 int
 135 value_cmp(
 136     struct berval       *v1,
 137     struct berval       *v2,
 138     int                 syntax,
 139     int                 normalize       /* 1 => arg 1; 2 => arg 2; 3 => both */
 140 )
 141 {
 142         int             rc;
 143
 144         if ( normalize & 1 ) {
 145                 v1 = ber_bvdup( v1 );
 146                 value_normalize( v1->bv_val, syntax );
 147         }
 148         if ( normalize & 2 ) {
 149                 v2 = ber_bvdup( v2 );
 150                 value_normalize( v2->bv_val, syntax );
 151         }
 152
 153         switch ( syntax ) {
 154         case SYNTAX_CIS:
 155         case (SYNTAX_CIS | SYNTAX_TEL):
 156         case (SYNTAX_CIS | SYNTAX_DN):
 157                 rc = strcasecmp( v1->bv_val, v2->bv_val );
 158                 break;
 159
 160         case SYNTAX_CES:
 161                 rc = strcmp( v1->bv_val, v2->bv_val );
 162                 break;
 163
 164         default:        /* Unknown syntax */
 165         case SYNTAX_BIN:
 166                 rc = (v1->bv_len == v2->bv_len
 167                       ? memcmp( v1->bv_val, v2->bv_val, v1->bv_len )
 168                       : v1->bv_len > v2->bv_len ? 1 : -1);
 169                 break;
 170         }
 171
 172         if ( normalize & 1 ) {
 173                 ber_bvfree( v1 );
 174         }
 175         if ( normalize & 2 ) {
 176                 ber_bvfree( v2 );
 177         }
 178
 179         return( rc );
 180 }
 181
 182 int
 183 value_find(
 184     struct berval       **vals,
 185     struct berval       *v,
 186     int                 syntax,
 187     int                 normalize
 188 )
 189 {
 190         int     i;
 191
 192         for ( i = 0; vals[i] != NULL; i++ ) {
 193                 if ( value_cmp( vals[i], v, syntax, normalize ) == 0 ) {
 194                         return( 0 );
 195                 }
 196         }
 197
 198         return( 1 );
 199 }
 200 #endif