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

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