core: allow event_route blocks to run ONEVENT_ROUTE|REQUEST_ROUTE functions
[sip-router] / src / core / sr_module.c
1 /*
2  * Copyright (C) 2001-2003 FhG Fokus
3  *
4  * This file is part of Kamailio, a free SIP server.
5  *
6  * Kamailio is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version
10  *
11  * Kamailio is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20
21 /**
22  * @file
23  * @brief Kamailio core :: modules loading, structures declarations and utilities
24  * @ingroup core
25  * Module: \ref core
26  */
27
28
29 #include "sr_module.h"
30 #include "mod_fix.h"
31 #include "dprint.h"
32 #include "error.h"
33 #include "mem/mem.h"
34 #include "core_cmd.h"
35 #include "ut.h"
36 #include "re.h"
37 #include "route_struct.h"
38 #include "flags.h"
39 #include "trim.h"
40 #include "pvapi.h"
41 #include "globals.h"
42 #include "rpc_lookup.h"
43 #include "sr_compat.h"
44 #include "ppcfg.h"
45 #include "async_task.h"
46
47 #include <sys/stat.h>
48 #include <regex.h>
49 #include <dlfcn.h>
50 #include <strings.h>
51 #include <stdlib.h>
52 #include <string.h>
53 #include <stddef.h> /* for offsetof */
54
55
56 struct sr_module* modules=0;
57
58 /*We need to define this symbol on Solaris becuase libcurl relies on libnspr which looks for this symbol.
59   If it is not defined, dynamic module loading (dlsym) fails */
60 #ifdef __OS_solaris
61         int nspr_use_zone_allocator = 0;
62 #endif
63
64
65 #ifdef STATIC_EXEC
66         extern struct module_exports exec_exports;
67 #endif
68 #ifdef STATIC_TM
69         extern struct module_exports tm_exports;
70 #endif
71
72 #ifdef STATIC_MAXFWD
73         extern struct module_exports maxfwd_exports;
74 #endif
75
76 #ifdef STATIC_AUTH
77         extern struct module_exports auth_exports;
78 #endif
79
80 #ifdef STATIC_RR
81         extern struct module_exports rr_exports;
82 #endif
83
84 #ifdef STATIC_USRLOC
85         extern struct module_exports usrloc_exports;
86 #endif
87
88 #ifdef STATIC_SL
89         extern struct module_exports sl_exports;
90 #endif
91
92 #ifndef offsetof
93 #warning "use null pointer dereference for offsetof"
94 #define offsetof(st, m) \
95                 ((size_t) ( (char *)&((st *)(0))->m - (char *)0 ))
96 #endif
97
98 int mod_response_cbk_no=0;
99 response_function* mod_response_cbks=0;
100
101 /* number of usec to wait before initializing a module */
102 static unsigned int modinit_delay = 0;
103
104 unsigned int set_modinit_delay(unsigned int v)
105 {
106         unsigned int r;
107         r =  modinit_delay;
108         modinit_delay = v;
109         return r;
110 }
111
112 /* keep state if server is in destroy modules phase */
113 static int _sr_destroy_modules_phase = 0;
114
115 /**
116  * return destroy modules phase state
117  */
118 int destroy_modules_phase(void)
119 {
120         return _sr_destroy_modules_phase;
121 }
122
123 /**
124  * if bit 1 set, SIP worker processes handle RPC commands as well
125  * if bit 2 set, RPC worker processes handle SIP commands as well
126  */
127 static int child_sip_rpc_mode = 0;
128
129 #define CHILD_SIP_RPC   1<<0
130 #define CHILD_RPC_SIP   1<<1
131
132 void set_child_sip_rpc_mode(void)
133 {
134         child_sip_rpc_mode |= CHILD_SIP_RPC;
135 }
136
137 void set_child_rpc_sip_mode(void)
138 {
139         child_sip_rpc_mode |= CHILD_RPC_SIP;
140 }
141
142 int is_rpc_worker(int rank)
143 {
144         if(rank==PROC_RPC
145                         || (rank>PROC_MAIN && (child_sip_rpc_mode&CHILD_SIP_RPC)!=0))
146                 return 1;
147         return 0;
148 }
149
150 int is_sip_worker(int rank)
151 {
152         if(rank>PROC_MAIN
153                         || ((rank==PROC_RPC || rank==PROC_NOCHLDINIT)
154                                         && (child_sip_rpc_mode&CHILD_RPC_SIP)!=0))
155                 return 1;
156         return 0;
157 }
158
159 /* initializes statically built (compiled in) modules*/
160 int register_builtin_modules()
161 {
162         int ret;
163
164         ret=0;
165 #ifdef STATIC_TM
166         ret=register_module(MODULE_INTERFACE_VER, &tm_exports,"built-in", 0);
167         if (ret<0) return ret;
168 #endif
169
170 #ifdef STATIC_EXEC
171         ret=register_module(MODULE_INTERFACE_VER, &exec_exports,"built-in", 0);
172         if (ret<0) return ret;
173 #endif
174
175 #ifdef STATIC_MAXFWD
176         ret=register_module(MODULE_INTERFACE_VER, &maxfwd_exports, "built-in", 0);
177         if (ret<0) return ret;
178 #endif
179
180 #ifdef STATIC_AUTH
181         ret=register_module(MODULE_INTERFACE_VER, &auth_exports, "built-in", 0);
182         if (ret<0) return ret;
183 #endif
184
185 #ifdef STATIC_RR
186         ret=register_module(MODULE_INTERFACE_VER, &rr_exports, "built-in", 0);
187         if (ret<0) return ret;
188 #endif
189
190 #ifdef STATIC_USRLOC
191         ret=register_module(MODULE_INTERFACE_VER, &usrloc_exports, "built-in", 0);
192         if (ret<0) return ret;
193 #endif
194
195 #ifdef STATIC_SL
196         ret=register_module(MODULE_INTERFACE_VER, &sl_exports, "built-in", 0);
197         if (ret<0) return ret;
198 #endif
199
200         return ret;
201 }
202
203
204
205 /** convert cmd exports to current format.
206  * @param ver - module interface versions (0 == ser, 1 == kam).
207  * @param src - null terminated array of cmd exports
208  *              (either ser_cmd_export_t or kam_cmd_export_t, depending
209  *               on ver).
210  * @param mod - pointer to module exports structure.
211  * @return - pkg_malloc'ed null terminated sr_cmd_export_v31_t array with
212  *           the converted cmd exports  or 0 on error.
213  */
214 static sr31_cmd_export_t* sr_cmd_exports_convert(unsigned ver,
215                                                                                                         void* src, void* mod)
216 {
217         int i, n;
218         ser_cmd_export_t* ser_cmd;
219         kam_cmd_export_t* kam_cmd;
220         sr31_cmd_export_t* ret;
221
222         ser_cmd = 0;
223         kam_cmd = 0;
224         ret = 0;
225         n = 0;
226         /* count the number of elements */
227         if (ver == 0) {
228                 ser_cmd = src;
229                 for (; ser_cmd[n].name; n++);
230         } else if (ver == 1) {
231                 kam_cmd = src;
232                 for (; kam_cmd[n].name; n++);
233         } else goto error; /* unknown interface version */
234         /* alloc & init new array */
235         ret = pkg_malloc(sizeof(*ret)*(n+1));
236         memset(ret, 0, sizeof(*ret)*(n+1));
237         /* convert/copy */
238         for (i=0; i < n; i++) {
239                 if (ver == 0) {
240                         ret[i].name = ser_cmd[i].name;
241                         ret[i].function = ser_cmd[i].function;
242                         ret[i].param_no = ser_cmd[i].param_no;
243                         ret[i].fixup = ser_cmd[i].fixup;
244                         ret[i].free_fixup = 0; /* no present in ser  <= 2.1 */
245                         ret[i].flags = ser_cmd[i].flags;
246                 } else {
247                         ret[i].name = kam_cmd[i].name;
248                         ret[i].function = kam_cmd[i].function;
249                         ret[i].param_no = kam_cmd[i].param_no;
250                         ret[i].fixup = kam_cmd[i].fixup;
251                         ret[i].free_fixup = kam_cmd[i].free_fixup;
252                         ret[i].flags = kam_cmd[i].flags;
253                 }
254                 /* 3.1+ specific stuff */
255                 ret[i].fixup_flags = 0;
256                 ret[i].module_exports = mod;
257                 /* fill known free fixups */
258                 if (ret[i].fixup && ret[i].free_fixup == 0)
259                         ret[i].free_fixup = get_fixup_free(ret[i].fixup);
260         }
261         return ret;
262 error:
263         return 0;
264 }
265
266
267
268 /* registers a module,  register_f= module register  functions
269  * returns <0 on error, 0 on success */
270 static int register_module(unsigned ver, union module_exports_u* e,
271                                         char* path, void* handle)
272 {
273         int ret, i;
274         struct sr_module* mod;
275         char defmod[64];
276
277         ret=-1;
278
279         /* add module to the list */
280         if ((mod=pkg_malloc(sizeof(struct sr_module)))==0){
281                 LM_ERR("memory allocation failure\n");
282                 ret=E_OUT_OF_MEM;
283                 goto error;
284         }
285         memset(mod,0, sizeof(struct sr_module));
286         mod->path=path;
287         mod->handle=handle;
288         mod->orig_mod_interface_ver=ver;
289         /* convert exports to sr31 format */
290         if (ver == 0) {
291                 /* ser <= 3.0 */
292                 mod->exports.name = e->v0.name;
293                 if (e->v0.cmds) {
294                         mod->exports.cmds = sr_cmd_exports_convert(ver, e->v0.cmds, mod);
295                         if (mod->exports.cmds == 0) {
296                                 LM_ERR("failed to convert module command exports to 3.1 format"
297                                                 " for module \"%s\" (%s), interface version %d\n",
298                                                 mod->exports.name, mod->path, ver);
299                                 ret = E_UNSPEC;
300                                 goto error;
301                         }
302                 }
303                 mod->exports.params = e->v0.params;
304                 mod->exports.init_f = e->v0.init_f;
305                 mod->exports.response_f = e->v0.response_f;
306                 mod->exports.destroy_f = e->v0.destroy_f;
307                 mod->exports.onbreak_f = e->v0.onbreak_f;
308                 mod->exports.init_child_f = e->v0.init_child_f;
309                 mod->exports.dlflags = 0; /* not used in ser <= 3.0 */
310                 mod->exports.rpc_methods = e->v0.rpc_methods;
311                 /* the rest are 0, not used in ser */
312         } else if (ver == 1) {
313                 /* kamailio <= 3.0 */
314                 mod->exports.name = e->v1.name;
315                 if (e->v1.cmds) {
316                         mod->exports.cmds = sr_cmd_exports_convert(ver, e->v1.cmds, mod);
317                         if (mod->exports.cmds == 0) {
318                                 LM_ERR("failed to convert module command exports to 3.1 format"
319                                                 " for module \"%s\" (%s), interface version %d\n",
320                                                 mod->exports.name, mod->path, ver);
321                                 ret = E_UNSPEC;
322                                 goto error;
323                         }
324                 }
325                 mod->exports.params = e->v1.params;
326                 mod->exports.init_f = e->v1.init_f;
327                 mod->exports.response_f = e->v1.response_f;
328                 mod->exports.destroy_f = e->v1.destroy_f;
329                 mod->exports.onbreak_f = 0; /* not used in k <= 3.0 */
330                 mod->exports.init_child_f = e->v1.init_child_f;
331                 mod->exports.dlflags = e->v1.dlflags;
332                 mod->exports.rpc_methods = 0; /* not used in k <= 3.0 */
333                 mod->exports.stats = e->v1.stats;
334                 mod->exports.nn_cmds = e->v1.nn_cmds;
335                 mod->exports.items = e->v1.items;
336                 mod->exports.procs = e->v1.procs;
337         } else {
338                 LM_ERR("unsupported module interface version %d\n", ver);
339                 ret = E_UNSPEC;
340                 goto error;
341         }
342
343         if (mod->exports.items) {
344                 /* register module pseudo-variables for kamailio modules */
345                 LM_DBG("register PV from: %s\n", mod->exports.name);
346                 if (register_pvars_mod(mod->exports.name, mod->exports.items)!=0) {
347                         LM_ERR("failed to register pseudo-variables for module %s (%s)\n",
348                                 mod->exports.name, path);
349                         ret = E_UNSPEC;
350                         goto error;
351                 }
352         }
353         if (mod->exports.rpc_methods){
354                 /* register rpcs for ser modules */
355                 i=rpc_register_array(mod->exports.rpc_methods);
356                 if (i<0){
357                         LM_ERR("failed to register RPCs for module %s (%s)\n",
358                                         mod->exports.name, path);
359                         ret = E_UNSPEC;
360                         goto error;
361                 }else if (i>0){
362                         LM_ERR("%d duplicate RPCs name detected while registering RPCs"
363                                         " declared in module %s (%s)\n",
364                                         i, mod->exports.name, path);
365                         ret = E_UNSPEC;
366                         goto error;
367                 }
368                 /* i==0 => success */
369         }
370
371         /* add cfg define for each module: MOD_modulename */
372         if(strlen(mod->exports.name)>=60) {
373                 LM_ERR("too long module name: %s\n", mod->exports.name);
374                 goto error;
375         }
376         strcpy(defmod, "MOD_");
377         strcat(defmod, mod->exports.name);
378         pp_define_set_type(0);
379         if(pp_define(strlen(defmod), defmod)<0) {
380                 LM_ERR("unable to set cfg define for module: %s\n",
381                                 mod->exports.name);
382                 goto error;
383         }
384
385         /* link module in the list */
386         mod->next=modules;
387         modules=mod;
388         return 0;
389 error:
390         if (mod)
391                 pkg_free(mod);
392         return ret;
393 }
394
395 static inline int version_control(void *handle, char *path)
396 {
397         char **m_ver;
398         char **m_flags;
399         char* error;
400
401         m_ver=(char **)dlsym(handle, "module_version");
402         if ((error=(char *)dlerror())!=0) {
403                 LM_ERR("no version info in module <%s>: %s\n", path, error);
404                 return 0;
405         }
406         m_flags=(char **)dlsym(handle, "module_flags");
407         if ((error=(char *)dlerror())!=0) {
408                 LM_ERR("no compile flags info in module <%s>: %s\n", path, error);
409                 return 0;
410         }
411         if (!m_ver || !(*m_ver)) {
412                 LM_ERR("no version in module <%s>\n", path );
413                 return 0;
414         }
415         if (!m_flags || !(*m_flags)) {
416                 LM_ERR("no compile flags in module <%s>\n", path );
417                 return 0;
418         }
419
420         if (strcmp(SER_FULL_VERSION, *m_ver)==0){
421                 if (strcmp(SER_COMPILE_FLAGS, *m_flags)==0)
422                         return 1;
423                 else {
424                         LM_ERR("module compile flags mismatch for %s "
425                                                 " \ncore: %s \nmodule: %s\n",
426                                                 path, SER_COMPILE_FLAGS, *m_flags);
427                         return 0;
428                 }
429         }
430         LM_ERR("module version mismatch for %s; "
431                 "core: %s; module: %s\n", path, SER_FULL_VERSION, *m_ver );
432         return 0;
433 }
434
435 /**
436  * \brief load a sr module
437  *
438  * tries to load the module specified by mod_path.
439  * If mod_path is 'modname' or 'modname.so' then
440  *  \<MODS_DIR\>/\<modname\>.so will be tried and if this fails
441  *  \<MODS_DIR\>/\<modname\>/\<modname\>.so
442  * If mod_path contain a '/' it is assumed to be the
443  * path to the module and tried first. If fails and mod_path is not
444  * absolute path (not starting with '/') then will try:
445  * \<MODS_DIR\>/mod_path
446  * @param mod_path path or module name
447  * @return 0 on success , <0 on error
448  */
449 int load_module(char* mod_path)
450 {
451         void* handle;
452         char* error;
453         mod_register_function mr;
454         union module_exports_u* exp;
455         unsigned* mod_if_ver;
456         struct sr_module* t;
457         struct stat stat_buf;
458         str modname;
459         char* mdir;
460         char* nxt_mdir;
461         char* path;
462         int mdir_len;
463         int len;
464         int dlflags;
465         int new_dlflags;
466         int retries;
467         int path_type;
468         str expref;
469         char exbuf[64];
470
471 #ifndef RTLD_NOW
472 /* for openbsd */
473 #define RTLD_NOW DL_LAZY
474 #endif
475         path=mod_path;
476         path_type = 0;
477         modname.s = path;
478         modname.len = strlen(mod_path);
479         if(modname.len>3 && strcmp(modname.s+modname.len-3, ".so")==0) {
480                 path_type = 1;
481                 modname.len -= 3;
482         }
483         if (!strchr(path, '/'))
484                 path_type |= 2;
485         if((path_type&2) || path[0] != '/') {
486                 /* module name was given, we try to construct the path */
487                 mdir=mods_dir; /* search path */
488                 do{
489                         nxt_mdir=strchr(mdir, ':');
490                         if (nxt_mdir) mdir_len=(int)(nxt_mdir-mdir);
491                         else mdir_len=strlen(mdir);
492
493                         if(path_type&2) {
494                                 /* try path <MODS_DIR>/<modname>.so */
495                                 path = (char*)pkg_malloc(mdir_len + 1 /* "/" */ +
496                                                                         modname.len + 3 /* ".so" */ + 1);
497                                 if (path==0) goto error;
498                                 memcpy(path, mdir, mdir_len);
499                                 len = mdir_len;
500                                 if (len != 0 && path[len - 1] != '/'){
501                                         path[len]='/';
502                                         len++;
503                                 }
504                                 path[len]=0;
505                                 strcat(path, modname.s);
506                                 if(!(path_type&1))
507                                         strcat(path, ".so");
508
509                                 if (stat(path, &stat_buf) == -1) {
510                                         LM_DBG("module file not found <%s>\n", path);
511                                         pkg_free(path);
512
513                                         /* try path <MODS_DIR>/<modname>/<modname>.so */
514                                         path = (char*)pkg_malloc(
515                                                 mdir_len + 1 /* "/" */ +
516                                                 modname.len + 1 /* "/" */ +
517                                                 modname.len + 3 /* ".so" */ + 1);
518                                         if (path==0) goto error;
519                                         memcpy(path, mdir, mdir_len);
520                                         len = mdir_len;
521                                         if (len != 0 && path[len - 1] != '/') {
522                                                 path[len]='/';
523                                                 len++;
524                                         }
525                                         path[len]=0;
526                                         strncat(path, modname.s, modname.len);
527                                         strcat(path, "/");
528                                         strcat(path, modname.s);
529                                         if(!(path_type&1))
530                                                 strcat(path, ".so");
531
532                                         if (stat(path, &stat_buf) == -1) {
533                                                 LM_DBG("module file not found <%s>\n", path);
534                                                 pkg_free(path);
535                                                 path=0;
536                                         }
537                                 }
538                         } else {
539                                 /* try mod_path - S compat */
540                                 if(path==mod_path) {
541                                         if (stat(path, &stat_buf) == -1) {
542                                                 LM_DBG("module file not found <%s>\n", path);
543                                                 path=0;
544                                         }
545                                 }
546                                 if(path==0) {
547                                         /* try path <MODS_DIR>/mod_path - K compat */
548                                         path = (char*)pkg_malloc(mdir_len + 1 /* "/" */ +
549                                                                         strlen(mod_path) + 1);
550                                         if (path==0) goto error;
551                                         memcpy(path, mdir, mdir_len);
552                                         len = mdir_len;
553                                         if (len != 0 && path[len - 1] != '/'){
554                                                 path[len]='/';
555                                                 len++;
556                                         }
557                                         path[len]=0;
558                                         strcat(path, mod_path);
559
560                                         if (stat(path, &stat_buf) == -1) {
561                                                 LM_DBG("module file not found <%s>\n", path);
562                                                 pkg_free(path);
563                                                 path=0;
564                                         }
565                                 }
566                         }
567                         mdir=nxt_mdir?nxt_mdir+1:0;
568                 }while(path==0 && mdir);
569                 if (path==0){
570                         LM_ERR("could not find module <%.*s> in <%s>\n",
571                                                 modname.len, modname.s, mods_dir);
572                         goto error;
573                 }
574         }
575         LM_DBG("trying to load <%s>\n", path);
576
577         retries=2;
578         dlflags=RTLD_NOW;
579 reload:
580         handle=dlopen(path, dlflags); /* resolve all symbols now */
581         if (handle==0){
582                 LM_ERR("could not open module <%s>: %s\n", path, dlerror());
583                 goto error;
584         }
585
586         for(t=modules;t; t=t->next){
587                 if (t->handle==handle){
588                         LM_WARN("attempting to load the same module twice (%s)\n", path);
589                         goto skip;
590                 }
591         }
592         /* version control */
593         if (!version_control(handle, path)) {
594                 exit(-1);
595         }
596         mod_if_ver = (unsigned *)dlsym(handle, "module_interface_ver");
597         if ( (error =(char*)dlerror())!=0 ){
598                 LM_ERR("no module interface version in module <%s>\n", path );
599                 goto error1;
600         }
601         /* launch register */
602         mr = (mod_register_function)dlsym(handle, "mod_register");
603         if (((error =(char*)dlerror())==0) && mr) {
604                 /* no error call it */
605                 new_dlflags=dlflags;
606                 if (mr(path, &new_dlflags, 0, 0)!=0) {
607                         LM_ERR("%s: mod_register failed\n", path);
608                         goto error1;
609                 }
610                 if (new_dlflags!=dlflags && new_dlflags!=0) {
611                         /* we have to reload the module */
612                         dlclose(handle);
613                         dlflags=new_dlflags;
614                         retries--;
615                         if (retries>0) goto reload;
616                         LM_ERR("%s: cannot agree on the dlflags\n", path);
617                         goto error;
618                 }
619         }
620         exp = (union module_exports_u*)dlsym(handle, "exports");
621         if(exp==NULL) {
622                 /* 'exports' structure not found, look up for '_modulename_exports' */
623                 mdir = strrchr(mod_path, '/');
624                 if (!mdir) {
625                         expref.s = mod_path;
626                 } else {
627                         expref.s = mdir+1;
628                 }
629                 expref.len = strlen(expref.s);
630                 if(expref.len>3 && strcmp(expref.s+expref.len-3, ".so")==0)
631                         expref.len -= 3;
632                 snprintf(exbuf, 62, "_%.*s_exports", expref.len, expref.s);
633                 exp = (union module_exports_u*)dlsym(handle, exbuf);
634                 LM_DBG("looking up exports with name: %s\n", exbuf);
635                 if ( (error =(char*)dlerror())!=0 ){
636                         LM_ERR("%s\n", error);
637                         goto error1;
638                 }
639         }
640         /* hack to allow for kamailio style dlflags inside exports */
641         if (*mod_if_ver == 1) {
642                 new_dlflags = exp->v1.dlflags;
643                 if (new_dlflags!=dlflags && new_dlflags!=DEFAULT_DLFLAGS) {
644                         /* we have to reload the module */
645                         dlclose(handle);
646                         DEBUG("%s: exports dlflags interface is deprecated and it will not"
647                                         " be supported in newer versions; consider using"
648                                         " mod_register() instead\n", path);
649                         dlflags=new_dlflags;
650                         retries--;
651                         if (retries>0) goto reload;
652                         LM_ERR("%s: cannot agree on the dlflags\n", path);
653                         goto error;
654                 }
655         }
656         if (register_module(*mod_if_ver, exp, path, handle)<0) goto error1;
657         return 0;
658
659 error1:
660         dlclose(handle);
661 error:
662 skip:
663         if (path && path!=mod_path)
664                 pkg_free(path);
665         return -1;
666 }
667
668 /**
669  * test if command flags are compatible with route block flags (type)
670  * - decide if the command is allowed to run within a specific route block
671  * - return: 1 if allowed; 0 if not allowed
672  */
673 static inline int sr_cmd_flags_match(int cflags, int rflags)
674 {
675         if((cflags & rflags) == rflags) {
676                 return 1;
677         }
678         if((rflags==EVENT_ROUTE) && (cflags & EVENT_ROUTE)) {
679                 return 1;
680         }
681         return 0;
682 }
683
684 /* searches the module list for function name in module mod and returns
685  *  a pointer to the "name" function record union or 0 if not found
686  * sets also *mod_if_ver to the original module interface version.
687  * mod==0 is a wildcard matching all modules
688  * flags parameter is OR value of all flags that must match
689  */
690 sr31_cmd_export_t* find_mod_export_record(char* mod, char* name,
691                                                                                         int param_no, int flags,
692                                                                                         unsigned* mod_if_ver)
693 {
694         struct sr_module* t;
695         sr31_cmd_export_t* cmd;
696
697         for(t=modules;t;t=t->next){
698                 if (mod!=0 && (strcmp(t->exports.name, mod) !=0))
699                         continue;
700                 if (t->exports.cmds)
701                         for(cmd=&t->exports.cmds[0]; cmd->name; cmd++) {
702                                 if((strcmp(name, cmd->name) == 0) &&
703                                         ((cmd->param_no == param_no) ||
704                                         (cmd->param_no==VAR_PARAM_NO)) &&
705                                         (sr_cmd_flags_match(cmd->flags, flags)==1)
706                                 ){
707                                         LM_DBG("found export of <%s> in module %s [%s]\n",
708                                                 name, t->exports.name, t->path);
709                                         *mod_if_ver=t->orig_mod_interface_ver;
710                                         return cmd;
711                                 }
712                         }
713         }
714         LM_DBG("export of <%s> not found (flags %d)\n", name, flags);
715         return 0;
716 }
717
718
719
720 /* searches the module list for function name and returns
721  *  a pointer to the "name" function record union or 0 if not found
722  * sets also *mod_if_ver to the module interface version (needed to know
723  * which member of the union should be accessed v0 or v1)
724  * mod==0 is a wildcard matching all modules
725  * flags parameter is OR value of all flags that must match
726  */
727 sr31_cmd_export_t* find_export_record(char* name,
728                                                                                         int param_no, int flags,
729                                                                                         unsigned* mod_if_ver)
730 {
731         return find_mod_export_record(0, name, param_no, flags, mod_if_ver);
732 }
733
734
735
736 cmd_function find_export(char* name, int param_no, int flags)
737 {
738         sr31_cmd_export_t* cmd;
739         unsigned mver;
740
741         cmd = find_export_record(name, param_no, flags, &mver);
742         return cmd?cmd->function:0;
743 }
744
745
746 rpc_export_t* find_rpc_export(char* name, int flags)
747 {
748         return rpc_lookup((char*)name, strlen(name));
749 }
750
751
752 /*
753  * searches the module list and returns pointer to "name" function in module
754  * "mod"
755  * 0 if not found
756  * flags parameter is OR value of all flags that must match
757  */
758 cmd_function find_mod_export(char* mod, char* name, int param_no, int flags)
759 {
760         sr31_cmd_export_t* cmd;
761         unsigned mver;
762
763         cmd=find_mod_export_record(mod, name, param_no, flags, &mver);
764         if (cmd)
765                 return cmd->function;
766
767         LM_DBG("<%s> in module <%s> not found\n", name, mod);
768         return 0;
769 }
770
771
772 struct sr_module* find_module_by_name(char* mod) {
773         struct sr_module* t;
774
775         for(t = modules; t; t = t->next) {
776                 if (strcmp(mod, t->exports.name) == 0) {
777                         return t;
778                 }
779         }
780         LM_DBG("module <%s> not found\n", mod);
781         return 0;
782 }
783
784
785 /*!
786  * \brief Find a parameter with given type
787  * \param mod module
788  * \param name parameter name
789  * \param type_mask parameter mask
790  * \param param_type parameter type
791  * \return parameter address in memory, if there is no such parameter, NULL is returned
792  */
793 void* find_param_export(struct sr_module* mod, char* name,
794                                                 modparam_t type_mask, modparam_t *param_type)
795 {
796         param_export_t* param;
797
798         if (!mod)
799                 return 0;
800         for(param = mod->exports.params ;param && param->name ; param++) {
801                 if ((strcmp(name, param->name) == 0) &&
802                         ((param->type & PARAM_TYPE_MASK(type_mask)) != 0)) {
803                         LM_DBG("found <%s> in module %s [%s]\n",
804                                 name, mod->exports.name, mod->path);
805                         *param_type = param->type;
806                         return param->param_pointer;
807                 }
808         }
809         LM_DBG("parameter <%s> not found in module <%s>\n",
810                         name, mod->exports.name);
811         return 0;
812 }
813
814
815 void destroy_modules()
816 {
817         struct sr_module* t, *foo;
818
819         _sr_destroy_modules_phase = 1;
820         /* call first destroy function from each module */
821         t=modules;
822         while(t) {
823                 foo=t->next;
824                 if (t->exports.destroy_f){
825                         t->exports.destroy_f();
826                 }
827                 t=foo;
828         }
829         /* free module exports structures */
830         t=modules;
831         while(t) {
832                 foo=t->next;
833                 pkg_free(t);
834                 t=foo;
835         }
836         modules=0;
837         if (mod_response_cbks){
838                 pkg_free(mod_response_cbks);
839                 mod_response_cbks=0;
840         }
841 }
842
843 #ifdef NO_REVERSE_INIT
844
845 /*
846  * Initialize all loaded modules, the initialization
847  * is done *AFTER* the configuration file is parsed
848  */
849 int init_modules(void)
850 {
851         struct sr_module* t;
852
853         if(async_task_init()<0)
854                 return -1;
855
856         for(t = modules; t; t = t->next) {
857                 if (t->exports.init_f) {
858                         if (t->exports.init_f() != 0) {
859                                 LM_ERR("Error while initializing module %s\n", t->exports.name);
860                                 return -1;
861                         }
862                         /* delay next module init, if configured */
863                         if(unlikely(modinit_delay>0))
864                                 sleep_us(modinit_delay);
865                 }
866                 if (t->exports.response_f)
867                         mod_response_cbk_no++;
868         }
869         mod_response_cbks=pkg_malloc(mod_response_cbk_no *
870                                                                         sizeof(response_function));
871         if (mod_response_cbks==0){
872                 LM_ERR("memory allocation failure for %d response_f callbacks\n",
873                                         mod_response_cbk_no);
874                 return -1;
875         }
876         for (t=modules, i=0; t && (i<mod_response_cbk_no); t=t->next) {
877                 if (t->exports.response_f) {
878                         mod_response_cbks[i]=t->exports.response_f;
879                         i++;
880                 }
881         }
882         return 0;
883 }
884
885
886
887 /*
888  * per-child initialization
889  */
890 int init_child(int rank)
891 {
892         struct sr_module* t;
893         char* type;
894
895         switch(rank) {
896         case PROC_MAIN:     type = "PROC_MAIN";     break;
897         case PROC_TIMER:    type = "PROC_TIMER";    break;
898         case PROC_FIFO:     type = "PROC_FIFO";     break;
899         case PROC_TCP_MAIN: type = "PROC_TCP_MAIN"; break;
900         default:            type = "CHILD";         break;
901         }
902         LM_DBG("initializing %s with rank %d\n", type, rank);
903
904         if(async_task_child_init(rank)<0)
905                 return -1;
906
907         for(t = modules; t; t = t->next) {
908                 if (t->exports.init_child_f) {
909                         if ((t->exports.init_child_f(rank)) < 0) {
910                                 LM_ERR("Initialization of child %d failed\n", rank);
911                                 return -1;
912                         }
913                 }
914         }
915         return 0;
916 }
917
918 #else
919
920
921 /* recursive module child initialization; (recursion is used to
922  * process the module linear list in the same order in
923  * which modules are loaded in config file
924  */
925
926 static int init_mod_child( struct sr_module* m, int rank )
927 {
928         if (m) {
929                 /* iterate through the list; if error occurs,
930                  * propagate it up the stack
931                  */
932                 if (init_mod_child(m->next, rank)!=0) return -1;
933                 if (m->exports.init_child_f) {
934                         LM_DBG("rank %d: %s\n", rank, m->exports.name);
935                         if (m->exports.init_child_f(rank)<0) {
936                                 LM_ERR("Error while initializing module %s (%s)\n",
937                                                         m->exports.name, m->path);
938                                 return -1;
939                         } else {
940                                 /* module correctly initialized */
941                                 return 0;
942                         }
943                 }
944                 /* no init function -- proceed with success */
945                 return 0;
946         } else {
947                 /* end of list */
948                 return 0;
949         }
950 }
951
952
953 /*
954  * per-child initialization
955  */
956 int init_child(int rank)
957 {
958         if(async_task_child_init(rank)<0)
959                 return -1;
960
961         return init_mod_child(modules, rank);
962 }
963
964
965
966 /* recursive module initialization; (recursion is used to
967  * process the module linear list in the same order in
968  * which modules are loaded in config file
969 */
970
971 static int init_mod( struct sr_module* m )
972 {
973         if (m) {
974                 /* iterate through the list; if error occurs,
975                  * propagate it up the stack
976                  */
977                 if (init_mod(m->next)!=0) return -1;
978                         if (m->exports.init_f) {
979                                 LM_DBG("%s\n", m->exports.name);
980                                 if (m->exports.init_f()!=0) {
981                                         LM_ERR("Error while initializing module %s (%s)\n",
982                                                                 m->exports.name, m->path);
983                                         return -1;
984                                 } else {
985                                         /* module correctly initialized */
986                                         return 0;
987                                 }
988                         }
989                         /* no init function -- proceed with success */
990                         return 0;
991         } else {
992                 /* end of list */
993                 return 0;
994         }
995 }
996
997 /*
998  * Initialize all loaded modules, the initialization
999  * is done *AFTER* the configuration file is parsed
1000  */
1001 int init_modules(void)
1002 {
1003         struct sr_module* t;
1004         int i;
1005
1006         if(async_task_init()<0)
1007                 return -1;
1008
1009         i = init_mod(modules);
1010         if(i!=0)
1011                 return i;
1012
1013         for(t = modules; t; t = t->next)
1014                 if (t->exports.response_f)
1015                         mod_response_cbk_no++;
1016         mod_response_cbks=pkg_malloc(mod_response_cbk_no *
1017                                                                         sizeof(response_function));
1018         if (mod_response_cbks==0){
1019                 LM_ERR("memory allocation failure for %d response_f callbacks\n", mod_response_cbk_no);
1020                 return -1;
1021         }
1022         for (t=modules, i=0; t && (i<mod_response_cbk_no); t=t->next)
1023                 if (t->exports.response_f) {
1024                         mod_response_cbks[i]=t->exports.response_f;
1025                         i++;
1026                 }
1027
1028         return 0;
1029 }
1030
1031 #endif
1032
1033
1034 action_u_t *fixup_get_param(void **cur_param, int cur_param_no,
1035                                                         int required_param_no)
1036 {
1037         action_u_t *a;
1038         /* cur_param points to a->u.string, get pointer to a */
1039         a = (void*) ((char *)cur_param - offsetof(action_u_t, u.string));
1040         return a + required_param_no - cur_param_no;
1041 }
1042
1043 int fixup_get_param_count(void **cur_param, int cur_param_no)
1044 {
1045         action_u_t *a;
1046         a = fixup_get_param(cur_param, cur_param_no, 0);
1047         if (a)
1048                 return a->u.number;
1049         else
1050                 return -1;
1051 }
1052
1053
1054
1055 /** get a pointer to a parameter internal type.
1056  * @param param
1057  * @return pointer to the parameter internal type.
1058  */
1059 action_param_type* fixup_get_param_ptype(void** param)
1060 {
1061         action_u_t* a;
1062         a = (void*)((char*)param - offsetof(action_u_t, u.string));
1063         return &a->type;
1064 }
1065
1066
1067 /** get a parameter internal type.
1068  * @see fixup_get_param_ptype().
1069  * @return paramter internal type.
1070  */
1071 action_param_type fixup_get_param_type(void** param)
1072 {
1073         return *fixup_get_param_ptype(param);
1074 }
1075
1076
1077
1078 /* fixes flag params (resolves possible named flags)
1079  * use PARAM_USE_FUNC|PARAM_STRING as a param. type and create
1080  * a wrapper function that does just:
1081  * return fix_flag(type, val, "my_module", "my_param", &flag_var)
1082  * see also param_func_t.
1083  */
1084 int fix_flag( modparam_t type, void* val,
1085                                         char* mod_name, char* param_name, int* flag)
1086 {
1087         int num;
1088         int err;
1089         int f, len;
1090         char* s;
1091         char *p;
1092
1093         if ((type & PARAM_STRING)==0){
1094                 LM_CRIT("%s: fix_flag(%s): bad parameter type\n",
1095                                         mod_name, param_name);
1096                 return -1;
1097         }
1098         s=(char*)val;
1099         len=strlen(s);
1100         f=-1;
1101         /* try to see if it's a number */
1102         num = str2s(s, len, &err);
1103         if (err != 0) {
1104                 /* see if it's in the name:<no> format */
1105                 p=strchr(s, ':');
1106                 if (p){
1107                         f= str2s(p+1, strlen(p+1), &err);
1108                         if (err!=0){
1109                                 LM_ERR("%s: invalid %s format: \"%s\"",
1110                                                 mod_name, param_name, s);
1111                                 return -1;
1112                         }
1113                         *p=0;
1114                 }
1115                 if ((num=get_flag_no(s, len))<0){
1116                         /* not declared yet, declare it */
1117                         num=register_flag(s, f);
1118                 }
1119                 if (num<0){
1120                         LM_ERR("%s: bad %s %s\n", mod_name, param_name, s);
1121                         return -1;
1122                 } else if ((f>0) && (num!=f)){
1123                         LM_ERR("%s: flag %s already defined"
1124                                         " as %d (and not %d), using %s:%d\n",
1125                                         mod_name, s, num, f, s, num);
1126                 }
1127         }
1128         *flag=num;
1129         return 0;
1130 }
1131
1132 /*
1133  * Common function parameter fixups
1134  */
1135
1136 /** Generic parameter fixup function.
1137  *  Creates a fparam_t structure.
1138  *  @param type  contains allowed parameter types
1139  *  @param param is the parameter that will be fixed-up
1140  *
1141  * @return
1142  *    0 on success,
1143  *    1 if the param doesn't match the specified type
1144  *    <0 on failure
1145  */
1146 int fix_param(int type, void** param)
1147 {
1148         fparam_t* p;
1149         str name, s;
1150         int num;
1151         int err;
1152
1153         p = (fparam_t*)pkg_malloc(sizeof(fparam_t));
1154         if (!p) {
1155                 LM_ERR("No memory left\n");
1156                 return E_OUT_OF_MEM;
1157         }
1158         memset(p, 0, sizeof(fparam_t));
1159         p->orig = *param;
1160
1161         switch(type) {
1162                 case FPARAM_UNSPEC:
1163                         LM_ERR("Invalid type value\n");
1164                         goto error;
1165                 case FPARAM_STRING:
1166                         p->v.asciiz = *param;
1167                         /* no break */
1168                 case FPARAM_STR:
1169                         p->v.str.s = (char*)*param;
1170                         p->v.str.len = strlen(p->v.str.s);
1171                         p->fixed = &p->v;
1172                         break;
1173                 case FPARAM_INT:
1174                         s.s = (char*)*param;
1175                         s.len = strlen(s.s);
1176                         err = str2sint(&s, &num);
1177                         if (err == 0) {
1178                                 p->v.i = (int)num;
1179                         } else {
1180                                 /* Not a number */
1181                                 pkg_free(p);
1182                                 return 1;
1183                         }
1184                         p->fixed = (void*)(long)num;
1185                         break;
1186                 case FPARAM_REGEX:
1187                         if ((p->v.regex = pkg_malloc(sizeof(regex_t))) == 0) {
1188                                 LM_ERR("No memory left\n");
1189                                 goto error;
1190                         }
1191                         if (regcomp(p->v.regex, *param,
1192                                                 REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
1193                                 pkg_free(p->v.regex);
1194                                 p->v.regex=0;
1195                                 /* not a valid regex */
1196                                 goto no_match;
1197                         }
1198                         p->fixed = p->v.regex;
1199                         break;
1200                 case FPARAM_AVP:
1201                         name.s = (char*)*param;
1202                         name.len = strlen(name.s);
1203                         trim(&name);
1204                         if (!name.len || name.s[0] != '$') {
1205                                 /* Not an AVP identifier */
1206                                 goto no_match;
1207                         }
1208                         name.s++;
1209                         name.len--;
1210                         if (parse_avp_ident(&name, &p->v.avp) < 0) {
1211                                 /* invalid avp identifier (=> no match) */
1212                                 goto no_match;
1213                         }
1214                         p->fixed = &p->v;
1215                         break;
1216                 case FPARAM_SELECT:
1217                         name.s = (char*)*param;
1218                         name.len = strlen(name.s);
1219                         trim(&name);
1220                         if (!name.len || name.s[0] != '@') {
1221                                 /* Not a select identifier */
1222                                 goto no_match;
1223                         }
1224                         if (parse_select(&name.s, &p->v.select) < 0) {
1225                                 LM_ERR("Error while parsing select identifier\n");
1226                                 goto error;
1227                         }
1228                         p->fixed = &p->v;
1229                         break;
1230                 case FPARAM_SUBST:
1231                         s.s = *param;
1232                         s.len = strlen(s.s);
1233                         p->v.subst = subst_parser(&s);
1234                         if (!p->v.subst) {
1235                                 LM_ERR("Error while parsing regex substitution\n");
1236                                 goto error;
1237                         }
1238                         p->fixed = &p->v;
1239                         break;
1240                 case FPARAM_PVS:
1241                         name.s = (char*)*param;
1242                         name.len = strlen(name.s);
1243                         trim(&name);
1244                         if (!name.len || name.s[0] != '$'){
1245                                 /* not a pvs identifier */
1246                                 goto no_match;
1247                         }
1248                         p->v.pvs=pkg_malloc(sizeof(pv_spec_t));
1249                         if (p->v.pvs==0){
1250                                 LM_ERR("out of memory while parsing pv_spec_t\n");
1251                                 goto error;
1252                         }
1253                         if (pv_parse_spec2(&name, p->v.pvs, 1)==0){
1254                                 /* not a valid pvs identifier (but it might be an avp) */
1255                                 pkg_free(p->v.pvs);
1256                                 p->v.pvs=0;
1257                                 goto no_match;
1258                         }
1259                         p->fixed = p->v.pvs;
1260                         break;
1261                 case FPARAM_PVE:
1262                         name.s = (char*)*param;
1263                         name.len = strlen(name.s);
1264                         if (pv_parse_format(&name, &p->v.pve)<0){
1265                                 LM_ERR("bad PVE format: \"%.*s\"\n", name.len, name.s);
1266                                 goto error;
1267                         }
1268                         p->fixed = &p->v;
1269                         break;
1270         }
1271
1272         p->type = type;
1273         *param = (void*)p;
1274         return 0;
1275
1276 no_match:
1277         pkg_free(p);
1278         return 1;
1279 error:
1280         pkg_free(p);
1281         return E_UNSPEC;
1282 }
1283
1284
1285
1286 /** fparam_t free function.
1287  *  Frees the "content" of a fparam, but not the fparam itself.
1288  *  Note: it doesn't free fp->orig!
1289  *  Assumes pkg_malloc'ed content.
1290  *  @param fp -  fparam to be freed
1291  *
1292  */
1293 void fparam_free_contents(fparam_t* fp)
1294 {
1295
1296         if (fp==0)
1297                 return;
1298         switch(fp->type) {
1299                 case FPARAM_UNSPEC:
1300                 case FPARAM_STRING: /* asciiz string, not str */
1301                 case FPARAM_INT:
1302                 case FPARAM_STR:
1303                         /* nothing to do */
1304                         break;
1305                 case FPARAM_REGEX:
1306                         if (fp->v.regex){
1307                                 regfree(fp->v.regex);
1308                                 pkg_free(fp->v.regex);
1309                                 fp->v.regex=0;
1310                         }
1311                         break;
1312                 case FPARAM_AVP:
1313                         free_avp_name(&fp->v.avp.flags, &fp->v.avp.name);
1314                         break;
1315                 case FPARAM_SELECT:
1316                         if (fp->v.select){
1317                                 free_select(fp->v.select);
1318                                 fp->v.select=0;
1319                         }
1320                         break;
1321                 case FPARAM_SUBST:
1322                         if (fp->v.subst){
1323                                 subst_expr_free(fp->v.subst);
1324                                 fp->v.subst=0;
1325                         }
1326                         break;
1327                 case FPARAM_PVS:
1328                         if (fp->v.pvs){
1329                                 pv_spec_free(fp->v.pvs);
1330                                 fp->v.pvs=0;
1331                         }
1332                         break;
1333                 case FPARAM_PVE:
1334                         if (fp->v.pve){
1335                                 pv_elem_free_all(fp->v.pve);
1336                                 fp->v.pve=0;
1337                         }
1338                         break;
1339         }
1340 }
1341
1342
1343 /**
1344  * @brief Generic free fixup type function for a fixed fparam
1345  *
1346  * Generic free fixup type function for a fixed fparam. It will free whatever
1347  * was allocated during the initial fparam fixup and restore the original param
1348  * value.
1349  * @param param freed parameters
1350  */
1351 void fparam_free_restore(void** param)
1352 {
1353         fparam_t *fp;
1354         void *orig;
1355
1356         fp = *param;
1357         orig = fp->orig;
1358         fp->orig = 0;
1359         fparam_free_contents(fp);
1360         pkg_free(fp);
1361         *param = orig;
1362 }
1363
1364
1365
1366 /** fix a param to one of the given types (mask).
1367  *
1368  * @param types - bitmap of the allowed types (e.g. FPARAM_INT|FPARAM_STR)
1369  * @param param - value/result
1370  * @return - 0 on success, -1 on error, 1 if param doesn't
1371  *           match any of the types
1372  */
1373 int fix_param_types(int types, void** param)
1374 {
1375         int ret;
1376         int t;
1377
1378         if (fixup_get_param_type(param) == STRING_RVE_ST &&
1379                         (types & (FPARAM_INT|FPARAM_STR|FPARAM_STRING))) {
1380                 /* if called with a RVE already converted to string =>
1381                  * don't try AVP, PVAR or SELECT (to avoid double
1382                  * deref., e.g.: $foo="$bar"; f($foo) ) */
1383                 types &= ~ (FPARAM_AVP|FPARAM_PVS|FPARAM_SELECT|FPARAM_PVE);
1384         }
1385         for (t=types & ~(types-1); types; types&=(types-1), t=types & ~(types-1)){
1386                 if ((ret=fix_param(t, param))<=0) return ret;
1387         }
1388         return E_UNSPEC;
1389 }
1390
1391
1392
1393 /*
1394  * Fixup variable string, the parameter can be
1395  * AVP, SELECT, or ordinary string. AVP and select
1396  * identifiers will be resolved to their values during
1397  * runtime
1398  *
1399  * The parameter value will be converted to fparam structure
1400  * This function returns -1 on an error
1401  */
1402 int fixup_var_str_12(void** param, int param_no)
1403 {
1404         int ret;
1405         if (fixup_get_param_type(param) != STRING_RVE_ST) {
1406                 /* if called with a RVE already converted to string =>
1407                  * don't try AVP, PVAR or SELECT (to avoid double
1408                  * deref., e.g.: $foo="$bar"; f($foo) ) */
1409                 if ((ret = fix_param(FPARAM_PVS, param)) <= 0) return ret;
1410                 if ((ret = fix_param(FPARAM_AVP, param)) <= 0) return ret;
1411                 if ((ret = fix_param(FPARAM_SELECT, param)) <= 0) return ret;
1412         }
1413         if ((ret = fix_param(FPARAM_STR, param)) <= 0) return ret;
1414         LM_ERR("Error while fixing parameter, PV, AVP, SELECT, and str conversions"
1415                         " failed\n");
1416         return -1;
1417 }
1418
1419 /* Same as fixup_var_str_12 but applies to the 1st parameter only */
1420 int fixup_var_str_1(void** param, int param_no)
1421 {
1422         if (param_no == 1) return fixup_var_str_12(param, param_no);
1423         else return 0;
1424 }
1425
1426 /* Same as fixup_var_str_12 but applies to the 2nd parameter only */
1427 int fixup_var_str_2(void** param, int param_no)
1428 {
1429         if (param_no == 2) return fixup_var_str_12(param, param_no);
1430         else return 0;
1431 }
1432
1433 /** fixup variable-pve-only-string.
1434  * The parameter can be a PVE (pv based format string)
1435  * or string.
1436  * non-static PVEs  identifiers will be resolved to
1437  * their values during runtime.
1438  * The parameter value will be converted to fparam structure
1439  * @param  param - double pointer to param, as for normal fixup functions.
1440  * @param  param_no - parameter number, ignored.
1441  * @return -1 on an error, 0 on success.
1442  */
1443 int fixup_var_pve_12(void** param, int param_no)
1444 {
1445         int ret;
1446         fparam_t* fp;
1447         if (fixup_get_param_type(param) != STRING_RVE_ST) {
1448                 /* if called with a RVE already converted to string =>
1449                  * don't try PVE again (to avoid double
1450                  * deref., e.g.: $foo="$bar"; f($foo) ) */
1451                 if ((ret = fix_param(FPARAM_PVE, param)) <= 0) {
1452                         if (ret < 0)
1453                                 return ret;
1454                         /* check if it resolved to a dynamic or "static" PVE.
1455                          * If the resulting PVE is static (normal string), discard
1456                          * it and use the normal string fixup (faster at runtime) */
1457                         fp = (fparam_t*)*param;
1458                         if (fp->v.pve->spec == 0 || fp->v.pve->spec->getf == 0)
1459                                 fparam_free_restore(param); /* fallback to STR below */
1460                         else
1461                                 return ret; /* dynamic PVE => return */
1462                 }
1463
1464         }
1465         if ((ret = fix_param(FPARAM_STR, param)) <= 0) return ret;
1466         LM_ERR("Error while fixing parameter - PVE or str conversions failed\n");
1467         return -1;
1468 }
1469
1470
1471
1472 /** fixup variable-pve-string.
1473  * The parameter can be a PVAR, AVP, SELECT, PVE (pv based format string)
1474  * or string.
1475  * PVAR, AVP and select and non-static PVEs  identifiers will be resolved to
1476  * their values during runtime.
1477  * The parameter value will be converted to fparam structure
1478  * @param  param - double pointer to param, as for normal fixup functions.
1479  * @param  param_no - parameter number, ignored.
1480  * @return -1 on an error, 0 on success.
1481  */
1482 int fixup_var_pve_str_12(void** param, int param_no)
1483 {
1484         int ret;
1485         fparam_t* fp;
1486         if (fixup_get_param_type(param) != STRING_RVE_ST) {
1487                 /* if called with a RVE already converted to string =>
1488                  * don't try AVP, PVAR, SELECT or PVE again (to avoid double
1489                  * deref., e.g.: $foo="$bar"; f($foo) ) */
1490                 if ((ret = fix_param(FPARAM_PVS, param)) <= 0) return ret;
1491                 if ((ret = fix_param(FPARAM_AVP, param)) <= 0) return ret;
1492                 if ((ret = fix_param(FPARAM_SELECT, param)) <= 0) return ret;
1493                 if ((ret = fix_param(FPARAM_PVE, param)) <= 0) {
1494                         if (ret < 0)
1495                                 return ret;
1496                         /* check if it resolved to a dynamic or "static" PVE.
1497                          * If the resulting PVE is static (normal string), discard
1498                          * it and use the normal string fixup (faster at runtime) */
1499                         fp = (fparam_t*)*param;
1500                         if (fp->v.pve->spec == 0 || fp->v.pve->spec->getf == 0)
1501                                 fparam_free_restore(param); /* fallback to STR below */
1502                         else
1503                                 return ret; /* dynamic PVE => return */
1504                 }
1505
1506         }
1507         if ((ret = fix_param(FPARAM_STR, param)) <= 0) return ret;
1508         LM_ERR("Error while fixing parameter, PV, AVP, SELECT, and str conversions"
1509                         " failed\n");
1510         return -1;
1511 }
1512
1513 /* Same as fixup_var_pve_str_12 but applies to the 1st parameter only */
1514 int fixup_var_pve_str_1(void** param, int param_no)
1515 {
1516         if (param_no == 1) return fixup_var_pve_str_12(param, param_no);
1517         else return 0;
1518 }
1519
1520 /* Same as fixup_var_pve_str_12 but applies to the 2nd parameter only */
1521 int fixup_var_pve_str_2(void** param, int param_no)
1522 {
1523         if (param_no == 2) return fixup_var_pve_str_12(param, param_no);
1524         else return 0;
1525 }
1526
1527
1528
1529 /*
1530  * Fixup variable integer, the parameter can be
1531  * AVP, SELECT, or ordinary integer. AVP and select
1532  * identifiers will be resolved to their values and
1533  * converted to int if necessary during runtime
1534  *
1535  * The parameter value will be converted to fparam structure
1536  * This function returns -1 on an error
1537  */
1538 int fixup_var_int_12(void** param, int param_no)
1539 {
1540         int ret;
1541         if (fixup_get_param_type(param) != STRING_RVE_ST) {
1542                 /* if called with a RVE already converted to string =>
1543                  * don't try AVP, PVAR or SELECT (to avoid double
1544                  * deref., e.g.: $foo="$bar"; f($foo) ) */
1545                 if ((ret = fix_param(FPARAM_PVS, param)) <= 0) return ret;
1546                 if ((ret = fix_param(FPARAM_AVP, param)) <= 0) return ret;
1547                 if ((ret = fix_param(FPARAM_SELECT, param)) <= 0) return ret;
1548         }
1549         if ((ret = fix_param(FPARAM_INT, param)) <= 0) return ret;
1550         LM_ERR("Error while fixing parameter, PV, AVP, SELECT, and int conversions"
1551                         " failed\n");
1552         return -1;
1553 }
1554
1555 /* Same as fixup_var_int_12 but applies to the 1st parameter only */
1556 int fixup_var_int_1(void** param, int param_no)
1557 {
1558         if (param_no == 1) return fixup_var_int_12(param, param_no);
1559         else return 0;
1560 }
1561
1562 /* Same as fixup_var_int_12 but applies to the 2nd parameter only */
1563 int fixup_var_int_2(void** param, int param_no)
1564 {
1565         if (param_no == 2) return fixup_var_int_12(param, param_no);
1566         else return 0;
1567 }
1568
1569
1570 /*
1571  * The parameter must be a regular expression which must compile, the
1572  * parameter will be converted to compiled regex
1573  */
1574 int fixup_regex_12(void** param, int param_no)
1575 {
1576         int ret;
1577
1578         if ((ret = fix_param(FPARAM_REGEX, param)) <= 0) return ret;
1579         LM_ERR("Error while compiling regex in function parameter\n");
1580         return -1;
1581 }
1582
1583 /* Same as fixup_regex_12 but applies to the 1st parameter only */
1584 int fixup_regex_1(void** param, int param_no)
1585 {
1586         if (param_no == 1) return fixup_regex_12(param, param_no);
1587         else return 0;
1588 }
1589
1590 /* Same as fixup_regex_12 but applies to the 2nd parameter only */
1591 int fixup_regex_2(void** param, int param_no)
1592 {
1593         if (param_no == 2) return fixup_regex_12(param, param_no);
1594         else return 0;
1595 }
1596
1597 /*
1598  * The string parameter will be converted to integer
1599  */
1600 int fixup_int_12(void** param, int param_no)
1601 {
1602         int ret;
1603
1604         if ((ret = fix_param(FPARAM_INT, param)) <= 0) return ret;
1605         LM_ERR("Cannot function parameter to integer\n");
1606         return -1;
1607
1608 }
1609
1610 /* Same as fixup_int_12 but applies to the 1st parameter only */
1611 int fixup_int_1(void** param, int param_no)
1612 {
1613         if (param_no == 1) return fixup_int_12(param, param_no);
1614         else return 0;
1615 }
1616
1617 /* Same as fixup_int_12 but applies to the 2nd parameter only */
1618 int fixup_int_2(void** param, int param_no)
1619 {
1620         if (param_no == 2) return fixup_int_12(param, param_no);
1621         else return 0;
1622 }
1623
1624 /*
1625  * Parse the parameter as static string, do not resolve
1626  * AVPs or selects, convert the parameter to str structure
1627  */
1628 int fixup_str_12(void** param, int param_no)
1629 {
1630         int ret;
1631
1632         if ((ret = fix_param(FPARAM_STR, param)) <= 0) return ret;
1633         LM_ERR("Cannot function parameter to string\n");
1634         return -1;
1635 }
1636
1637 /* Same as fixup_str_12 but applies to the 1st parameter only */
1638 int fixup_str_1(void** param, int param_no)
1639 {
1640         if (param_no == 1) return fixup_str_12(param, param_no);
1641         else return 0;
1642 }
1643
1644 /* Same as fixup_str_12 but applies to the 2nd parameter only */
1645 int fixup_str_2(void** param, int param_no)
1646 {
1647         if (param_no == 2) return fixup_str_12(param, param_no);
1648         else return 0;
1649 }
1650
1651
1652
1653 /** Get the function parameter value as string.
1654  *  @return  0 - Success
1655  *          -1 - Cannot get value
1656  */
1657 int get_str_fparam(str* dst, struct sip_msg* msg, fparam_t* param)
1658 {
1659         int_str val;
1660         int ret;
1661         avp_t* avp;
1662         pv_value_t pv_val;
1663
1664         switch(param->type) {
1665                 case FPARAM_REGEX:
1666                 case FPARAM_UNSPEC:
1667                 case FPARAM_INT:
1668                         return -1;
1669                 case FPARAM_STRING:
1670                         dst->s = param->v.asciiz;
1671                         dst->len = strlen(param->v.asciiz);
1672                         break;
1673                 case FPARAM_STR:
1674                         *dst = param->v.str;
1675                         break;
1676                 case FPARAM_AVP:
1677                         avp = search_first_avp(param->v.avp.flags, param->v.avp.name,
1678                                                                         &val, 0);
1679                         if (unlikely(!avp)) {
1680                                 LM_DBG("Could not find AVP from function parameter '%s'\n",
1681                                                 param->orig);
1682                                 return -1;
1683                         }
1684                         if (likely(avp->flags & AVP_VAL_STR)) {
1685                                 *dst = val.s;
1686                         } else {
1687                                 /* The caller does not know of what type the AVP will be so
1688                                  * convert int AVPs into string here
1689                                  */
1690                                 dst->s = int2str(val.n, &dst->len);
1691                         }
1692                         break;
1693                 case FPARAM_SELECT:
1694                         ret = run_select(dst, param->v.select, msg);
1695                         if (unlikely(ret < 0 || ret > 0)) return -1;
1696                         break;
1697                 case FPARAM_PVS:
1698                         if (likely((pv_get_spec_value(msg, param->v.pvs, &pv_val)==0) &&
1699                                                 ((pv_val.flags&(PV_VAL_NULL|PV_VAL_STR))==PV_VAL_STR))){
1700                                         *dst=pv_val.rs;
1701                         }else{
1702                                 LM_ERR("Could not convert PV to str\n");
1703                                 return -1;
1704                         }
1705                         break;
1706                 case FPARAM_PVE:
1707                         dst->s=pv_get_buffer();
1708                         dst->len=pv_get_buffer_size();
1709                         if (unlikely(pv_printf(msg, param->v.pve, dst->s, &dst->len)!=0)){
1710                                 LM_ERR("Could not convert the PV-formated string to str\n");
1711                                 dst->len=0;
1712                                 return -1;
1713                         };
1714                         break;
1715         }
1716         return 0;
1717 }
1718
1719
1720 /** Get the function parameter value as integer.
1721  *  @return  0 - Success
1722  *          -1 - Cannot get value
1723  */
1724 int get_int_fparam(int* dst, struct sip_msg* msg, fparam_t* param)
1725 {
1726         int_str val;
1727         int ret;
1728         avp_t* avp;
1729         str tmp;
1730         pv_value_t pv_val;
1731
1732         switch(param->type) {
1733                 case FPARAM_INT:
1734                         *dst = param->v.i;
1735                         return 0;
1736                 case FPARAM_REGEX:
1737                 case FPARAM_UNSPEC:
1738                 case FPARAM_STRING:
1739                 case FPARAM_STR:
1740                         LM_ERR("Unsupported param type for int value: %d\n", param->type);
1741                         return -1;
1742                 case FPARAM_AVP:
1743                         avp = search_first_avp(param->v.avp.flags, param->v.avp.name,
1744                                                                         &val, 0);
1745                         if (unlikely(!avp)) {
1746                                 LM_DBG("Could not find AVP from function parameter '%s'\n",
1747                                                 param->orig);
1748                                 return -1;
1749                         }
1750                         if (avp->flags & AVP_VAL_STR) {
1751                                 if (str2int(&val.s, (unsigned int*)dst) < 0) {
1752                                         LM_ERR("Could not convert AVP string value to int\n");
1753                                         return -1;
1754                                 }
1755                         } else {
1756                                 *dst = val.n;
1757                         }
1758                         break;
1759                 case FPARAM_SELECT:
1760                         ret = run_select(&tmp, param->v.select, msg);
1761                         if (unlikely(ret < 0 || ret > 0)) return -1;
1762                         if (unlikely(str2int(&tmp, (unsigned int*)dst) < 0)) {
1763                                 LM_ERR("Could not convert select result to int\n");
1764                                 return -1;
1765                         }
1766                         break;
1767                 case FPARAM_PVS:
1768                         if (likely((pv_get_spec_value(msg, param->v.pvs, &pv_val)==0) &&
1769                                                 ((pv_val.flags&(PV_VAL_NULL|PV_VAL_INT))==PV_VAL_INT))){
1770                                         *dst=pv_val.ri;
1771                         }else{
1772                                 LM_ERR("Could not convert PV to int\n");
1773                                 return -1;
1774                         }
1775                         break;
1776                 case FPARAM_PVE:
1777                         LM_ERR("Unsupported param type for int value: %d\n", param->type);
1778                         return -1;
1779                 default:
1780                         LM_ERR("Unexpected param type: %d\n", param->type);
1781                         return -1;
1782         }
1783         return 0;
1784 }
1785
1786 /** Get the function parameter value as string or/and integer (if possible).
1787  *  @return  0 - Success
1788  *          -1 - Cannot get value
1789  */
1790 int get_is_fparam(int* i_dst, str* s_dst, struct sip_msg* msg, fparam_t* param, unsigned int *flags)
1791 {
1792         int_str val;
1793         int ret;
1794         avp_t* avp;
1795         str tmp;
1796         pv_value_t pv_val;
1797
1798         *flags = 0;
1799         switch(param->type) {
1800                 case FPARAM_INT:
1801                         *i_dst = param->v.i;
1802                         *flags |= PARAM_INT;
1803                         return 0;
1804                 case FPARAM_REGEX:
1805                 case FPARAM_UNSPEC:
1806                 case FPARAM_STRING:
1807                         s_dst->s = param->v.asciiz;
1808                         s_dst->len = strlen(param->v.asciiz);
1809                         *flags |= PARAM_STR;
1810                         break;
1811                 case FPARAM_STR:
1812                         *s_dst = param->v.str;
1813                         *flags |= PARAM_STR;
1814                         break;
1815                 case FPARAM_AVP:
1816                         avp = search_first_avp(param->v.avp.flags, param->v.avp.name,
1817                                                                         &val, 0);
1818                         if (unlikely(!avp)) {
1819                                 LM_DBG("Could not find AVP from function parameter '%s'\n",
1820                                                 param->orig);
1821                                 return -1;
1822                         }
1823                         if (avp->flags & AVP_VAL_STR) {
1824                                 *s_dst = val.s;
1825                                 *flags |= PARAM_STR;
1826                                 if (str2int(&val.s, (unsigned int*)i_dst) < 0) {
1827                                         LM_ERR("Could not convert AVP string value to int\n");
1828                                         return -1;
1829                                 }
1830                         } else {
1831                                 *i_dst = val.n;
1832                                 *flags |= PARAM_INT;
1833                         }
1834                         break;
1835                 case FPARAM_SELECT:
1836                         ret = run_select(&tmp, param->v.select, msg);
1837                         if (unlikely(ret < 0 || ret > 0)) return -1;
1838                         if (unlikely(str2int(&tmp, (unsigned int*)i_dst) < 0)) {
1839                                 LM_ERR("Could not convert select result to int\n");
1840                                 return -1;
1841                         }
1842                         *flags |= PARAM_INT;
1843                         break;
1844                 case FPARAM_PVS:
1845                         if (likely(pv_get_spec_value(msg, param->v.pvs, &pv_val)==0)) {
1846                                 if ((pv_val.flags&(PV_VAL_NULL|PV_VAL_INT))==PV_VAL_INT){
1847                                         *i_dst=pv_val.ri;
1848                                         *flags |= PARAM_INT;
1849                                 }
1850                                 if ((pv_val.flags&(PV_VAL_NULL|PV_VAL_STR))==PV_VAL_STR){
1851                                         *s_dst=pv_val.rs;
1852                                         *flags |= PARAM_STR;
1853                                 }
1854                         }else{
1855                                 LM_ERR("Could not get PV\n");
1856                                 return -1;
1857                         }
1858                         break;
1859                 case FPARAM_PVE:
1860                         s_dst->s=pv_get_buffer();
1861                         s_dst->len=pv_get_buffer_size();
1862                         if (unlikely(pv_printf(msg, param->v.pve, s_dst->s, &s_dst->len)!=0)){
1863                                 LM_ERR("Could not convert the PV-formated string to str\n");
1864                                 s_dst->len=0;
1865                                 return -1;
1866                         }
1867                         *flags |= PARAM_STR;
1868                         break;
1869         }
1870
1871         /* Let's convert to int, if possible */
1872         if (!(*flags & PARAM_INT) && (*flags & PARAM_STR) && str2sint(s_dst, i_dst) == 0)
1873                 *flags |= PARAM_INT;
1874
1875         if (!*flags) return -1;
1876
1877         return 0;
1878 }
1879
1880 /**
1881  * Retrieve the compiled RegExp.
1882  * @return: 0 for success, negative on error.
1883  */
1884 int get_regex_fparam(regex_t *dst, struct sip_msg* msg, fparam_t* param)
1885 {
1886         switch (param->type) {
1887                 case FPARAM_REGEX:
1888                         *dst = *param->v.regex;
1889                         return 0;
1890                 default:
1891                         LM_ERR("unexpected parameter type (%d), instead of regexp.\n",
1892                                         param->type);
1893         }
1894         return -1;
1895 }
1896
1897
1898
1899 /** generic free fixup function for "pure" fparam type fixups.
1900  * @param  param - double pointer to param, as for normal fixup functions.
1901  * @param  param_no - parameter number, ignored.
1902  * @return 0 on success (always).
1903  */
1904 int fixup_free_fparam_all(void** param, int param_no)
1905 {
1906         fparam_free_restore(param);
1907         return 0;
1908 }
1909
1910
1911
1912 /** generic free fixup function for "pure"  first parameter fparam type fixups.
1913  * @param  param - double pointer to param, as for normal fixup functions.
1914  * @param  param_no - parameter number: the function will work only for
1915  *                     param_no == 1 (first parameter).
1916  * @return 0 on success (always).
1917  */
1918 int fixup_free_fparam_1(void** param, int param_no)
1919 {
1920         if (param_no == 1)
1921                 fparam_free_restore(param);
1922         return 0;
1923 }
1924
1925
1926
1927 /** generic free fixup function for "pure"  2nd parameter fparam type fixups.
1928  * @param  param - double pointer to param, as for normal fixup functions.
1929  * @param  param_no - parameter number: the function will work only for
1930  *                     param_no == 2 (2nd parameter).
1931  * @return 0 on success (always).
1932  */
1933 int fixup_free_fparam_2(void** param, int param_no)
1934 {
1935         if (param_no == 2)
1936                 fparam_free_restore(param);
1937         return 0;
1938 }
1939
1940
1941
1942 /** returns true if a fixup is a fparam_t* one.
1943  * Used to automatically detect "pure" fparam fixups that can be used with non
1944  * contant RVEs.
1945  * @param f - function pointer
1946  * @return 1 for fparam fixups, 0 for others.
1947  */
1948 int is_fparam_rve_fixup(fixup_function f)
1949 {
1950         if (f == fixup_var_str_12 ||
1951                 f == fixup_var_str_1 ||
1952                 f == fixup_var_str_2 ||
1953                 f == fixup_var_pve_str_12 ||
1954                 f == fixup_var_pve_str_1 ||
1955                 f == fixup_var_pve_str_2 ||
1956                 f == fixup_var_int_12 ||
1957                 f == fixup_var_int_1 ||
1958                 f == fixup_var_int_2 ||
1959                 f == fixup_int_12 ||
1960                 f == fixup_int_1 ||
1961                 f == fixup_int_2 ||
1962                 f == fixup_str_12 ||
1963                 f == fixup_str_1 ||
1964                 f == fixup_str_2 ||
1965                 f == fixup_regex_12 ||
1966                 f == fixup_regex_1 ||
1967                 f == fixup_regex_2
1968                 )
1969                 return 1;
1970         return 0;
1971 }
1972
1973
1974 /**
1975  * @brief returns the corresponding fixup_free* for various known fixup types
1976  *
1977  * Returns the corresponding fixup_free* for various known fixup types.
1978  * Used to automatically fill in free_fixup* functions.
1979  * @param f fixup function pointer
1980  * @return free fixup function pointer on success, 0 on failure (unknown
1981  * fixup or no free fixup function).
1982  */
1983 free_fixup_function get_fixup_free(fixup_function f)
1984 {
1985         free_fixup_function ret;
1986         /* "pure" fparam, all parameters */
1987         if (f == fixup_var_str_12 ||
1988                 f == fixup_var_pve_str_12 ||
1989                 f == fixup_var_int_12 ||
1990                 f == fixup_int_12 ||
1991                 f == fixup_str_12 ||
1992                 f == fixup_regex_12)
1993                 return fixup_free_fparam_all;
1994
1995         /* "pure" fparam, 1st parameter */
1996         if (f == fixup_var_str_1 ||
1997                 f == fixup_var_pve_str_1 ||
1998                 f == fixup_var_int_1 ||
1999                 f == fixup_int_1 ||
2000                 f == fixup_str_1 ||
2001                 f == fixup_regex_1)
2002                 return fixup_free_fparam_1;
2003
2004         /* "pure" fparam, 2nd parameters */
2005         if (f == fixup_var_str_2 ||
2006                 f == fixup_var_pve_str_2 ||
2007                 f == fixup_var_int_2 ||
2008                 f == fixup_int_2 ||
2009                 f == fixup_str_2 ||
2010                 f == fixup_regex_2)
2011                 return fixup_free_fparam_2;
2012
2013         /* mod_fix.h kamailio style fixups */
2014         if ((ret = mod_fix_get_fixup_free(f)) != 0)
2015                 return ret;
2016
2017         /* unknown */
2018         return 0;
2019 }