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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2000-2003 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15 /* ACKNOWLEDGEMENT:
  16  * This work was initially developed by Pierangelo Masarati for
  17  * inclusion in OpenLDAP Software.
  18  */
  19
  20 #include <portable.h>
  21
  22 #include "rewrite-int.h"
  23
  24 /*
  25  * Compares two vars
  26  */
  27 static int
  28 rewrite_var_cmp(
  29                 const void *c1,
  30                 const void *c2
  31 )
  32 {
  33         const struct rewrite_var *v1, *v2;
  34
  35         v1 = ( const struct rewrite_var * )c1;
  36         v2 = ( const struct rewrite_var * )c2;
  37
  38         assert( v1 != NULL );
  39         assert( v2 != NULL );
  40         assert( v1->lv_name != NULL );
  41         assert( v2->lv_name != NULL );
  42
  43         return strcasecmp( v1->lv_name, v2->lv_name );
  44 }
  45
  46 /*
  47  * Duplicate var ?
  48  */
  49 static int
  50 rewrite_var_dup(
  51                 void *c1,
  52                 void *c2
  53 )
  54 {
  55         struct rewrite_var *v1, *v2;
  56
  57         v1 = ( struct rewrite_var * )c1;
  58         v2 = ( struct rewrite_var * )c2;
  59
  60         assert( v1 != NULL );
  61         assert( v2 != NULL );
  62         assert( v1->lv_name != NULL );
  63         assert( v2->lv_name != NULL );
  64
  65         return ( strcasecmp( v1->lv_name, v2->lv_name ) == 0 ? -1 : 0 );
  66 }
  67
  68 /*
  69  * Finds a var
  70  */
  71 struct rewrite_var *
  72 rewrite_var_find(
  73                 Avlnode *tree,
  74                 const char *name
  75 )
  76 {
  77         struct rewrite_var var;
  78
  79         assert( name != NULL );
  80
  81         var.lv_name = ( char * )name;
  82         return ( struct rewrite_var * )avl_find( tree,
  83                         ( caddr_t )&var, rewrite_var_cmp );
  84 }
  85
  86 /*
  87  * Inserts a newly created var
  88  */
  89 struct rewrite_var *
  90 rewrite_var_insert(
  91                 Avlnode **tree,
  92                 const char *name,
  93                 const char *value
  94 )
  95 {
  96         struct rewrite_var *var;
  97         int rc;
  98
  99         assert( tree != NULL );
 100         assert( name != NULL );
 101         assert( value != NULL );
 102
 103         var = calloc( sizeof( struct rewrite_var ), 1 );
 104         if ( var == NULL ) {
 105                 return NULL;
 106         }
 107         memset( var, 0, sizeof( struct rewrite_var ) );
 108         var->lv_name = strdup( name );
 109         if ( var->lv_name == NULL ) {
 110                 rc = -1;
 111                 goto cleanup;
 112         }
 113         var->lv_value.bv_val = strdup( value );
 114         if ( var->lv_value.bv_val == NULL ) {
 115                 rc = -1;
 116                 goto cleanup;
 117         }
 118         var->lv_value.bv_len = strlen( value );
 119         rc = avl_insert( tree, ( caddr_t )var,
 120                         rewrite_var_cmp, rewrite_var_dup );
 121         if ( rc != 0 ) {
 122                 rc = -1;
 123                 goto cleanup;
 124         }
 125
 126 cleanup:;
 127         if ( rc != 0 ) {
 128                 free( var->lv_name );
 129                 free( var->lv_value.bv_val );
 130                 free( var );
 131                 var = NULL;
 132         }
 133
 134         return var;
 135 }
 136
 137 /*
 138  * Sets/inserts a var
 139  */
 140 struct rewrite_var *
 141 rewrite_var_set(
 142                 Avlnode **tree,
 143                 const char *name,
 144                 const char *value,
 145                 int insert
 146 )
 147 {
 148         struct rewrite_var *var;
 149
 150         assert( tree != NULL );
 151         assert( name != NULL );
 152         assert( value != NULL );
 153
 154         var = rewrite_var_find( *tree, name );
 155         if ( var == NULL ) {
 156                 if ( insert ) {
 157                         return rewrite_var_insert( tree, name, value );
 158                 } else {
 159                         return NULL;
 160                 }
 161         } else {
 162                 assert( var->lv_value.bv_val != NULL );
 163
 164                 free( var->lv_value.bv_val );
 165                 var->lv_value.bv_val = ( char * )value;
 166                 var->lv_value.bv_len = strlen( value );
 167         }
 168
 169         return var;
 170 }
 171
 172 /*
 173  * Frees a var
 174  */
 175 static void
 176 rewrite_var_free(
 177                 void *v_var
 178 )
 179 {
 180         struct rewrite_var *var = v_var;
 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         free( var );
 189 }
 190
 191 /*
 192  * Deletes a var tree
 193  */
 194 int
 195 rewrite_var_delete(
 196                 Avlnode *tree
 197 )
 198 {
 199         avl_free( tree, rewrite_var_free );
 200         return REWRITE_SUCCESS;
 201 }
 202