git.sip-router.org Git - sip-router/blob - cfg/cfg.c

   1 /*
   2  * $Id$
   3  *
   4  * Copyright (C) 2007 iptelorg GmbH
   5  *
   6  * This file is part of ser, a free SIP server.
   7  *
   8  * ser is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version
  12  *
  13  * For a license to use the ser software under conditions
  14  * other than those described here, or to purchase support for this
  15  * software, please contact iptel.org by e-mail at the following addresses:
  16  *    info@iptel.org
  17  *
  18  * ser is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; if not, write to the Free Software
  25  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  26  *
  27  * History
  28  * -------
  29  *  2007-12-03  Initial version (Miklos)
  30  */
  31
  32 #include <string.h>
  33
  34 #include "../ut.h"
  35 #include "../mem/mem.h"
  36 #include "cfg_struct.h"
  37 #include "cfg_ctx.h"
  38 #include "cfg_script.h"
  39 #include "cfg.h"
  40
  41 /* declares a new cfg group
  42  * handler is set to the memory area where the variables are stored
  43  * return value is -1 on error
  44  */
  45 int cfg_declare(char *group_name, cfg_def_t *def, void *values, int def_size,
  46                         void **handle)
  47 {
  48         int     i, num, size, group_name_len;
  49         cfg_mapping_t   *mapping = NULL;
  50
  51         /* check the number of the variables */
  52         for (num=0; def[num].name; num++);
  53
  54         mapping = (cfg_mapping_t *)pkg_malloc(sizeof(cfg_mapping_t)*num);
  55         if (!mapping) {
  56                 LOG(L_ERR, "ERROR: register_cfg_def(): not enough memory\n");
  57                 goto error;
  58         }
  59         memset(mapping, 0, sizeof(cfg_mapping_t)*num);
  60
  61         /* calculate the size of the memory block that has to
  62         be allocated for the cfg variables, and set the content of the
  63         cfg_mapping array the same time */
  64         for (i=0, size=0; i<num; i++) {
  65                 mapping[i].def = &(def[i]);
  66                 mapping[i].name_len = strlen(def[i].name);
  67
  68                 /* padding depends on the type of the next variable */
  69                 switch (CFG_VAR_MASK(def[i].type)) {
  70
  71                 case CFG_VAR_INT:
  72                         size = ROUND_INT(size);
  73                         mapping[i].offset = size;
  74                         size += sizeof(int);
  75                         break;
  76
  77                 case CFG_VAR_STRING:
  78                 case CFG_VAR_POINTER:
  79                         size = ROUND_POINTER(size);
  80                         mapping[i].offset = size;
  81                         size += sizeof(char *);
  82                         break;
  83
  84                 case CFG_VAR_STR:
  85                         size = ROUND_POINTER(size);
  86                         mapping[i].offset = size;
  87                         size += sizeof(str);
  88                         break;
  89
  90                 default:
  91                         LOG(L_ERR, "ERROR: register_cfg_def(): %s.%s: unsupported variable type\n",
  92                                         group_name, def[i].name);
  93                         goto error;
  94                 }
  95
  96                 /* verify the type of the input */
  97                 if (CFG_INPUT_MASK(def[i].type)==0) {
  98                         def[i].type |= def[i].type << CFG_INPUT_SHIFT;
  99                 } else {
 100                         if ((CFG_INPUT_MASK(def[i].type) != CFG_VAR_MASK(def[i].type) << CFG_INPUT_SHIFT)
 101                         && (def[i].on_change_cb == 0)) {
 102                                 LOG(L_ERR, "ERROR: register_cfg_def(): %s.%s: variable and input types are "
 103                                         "different, but no callback is defined for conversion\n",
 104                                         group_name, def[i].name);
 105                                 goto error;
 106                         }
 107                 }
 108
 109                 if (CFG_INPUT_MASK(def[i].type) > CFG_INPUT_STR) {
 110                         LOG(L_ERR, "ERROR: register_cfg_def(): %s.%s: unsupported input type\n",
 111                                         group_name, def[i].name);
 112                         goto error;
 113                 }
 114         }
 115
 116         /* minor validation */
 117         if (size != def_size) {
 118                 LOG(L_ERR, "ERROR: register_cfg_def(): the specified size of the config "
 119                         "structure does not equal with the calculated size, check whether "
 120                         "the variable types are correctly defined!\n");
 121                 goto error;
 122         }
 123
 124         group_name_len = strlen(group_name);
 125         /* create a new group
 126         I will allocate memory in shm mem for the variables later in a single block,
 127         when we know the size of all the registered groups. */
 128         if (!cfg_new_group(group_name, group_name_len, num, mapping, values, size, handle))
 129                 goto error;
 130
 131         /* The cfg variables are ready to use, let us set the handle
 132         before passing the new definitions to the drivers.
 133         We make the interface usable for the fixup functions
 134         at this step */
 135         *handle = values;
 136
 137         /* notify the drivers about the new config definition */
 138         cfg_notify_drivers(group_name, group_name_len, def);
 139
 140         LOG(L_DBG, "DEBUG: register_cfg_def(): "
 141                 "new config group has been registered: '%s' (num=%d, size=%d)\n",
 142                 group_name, num, size);
 143
 144         return 0;
 145
 146 error:
 147         if (mapping) pkg_free(mapping);
 148         LOG(L_ERR, "ERROR: register_cfg_def(): Failed to register the config group: %s\n",
 149                         group_name);
 150
 151         return -1;
 152 }
 153
 154 /* declares a single variable with integer type */
 155 int cfg_declare_int(char *group_name, char *var_name, int val, char *descr)
 156 {
 157         cfg_script_var_t        *var;
 158
 159         if ((var = new_cfg_script_var(group_name, var_name, CFG_VAR_INT, descr)) == NULL)
 160                 return -1;
 161
 162         var->val.i = val;
 163
 164         return 0;
 165 }
 166
 167 /* declares a single variable with str type */
 168 int cfg_declare_str(char *group_name, char *var_name, char *val, char *descr)
 169 {
 170         cfg_script_var_t        *var;
 171         int     len;
 172
 173         if ((var = new_cfg_script_var(group_name, var_name, CFG_VAR_STR, descr)) == NULL)
 174                 return -1;
 175
 176         if (val) {
 177                 len = strlen(val);
 178                 var->val.s.s = (char *)pkg_malloc(sizeof(char) * (len + 1));
 179                 if (!var->val.s.s) {
 180                         LOG(L_ERR, "ERROR: cfg_declare_str(): not enough memory\n");
 181                         return -1;
 182                 }
 183                 memcpy(var->val.s.s, val, len + 1);
 184                 var->val.s.len = len;
 185         } else {
 186                 var->val.s.s = NULL;
 187                 var->val.s.len = 0;
 188         }
 189
 190         return 0;
 191 }