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 <ac/string.h>
  28
  29 #include "rewrite-int.h"
  30
  31 /*
  32  * Compares two vars
  33  */
  34 static int
  35 rewrite_var_cmp(
  36                 const void *c1,
  37                 const void *c2
  38 )
  39 {
  40         const struct rewrite_var *v1, *v2;
  41
  42         v1 = ( struct rewrite_var * )c1;
  43         v2 = ( struct rewrite_var * )c2;
  44
  45         assert( v1 != NULL );
  46         assert( v2 != NULL );
  47         assert( v1->lv_name != NULL );
  48         assert( v2->lv_name != NULL );
  49
  50         return strcasecmp( v1->lv_name, v2->lv_name );
  51 }
  52
  53 /*
  54  * Duplicate var ?
  55  */
  56 static int
  57 rewrite_var_dup(
  58                 void *c1,
  59                 void *c2
  60 )
  61 {
  62         struct rewrite_var *v1, *v2;
  63
  64         v1 = ( struct rewrite_var * )c1;
  65         v2 = ( struct rewrite_var * )c2;
  66
  67         assert( v1 != NULL );
  68         assert( v2 != NULL );
  69         assert( v1->lv_name != NULL );
  70         assert( v2->lv_name != NULL );
  71
  72         return ( strcasecmp( v1->lv_name, v2->lv_name ) == 0 ? -1 : 0 );
  73 }
  74
  75 /*
  76  * Finds a var
  77  */
  78 struct rewrite_var *
  79 rewrite_var_find(
  80                 Avlnode *tree,
  81                 const char *name
  82 )
  83 {
  84         struct rewrite_var var;
  85
  86         assert( name != NULL );
  87
  88         var.lv_name = ( char * )name;
  89         return ( struct rewrite_var * )avl_find( tree,
  90                         ( caddr_t )&var, rewrite_var_cmp );
  91 }
  92
  93 /*
  94  * Inserts a newly created var
  95  */
  96 struct rewrite_var *
  97 rewrite_var_insert(
  98                 Avlnode **tree,
  99                 const char *name,
 100                 const char *value
 101 )
 102 {
 103         struct rewrite_var *var;
 104         int rc;
 105
 106         assert( tree != NULL );
 107         assert( name != NULL );
 108         assert( value != NULL );
 109
 110         var = calloc( sizeof( struct rewrite_var ), 1 );
 111         if ( var == NULL ) {
 112                 return NULL;
 113         }
 114         var->lv_name = ( char * )strdup( name );
 115         if ( var->lv_name == NULL ) {
 116                 free( var );
 117                 return NULL;
 118         }
 119         var->lv_value.bv_val = strdup( value );
 120         if ( var->lv_value.bv_val == NULL ) {
 121                 free( var );
 122                 free( var->lv_name );
 123                 return NULL;
 124         }
 125         var->lv_value.bv_len = strlen( value );
 126         rc = avl_insert( tree, ( caddr_t )var,
 127                         rewrite_var_cmp, rewrite_var_dup );
 128         if ( rc != 0 ) {
 129                 free( var );
 130                 free( var->lv_name );
 131                 free( var->lv_value.bv_val );
 132                 return NULL;
 133         }
 134
 135         return var;
 136 }
 137
 138 /*
 139  * Sets/inserts a var
 140  */
 141 struct rewrite_var *
 142 rewrite_var_set(
 143                 Avlnode **tree,
 144                 const char *name,
 145                 const char *value,
 146                 int insert
 147 )
 148 {
 149         struct rewrite_var *var;
 150
 151         assert( tree != NULL );
 152         assert( name != NULL );
 153         assert( value != NULL );
 154
 155         var = rewrite_var_find( *tree, name );
 156         if ( var == NULL ) {
 157                 if ( insert ) {
 158                         return rewrite_var_insert( tree, name, value );
 159                 } else {
 160                         return NULL;
 161                 }
 162         } else {
 163                 assert( var->lv_value.bv_val != NULL );
 164
 165                 free( var->lv_value.bv_val );
 166                 var->lv_value.bv_val = ( char * )value;
 167                 var->lv_value.bv_len = strlen( value );
 168         }
 169
 170         return var;
 171 }
 172
 173 /*
 174  * Frees a var
 175  */
 176 static void
 177 rewrite_var_free(
 178                 struct rewrite_var *var
 179 )
 180 {
 181         assert( var != NULL );
 182
 183         assert( var->lv_name != NULL );
 184         assert( var->lv_value.bv_val != NULL );
 185
 186         free( var->lv_name );
 187         free( var->lv_value.bv_val );
 188 }
 189
 190 /*
 191  * Deletes a var tree
 192  */
 193 int
 194 rewrite_var_delete(
 195                 Avlnode *tree
 196 )
 197 {
 198         avl_free( tree, ( AVL_FREE )rewrite_var_free );
 199         return REWRITE_SUCCESS;
 200 }
 201