core: Changed WS from being a flag on a TCP/TLS connection to a protocol in its own...
[sip-router] / sr_module.h
1 /*
2  * Copyright (C) 2001-2003 FhG Fokus
3  *
4  * This file is part of ser, a free SIP server.
5  *
6  * ser 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  * For a license to use the ser software under conditions
12  * other than those described here, or to purchase support for this
13  * software, please contact iptel.org by e-mail at the following addresses:
14  *    info@iptel.org
15  *
16  * ser is distributed in the hope that it will be useful,
17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
19  * GNU General Public License for more details.
20  *
21  * You should have received a copy of the GNU General Public License
22  * along with this program; if not, write to the Free Software
23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
24  */
25
26 /*
27  * History:
28  * --------
29  *  2003-03-10  changed module exports interface: added struct cmd_export
30  *               and param_export (andrei)
31  *  2003-03-16  Added flags field to cmd_export_ (janakj)
32  *  2003-04-05  s/reply_route/failure_route, onreply_route introduced (jiri)
33  *  2004-03-12  extra flag USE_FUNC_PARAM added to modparam type -
34  *              instead of copying the param value, a func is called (bogdan)
35  *  2004-09-19  switched to version.h for the module versions checks (andrei)
36  *  2004-12-03  changed param_func_t to (modparam_t, void*), killed
37  *               param_func_param_t   (andrei)
38  *  2007-06-07  added PROC_INIT, called in the main process context
39  *               (same as PROC_MAIN), buf guaranteed to be called before
40  *               any other process is forked (andrei)
41  *  2008-11-17  sip-router version: includes some of the openser/kamailio
42  *               changes: f(void) instead of f(), free_fixup_function()
43  *              dual module interface support: ser & kamailio (andrei)
44  *  2008-11-18  prototypes for various fixed parameters numbers module
45  *               functions (3, 4, 5 & 6) and variable parameters (andrei)
46  *  2008-11-26  added fparam_free_contents() and fix_param_types (andrei)
47  */
48
49 /**
50  * @file
51  * @brief SIP-Router core :: modules loading, structures declarations and utilities
52  * @ingroup core
53  * Module: \ref core
54  */
55
56
57 #ifndef sr_module_h
58 #define sr_module_h
59
60 #include <dlfcn.h>
61
62 #include "parser/msg_parser.h" /* for sip_msg */
63 #include "ver_defs.h"
64 #include "rpc.h"
65 #include "route_struct.h"
66 #include "route.h"
67 #include "str.h"
68
69 /* kamailio compat */
70 #include "kstats_types.h"
71 #include "mi/mi_types.h"
72 #include "pvar.h"
73
74
75
76 #if defined KAMAILIO_MOD_INTERFACE || defined OPENSER_MOD_INTERFACE || \
77         defined MOD_INTERFACE_V1
78
79 #define MODULE_INTERFACE_VER 1
80 #define cmd_export_t kam_cmd_export_t
81 #define module_exports kam_module_exports
82
83 #elif defined SER_MOD_INTERFACE || defined MOD_INTERFACE_V0
84
85 #define MODULE_INTERFACE_VER 0
86 #define cmd_export_t ser_cmd_export_t
87 #define module_exports ser_module_exports
88
89 #else
90
91 /* do nothing for core */
92
93 #endif
94
95 /**
96  * @brief type used for the mod_register function export
97  * 
98  * mod_register is a function called when loading a module
99  * (if present), prior to registering the module exports.
100  * @param path path to the module, including file name
101  * @param dlflags pointer to the dlflags used when loading the module.
102  * If the value is changed to a different and non-zero value, the
103  * module will be reloaded with the new flags.
104  * @param reserved1 - reserved for future use.
105  * @param reserved2 - reserved for future use
106  * @return 0 on success, -1 on error, all the other values are reserved
107  *                      for future use (<0 meaning error and >0 success)
108  */
109 typedef  int (*mod_register_function)(char* path, int* dlflags, void* reserved1, void* reserved2);
110
111 typedef  struct module_exports* (*module_register)(void);
112
113 /**
114  * @brief main two parameter module function
115  * 
116  * Main two parameter module function, default and oldest version.
117  * @param sip_msg SIP message
118  * @param param1 first parameter
119  * @param param2 second parameter
120  * @return positive on success, negative on error, 0 to stop processing (drop message)
121  */
122 typedef  int (*cmd_function)(struct sip_msg*, char* param1, char* param2);
123 typedef  int (*cmd_function3)(struct sip_msg*, char*, char*, char*);
124 typedef  int (*cmd_function4)(struct sip_msg*, char*, char*, char*, char*);
125 typedef  int (*cmd_function5)(struct sip_msg*,  char*, char*, char*,
126                                                                                                 char*, char*);
127 typedef  int (*cmd_function6)(struct sip_msg*,  char*, char*, char*,
128                                                                                                 char*, char*, char*);
129 /**
130  * @brief variable number of parameter module function
131  * 
132  * Variable number of parameter module function, takes as param the sip_msg,
133  * extra parameters number and a pointer to an array of parameters
134  * @param sip_msg SIP message
135  * @param no extra parameters number
136  * @param vals extra parameters
137  * @return positive on success, negative on error, 0 to stop processing (drop message)
138  */
139 typedef int (*cmd_function_var)(struct sip_msg*, int no, action_u_t* vals );
140 typedef int (*fixup_function)(void** param, int param_no);
141 typedef int (*free_fixup_function)(void** param, int param_no);
142
143 /**
144  * @brief response module function prototype
145  * @param sip_msg SIP message
146  * @return positive if ok, 0 to stop processing
147  */
148 typedef int (*response_function)(struct sip_msg*);
149 typedef void (*onbreak_function)(struct sip_msg*);
150 typedef void (*destroy_function)(void);
151
152 typedef int (*init_function)(void);
153 typedef int (*child_init_function)(int rank);
154
155
156 #define PARAM_STRING     (1U<<0)  /**< String (char *) parameter type */
157 #define PARAM_INT        (1U<<1)  /**< Integer parameter type */
158 #define PARAM_STR        (1U<<2)  /**< struct str parameter type */
159 #define PARAM_USE_FUNC   (1U<<(8*sizeof(int)-1))
160 #define PARAM_TYPE_MASK(_x)   ((_x)&(~PARAM_USE_FUNC))
161
162 /* temporary, for backward compatibility only until all modules adjust it */
163 #define STR_PARAM PARAM_STRING
164 #define INT_PARAM PARAM_INT
165 #define USE_FUNC_PARAM PARAM_USE_FUNC
166
167 typedef unsigned int modparam_t;
168
169 typedef int (*param_func_t)( modparam_t type, void* val);
170
171 /* magic parameter number values */
172
173 #define NO_SCRIPT     -1    /**< export not usable from scripts */
174 #define VAR_PARAM_NO  -128  /**< function has variable number of parameters
175                                                            (see cmd_function_var for the prototype) */
176
177 /**
178  * special fixup function flags fparam fixup, rve ready,
179  * they are kept in the first 2 bits inside the pointer
180  */
181 #define FIXUP_F_FPARAM_RVE (unsigned long)1
182
183 #define call_fixup(fixup, param, param_no) \
184         ((fixup) ? (fixup)(param, param_no) : 0)
185
186 /* Macros - used as rank in child_init function */
187 #define PROC_MAIN      0  /**< Main ser process */
188 #define PROC_TIMER    -1  /**< Timer attendant process */
189 #define PROC_RPC      -2  /**< RPC type process */
190 #define PROC_FIFO      PROC_RPC  /**< FIFO attendant process */
191 #define PROC_TCP_MAIN -4  /**< TCP main process */
192 #define PROC_UNIXSOCK -5  /**< Unix socket server */
193 #define PROC_ATTENDANT -10  /**< main "attendant process */
194 #define PROC_INIT     -127 /**< special rank, the context is the main ser
195                                                           process, but this is guaranteed to be executed
196                                                           before any process is forked, so it can be used
197                                                           to setup shared variables that depend on some
198                                                           after mod_init available information (e.g.
199                                                           total number of processes).
200                                                           @warning child_init(PROC_MAIN) is again called
201                                                          in the same process (main), but latter 
202                                                          (before tcp), so make sure you don't init things 
203                                                          twice, bot in PROC_MAIN and PROC_INT */
204 #define PROC_NOCHLDINIT -128 /**< no child init functions will be called
205                                 if this rank is used in fork_process() */
206
207 #define PROC_SIPINIT      1  /**< First SIP worker - some modules do special
208                                                          processing in this child, like loading db data */
209 #define PROC_SIPRPC       127  /**< Used to init RPC worker as SIP commands
210                                                            handler. Don't do any special processing in the
211                                                            child init with this rank - just bare child
212                                                            initialization */
213
214 #define PROC_MIN PROC_NOCHLDINIT /**< Minimum process rank */
215
216
217 #define DEFAULT_DLFLAGS 0 /**< value that signals to module loader to
218                                                         use default dlopen flags in Kamailio */
219 #ifndef RTLD_NOW
220 /* for openbsd */
221 #define RTLD_NOW DL_LAZY
222 #endif
223
224 #define KAMAILIO_DLFLAGS        RTLD_NOW
225
226
227 #define MODULE_VERSION \
228         char *module_version=SER_FULL_VERSION; \
229         char *module_flags=SER_COMPILE_FLAGS; \
230         unsigned int module_interface_ver=MODULE_INTERFACE_VER; 
231
232 /** ser version */
233 struct ser_cmd_export_ {
234         char* name;             /**< null terminated command name */
235         cmd_function function;  /**< pointer to the corresponding function */
236         int param_no;           /**< number of parameters used by the function */
237         fixup_function fixup;   /**< pointer to the function called to "fix" the
238                                                            parameters */
239         int flags;              /**< Function flags */
240 };
241
242
243 /** kamailo/openser version */
244 struct kam_cmd_export_ {
245         char* name;             /**< null terminated command name */
246         cmd_function function;  /**< pointer to the corresponding function */
247         int param_no;           /**< number of parameters used by the function */
248         fixup_function fixup;   /**< pointer to the function called to "fix" the
249                                                            parameters */
250         free_fixup_function free_fixup; /**< function called to free the "fixed"
251                                                                            parameters */
252         int flags;              /**< Function flags */
253 };
254
255 /** sip-router version */
256 struct sr31_cmd_export_ {
257         char* name;             /**< null terminated command name */
258         cmd_function function;  /**< pointer to the corresponding function */
259         int param_no;           /**< number of parameters used by the function */
260         fixup_function fixup;   /**< pointer to the function called to "fix" the
261                                                            parameters */
262         free_fixup_function free_fixup; /**< function called to free the "fixed"
263                                                                            parameters */
264         int flags;              /**< Function flags */
265         int fixup_flags;
266         void* module_exports; /**< pointer to module structure */
267 };
268
269
270 /** members situated at the same place in memory in both ser & kamailio
271    cmd_export */
272 struct cmd_export_common_ {
273         char* name;
274         cmd_function function; 
275         int param_no;
276         fixup_function fixup;
277 };
278
279
280 struct param_export_ {
281         char* name;             /**< null terminated param. name */
282         modparam_t type;        /**< param. type */
283         void* param_pointer;    /**< pointer to the param. memory location */
284 };
285
286
287 /*
288  * Allowed parameter types, the types _must_ be in "fallback" order,
289  * e.g. FPARAM_STR should be the last to allow fallback to it,
290  * F_PARAM_PVS should be in front of F_PARAM_AVP (so that
291  * for fix_param_types(FPARAM_AVP|FPARAM_PVS|FPARAM_STR, param) and $foo
292  * the pvars will be checked first and only if no pvar is found the
293  * param will be resolved to an avp)
294  */
295 enum {
296         FPARAM_UNSPEC = 0,
297         FPARAM_INT    = (1 << 0),
298         FPARAM_SELECT = (1 << 1),
299         FPARAM_PVS    = (1 << 2),
300         FPARAM_AVP    = (1 << 3),
301         FPARAM_STRING = (1 << 4),
302         FPARAM_STR    = (1 << 5),
303         /* special types: no fallback between them possible */
304         FPARAM_REGEX  = (1 << 6),
305         FPARAM_SUBST  = (1 << 7),
306         FPARAM_PVE    = (1 << 8)
307 };
308
309 /**
310  * Function parameter
311  */
312 typedef struct fparam {
313         char* orig;                       /**< The original value */
314         int type;                         /**< Type of parameter */
315         union {
316                 char* asciiz;             /**< Zero terminated ASCII string */
317                 struct _str str;          /**< pointer/len string */
318                 int i;                    /**< Integer value */
319                 regex_t* regex;           /**< Compiled regular expression */
320                 avp_ident_t avp;          /**< AVP identifier */
321                 select_t* select;         /**< select structure */ 
322                 struct subst_expr* subst; /**< Regex substitution */
323                 pv_spec_t* pvs;    /**< kamailio pseudo-vars */
324                 pv_elem_t* pve;    /**< kamailio pseudo-vars in a string */
325         } v;
326         void *fixed;
327 } fparam_t;
328
329
330 typedef struct param_export_ param_export_t;  
331 typedef struct ser_cmd_export_ ser_cmd_export_t;
332 typedef struct kam_cmd_export_ kam_cmd_export_t;
333 typedef struct cmd_export_common_ cmd_export_common_t;
334 typedef struct sr31_cmd_export_ sr31_cmd_export_t;
335
336
337 /** ser module exports version */
338 struct ser_module_exports {
339         char* name;                     /**< null terminated module name */
340         ser_cmd_export_t* cmds;         /**< null terminated array of the exported
341                                                                            commands */
342         rpc_export_t* rpc_methods;      /**< null terminated array of exported rpc methods */
343         param_export_t* params;         /**< null terminated array of the exported
344                                                                            module parameters */
345         init_function init_f;           /**< Initialization function */
346         response_function response_f;   /**< function used for responses,
347                                                                            returns yes or no; can be null */
348         destroy_function destroy_f;     /**< function called when the module should
349                                                                            be "destroyed", e.g: on ser exit;
350                                                                            can be null */
351         onbreak_function onbreak_f;
352         child_init_function init_child_f;  /**< function called by all processes
353                                                                                   after the fork */
354 };
355
356
357 /** kamailio/openser proc_export (missing from ser) */
358 typedef void (*mod_proc)(int no);
359
360 typedef int (*mod_proc_wrapper)(void);
361
362 struct proc_export_ {
363         char *name;
364         mod_proc_wrapper pre_fork_function;
365         mod_proc_wrapper post_fork_function;
366         mod_proc function;
367         unsigned int no;
368 };
369
370 typedef struct proc_export_ proc_export_t;
371
372
373 /** kamailio/openser module exports version */
374 struct kam_module_exports {
375         char* name;                             /**< null terminated module name */
376         unsigned int dlflags;                   /**< flags for dlopen  */
377         kam_cmd_export_t* cmds;                 /**< null terminated array of the exported
378                                                                            commands */
379         param_export_t* params;                 /**< null terminated array of the exported
380                                                                            module parameters */
381         stat_export_t* stats;                   /**< null terminated array of the exported
382                                                                           module statistics */
383         mi_export_t* mi_cmds;                   /**< null terminated array of the exported
384                                                                           MI functions */
385         pv_export_t* items;                             /*!< null terminated array of the exported
386                                                                            module items (pseudo-variables) */
387         proc_export_t* procs;                   /**< null terminated array of the
388                                                                           additional processes required by the
389                                                                           module */
390         init_function init_f;                   /**< Initialization function */
391         response_function response_f;           /**< function used for responses,
392                                                                            returns yes or no; can be null */
393         destroy_function destroy_f;                     /**< function called when the module should
394                                                                            be "destroyed", e.g: on ser exit;
395                                                                            can be null */
396         child_init_function init_child_f;       /**< function called by all processes
397                                                                                   after the fork */
398 };
399
400
401
402 /**
403  * @brief sr/ser 3.1+ module exports version
404  * 
405  * sr/ser 3.1+ module exports version, Includes ser and kamailio versions,
406  * re-arraranged + some extras.
407  * @note Some of the members will be obsoleted and are kept only for
408  * backward compatibility (avoid re-writing all the modules exports
409  * declarations).
410  */
411 struct sr31_module_exports {
412         char* name;                     /**< null terminated module name */
413         sr31_cmd_export_t* cmds;        /**< null terminated array of the exported
414                                                                            commands */
415         param_export_t* params;         /**< null terminated array of the exported
416                                                                            module parameters */
417         init_function init_f;           /**< Initialization function */
418         response_function response_f;   /**< function used for responses,
419                                                                            returns yes or no; can be null */
420         destroy_function destroy_f;     /**< function called when the module should
421                                                                            be "destroyed", e.g: on ser exit;
422                                                                            can be null */
423         onbreak_function onbreak_f;
424         child_init_function init_child_f;/**< function called by all processes
425                                                                                   after the fork */
426         unsigned int dlflags;           /**< flags for dlopen */
427         /* ser specific exports
428            (to be obsoleted and replaced by register_...) */
429         rpc_export_t* rpc_methods;      /**< null terminated array of exported
430                                                         rpc methods */
431         /* kamailio specific exports
432            (to be obsoleted and replaced by register_...) */
433         stat_export_t* stats;                   /**< null terminated array of the exported
434                                                                           module statistics */
435         mi_export_t* mi_cmds;                   /**< null terminated array of the exported
436                                                                           MI functions */
437         pv_export_t* items;                     /**< null terminated array of the exported
438                                                                            module items (pseudo-variables) */
439         proc_export_t* procs;                   /**< null terminated array of the
440                                                                           additional processes required by the
441                                                                           module */
442 };
443
444
445
446 /** module exports in the same place in memory in both ser & kamailio */
447 struct module_exports_common {
448         char* name;
449 };
450
451
452 union module_exports_u {
453                 struct module_exports_common c; /**< common members for all the versions */
454                 struct ser_module_exports v0;
455                 struct kam_module_exports v1;
456 };
457
458
459 struct sr_module {
460         char* path;
461         void* handle;
462         unsigned int orig_mod_interface_ver;
463         struct sr31_module_exports exports;
464         struct sr_module* next;
465 };
466
467
468 extern struct sr_module* modules; /**< global module list*/
469 extern response_function* mod_response_cbks; /**< response callback array */
470 extern int mod_response_cbk_no; /**< size of reponse callbacks array */
471
472 int register_builtin_modules(void);
473 int load_module(char* path);
474 sr31_cmd_export_t* find_export_record(char* name, int param_no, int flags,
475                                                                                 unsigned *ver);
476 cmd_function find_export(char* name, int param_no, int flags);
477 cmd_function find_mod_export(char* mod, char* name, int param_no, int flags);
478 rpc_export_t* find_rpc_export(char* name, int flags);
479 void destroy_modules(void);
480 int init_child(int rank);
481 int init_modules(void);
482 struct sr_module* find_module_by_name(char* mod);
483
484 /**< true if the module with name 'mod_name' is loaded */
485 #define module_loaded(mod_name) (find_module_by_name(mod_name)!=0)
486
487
488 /**
489  * @brief Find a parameter with given type
490  * @param mod module
491  * @param name parameter name
492  * @param type_mask parameter mask
493  * @param param_type parameter type
494  * @return parameter address in memory, if there is no such parameter, NULL is returned
495  */
496 void* find_param_export(struct sr_module* mod, char* name, modparam_t type_mask, modparam_t *param_type);
497
498
499 /** API function to get other parameters from fixup */
500 action_u_t *fixup_get_param(void **cur_param, int cur_param_no, int required_param_no);
501 int fixup_get_param_count(void **cur_param, int cur_param_no);
502
503 int fix_flag( modparam_t type, void* val,
504                                         char* mod_name, char* param_name, int* flag);
505
506
507 /*
508  * Common function parameter fixups
509  */
510
511 /**
512  * @brief Generic parameter fixup function
513  * 
514  * Generic parameter fixup function which creates fparam_t structure.
515  * Type parameter contains allowed parameter types.
516  * @param type parameter type
517  * @param param fixed parameter
518  * @return 0 on success, -1 on error
519  */
520 int fix_param(int type, void** param);
521 void fparam_free_contents(fparam_t* fp);
522
523 /** fix a param to one of the given types (mask).
524   */
525 int fix_param_types(int types, void** param);
526
527 /**
528  * @brief Fixup variable string, 
529  * 
530  * Fixup variable string, the parameter can be AVP, SELECT, or ordinary
531  * string. AVP and select identifiers will be resolved to their values
532  * during runtime. The parameter value will be converted to fparam structure.
533  * @param param fixed parameter value
534  * @param param_no number of parameter
535  * @return 0 on success, -1 on an error
536  */
537 int fixup_var_str_12(void** param, int param_no);
538
539 /** Same as fixup_var_str_12 but applies to the 1st parameter only */
540 int fixup_var_str_1(void** param, int param_no);
541
542 /** Same as fixup_var_str_12 but applies to the 2nd parameter only */
543 int fixup_var_str_2(void** param, int param_no);
544
545 /** fixup variable-pve-only-string. */
546 int fixup_var_pve_12(void** param, int param_no);
547
548 /** fixup variable-pve-string.
549  * The parameter can be a PVAR, AVP, SELECT, PVE (pv based format string)
550  * or string.
551  */
552 int fixup_var_pve_str_12(void** param, int param_no);
553
554 /** same as fixup_var_pve_str_12 but applies to the 1st parameter only */
555 int fixup_var_pve_str_1(void** param, int param_no);
556
557 /** same as fixup_var_pve_str_12 but applies to the 2nd parameter only */
558 int fixup_var_pve_str_2(void** param, int param_no);
559
560 /**
561  * @brief Fixup variable integer
562  *
563  * Fixup variable integer, the parameter can be AVP, SELECT, or ordinary
564  * integer. AVP and select identifiers will be resolved to their values
565  * and converted to int if necessary during runtime. The parameter value will
566  * be converted to fparam structure
567  * @param param fixed parameter value
568  * @param param_no number of parameter
569  * @return 0 on success, -1 on an error
570  */
571 int fixup_var_int_12(void** param, int param_no);
572
573 /** Same as fixup_var_int_12 but applies to the 1st parameter only */
574 int fixup_var_int_1(void** param, int param_no);
575
576 /** Same as fixup_var_int_12 but applies to the 2nd parameter only */
577 int fixup_var_int_2(void** param, int param_no);
578
579 /**
580  * The parameter must be a regular expression which must compile, the
581  * parameter will be converted to compiled regex
582  */
583 int fixup_regex_12(void** param, int param_no);
584
585 /** Same as fixup_regex_12 but applies to the 1st parameter only */
586 int fixup_regex_1(void** param, int param_no);
587
588 /** Same as fixup_regex_12 but applies to the 2nd parameter only */
589 int fixup_regex_2(void** param, int param_no);
590
591 /**
592  * The string parameter will be converted to integer
593  */
594 int fixup_int_12(void** param, int param_no);
595
596 /** Same as fixup_int_12 but applies to the 1st parameter only */
597 int fixup_int_1(void** param, int param_no);
598
599 /** Same as fixup_int_12 but applies to the 2nd parameter only */
600 int fixup_int_2(void** param, int param_no);
601
602 /**
603  * Parse the parameter as static string, do not resolve
604  * AVPs or selects, convert the parameter to str structure
605  */
606 int fixup_str_12(void** param, int param_no);
607
608 /** Same as fixup_str_12 but applies to the 1st parameter only */
609 int fixup_str_1(void** param, int param_no);
610
611 /** Same as fixup_str_12 but applies to the 2nd parameter only */
612 int fixup_str_2(void** param, int param_no);
613
614 /**
615  * @brief Get the function parameter value as string
616  * @param dst string destination
617  * @param msg SIP message
618  * @param param function parameters
619  * @return 0 on success, 1 on error, e.g. cannot get value
620  */
621 int get_str_fparam(str* dst, struct sip_msg* msg, fparam_t* param);
622
623 /**
624  * @brief Get the function parameter value as integer
625  * @param dst string destination
626  * @param msg SIP message
627  * @param param function parameters
628  * @return 0 on success, 1 on error, e.g. cannot get value
629  */
630 int get_int_fparam(int* dst, struct sip_msg* msg, fparam_t* param);
631
632 /**
633  * @brief Get the function parameter value as compiled regular expression
634  * @param dst string destination
635  * @param msg SIP message
636  * @param param function parameters
637  * @return 0 on success, 1 on error, e.g. cannot get value
638  */
639 int get_regex_fparam(regex_t *dst, struct sip_msg* msg, fparam_t* param);
640
641
642 int is_fparam_rve_fixup(fixup_function f);
643
644 /**
645  * @brief Generic free fixup type function for a fixed fparam
646  * 
647  * Generic free fixup type function for a fixed fparam. It will free whatever
648  * was allocated during the initial fparam fixup and restore the original param
649  * value.
650  * @param param freed parameters
651  */
652 void fparam_free_restore(void** param);
653 int fixup_free_fparam_all(void** param, int param_no);
654 int fixup_free_fparam_1(void** param, int param_no);
655 int fixup_free_fparam_2(void** param, int param_no);
656
657 /**
658  * @brief returns the corresponding fixup_free* for various known fixup types
659  * 
660  * Returns the corresponding fixup_free* for various known fixup types.
661  * Used to automatically fill in free_fixup* functions.
662  * @param f fixup function pointer
663  * @return free fixup function pointer on success, 0 on failure (unknown
664  * fixup or no free fixup function).
665  */
666 free_fixup_function get_fixup_free(fixup_function f);
667
668 void set_child_sip_rpc_mode(void);
669 void set_child_rpc_sip_mode(void);
670 int is_sip_worker(int rank);
671 int is_rpc_worker(int rank);
672
673 #endif /* sr_module_h */