@cfg_get.<group_name>.<var_name> is documented
[sip-router] / modparam.c
1 /*
2  * $Id$
3  *
4  *
5  * Copyright (C) 2001-2003 FhG Fokus
6  *
7  * This file is part of ser, a free SIP server.
8  *
9  * ser is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version
13  *
14  * For a license to use the ser software under conditions
15  * other than those described here, or to purchase support for this
16  * software, please contact iptel.org by e-mail at the following addresses:
17  *    info@iptel.org
18  *
19  * ser is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License
25  * along with this program; if not, write to the Free Software
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27  *
28  * History:
29  * -------
30  * 2003-03-20  regex support in modparam (janakj)
31  * 2004-03-12  extra flag USE_FUNC_PARAM added to modparam type -
32  *             instead of copying the param value, a func is called (bogdan)
33  * 2005-07-01  PARAM_STRING & PARAM_STR support
34  */
35
36
37 #include "modparam.h"
38 #include "dprint.h"
39 #include "mem/mem.h"
40 #include <sys/types.h>
41 #include <regex.h>
42 #include <string.h>
43
44 int set_mod_param(char* _mod, char* _name, modparam_t _type, void* _val)
45 {
46         return set_mod_param_regex(_mod, _name, _type, _val);
47 }
48
49 int set_mod_param_regex(char* regex, char* name, modparam_t type, void* val)
50 {
51         struct sr_module* t;
52         regex_t preg;
53         int mod_found, len;
54         char* reg;
55         void *ptr, *val2;
56         modparam_t param_type;
57         str s;
58
59         if (!regex) {
60                 LOG(L_ERR, "set_mod_param_regex(): Invalid mod parameter value\n");
61                 return -5;
62         }
63         if (!name) {
64                 LOG(L_ERR, "set_mod_param_regex(): Invalid name parameter value\n");
65                 return -6;
66         }
67
68         len = strlen(regex);
69         reg = pkg_malloc(len + 2 + 1);
70         if (reg == 0) {
71                 LOG(L_ERR, "set_mod_param_regex(): No memory left\n");
72                 return -1;
73         }
74         reg[0] = '^';
75         memcpy(reg + 1, regex, len);
76         reg[len + 1] = '$';
77         reg[len + 2] = '\0';
78
79         if (regcomp(&preg, reg, REG_EXTENDED | REG_NOSUB | REG_ICASE)) {
80                 LOG(L_ERR, "set_mod_param_regex(): Error while compiling regular expression\n");
81                 pkg_free(reg);
82                 return -2;
83         }
84
85         mod_found = 0;
86         for(t = modules; t; t = t->next) {
87                 if (regexec(&preg, t->exports->name, 0, 0, 0) == 0) {
88                         DBG("set_mod_param_regex: '%s' matches module '%s'\n", regex, t->exports->name);
89                         mod_found = 1;
90                         /* PARAM_STR (PARAM_STRING) may be assigned also to PARAM_STRING(PARAM_STR) so let get both module param */
91                         ptr = find_param_export(t, name, type | ((type & (PARAM_STR|PARAM_STRING))?PARAM_STR|PARAM_STRING:0), &param_type);
92                         if (ptr) {
93                                      /* type casting */
94                                 if (type == PARAM_STRING && PARAM_TYPE_MASK(param_type) == PARAM_STR) {
95                                         s.s = (char*)val;
96                                         s.len = s.s ? strlen(s.s) : 0;
97                                         val2 = &s;
98                                 } else if (type == PARAM_STR && PARAM_TYPE_MASK(param_type) == PARAM_STRING) {
99                                         val2 = s.s;     /* zero terminator expected */
100                                 } else {
101                                         val2 = val;
102                                 }
103                                 DBG("set_mod_param_regex: found <%s> in module %s [%s]\n", name, t->exports->name, t->path);
104                                 if (param_type & PARAM_USE_FUNC) {
105                                         if ( ((param_func_t)(ptr))(param_type, val2) < 0) {
106                                                 regfree(&preg);
107                                                 pkg_free(reg);
108                                                 return -4;
109                                         }
110                                 }
111                                 else {
112                                         switch(PARAM_TYPE_MASK(param_type)) {
113                                                 case PARAM_STRING:
114                                                         *((char**)ptr) = pkg_malloc(strlen((char*)val2)+1);
115                                                         if (!*((char**)ptr)) {
116                                                                 LOG(L_ERR, "set_mod_param_regex(): No memory left\n");
117                                                                 return -1;
118                                                         }
119                                                         strcpy(*((char**)ptr), (char*)val2);
120                                                         break;
121
122                                                 case PARAM_STR:
123                                                         ((str*)ptr)->s = pkg_malloc(((str*)val2)->len+1);
124                                                         if (!((str*)ptr)->s) {
125                                                                 LOG(L_ERR, "set_mod_param_regex(): No memory left\n");
126                                                                 return -1;
127                                                         }
128                                                         memcpy(((str*)ptr)->s, ((str*)val2)->s, ((str*)val2)->len);
129                                                         ((str*)ptr)->len = ((str*)val2)->len;
130                                                         ((str*)ptr)->s[((str*)ptr)->len] = 0;
131                                                         break;
132
133                                                 case PARAM_INT:
134                                                         *((int*)ptr) = (int)(long)val2;
135                                                         break;
136                                         }
137                                 }
138                         }
139                         else {
140                                 LOG(L_ERR, "set_mod_param_regex: parameter <%s> not found in module <%s>\n",
141                                     name, t->exports->name);
142                                 regfree(&preg);
143                                 pkg_free(reg);
144                                 return -3;
145                         }
146                 }
147         }
148
149         regfree(&preg);
150         pkg_free(reg);
151         if (!mod_found) {
152                 LOG(L_ERR, "set_mod_param_regex: No module matching <%s> found\n", regex);
153                 return -4;
154         }
155         return 0;
156 }