git.sur5r.net Git - openldap/blob - libraries/librewrite/var.c

   1 /******************************************************************************
   2  *
   3  * Copyright (C) 2000 Pierangelo Masarati, <ando@sys-net.it>
   4  * All rights reserved.
   5  *
   6  * Permission is granted to anyone to use this software for any purpose
   7  * on any computer system, and to alter it and redistribute it, subject
   8  * to the following restrictions:
   9  *
  10  * 1. The author is not responsible for the consequences of use of this
  11  * software, no matter how awful, even if they arise from flaws in it.
  12  *
  13  * 2. The origin of this software must not be misrepresented, either by
  14  * explicit claim or by omission.  Since few users ever read sources,
  15  * credits should appear in the documentation.
  16  *
  17  * 3. Altered versions must be plainly marked as such, and must not be
  18  * misrepresented as being the original software.  Since few users
  19  * ever read sources, credits should appear in the documentation.
  20  *
  21  * 4. This notice may not be removed or altered.
  22  *
  23  ******************************************************************************/
  24
  25 #include <portable.h>
  26
  27 #include "rewrite-int.h"
  28
  29 /*
  30  * Compares two vars
  31  */
  32 static int
  33 rewrite_var_cmp(
  34                 const void *c1,
  35                 const void *c2
  36 )
  37 {
  38         const struct rewrite_var *v1, *v2;
  39
  40         v1 = ( const struct rewrite_var * )c1;
  41         v2 = ( const struct rewrite_var * )c2;
  42
  43         assert( v1 != NULL );
  44         assert( v2 != NULL );
  45         assert( v1->lv_name != NULL );
  46         assert( v2->lv_name != NULL );
  47
  48         return strcasecmp( v1->lv_name, v2->lv_name );
  49 }
  50
  51 /*
  52  * Duplicate var ?
  53  */
  54 static int
  55 rewrite_var_dup(
  56                 void *c1,
  57                 void *c2
  58 )
  59 {
  60         struct rewrite_var *v1, *v2;
  61
  62         v1 = ( struct rewrite_var * )c1;
  63         v2 = ( struct rewrite_var * )c2;
  64
  65         assert( v1 != NULL );
  66         assert( v2 != NULL );
  67         assert( v1->lv_name != NULL );
  68         assert( v2->lv_name != NULL );
  69
  70         return ( strcasecmp( v1->lv_name, v2->lv_name ) == 0 ? -1 : 0 );
  71 }
  72
  73 /*
  74  * Finds a var
  75  */
  76 struct rewrite_var *
  77 rewrite_var_find(
  78                 Avlnode *tree,
  79                 const char *name
  80 )
  81 {
  82         struct rewrite_var var;
  83
  84         assert( name != NULL );
  85
  86         var.lv_name = ( char * )name;
  87         return ( struct rewrite_var * )avl_find( tree,
  88                         ( caddr_t )&var, rewrite_var_cmp );
  89 }
  90
  91 /*
  92  * Inserts a newly created var
  93  */
  94 struct rewrite_var *
  95 rewrite_var_insert(
  96                 Avlnode **tree,
  97                 const char *name,
  98                 const char *value
  99 )
 100 {
 101         struct rewrite_var *var;
 102         int rc;
 103
 104         assert( tree != NULL );
 105         assert( name != NULL );
 106         assert( value != NULL );
 107
 108         var = calloc( sizeof( struct rewrite_var ), 1 );
 109         if ( var == NULL ) {
 110                 return NULL;
 111         }
 112         var->lv_name = ( char * )strdup( name );
 113         if ( var->lv_name == NULL ) {
 114                 free( var );
 115                 return NULL;
 116         }
 117         var->lv_value.bv_val = strdup( value );
 118         if ( var->lv_value.bv_val == NULL ) {
 119                 free( var );
 120                 free( var->lv_name );
 121                 return NULL;
 122         }
 123         var->lv_value.bv_len = strlen( value );
 124         rc = avl_insert( tree, ( caddr_t )var,
 125                         rewrite_var_cmp, rewrite_var_dup );
 126         if ( rc != 0 ) {
 127                 free( var );
 128                 free( var->lv_name );
 129                 free( var->lv_value.bv_val );
 130                 return NULL;
 131         }
 132
 133         return var;
 134 }
 135
 136 /*
 137  * Sets/inserts a var
 138  */
 139 struct rewrite_var *
 140 rewrite_var_set(
 141                 Avlnode **tree,
 142                 const char *name,
 143                 const char *value,
 144                 int insert
 145 )
 146 {
 147         struct rewrite_var *var;
 148
 149         assert( tree != NULL );
 150         assert( name != NULL );
 151         assert( value != NULL );
 152
 153         var = rewrite_var_find( *tree, name );
 154         if ( var == NULL ) {
 155                 if ( insert ) {
 156                         return rewrite_var_insert( tree, name, value );
 157                 } else {
 158                         return NULL;
 159                 }
 160         } else {
 161                 assert( var->lv_value.bv_val != NULL );
 162
 163                 free( var->lv_value.bv_val );
 164                 var->lv_value.bv_val = ( char * )value;
 165                 var->lv_value.bv_len = strlen( value );
 166         }
 167
 168         return var;
 169 }
 170
 171 /*
 172  * Frees a var
 173  */
 174 static void
 175 rewrite_var_free(
 176                 void *v_var
 177 )
 178 {
 179         struct rewrite_var *var = v_var;
 180         assert( var != NULL );
 181
 182         assert( var->lv_name != NULL );
 183         assert( var->lv_value.bv_val != NULL );
 184
 185         free( var->lv_name );
 186         free( var->lv_value.bv_val );
 187 }
 188
 189 /*
 190  * Deletes a var tree
 191  */
 192 int
 193 rewrite_var_delete(
 194                 Avlnode *tree
 195 )
 196 {
 197         avl_free( tree, rewrite_var_free );
 198         return REWRITE_SUCCESS;
 199 }
 200