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         memset( var, 0, sizeof( struct rewrite_var ) );
 113         var->lv_name = strdup( name );
 114         if ( var->lv_name == NULL ) {
 115                 rc = -1;
 116                 goto cleanup;
 117         }
 118         var->lv_value.bv_val = strdup( value );
 119         if ( var->lv_value.bv_val == NULL ) {
 120                 rc = -1;
 121                 goto cleanup;
 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                 rc = -1;
 128                 goto cleanup;
 129         }
 130
 131 cleanup:;
 132         if ( rc != 0 ) {
 133                 free( var->lv_name );
 134                 free( var->lv_value.bv_val );
 135                 free( var );
 136                 var = NULL;
 137         }
 138
 139         return var;
 140 }
 141
 142 /*
 143  * Sets/inserts a var
 144  */
 145 struct rewrite_var *
 146 rewrite_var_set(
 147                 Avlnode **tree,
 148                 const char *name,
 149                 const char *value,
 150                 int insert
 151 )
 152 {
 153         struct rewrite_var *var;
 154
 155         assert( tree != NULL );
 156         assert( name != NULL );
 157         assert( value != NULL );
 158
 159         var = rewrite_var_find( *tree, name );
 160         if ( var == NULL ) {
 161                 if ( insert ) {
 162                         return rewrite_var_insert( tree, name, value );
 163                 } else {
 164                         return NULL;
 165                 }
 166         } else {
 167                 assert( var->lv_value.bv_val != NULL );
 168
 169                 free( var->lv_value.bv_val );
 170                 var->lv_value.bv_val = ( char * )value;
 171                 var->lv_value.bv_len = strlen( value );
 172         }
 173
 174         return var;
 175 }
 176
 177 /*
 178  * Frees a var
 179  */
 180 static void
 181 rewrite_var_free(
 182                 void *v_var
 183 )
 184 {
 185         struct rewrite_var *var = v_var;
 186         assert( var != NULL );
 187
 188         assert( var->lv_name != NULL );
 189         assert( var->lv_value.bv_val != NULL );
 190
 191         free( var->lv_name );
 192         free( var->lv_value.bv_val );
 193         free( var );
 194 }
 195
 196 /*
 197  * Deletes a var tree
 198  */
 199 int
 200 rewrite_var_delete(
 201                 Avlnode *tree
 202 )
 203 {
 204         avl_free( tree, rewrite_var_free );
 205         return REWRITE_SUCCESS;
 206 }
 207