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

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