git.sip-router.org Git - sip-router/blob - sr_module.h

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