app_lua: removed old Lua sr module exports

- exporting only KSR via KEMI framework
- Lua sr module is relocated to app_lua_sr kamailio module, to be
obsoleted and removed over the time
- export KSR.pv submodule using implementation from core

src/modules/app_lua/app_lua_api.c

@@ -32,13 +32,30 @@
 #include "../../core/data_lump.h"
 #include "../../core/data_lump_rpl.h"
 #include "../../core/strutils.h"
+#include "../../core/rpc.h"
+#include "../../core/rpc_lookup.h"
 
 #include "app_lua_api.h"
-#include "app_lua_sr.h"
-#include "app_lua_exp.h"
+#include "app_lua_kemi_export.h"
 
+#define KSRVERSION "2.0"
 
-#define SRVERSION "1.0"
+#define KSR_APP_LUA_LOG_EXPORTS (1<<0)
+
+extern int _ksr_app_lua_log_mode;
+
+void lua_sr_kemi_register_libs(lua_State *L);
+
+static app_lua_openlibs_f app_lua_openlibs_cb = NULL;
+
+/**
+ *
+ */
+int app_lua_openlibs_register(app_lua_openlibs_f rfunc)
+{
+	app_lua_openlibs_cb = rfunc;
+	return 0;
+}
 
 /**
  * reload enabled param
@@ -151,17 +168,6 @@ int sr_lua_load_script(char *script)
 	return 0;
 }
 
-
-/**
- *
- */
-int sr_lua_register_module(char *mname)
-{
-	if(lua_sr_exp_register_mod(mname)==0)
-		return 0;
-	return -1;
-}
-
 /**
  *
  */
@@ -183,8 +189,9 @@ int sr_lua_reload_module(unsigned int reload)
  */
 void lua_sr_openlibs(lua_State *L)
 {
-	lua_sr_core_openlibs(L);
-	lua_sr_exp_openlibs(L);
+	if(app_lua_openlibs_cb!=NULL) {
+		app_lua_openlibs_cb(L);
+	}
 	lua_sr_kemi_register_libs(L);
 }
 
@@ -194,15 +201,12 @@ void lua_sr_openlibs(lua_State *L)
 int lua_sr_init_mod(void)
 {
 	/* allocate shm */
-	if(lua_sr_alloc_script_ver()<0)
-	{
+	if(lua_sr_alloc_script_ver()<0) {
 		LM_CRIT("failed to alloc shm for version\n");
 		return -1;
 	}
 
 	memset(&_sr_L_env, 0, sizeof(sr_lua_env_t));
-	if(lua_sr_exp_init_mod()<0)
-		return -1;
 
 	return 0;
 
@@ -228,7 +232,7 @@ int lua_sr_init_probe(void)
 	lua_sr_openlibs(L);
 
 	/* force loading lua lib now */
-	if(luaL_dostring(L, "sr.probe()")!=0)
+	if(luaL_dostring(L, "KSR.x.probe()")!=0)
 	{
 		txt = (char*)lua_tostring(L, -1);
 		LM_ERR("error initializing Lua: %s\n", (txt)?txt:"unknown");
@@ -278,13 +282,13 @@ int lua_sr_init_child(void)
 	luaL_openlibs(_sr_L_env.L);
 	lua_sr_openlibs(_sr_L_env.L);
 
-	/* set SR lib version */
+	/* set KSR lib version */
 #if LUA_VERSION_NUM >= 502
-	lua_pushstring(_sr_L_env.L, SRVERSION);
-	lua_setglobal(_sr_L_env.L, "SRVERSION");
+	lua_pushstring(_sr_L_env.L, KSRVERSION);
+	lua_setglobal(_sr_L_env.L, "KSRVERSION");
 #else
-	lua_pushstring(_sr_L_env.L, "SRVERSION");
-	lua_pushstring(_sr_L_env.L, SRVERSION);
+	lua_pushstring(_sr_L_env.L, "KSRVERSION");
+	lua_pushstring(_sr_L_env.L, KSRVERSION);
 	lua_settable(_sr_L_env.L, LUA_GLOBALSINDEX);
 #endif
 	if(_sr_lua_load_list != NULL)
@@ -300,15 +304,15 @@ int lua_sr_init_child(void)
 
 		/* set SR lib version */
 #if LUA_VERSION_NUM >= 502
-		lua_pushstring(_sr_L_env.LL, SRVERSION);
-		lua_setglobal(_sr_L_env.LL, "SRVERSION");
+		lua_pushstring(_sr_L_env.LL, KSRVERSION);
+		lua_setglobal(_sr_L_env.LL, "KSRVERSION");
 #else
-		lua_pushstring(_sr_L_env.LL, "SRVERSION");
-		lua_pushstring(_sr_L_env.LL, SRVERSION);
+		lua_pushstring(_sr_L_env.LL, "KSRVERSION");
+		lua_pushstring(_sr_L_env.LL, KSRVERSION);
 		lua_settable(_sr_L_env.LL, LUA_GLOBALSINDEX);
 #endif
 		/* force loading lua lib now */
-		if(luaL_dostring(_sr_L_env.LL, "sr.probe()")!=0)
+		if(luaL_dostring(_sr_L_env.LL, "KSR.x.probe()")!=0)
 		{
 			txt = (char*)lua_tostring(_sr_L_env.LL, -1);
 			LM_ERR("error initializing Lua: %s\n", (txt)?txt:"unknown");
@@ -786,3 +790,1229 @@ void app_lua_dump_stack(lua_State *L)
 		}
 	}
 }
+
+/**
+ *
+ */
+int sr_kemi_lua_return_int(lua_State* L, sr_kemi_t *ket, int rc)
+{
+	if(ket->rtype==SR_KEMIP_INT) {
+		lua_pushinteger(L, rc);
+		return 1;
+	}
+	if(ket->rtype==SR_KEMIP_BOOL && rc!=SR_KEMI_FALSE) {
+		return app_lua_return_true(L);
+	}
+	return app_lua_return_false(L);
+}
+
+
+/**
+ *
+ */
+int sr_kemi_lua_return_xval(lua_State* L, sr_kemi_t *ket, sr_kemi_xval_t *rx)
+{
+	switch(rx->vtype) {
+		case SR_KEMIP_NONE:
+			return 0;
+		case SR_KEMIP_INT:
+			lua_pushinteger(L, rx->v.n);
+			return 1;
+		case SR_KEMIP_STR:
+			lua_pushlstring(L, rx->v.s.s, rx->v.s.len);
+			return 1;
+		case SR_KEMIP_BOOL:
+			if(rx->v.n!=SR_KEMI_FALSE) {
+				lua_pushboolean(L, SRLUA_TRUE);
+			} else {
+				lua_pushboolean(L, SRLUA_FALSE);
+			}
+			return 1;
+		case SR_KEMIP_XVAL:
+			/* unknown content - return false */
+			lua_pushboolean(L, SRLUA_FALSE);
+			return 1;
+		case SR_KEMIP_NULL:
+			lua_pushnil(L);
+			return 1;
+		default:
+			/* unknown type - return false */
+			lua_pushboolean(L, SRLUA_FALSE);
+			return 1;
+	}
+}
+
+/**
+ *
+ */
+int sr_kemi_lua_exec_func_ex(lua_State* L, sr_kemi_t *ket, int pdelta)
+{
+	int i;
+	int argc;
+	int ret;
+	str *fname;
+	str *mname;
+	sr_kemi_val_t vps[SR_KEMI_PARAMS_MAX];
+	sr_lua_env_t *env_L;
+	sr_kemi_xval_t *xret;
+
+	env_L = sr_lua_env_get();
+
+	if(env_L==NULL || env_L->msg==NULL || ket==NULL) {
+		LM_ERR("invalid Lua environment attributes or parameters\n");
+		return app_lua_return_false(L);
+	}
+
+	fname = &ket->fname;
+	mname = &ket->mname;
+
+	argc = lua_gettop(L);
+	if(argc==pdelta && ket->ptypes[0]==SR_KEMIP_NONE) {
+		if(ket->rtype==SR_KEMIP_XVAL) {
+			xret = ((sr_kemi_xfm_f)(ket->func))(env_L->msg);
+			return sr_kemi_lua_return_xval(L, ket, xret);
+		} else {
+			ret = ((sr_kemi_fm_f)(ket->func))(env_L->msg);
+			return sr_kemi_lua_return_int(L, ket, ret);
+		}
+	}
+	if(argc==pdelta && ket->ptypes[0]!=SR_KEMIP_NONE) {
+		LM_ERR("invalid number of parameters for: %.*s.%.*s\n",
+				mname->len, mname->s, fname->len, fname->s);
+		return app_lua_return_false(L);
+	}
+
+	if(argc>=SR_KEMI_PARAMS_MAX+pdelta) {
+		LM_ERR("too many parameters for: %.*s.%.*s\n",
+				mname->len, mname->s, fname->len, fname->s);
+		return app_lua_return_false(L);
+	}
+
+	memset(vps, 0, SR_KEMI_PARAMS_MAX*sizeof(sr_kemi_val_t));
+	for(i=0; i<SR_KEMI_PARAMS_MAX; i++) {
+		if(ket->ptypes[i]==SR_KEMIP_NONE) {
+			break;
+		}
+		if(argc<i+pdelta+1) {
+			LM_ERR("not enough parameters for: %.*s.%.*s\n",
+					mname->len, mname->s, fname->len, fname->s);
+			return app_lua_return_false(L);
+		}
+		if(ket->ptypes[i]==SR_KEMIP_STR) {
+			vps[i].s.s = (char*)lua_tostring(L, i+pdelta+1);
+			if(vps[i].s.s!=NULL) {
+				if(lua_isstring(L, i+pdelta+1)) {
+#if LUA_VERSION_NUM > 501
+					vps[i].s.len = lua_rawlen(L, i+pdelta+1);
+#else
+					vps[i].s.len = lua_strlen(L, i+pdelta+1);
+#endif
+				} else {
+					vps[i].s.len = strlen(vps[i].s.s);
+				}
+			} else {
+				vps[i].s.len = 0;
+			}
+			LM_DBG("param[%d] for: %.*s is str: %.*s\n", i,
+				fname->len, fname->s, vps[i].s.len, vps[i].s.s);
+		} else if(ket->ptypes[i]==SR_KEMIP_INT) {
+			vps[i].n = lua_tointeger(L, i+pdelta+1);
+			LM_DBG("param[%d] for: %.*s is int: %d\n", i,
+				fname->len, fname->s, vps[i].n);
+		} else {
+			LM_ERR("unknown parameter type %d (%d)\n", ket->ptypes[i], i);
+			return app_lua_return_false(L);
+		}
+	}
+
+	switch(i) {
+		case 1:
+			if(ket->ptypes[0]==SR_KEMIP_INT) {
+				if(ket->rtype==SR_KEMIP_XVAL) {
+					xret = ((sr_kemi_xfmn_f)(ket->func))(env_L->msg, vps[0].n);
+					return sr_kemi_lua_return_xval(L, ket, xret);
+				} else {
+					ret = ((sr_kemi_fmn_f)(ket->func))(env_L->msg, vps[0].n);
+					return sr_kemi_lua_return_int(L, ket, ret);
+				}
+			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
+				if(ket->rtype==SR_KEMIP_XVAL) {
+					xret = ((sr_kemi_xfms_f)(ket->func))(env_L->msg, &vps[0].s);
+					return sr_kemi_lua_return_xval(L, ket, xret);
+				} else {
+					ret = ((sr_kemi_fms_f)(ket->func))(env_L->msg, &vps[0].s);
+					return sr_kemi_lua_return_int(L, ket, ret);
+				}
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n",
+						fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		case 2:
+			if(ket->ptypes[0]==SR_KEMIP_INT) {
+				if(ket->ptypes[1]==SR_KEMIP_INT) {
+					if(ket->rtype==SR_KEMIP_XVAL) {
+						xret = ((sr_kemi_xfmnn_f)(ket->func))(env_L->msg, vps[0].n, vps[1].n);
+						return sr_kemi_lua_return_xval(L, ket, xret);
+					} else {
+						ret = ((sr_kemi_fmnn_f)(ket->func))(env_L->msg, vps[0].n, vps[1].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					}
+				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
+					if(ket->rtype==SR_KEMIP_XVAL) {
+						xret = ((sr_kemi_xfmns_f)(ket->func))(env_L->msg, vps[0].n, &vps[1].s);
+						return sr_kemi_lua_return_xval(L, ket, xret);
+					} else {
+						ret = ((sr_kemi_fmns_f)(ket->func))(env_L->msg, vps[0].n, &vps[1].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					}
+				} else {
+					LM_ERR("invalid parameters for: %.*s\n",
+							fname->len, fname->s);
+					return app_lua_return_false(L);
+				}
+			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
+				if(ket->ptypes[1]==SR_KEMIP_INT) {
+					if(ket->rtype==SR_KEMIP_XVAL) {
+						xret = ((sr_kemi_xfmsn_f)(ket->func))(env_L->msg, &vps[0].s, vps[1].n);
+						return sr_kemi_lua_return_xval(L, ket, xret);
+					} else {
+						ret = ((sr_kemi_fmsn_f)(ket->func))(env_L->msg, &vps[0].s, vps[1].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					}
+				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
+					if(ket->rtype==SR_KEMIP_XVAL) {
+						xret = ((sr_kemi_xfmss_f)(ket->func))(env_L->msg, &vps[0].s, &vps[1].s);
+						return sr_kemi_lua_return_xval(L, ket, xret);
+					} else {
+						ret = ((sr_kemi_fmss_f)(ket->func))(env_L->msg, &vps[0].s, &vps[1].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					}
+				} else {
+					LM_ERR("invalid parameters for: %.*s\n",
+							fname->len, fname->s);
+					return app_lua_return_false(L);
+				}
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n",
+						fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		case 3:
+			if(ket->ptypes[0]==SR_KEMIP_INT) {
+				if(ket->ptypes[1]==SR_KEMIP_INT) {
+					if(ket->ptypes[2]==SR_KEMIP_INT) {
+						ret = ((sr_kemi_fmnnn_f)(ket->func))(env_L->msg,
+								vps[0].n, vps[1].n, vps[2].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
+						ret = ((sr_kemi_fmnns_f)(ket->func))(env_L->msg,
+								vps[0].n, vps[1].n, &vps[2].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else {
+						LM_ERR("invalid parameters for: %.*s\n",
+								fname->len, fname->s);
+						return app_lua_return_false(L);
+					}
+				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
+					if(ket->ptypes[2]==SR_KEMIP_INT) {
+						ret = ((sr_kemi_fmnsn_f)(ket->func))(env_L->msg,
+								vps[0].n, &vps[1].s, vps[2].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
+						ret = ((sr_kemi_fmnss_f)(ket->func))(env_L->msg,
+								vps[0].n, &vps[1].s, &vps[2].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else {
+						LM_ERR("invalid parameters for: %.*s\n",
+								fname->len, fname->s);
+						return app_lua_return_false(L);
+					}
+				} else {
+					LM_ERR("invalid parameters for: %.*s\n",
+							fname->len, fname->s);
+					return app_lua_return_false(L);
+				}
+			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
+				if(ket->ptypes[1]==SR_KEMIP_INT) {
+					if(ket->ptypes[2]==SR_KEMIP_INT) {
+						ret = ((sr_kemi_fmsnn_f)(ket->func))(env_L->msg,
+								&vps[0].s, vps[1].n, vps[2].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
+						ret = ((sr_kemi_fmsns_f)(ket->func))(env_L->msg,
+								&vps[0].s, vps[1].n, &vps[2].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else {
+						LM_ERR("invalid parameters for: %.*s\n",
+								fname->len, fname->s);
+						return app_lua_return_false(L);
+					}
+				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
+					if(ket->ptypes[2]==SR_KEMIP_INT) {
+						ret = ((sr_kemi_fmssn_f)(ket->func))(env_L->msg,
+								&vps[0].s, &vps[1].s, vps[2].n);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
+						ret = ((sr_kemi_fmsss_f)(ket->func))(env_L->msg,
+								&vps[0].s, &vps[1].s, &vps[2].s);
+						return sr_kemi_lua_return_int(L, ket, ret);
+					} else {
+						LM_ERR("invalid parameters for: %.*s\n",
+								fname->len, fname->s);
+						return app_lua_return_false(L);
+					}
+				} else {
+					LM_ERR("invalid parameters for: %.*s\n",
+							fname->len, fname->s);
+					return app_lua_return_false(L);
+				}
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n",
+						fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		case 4:
+			if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmssss_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsssn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmssns_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmssnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnss_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnsn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnns_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnsss_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnssn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnsns_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnsnn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnss_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnsn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnns_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, &vps[3].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnnn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, vps[3].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n", fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		case 5:
+			if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsssss_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmssssn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsssns_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsssnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmssnss_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmssnsn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmssnns_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmssnnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnsss_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnssn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnsns_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnsnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnnss_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnnsn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmsnnns_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmsnnnn_f)(ket->func))(env_L->msg,
+						&vps[0].s, vps[1].n, vps[2].n, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnssss_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnsssn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnssns_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnssnn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnsnss_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnsnsn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnsnns_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnsnnn_f)(ket->func))(env_L->msg,
+						vps[0].n, &vps[1].s, vps[2].n, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnsss_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnssn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnsns_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnsnn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, &vps[2].s, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnnss_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, &vps[3].s, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnnsn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, &vps[3].s, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmnnnns_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, vps[3].n, &vps[4].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else if(ket->ptypes[0]==SR_KEMIP_INT
+					&& ket->ptypes[1]==SR_KEMIP_INT
+					&& ket->ptypes[2]==SR_KEMIP_INT
+					&& ket->ptypes[3]==SR_KEMIP_INT
+					&& ket->ptypes[4]==SR_KEMIP_INT) {
+				ret = ((sr_kemi_fmnnnnn_f)(ket->func))(env_L->msg,
+						vps[0].n, vps[1].n, vps[2].n, vps[3].n, vps[4].n);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n", fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		case 6:
+			if(ket->ptypes[0]==SR_KEMIP_STR
+					&& ket->ptypes[1]==SR_KEMIP_STR
+					&& ket->ptypes[2]==SR_KEMIP_STR
+					&& ket->ptypes[3]==SR_KEMIP_STR
+					&& ket->ptypes[4]==SR_KEMIP_STR
+					&& ket->ptypes[5]==SR_KEMIP_STR) {
+				ret = ((sr_kemi_fmssssss_f)(ket->func))(env_L->msg,
+						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s,
+						&vps[4].s, &vps[5].s);
+				return sr_kemi_lua_return_int(L, ket, ret);
+			} else {
+				LM_ERR("invalid parameters for: %.*s\n",
+						fname->len, fname->s);
+				return app_lua_return_false(L);
+			}
+		break;
+		default:
+			LM_ERR("invalid parameters for: %.*s\n",
+					fname->len, fname->s);
+			return app_lua_return_false(L);
+	}
+}
+
+/**
+ *
+ */
+int sr_kemi_exec_func(lua_State* L, str *mname, int midx, str *fname)
+{
+	int pdelta;
+	sr_kemi_t *ket = NULL;
+	sr_lua_env_t *env_L;
+
+	env_L = sr_lua_env_get();
+
+	if(env_L==NULL || env_L->msg==NULL) {
+		LM_ERR("invalid Lua environment attributes\n");
+		return app_lua_return_false(L);
+	}
+
+	ket = sr_kemi_lookup(mname, midx, fname);
+	if(ket==NULL) {
+		LM_ERR("cannot find function (%d): %.*s.%.*s\n", midx,
+				(mname && mname->len>0)?mname->len:0,
+				(mname && mname->len>0)?mname->s:"",
+				fname->len, fname->s);
+		return app_lua_return_false(L);
+	}
+	if(mname->len<=0) {
+		pdelta = 1;
+	} else {
+		pdelta = 3;
+	}
+	return sr_kemi_lua_exec_func_ex(L, ket, pdelta);
+}
+
+/**
+ *
+ */
+int sr_kemi_lua_exec_func(lua_State* L, int eidx)
+{
+	sr_kemi_t *ket;
+	int ret;
+	struct timeval tvb, tve;
+	struct timezone tz;
+	unsigned int tdiff;
+	lua_Debug dinfo;
+
+	ket = sr_kemi_lua_export_get(eidx);
+	if(unlikely(cfg_get(core, core_cfg, latency_limit_action)>0)
+			&& is_printable(cfg_get(core, core_cfg, latency_log))) {
+		gettimeofday(&tvb, &tz);
+	}
+
+	ret = sr_kemi_lua_exec_func_ex(L, ket, 0);
+
+	if(unlikely(cfg_get(core, core_cfg, latency_limit_action)>0)
+			&& is_printable(cfg_get(core, core_cfg, latency_log))) {
+		gettimeofday(&tve, &tz);
+		tdiff = (tve.tv_sec - tvb.tv_sec) * 1000000
+				   + (tve.tv_usec - tvb.tv_usec);
+		if(tdiff >= cfg_get(core, core_cfg, latency_limit_action)) {
+			memset(&dinfo, 0, sizeof(lua_Debug));
+			if(lua_getstack(L, 1, &dinfo)>0
+						&& lua_getinfo(L, "nSl", &dinfo)>0) {
+				LOG(cfg_get(core, core_cfg, latency_log),
+						"alert - action KSR.%s%s%s(...)"
+						" took too long [%u us] (%s:%d - %s [%s])\n",
+						(ket->mname.len>0)?ket->mname.s:"",
+						(ket->mname.len>0)?".":"", ket->fname.s,
+						tdiff,
+						(dinfo.short_src[0])?dinfo.short_src:"<unknown>",
+						dinfo.currentline,
+						(dinfo.name)?dinfo.name:"<unknown>",
+						(dinfo.what)?dinfo.what:"<unknown>");
+			} else {
+				LOG(cfg_get(core, core_cfg, latency_log),
+						"alert - action KSR.%s%s%s(...)"
+						" took too long [%u us]\n",
+						(ket->mname.len>0)?ket->mname.s:"",
+						(ket->mname.len>0)?".":"", ket->fname.s,
+						tdiff);
+			}
+		}
+	}
+
+	return ret;
+}
+
+/**
+ *
+ */
+static int sr_kemi_lua_modf (lua_State *L)
+{
+	int ret;
+	char *luav[MAX_ACTIONS];
+	char *argv[MAX_ACTIONS];
+	int argc;
+	int i;
+	int mod_type;
+	struct run_act_ctx ra_ctx;
+	struct action *act;
+	ksr_cmd_export_t* expf;
+	sr_lua_env_t *env_L;
+
+	ret = 1;
+	act = NULL;
+	argc = 0;
+	memset(luav, 0, MAX_ACTIONS*sizeof(char*));
+	memset(argv, 0, MAX_ACTIONS*sizeof(char*));
+	env_L = sr_lua_env_get();
+	if(env_L->msg==NULL)
+		goto error;
+
+#if 0
+	app_lua_dump_stack(L);
+#endif
+	argc = lua_gettop(L);
+	if(argc==0)
+	{
+		LM_ERR("name of module function not provided\n");
+		goto error;
+	}
+	if(argc>=MAX_ACTIONS)
+	{
+		LM_ERR("too many parameters\n");
+		goto error;
+	}
+	/* first is function name, then parameters */
+	for(i=1; i<=argc; i++)
+	{
+		if (!lua_isstring(L, i))
+		{
+			LM_ERR("invalid parameter type (%d)\n", i);
+			goto error;
+		}
+		luav[i-1] = (char*)lua_tostring(L, i);
+	}
+	/* pkg copy only parameters */
+	for(i=1; i<MAX_ACTIONS; i++)
+	{
+		if(luav[i]!=NULL)
+		{
+			argv[i] = (char*)pkg_malloc(strlen(luav[i])+1);
+			if(argv[i]==NULL)
+			{
+				PKG_MEM_ERROR;
+				goto error;
+			}
+			strcpy(argv[i], luav[i]);
+		}
+	}
+
+	expf = find_export_record(luav[0], argc-1, 0);
+	if (expf==NULL) {
+		LM_ERR("function '%s' is not available\n", luav[0]);
+		goto error;
+	}
+	/* check fixups */
+	if (expf->fixup!=NULL && expf->free_fixup==NULL) {
+		LM_ERR("function '%s' has fixup - cannot be used\n", luav[0]);
+		goto error;
+	}
+	switch(expf->param_no) {
+		case 0:
+			mod_type = MODULE0_T;
+			break;
+		case 1:
+			mod_type = MODULE1_T;
+			break;
+		case 2:
+			mod_type = MODULE2_T;
+			break;
+		case 3:
+			mod_type = MODULE3_T;
+			break;
+		case 4:
+			mod_type = MODULE4_T;
+			break;
+		case 5:
+			mod_type = MODULE5_T;
+			break;
+		case 6:
+			mod_type = MODULE6_T;
+			break;
+		case VAR_PARAM_NO:
+			mod_type = MODULEX_T;
+			break;
+		default:
+			LM_ERR("unknown/bad definition for function '%s' (%d params)\n",
+					luav[0], expf->param_no);
+			goto error;
+	}
+
+	act = mk_action(mod_type,  argc+1   /* number of (type, value) pairs */,
+					MODEXP_ST, expf,    /* function */
+					NUMBER_ST, argc-1,  /* parameter number */
+					STRING_ST, argv[1], /* param. 1 */
+					STRING_ST, argv[2], /* param. 2 */
+					STRING_ST, argv[3], /* param. 3 */
+					STRING_ST, argv[4], /* param. 4 */
+					STRING_ST, argv[5], /* param. 5 */
+					STRING_ST, argv[6]  /* param. 6 */
+			);
+
+	if (act==NULL) {
+		LM_ERR("action structure could not be created for '%s'\n", luav[0]);
+		goto error;
+	}
+
+	/* handle fixups */
+	if (expf->fixup) {
+		if(argc==1)
+		{ /* no parameters */
+			if(expf->fixup(0, 0)<0)
+			{
+				LM_ERR("Error in fixup (0) for '%s'\n", luav[0]);
+				goto error;
+			}
+		} else {
+			for(i=1; i<argc; i++)
+			{
+				if(expf->fixup(&(act->val[i+1].u.data), i)<0)
+				{
+					LM_ERR("Error in fixup (%d) for '%s'\n", i, luav[0]);
+					goto error;
+				}
+				act->val[i+1].type = MODFIXUP_ST;
+			}
+		}
+	}
+	init_run_actions_ctx(&ra_ctx);
+	ret = do_action(&ra_ctx, act, env_L->msg);
+
+	/* free fixups */
+	if (expf->fixup) {
+		for(i=1; i<argc; i++)
+		{
+			if ((act->val[i+1].type == MODFIXUP_ST) && (act->val[i+1].u.data))
+			{
+				expf->free_fixup(&(act->val[i+1].u.data), i);
+			}
+		}
+	}
+	pkg_free(act);
+	for(i=0; i<MAX_ACTIONS; i++)
+	{
+		if(argv[i]!=NULL) pkg_free(argv[i]);
+		argv[i] = 0;
+	}
+	lua_pushinteger(L, ret);
+	return 1;
+
+error:
+	if(act!=NULL)
+		pkg_free(act);
+	for(i=0; i<MAX_ACTIONS; i++)
+	{
+		if(argv[i]!=NULL) pkg_free(argv[i]);
+		argv[i] = 0;
+	}
+	lua_pushinteger(L, -1);
+	return 1;
+}
+
+/**
+ *
+ */
+static int sr_kemi_lua_exit (lua_State *L)
+{
+	str *s;
+
+	LM_DBG("script exit call\n");
+	s = sr_kemi_lua_exit_string_get();
+	lua_getglobal(L, "error");
+	lua_pushstring(L, s->s);
+	lua_call(L, 1, 0);
+	return 0;
+}
+
+/**
+ *
+ */
+static int sr_kemi_lua_drop (lua_State *L)
+{
+	str *s;
+
+	LM_DBG("script drop call\n");
+	sr_kemi_core_set_drop(NULL);
+	s = sr_kemi_lua_exit_string_get();
+	lua_getglobal(L, "error");
+	lua_pushstring(L, s->s);
+	lua_call(L, 1, 0);
+	return 0;
+}
+
+/**
+ *
+ */
+static int sr_kemi_lua_probe (lua_State *L)
+{
+	LM_DBG("someone probing from lua\n");
+	return 0;
+}
+
+/**
+ *
+ */
+static const luaL_Reg _sr_kemi_x_Map [] = {
+	{"modf",      sr_kemi_lua_modf},
+	{"exit",      sr_kemi_lua_exit},
+	{"drop",      sr_kemi_lua_drop},
+	{"probe",     sr_kemi_lua_probe},
+	{NULL, NULL}
+};
+
+
+/**
+ *
+ */
+luaL_Reg *_sr_KSRMethods = NULL;
+
+#define SR_LUA_KSR_MODULES_SIZE	256
+#define SR_LUA_KSR_METHODS_SIZE	(SR_KEMI_LUA_EXPORT_SIZE + SR_LUA_KSR_MODULES_SIZE)
+
+/**
+ *
+ */
+void lua_sr_kemi_register_libs(lua_State *L)
+{
+	luaL_Reg *_sr_crt_KSRMethods = NULL;
+	sr_kemi_module_t *emods = NULL;
+	int emods_size = 0;
+	int i;
+	int k;
+	int n;
+	char mname[128];
+
+#if 0
+	/* dynamic lookup on function name */
+	lua_sr_kemi_register_core(L);
+	lua_sr_kemi_register_modules(L);
+#endif
+
+	_sr_KSRMethods = malloc(SR_LUA_KSR_METHODS_SIZE * sizeof(luaL_Reg));
+	if(_sr_KSRMethods==NULL) {
+		LM_ERR("no more pkg memory\n");
+		return;
+	}
+	memset(_sr_KSRMethods, 0, SR_LUA_KSR_METHODS_SIZE * sizeof(luaL_Reg));
+
+	emods_size = sr_kemi_modules_size_get();
+	emods = sr_kemi_modules_get();
+
+	n = 0;
+	_sr_crt_KSRMethods = _sr_KSRMethods;
+	if(emods_size==0 || emods[0].kexp==NULL) {
+		LM_ERR("no kemi exports registered\n");
+		return;
+	}
+
+	for(i=0; emods[0].kexp[i].func!=NULL; i++) {
+		if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
+			LM_DBG("exporting KSR.%s(...)\n", emods[0].kexp[i].fname.s);
+		}
+		_sr_crt_KSRMethods[i].name = emods[0].kexp[i].fname.s;
+		_sr_crt_KSRMethods[i].func =
+			sr_kemi_lua_export_associate(&emods[0].kexp[i]);
+		if(_sr_crt_KSRMethods[i].func == NULL) {
+			LM_ERR("failed to associate kemi function with lua export\n");
+			free(_sr_KSRMethods);
+			_sr_KSRMethods = NULL;
+			return;
+		}
+		n++;
+	}
+
+	luaL_openlib(L, "KSR", _sr_crt_KSRMethods, 0);
+
+	luaL_openlib(L, "KSR.x",  _sr_kemi_x_Map, 0);
+
+	/* registered kemi modules */
+	if(emods_size>1) {
+		for(k=1; k<emods_size; k++) {
+			n++;
+			_sr_crt_KSRMethods = _sr_KSRMethods + n;
+			snprintf(mname, 128, "KSR.%s", emods[k].kexp[0].mname.s);
+			for(i=0; emods[k].kexp[i].func!=NULL; i++) {
+				if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
+					LM_DBG("exporting %s.%s(...)\n", mname,
+							emods[k].kexp[i].fname.s);
+				}
+				_sr_crt_KSRMethods[i].name = emods[k].kexp[i].fname.s;
+				_sr_crt_KSRMethods[i].func =
+					sr_kemi_lua_export_associate(&emods[k].kexp[i]);
+				if(_sr_crt_KSRMethods[i].func == NULL) {
+					LM_ERR("failed to associate kemi function with func export\n");
+					free(_sr_KSRMethods);
+					_sr_KSRMethods = NULL;
+					return;
+				}
+				n++;
+			}
+			if(!lua_checkstack(L, i+8)) {
+				LM_ERR("not enough Lua stack capacity\n");
+				exit(-1);
+			}
+			luaL_openlib(L, mname, _sr_crt_KSRMethods, 0);
+			if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
+				LM_DBG("initializing kemi sub-module: %s (%s) (%d/%d/%d)\n",
+						mname, emods[k].kexp[0].mname.s, i, k, n);
+			}
+		}
+	}
+	LM_DBG("module 'KSR' has been initialized (%d/%d)\n", emods_size, n);
+}
+
+static const char* app_lua_rpc_api_list_doc[2] = {
+	"list kemi exports to lua",
+	0
+};
+
+static void app_lua_rpc_api_list(rpc_t* rpc, void* ctx)
+{
+	int i;
+	int n;
+	sr_kemi_t *ket;
+	void* th;
+	void* sh;
+	void* ih;
+
+	if (rpc->add(ctx, "{", &th) < 0) {
+		rpc->fault(ctx, 500, "Internal error root reply");
+		return;
+	}
+
+	/* count the number of exported functions */
+	n = 0;
+	for(i=0; i<SR_KEMI_LUA_EXPORT_SIZE; i++) {
+		ket = sr_kemi_lua_export_get(i);
+		if(ket==NULL) continue;
+		n++;
+	}
+
+	if(rpc->struct_add(th, "d[",
+				"msize", n,
+				"methods",  &ih)<0)
+	{
+		rpc->fault(ctx, 500, "Internal error array structure");
+		return;
+	}
+	for(i=0; i<SR_KEMI_LUA_EXPORT_SIZE; i++) {
+		ket = sr_kemi_lua_export_get(i);
+		if(ket==NULL) continue;
+		if(rpc->struct_add(ih, "{", "func", &sh)<0) {
+			rpc->fault(ctx, 500, "Internal error internal structure");
+			return;
+		}
+		if(rpc->struct_add(sh, "SSSS",
+				"ret", sr_kemi_param_map_get_name(ket->rtype),
+				"module", &ket->mname,
+				"name", &ket->fname,
+				"params", sr_kemi_param_map_get_params(ket->ptypes))<0) {
+			LM_ERR("failed to add the structure with attributes (%d)\n", i);
+			rpc->fault(ctx, 500, "Internal error creating dest struct");
+			return;
+		}
+	}
+}
+
+/*** RPC implementation ***/
+
+static const char* app_lua_rpc_reload_doc[2] = {
+	"Reload lua script",
+	0
+};
+
+static const char* app_lua_rpc_list_doc[2] = {
+	"list lua scripts",
+	0
+};
+
+static void app_lua_rpc_reload(rpc_t* rpc, void* ctx)
+{
+	int pos = -1;
+
+	rpc->scan(ctx, "*d", &pos);
+	LM_DBG("selected index: %d\n", pos);
+	if(lua_sr_reload_script(pos)<0)
+		rpc->fault(ctx, 500, "Reload Failed");
+	return;
+}
+
+static void app_lua_rpc_list(rpc_t* rpc, void* ctx)
+{
+	int i;
+	sr_lua_load_t *list = NULL, *li;
+	if(lua_sr_list_script(&list)<0)
+	{
+		LM_ERR("Can't get loaded scripts\n");
+		return;
+	}
+	if(list)
+	{
+		li = list;
+		i = 0;
+		while(li)
+		{
+			rpc->rpl_printf(ctx, "%d: [%s]", i, li->script);
+			li = li->next;
+			i += 1;
+		}
+	}
+	else {
+		rpc->rpl_printf(ctx,"No scripts loaded");
+	}
+	return;
+}
+
+rpc_export_t app_lua_rpc_cmds[] = {
+	{"app_lua.reload", app_lua_rpc_reload,
+		app_lua_rpc_reload_doc, 0},
+	{"app_lua.list", app_lua_rpc_list,
+		app_lua_rpc_list_doc, 0},
+	{"app_lua.api_list", app_lua_rpc_api_list,
+		app_lua_rpc_api_list_doc, 0},
+	{0, 0, 0, 0}
+};
+
+/**
+ * register RPC commands
+ */
+int app_lua_init_rpc(void)
+{
+	if (rpc_register_array(app_lua_rpc_cmds)!=0)
+	{
+		LM_ERR("failed to register RPC commands\n");
+		return -1;
+	}
+	return 0;
+}

src/modules/app_lua/app_lua_api.h

@@ -27,6 +27,7 @@
 #include <lualib.h>
 
 #include "../../core/parser/msg_parser.h"
+#include "../../core/kemi.h"
 
 /**
  * version variable stores a version counter for each script loaded.
@@ -54,6 +55,10 @@ typedef struct _sr_lua_load
 	struct _sr_lua_load *next;
 } sr_lua_load_t;
 
+typedef void (*app_lua_openlibs_f)(lua_State *L);
+
+int app_lua_openlibs_register(app_lua_openlibs_f rfunc);
+
 sr_lua_env_t *sr_lua_env_get(void);
 
 int lua_sr_initialized(void);
@@ -66,7 +71,6 @@ int lua_sr_list_script(sr_lua_load_t **list);
 
 int sr_lua_load_script(char *script);
 int sr_lua_reload_script(void);
-int sr_lua_register_module(char *mname);
 int sr_lua_reload_module(unsigned int reload);
 
 int app_lua_dostring(struct sip_msg *msg, char *script);
@@ -89,5 +93,9 @@ void app_lua_dump_stack(lua_State *L);
 
 str* sr_kemi_lua_exit_string_get(void);
 
+int sr_kemi_lua_exec_func(lua_State* L, int eidx);
+
+int app_lua_init_rpc(void);
+
 #endif
 

src/modules/app_lua/app_lua_exp.c

@@ -1,3730 +0,0 @@
-/**
- * Copyright (C) 2010-2016 Daniel-Constantin Mierla (asipto.com)
- *
- * This file is part of Kamailio, a free SIP server.
- *
- * Kamailio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version
- *
- * Kamailio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-#include "../../core/sr_module.h"
-#include "../../core/dprint.h"
-#include "../../core/route.h"
-#include "../../core/ut.h"
-
-#include "../../modules/sl/sl.h"
-#include "../../modules/tm/tm_load.h"
-#include "../../modules/sqlops/sql_api.h"
-#include "../../modules/rr/api.h"
-#include "../../modules/auth/api.h"
-#include "../../modules/auth_db/api.h"
-#include "../../modules/maxfwd/api.h"
-#include "../../modules/registrar/api.h"
-#include "../../modules/dispatcher/api.h"
-#include "../../modules/xhttp/api.h"
-#include "../../modules/sdpops/api.h"
-#include "../../modules/presence/bind_presence.h"
-#include "../../modules/presence_xml/api.h"
-#include "../../modules/textops/api.h"
-#include "../../modules/pua_usrloc/api.h"
-#include "../../modules/siputils/siputils.h"
-#include "../../modules/rls/api.h"
-#include "../../modules/alias_db/api.h"
-#include "../../modules/msilo/api.h"
-#include "../../modules/uac/api.h"
-#include "../../modules/sanity/api.h"
-#include "../../modules/cfgutils/api.h"
-#include "../../modules/tmx/api.h"
-#include "../../modules/mqueue/api.h"
-#include "../../modules/ndb_mongodb/api.h"
-
-#include "app_lua_api.h"
-
-#define SR_LUA_EXP_MOD_SL         (1<<0)
-#define SR_LUA_EXP_MOD_TM         (1<<1)
-#define SR_LUA_EXP_MOD_SQLOPS     (1<<2)
-#define SR_LUA_EXP_MOD_RR         (1<<3)
-#define SR_LUA_EXP_MOD_AUTH       (1<<4)
-#define SR_LUA_EXP_MOD_AUTH_DB    (1<<5)
-#define SR_LUA_EXP_MOD_MAXFWD     (1<<6)
-#define SR_LUA_EXP_MOD_REGISTRAR  (1<<7)
-#define SR_LUA_EXP_MOD_DISPATCHER (1<<8)
-#define SR_LUA_EXP_MOD_XHTTP      (1<<9)
-#define SR_LUA_EXP_MOD_SDPOPS     (1<<10)
-#define SR_LUA_EXP_MOD_PRESENCE   (1<<11)
-#define SR_LUA_EXP_MOD_PRESENCE_XML (1<<12)
-#define SR_LUA_EXP_MOD_TEXTOPS    (1<<13)
-#define SR_LUA_EXP_MOD_PUA_USRLOC (1<<14)
-#define SR_LUA_EXP_MOD_SIPUTILS   (1<<15)
-#define SR_LUA_EXP_MOD_RLS        (1<<16)
-#define SR_LUA_EXP_MOD_ALIAS_DB   (1<<17)
-#define SR_LUA_EXP_MOD_MSILO      (1<<18)
-#define SR_LUA_EXP_MOD_UAC        (1<<19)
-#define SR_LUA_EXP_MOD_SANITY     (1<<20)
-#define SR_LUA_EXP_MOD_CFGUTILS   (1<<21)
-#define SR_LUA_EXP_MOD_TMX        (1<<22)
-#define SR_LUA_EXP_MOD_MQUEUE     (1<<23)
-#define SR_LUA_EXP_MOD_NDB_MONGODB (1<<24)
-
-/**
- *
- */
-static unsigned int _sr_lua_exp_reg_mods = 0;
-
-/**
- * auth
- */
-static auth_api_s_t _lua_authb;
-
-/**
- * auth_db
- */
-static auth_db_api_t _lua_auth_dbb;
-
-/**
- * dispatcher
- */
-static dispatcher_api_t _lua_dispatcherb;
-
-/**
- * maxfwd
- */
-static maxfwd_api_t _lua_maxfwdb;
-
-/**
- * registrar
- */
-static registrar_api_t _lua_registrarb;
-
-/**
- * rr
- */
-static rr_api_t _lua_rrb;
-
-/**
- * sqlops
- */
-static sqlops_api_t _lua_sqlopsb;
-
-/**
- * sl
- */
-static sl_api_t _lua_slb;
-
-/**
- * tm
- */
-static tm_api_t  _lua_tmb;
-static tm_xapi_t _lua_xtmb;
-
-/**
- * xhttp
- */
-static xhttp_api_t _lua_xhttpb;
-
-/**
- * sdpops
- */
-static sdpops_api_t _lua_sdpopsb;
-
-/**
- * presence
- */
-static presence_api_t _lua_presenceb;
-
-/**
- * presence_xml
- */
-static presence_xml_api_t _lua_presence_xmlb;
-
-/**
- * textops
- */
-static textops_api_t _lua_textopsb;
-
-/**
- * pua_usrloc
- */
-static pua_usrloc_api_t _lua_pua_usrlocb;
-
-/**
- * siputils
- */
-static siputils_api_t _lua_siputilsb;
-
-/**
- * rls
- */
-static rls_api_t _lua_rlsb;
-
-/**
- * alias_db
- */
-static alias_db_api_t _lua_alias_dbb;
-
-/**
- * msilo
- */
-static msilo_api_t _lua_msilob;
-
-/**
- * uac
- */
-static uac_api_t _lua_uacb;
-
-/**
- * sanity
- */
-static sanity_api_t _lua_sanityb;
-
-/**
- * cfgutils
- */
-static cfgutils_api_t _lua_cfgutilsb;
-
-/**
- * tmx
- */
-static tmx_api_t _lua_tmxb;
-
-/**
- * mqueue
- */
-static mq_api_t _lua_mqb;
-
-/**
- * mqueue
- */
-static ndb_mongodb_api_t _lua_ndb_mongodbb;
-
-
-/**
- *
- */
-static int lua_sr_sl_send_reply (lua_State *L)
-{
-	str txt;
-	int code;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SL))
-	{
-		LM_WARN("weird: sl function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	code = lua_tointeger(L, -2);
-
-	if(code<100 || code>=800)
-		return app_lua_return_error(L);
-
-	txt.s = (char*)lua_tostring(L, -1);
-	if(txt.s==NULL || env_L->msg==NULL)
-		return app_lua_return_error(L);
-
-	txt.len = strlen(txt.s);
-	ret = _lua_slb.freply(env_L->msg, code, &txt);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sl_get_reply_totag (lua_State *L)
-{
-	str txt;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SL))
-	{
-		LM_WARN("weird: sl function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_slb.get_reply_totag(env_L->msg, &txt);
-	if(ret<0)
-	{
-		LM_WARN("sl get_reply_totag returned false\n");
-		return app_lua_return_false(L);
-	}
-	lua_pushlstring(L, txt.s, txt.len);
-	return 1;
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_sl_Map [] = {
-	{"send_reply",      lua_sr_sl_send_reply},
-	{"get_reply_totag", lua_sr_sl_get_reply_totag},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_tm_t_reply(lua_State *L)
-{
-	char *txt;
-	int code;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	code = lua_tointeger(L, -2);
-
-	if(code<100 || code>=800)
-		return app_lua_return_error(L);
-
-	txt = (char*)lua_tostring(L, -1);
-	if(txt!=NULL && env_L->msg!=NULL)
-	{
-		ret = _lua_tmb.t_reply(env_L->msg, code, txt);
-		return app_lua_return_int(L, ret);
-	}
-	return app_lua_return_error(L);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_relay(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_tmb.t_relay(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_on_failure(lua_State *L)
-{
-	char *name;
-	int i;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	name = (char*)lua_tostring(L, -1);
-	if(name==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	i = route_get(&failure_rt, name);
-	if(failure_rt.rlist[i]==0)
-	{
-		LM_WARN("no actions in failure_route[%s]\n", name);
-		return app_lua_return_error(L);
-	}
-
-	_lua_xtmb.t_on_failure((unsigned int)i);
-	return app_lua_return_int(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_on_branch(lua_State *L)
-{
-	char *name;
-	int i;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	name = (char*)lua_tostring(L, -1);
-	if(name==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	i = route_get(&branch_rt, name);
-	if(branch_rt.rlist[i]==0)
-	{
-		LM_WARN("no actions in branch_route[%s]\n", name);
-		return app_lua_return_error(L);
-	}
-
-	_lua_xtmb.t_on_branch((unsigned int)i);
-	return app_lua_return_int(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_on_reply(lua_State *L)
-{
-	char *name;
-	int i;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	name = (char*)lua_tostring(L, -1);
-	if(name==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	i = route_get(&onreply_rt, name);
-	if(onreply_rt.rlist[i]==0)
-	{
-		LM_WARN("no actions in onreply_route[%s]\n", name);
-		return app_lua_return_error(L);
-	}
-
-	_lua_xtmb.t_on_reply((unsigned int)i);
-	return app_lua_return_int(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_check_trans(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_xtmb.t_check_trans(env_L->msg);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_is_canceled(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_xtmb.t_is_canceled(env_L->msg);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_newtran(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_tmb.t_newtran(env_L->msg);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_release(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_tmb.t_release(env_L->msg);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_replicate(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-	str suri;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	suri.s = (char*)lua_tostring(L, -1);
-	if(suri.s == NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	suri.len = strlen(suri.s);
-
-	ret = _lua_tmb.t_replicate(env_L->msg, &suri);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-#define BRANCH_FAILURE_ROUTE_PREFIX "tm:branch-failure"
-static int lua_sr_tm_t_on_branch_failure(lua_State *L)
-{
-	static str rt_name = {NULL, 0};
-	char *name;
-	int rt_name_len;
-	int i;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	name = (char*)lua_tostring(L, -1);
-	if(name==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	rt_name_len = strlen(BRANCH_FAILURE_ROUTE_PREFIX) + 1 + strlen(name);
-	if (rt_name_len > rt_name.len)
-	{
-		if ((rt_name.s = pkg_reallocxf(rt_name.s, rt_name_len+1)) == NULL)
-		{
-			PKG_MEM_ERROR;
-			return -1;
-		}
-		rt_name.len = rt_name_len;
-	}
-	sprintf(rt_name.s, "%s:%s", BRANCH_FAILURE_ROUTE_PREFIX, name);
-
-	i = route_get(&event_rt, rt_name.s);
-	if(i < 0 || event_rt.rlist[i]==0)
-	{
-		LM_WARN("no actions in branch_failure_route[%s]\n", name);
-		return app_lua_return_error(L);
-	}
-
-	_lua_xtmb.t_on_branch_failure((unsigned int)i);
-	return app_lua_return_int(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_load_contacts(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_tmb.t_load_contacts(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_tm_t_next_contacts(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM))
-	{
-		LM_WARN("weird: tm function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_tmb.t_next_contacts(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_tm_Map [] = {
-	{"t_reply",             lua_sr_tm_t_reply},
-	{"t_relay",             lua_sr_tm_t_relay},
-	{"t_on_failure",        lua_sr_tm_t_on_failure},
-	{"t_on_branch",         lua_sr_tm_t_on_branch},
-	{"t_on_reply",          lua_sr_tm_t_on_reply},
-	{"t_check_trans",       lua_sr_tm_t_check_trans},
-	{"t_is_canceled",       lua_sr_tm_t_is_canceled},
-	{"t_newtran",           lua_sr_tm_t_newtran},
-	{"t_release",           lua_sr_tm_t_release},
-	{"t_replicate",         lua_sr_tm_t_replicate},
-	{"t_on_branch_failure", lua_sr_tm_t_on_branch_failure},
-	{"t_load_contacts",     lua_sr_tm_t_load_contacts},
-	{"t_next_contacts",     lua_sr_tm_t_next_contacts},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_sqlops_query(lua_State *L)
-{
-	str scon;
-	str squery;
-	str sres;
-	int ret;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	scon.s = (char*)lua_tostring(L, -3);
-	squery.s = (char*)lua_tostring(L, -2);
-	sres.s = (char*)lua_tostring(L, -1);
-	if(scon.s == NULL || squery.s == NULL || sres.s == NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	scon.len = strlen(scon.s);
-	squery.len = strlen(squery.s);
-	sres.len = strlen(sres.s);
-
-	ret = _lua_sqlopsb.query(&scon, &squery, &sres);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_value(lua_State *L)
-{
-	str sres;
-	int col;
-	int row;
-	sql_val_t *val;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -3);
-	row = lua_tointeger(L, -2);
-	col = lua_tointeger(L, -1);
-	if(row<0 || col<0 || sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	if(_lua_sqlopsb.value(&sres, row, col, &val)<0)
-		return app_lua_return_false(L);
-	if(val->flags&PV_VAL_NULL)
-	{
-		lua_pushinteger(L, 0);
-		return 1;
-	}
-
-	if(val->flags&PV_VAL_INT)
-	{
-		lua_pushinteger(L, val->value.n);
-		return 1;
-	}
-	lua_pushlstring(L, val->value.s.s, val->value.s.len);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_is_null(lua_State *L)
-{
-	str sres;
-	int col;
-	int row;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -3);
-	row = lua_tointeger(L, -2);
-	col = lua_tointeger(L, -1);
-	if(row<0 || col<0 || sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	if(_lua_sqlopsb.is_null(&sres, row, col)==1)
-		return app_lua_return_true(L);
-	return app_lua_return_false(L);
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_column(lua_State *L)
-{
-	str sres;
-	int col;
-	str name = {0, 0};
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -2);
-	col = lua_tointeger(L, -1);
-	if(col<0 || sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	if(_lua_sqlopsb.column(&sres, col, &name)<0)
-		return app_lua_return_false(L);
-	lua_pushlstring(L, name.s, name.len);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_nrows(lua_State *L)
-{
-	str sres;
-	int rows;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -1);
-	if(sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	rows = _lua_sqlopsb.nrows(&sres);
-	if(rows<0)
-		return app_lua_return_false(L);
-	lua_pushinteger(L, rows);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_ncols(lua_State *L)
-{
-	str sres;
-	int cols;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -1);
-	if(sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	cols = _lua_sqlopsb.ncols(&sres);
-	if(cols<0)
-		return app_lua_return_false(L);
-	lua_pushinteger(L, cols);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_reset(lua_State *L)
-{
-	str sres;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_false(L);
-	}
-	sres.s = (char*)lua_tostring(L, -1);
-	if(sres.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-	sres.len = strlen(sres.s);
-	_lua_sqlopsb.reset(&sres);
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_sqlops_xquery(lua_State *L)
-{
-	str scon;
-	str squery;
-	str sres;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS))
-	{
-		LM_WARN("weird: sqlops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	scon.s = (char*)lua_tostring(L, -3);
-	squery.s = (char*)lua_tostring(L, -2);
-	sres.s = (char*)lua_tostring(L, -1);
-	if(scon.s == NULL || squery.s == NULL || sres.s == NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	scon.len = strlen(scon.s);
-	squery.len = strlen(squery.s);
-	sres.len = strlen(sres.s);
-
-	ret = _lua_sqlopsb.xquery(env_L->msg, &scon, &squery, &sres);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_sqlops_Map [] = {
-	{"query",   lua_sr_sqlops_query},
-	{"value",   lua_sr_sqlops_value},
-	{"is_null", lua_sr_sqlops_is_null},
-	{"column",  lua_sr_sqlops_column},
-	{"nrows",   lua_sr_sqlops_nrows},
-	{"ncols",   lua_sr_sqlops_ncols},
-	{"reset",   lua_sr_sqlops_reset},
-	{"xquery",  lua_sr_sqlops_xquery},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_rr_record_route(lua_State *L)
-{
-	int ret;
-	str sv = {0, 0};
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RR))
-	{
-		LM_WARN("weird: rr function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==1)
-	{
-		sv.s = (char*)lua_tostring(L, -1);
-		if(sv.s!=NULL)
-			sv.len = strlen(sv.s);
-	}
-	ret = _lua_rrb.record_route(env_L->msg, (sv.len>0)?&sv:NULL);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_rr_loose_route(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RR))
-	{
-		LM_WARN("weird: rr function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_rrb.loose_route(env_L->msg);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_rr_add_rr_param(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-	str param;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RR))
-	{
-		LM_WARN("weird: rr function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters\n");
-		return app_lua_return_error(L);
-	}
-
-	param.s = (char*)lua_tostring(L, -1);
-	if(param.s!=NULL)
-		param.len = strlen(param.s);
-
-	ret = _lua_rrb.add_rr_param(env_L->msg, &param);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_rr_Map [] = {
-	{"record_route",    lua_sr_rr_record_route},
-	{"loose_route",     lua_sr_rr_loose_route},
-	{"add_rr_param",    lua_sr_rr_add_rr_param},
-	{NULL, NULL}
-};
-
-
-static int lua_sr_auth_challenge_hftype(lua_State *L, int hftype)
-{
-	int ret;
-	str realm = {0, 0};
-	int flags;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH))
-	{
-		LM_WARN("weird: auth function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=2)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.s = (char*)lua_tostring(L, -2);
-	flags   = lua_tointeger(L, -1);
-	if(flags<0 || realm.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.len = strlen(realm.s);
-	ret = _lua_authb.auth_challenge_hftype(env_L->msg, &realm, flags, hftype);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_auth_www_challenge(lua_State *L)
-{
-	return lua_sr_auth_challenge_hftype(L, HDR_AUTHORIZATION_T);
-}
-
-/**
- *
- */
-static int lua_sr_auth_proxy_challenge(lua_State *L)
-{
-	return lua_sr_auth_challenge_hftype(L, HDR_PROXYAUTH_T);
-}
-
-/**
- *
- */
-static int lua_sr_auth_pv_authenticate(lua_State *L, int hftype)
-{
-	int ret;
-	str realm  = {0, 0};
-	str passwd = {0, 0};
-	int flags;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH))
-	{
-		LM_WARN("weird: auth function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=3)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.s  = (char*)lua_tostring(L, -3);
-	passwd.s = (char*)lua_tostring(L, -2);
-	flags    = lua_tointeger(L, -1);
-	if(flags<0 || realm.s==NULL || passwd.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.len = strlen(realm.s);
-	passwd.len = strlen(passwd.s);
-	ret = _lua_authb.pv_authenticate(env_L->msg, &realm, &passwd, flags,
-			hftype, &env_L->msg->first_line.u.request.method);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_auth_pv_www_authenticate(lua_State *L)
-{
-	return lua_sr_auth_pv_authenticate(L, HDR_AUTHORIZATION_T);
-}
-
-/**
- *
- */
-static int lua_sr_auth_pv_proxy_authenticate(lua_State *L)
-{
-	return lua_sr_auth_pv_authenticate(L, HDR_PROXYAUTH_T);
-}
-
-/**
- *
- */
-static int lua_sr_auth_consume_credentials(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH))
-	{
-		LM_WARN("weird: auth function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_authb.consume_credentials(env_L->msg);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_auth_Map [] = {
-	{"www_challenge",            lua_sr_auth_www_challenge},
-	{"proxy_challenge",          lua_sr_auth_proxy_challenge},
-	{"pv_www_authenticate",      lua_sr_auth_pv_www_authenticate},
-	{"pv_proxy_authenticate",    lua_sr_auth_pv_proxy_authenticate},
-	{"consume_credentials",      lua_sr_auth_consume_credentials},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_auth_db_authenticate(lua_State *L, hdr_types_t hftype)
-{
-	int ret;
-	str realm = {0, 0};
-	str table = {0, 0};
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH_DB))
-	{
-		LM_WARN("weird: auth function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=2)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.s  = (char*)lua_tostring(L, -2);
-	table.s  = (char*)lua_tostring(L, -1);
-	if(realm.s==NULL || table.s==NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	realm.len = strlen(realm.s);
-	table.len = strlen(table.s);
-	ret = _lua_auth_dbb.digest_authenticate(env_L->msg, &realm, &table,
-			hftype, &env_L->msg->first_line.u.request.method);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_auth_db_www_authenticate(lua_State *L)
-{
-	return lua_sr_auth_db_authenticate(L, HDR_AUTHORIZATION_T);
-}
-
-/**
- *
- */
-static int lua_sr_auth_db_proxy_authenticate(lua_State *L)
-{
-	return lua_sr_auth_db_authenticate(L, HDR_PROXYAUTH_T);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_auth_db_Map [] = {
-	{"www_authenticate",      lua_sr_auth_db_www_authenticate},
-	{"proxy_authenticate",    lua_sr_auth_db_proxy_authenticate},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_maxfwd_process_maxfwd(lua_State *L)
-{
-	int ret;
-	int limit;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MAXFWD))
-	{
-		LM_WARN("weird: maxfwd function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	limit = lua_tointeger(L, -1);
-	if(limit<0)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_maxfwdb.process_maxfwd(env_L->msg, limit);
-
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_maxfwd_Map [] = {
-	{"process_maxfwd",      lua_sr_maxfwd_process_maxfwd},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_registrar_save(lua_State *L)
-{
-	int ret;
-	int flags;
-	str table = STR_NULL;
-	str uri = STR_NULL;
-	sr_lua_env_t *env_L;
-
-	flags = 0;
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR))
-	{
-		LM_WARN("weird: registrar function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==1)
-	{
-		table.s  = (char*)lua_tostring(L, -1);
-	} else if(lua_gettop(L)==2) {
-		table.s  = (char*)lua_tostring(L, -2);
-		flags = lua_tointeger(L, -1);
-	} else if(lua_gettop(L)==3) {
-		table.s  = (char*)lua_tostring(L, -3);
-		flags = lua_tointeger(L, -2);
-		uri.s = (char*)lua_tostring(L, -1);
-		uri.len = strlen(uri.s);
-	} else {
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if(table.s==NULL || (table.len=strlen(table.s))==0)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if (lua_gettop(L)==3) {
-		ret = _lua_registrarb.save_uri(env_L->msg, &table, flags, &uri);
-	} else {
-		ret = _lua_registrarb.save(env_L->msg, &table, flags);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_registrar_lookup(lua_State *L)
-{
-	int ret;
-	str table = STR_NULL;
-	str uri = STR_NULL;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR))
-	{
-		LM_WARN("weird: registrar function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==1)
-	{
-		table.s = (char*)lua_tostring(L, -1);
-	}
-	else if (lua_gettop(L)==2)
-	{
-		table.s = (char*)lua_tostring(L, -2);
-		uri.s = (char*)lua_tostring(L, -1);
-		uri.len = strlen(uri.s);
-	} else
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if(table.s==NULL || (table.len=strlen(table.s))==0)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==2)
-	{
-		ret = _lua_registrarb.lookup_uri(env_L->msg, &table, &uri);
-	} else {
-		ret = _lua_registrarb.lookup(env_L->msg, &table);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_registrar_lookup_to_dset(lua_State *L)
-{
-	int ret;
-	str table = STR_NULL;
-	str uri = STR_NULL;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR))
-	{
-		LM_WARN("weird: registrar function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==1)
-	{
-		table.s = (char*)lua_tostring(L, -1);
-	}
-	else if (lua_gettop(L)==2)
-	{
-		table.s = (char*)lua_tostring(L, -2);
-		uri.s = (char*)lua_tostring(L, -1);
-		uri.len = strlen(uri.s);
-	} else
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if(table.s==NULL || (table.len=strlen(table.s))==0)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==2)
-	{
-		ret = _lua_registrarb.lookup_to_dset(env_L->msg, &table, &uri);
-	} else {
-		ret = _lua_registrarb.lookup_to_dset(env_L->msg, &table, NULL);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_registrar_registered(lua_State *L)
-{
-	int ret;
-	str table;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR))
-	{
-		LM_WARN("weird: registrar function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	table.s = (char*)lua_tostring(L, -1);
-	if(table.s==NULL || (table.len=strlen(table.s))==0)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_registrarb.registered(env_L->msg, &table);
-
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_registrar_Map [] = {
-	{"save",      lua_sr_registrar_save},
-	{"lookup",    lua_sr_registrar_lookup},
-	{"lookup_to_dset",lua_sr_registrar_lookup_to_dset},
-	{"registered",lua_sr_registrar_registered},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_dispatcher_select(lua_State *L)
-{
-	int ret;
-	int setid;
-	int algid;
-	int mode;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER))
-	{
-		LM_WARN("weird: dispatcher function executed but module"
-				" not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)==3)
-	{
-		setid = lua_tointeger(L, -3);
-		algid = lua_tointeger(L, -2);
-		mode  = lua_tointeger(L, -1);
-	} else if(lua_gettop(L)==2) {
-		setid = lua_tointeger(L, -2);
-		algid = lua_tointeger(L, -1);
-		mode  = 0;
-	} else {
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	ret = _lua_dispatcherb.select(env_L->msg, setid, algid, mode);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_dispatcher_next(lua_State *L)
-{
-	int ret;
-	int mode;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER))
-	{
-		LM_WARN("weird: dispatcher function executed but module"
-				" not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	mode = 0;
-	if(lua_gettop(L)==1)
-	{
-		/* mode given as parameter */
-		mode  = lua_tointeger(L, -1);
-	}
-	ret = _lua_dispatcherb.next(env_L->msg, mode);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_dispatcher_mark(lua_State *L)
-{
-	int ret;
-	int mode;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER))
-	{
-		LM_WARN("weird: dispatcher function executed but module"
-				" not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	mode = 0;
-	if(lua_gettop(L)==1)
-	{
-		/* mode given as parameter */
-		mode  = lua_tointeger(L, -1);
-	}
-	ret = _lua_dispatcherb.mark(env_L->msg, mode);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_dispatcher_is_from(lua_State *L)
-{
-	int ret;
-	int mode;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER))
-	{
-		LM_WARN("weird: dispatcher function executed but module"
-				" not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	mode = -1;
-	if(lua_gettop(L)==1)
-	{
-		/* mode given as parameter */
-		mode  = lua_tointeger(L, -1);
-	}
-	ret = _lua_dispatcherb.is_from(env_L->msg, mode);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_dispatcher_Map [] = {
-	{"select",      lua_sr_dispatcher_select},
-	{"next",        lua_sr_dispatcher_next},
-	{"mark",        lua_sr_dispatcher_mark},
-	{"is_from",     lua_sr_dispatcher_is_from},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_xhttp_reply(lua_State *L)
-{
-	int rcode;
-	str reason;
-	str ctype;
-	str mbody;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_XHTTP))
-	{
-		LM_WARN("weird: xhttp function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	rcode = lua_tointeger(L, -4);
-	reason.s = (char*)lua_tostring(L, -3);
-	ctype.s = (char*)lua_tostring(L, -2);
-	mbody.s = (char*)lua_tostring(L, -1);
-	if(reason.s == NULL || ctype.s == NULL || mbody.s == NULL)
-	{
-		LM_WARN("invalid parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	reason.len = strlen(reason.s);
-	ctype.len = strlen(ctype.s);
-	mbody.len = strlen(mbody.s);
-
-	ret = _lua_xhttpb.reply(env_L->msg, rcode, &reason, &ctype, &mbody);
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_xhttp_Map [] = {
-	{"reply",       lua_sr_xhttp_reply},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_sdpops_with_media(lua_State *L)
-{
-	int ret;
-	str media;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	media.s = (char*)lua_tostring(L, -1);
-	media.len = strlen(media.s);
-
-	ret = _lua_sdpopsb.sdp_with_media(env_L->msg, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_with_active_media(lua_State *L)
-{
-	int ret;
-	str media;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	media.s = (char*)lua_tostring(L, -1);
-	media.len = strlen(media.s);
-
-	ret = _lua_sdpopsb.sdp_with_active_media(env_L->msg, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_with_transport(lua_State *L)
-{
-	int ret;
-	str transport;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	transport.s = (char*)lua_tostring(L, -1);
-	transport.len = strlen(transport.s);
-
-	ret = _lua_sdpopsb.sdp_with_transport(env_L->msg, &transport, 0);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_with_codecs_by_id(lua_State *L)
-{
-	int ret;
-	str codecs;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -1);
-	codecs.len = strlen(codecs.s);
-
-	ret = _lua_sdpopsb.sdp_with_codecs_by_id(env_L->msg, &codecs);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_with_codecs_by_name(lua_State *L)
-{
-	int ret;
-	str codecs;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -1);
-	codecs.len = strlen(codecs.s);
-
-	ret = _lua_sdpopsb.sdp_with_codecs_by_name(env_L->msg, &codecs);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_with_ice(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=0)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_sdpopsb.sdp_with_ice(env_L->msg);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_keep_codecs_by_id(lua_State *L)
-{
-	int ret;
-	str codecs;
-	str media;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=2)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -2);
-	codecs.len = strlen(codecs.s);
-
-	media.s = (char*)lua_tostring(L, -1);
-	media.len = strlen(media.s);
-
-	ret = _lua_sdpopsb.sdp_keep_codecs_by_id(env_L->msg, &codecs, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_keep_codecs_by_name(lua_State *L)
-{
-	int ret;
-	str media;
-	str codecs;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=2)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -2);
-	codecs.len = strlen(codecs.s);
-
-	media.s = (char*)lua_tostring(L, -1);
-	media.len = strlen(media.s);
-
-	ret = _lua_sdpopsb.sdp_keep_codecs_by_name(env_L->msg, &codecs, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_remove_media(lua_State *L)
-{
-	int ret;
-	str media;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	media.s = (char*)lua_tostring(L, -1);
-	media.len = strlen(media.s);
-
-	ret = _lua_sdpopsb.sdp_remove_media(env_L->msg, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_remove_transport(lua_State *L)
-{
-	int ret;
-	str transport;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	transport.s = (char*)lua_tostring(L, -1);
-	transport.len = strlen(transport.s);
-
-	ret = _lua_sdpopsb.sdp_remove_transport(env_L->msg, &transport);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_remove_line_by_prefix(lua_State *L)
-{
-	int ret;
-	str prefix = STR_NULL;
-	str media = STR_NULL;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)==1)
-	{
-		prefix.s = (char *) lua_tostring(L, -1);
-		prefix.len = strlen(prefix.s);
-	} else if(lua_gettop(L)==2)
-	{
-		prefix.s = (char *) lua_tostring(L, -2);
-		prefix.len = strlen(prefix.s);
-		media.s = (char *) lua_tostring(L, -1);
-		media.len = strlen(media.s);
-	} else {
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_sdpopsb.sdp_remove_line_by_prefix(env_L->msg, &prefix, &media);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_remove_codecs_by_id(lua_State *L)
-{
-	int ret;
-	str codecs;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -1);
-	codecs.len = strlen(codecs.s);
-
-	ret = _lua_sdpopsb.sdp_remove_codecs_by_id(env_L->msg, &codecs, NULL);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_sdpops_remove_codecs_by_name(lua_State *L)
-{
-	int ret;
-	str codecs;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS))
-	{
-		LM_WARN("weird: sdpops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	codecs.s = (char*)lua_tostring(L, -1);
-	codecs.len = strlen(codecs.s);
-
-	ret = _lua_sdpopsb.sdp_remove_codecs_by_name(env_L->msg, &codecs, NULL);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_sdpops_Map [] = {
-	{"sdp_with_media",            lua_sr_sdpops_with_media},
-	{"sdp_with_active_media",     lua_sr_sdpops_with_active_media},
-	{"sdp_with_transport",        lua_sr_sdpops_with_transport},
-	{"sdp_with_codecs_by_id",     lua_sr_sdpops_with_codecs_by_id},
-	{"sdp_with_codecs_by_name",   lua_sr_sdpops_with_codecs_by_name},
-	{"sdp_with_ice",              lua_sr_sdpops_with_ice},
-	{"sdp_keep_codecs_by_id",     lua_sr_sdpops_keep_codecs_by_id},
-	{"sdp_keep_codecs_by_name",   lua_sr_sdpops_keep_codecs_by_name},
-	{"sdp_remove_media",          lua_sr_sdpops_remove_media},
-	{"sdp_remove_transport",      lua_sr_sdpops_remove_transport},
-	{"sdp_remove_line_by_prefix", lua_sr_sdpops_remove_line_by_prefix},
-	{"sdp_remove_codecs_by_id",   lua_sr_sdpops_remove_codecs_by_id},
-	{"sdp_remove_codecs_by_name", lua_sr_sdpops_remove_codecs_by_name},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_pres_auth_status(lua_State *L)
-{
-	str param[2];
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE))
-	{
-		LM_WARN("weird: presence function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=2)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -2);
-	param[0].len = strlen(param[0].s);
-	param[1].s = (char *) lua_tostring(L, -1);
-	param[1].len = strlen(param[1].s);
-
-	ret = _lua_presenceb.pres_auth_status(env_L->msg, param[0], param[1]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_pres_handle_publish(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE))
-	{
-		LM_WARN("weird: presence function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=0)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_presenceb.handle_publish(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_pres_handle_subscribe(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE))
-	{
-		LM_WARN("weird: presence function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)==0)
-		ret = _lua_presenceb.handle_subscribe0(env_L->msg);
-	else if (lua_gettop(L)==1)
-	{
-		str wuri;
-		struct sip_uri parsed_wuri;
-
-		wuri.s = (char *) lua_tostring(L, -1);
-		wuri.len = strlen(wuri.s);
-		if (parse_uri(wuri.s, wuri.len, &parsed_wuri))
-		{
-			LM_ERR("failed to parse watcher URI\n");
-			return app_lua_return_error(L);
-		}
-		ret = _lua_presenceb.handle_subscribe(env_L->msg, parsed_wuri.user, parsed_wuri.host);
-	}
-	else
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_presence_Map [] = {
-	{"pres_auth_status",       lua_sr_pres_auth_status},
-	{"handle_publish",         lua_sr_pres_handle_publish},
-	{"handle_subscribe",       lua_sr_pres_handle_subscribe},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_pres_check_basic(lua_State *L)
-{
-	str param[2];
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE_XML))
-	{
-		LM_WARN("weird: presence_xml function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=2)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -2);
-	param[0].len = strlen(param[0].s);
-	param[1].s = (char *) lua_tostring(L, -1);
-	param[1].len = strlen(param[1].s);
-
-	ret = _lua_presence_xmlb.pres_check_basic(env_L->msg, param[0], param[1]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_pres_check_activities(lua_State *L)
-{
-	str param[2];
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE_XML))
-	{
-		LM_WARN("weird: presence_xml function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=2)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -2);
-	param[0].len = strlen(param[0].s);
-	param[1].s = (char *) lua_tostring(L, -1);
-	param[1].len = strlen(param[1].s);
-
-	ret = _lua_presence_xmlb.pres_check_activities(env_L->msg, param[0], param[1]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_presence_xml_Map [] = {
-	{"pres_check_basic",       lua_sr_pres_check_basic},
-	{"pres_check_activities",  lua_sr_pres_check_activities},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_textops_is_privacy(lua_State *L)
-{
-	str param[1];
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TEXTOPS))
-	{
-		LM_WARN("weird: textops function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -1);
-	param[0].len = strlen(param[0].s);
-
-	ret = _lua_textopsb.is_privacy(env_L->msg, &param[0]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_textops_Map [] = {
-	{"is_privacy",       lua_sr_textops_is_privacy},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_pua_usrloc_set_publish(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PUA_USRLOC))
-	{
-		LM_WARN("weird: pua_usrloc function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=0)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_pua_usrlocb.pua_set_publish(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_pua_usrloc_Map [] = {
-	{"set_publish",            lua_sr_pua_usrloc_set_publish},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_siputils_has_totag(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SIPUTILS))
-	{
-		LM_WARN("weird: siputils function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=0)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_siputilsb.has_totag(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_siputils_is_uri_user_e164(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-	str param[1];
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SIPUTILS))
-	{
-		LM_WARN("weird: siputils function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -1);
-	param[0].len = strlen(param[0].s);
-
-	ret = _lua_siputilsb.is_uri_user_e164(&param[0]);
-	if (ret < 0)
-		return app_lua_return_false(L);
-
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_siputils_Map [] = {
-	{"has_totag",            lua_sr_siputils_has_totag},
-	{"is_uri_user_e164",     lua_sr_siputils_is_uri_user_e164},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_rls_handle_subscribe(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RLS))
-	{
-		LM_WARN("weird: rls function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)==0)
-		ret = _lua_rlsb.rls_handle_subscribe0(env_L->msg);
-	else if (lua_gettop(L)==1)
-	{
-		str wuri;
-		struct sip_uri parsed_wuri;
-
-		wuri.s = (char *) lua_tostring(L, -1);
-		wuri.len = strlen(wuri.s);
-		if (parse_uri(wuri.s, wuri.len, &parsed_wuri))
-		{
-			LM_ERR("failed to parse watcher URI\n");
-			return app_lua_return_error(L);
-		}
-		ret = _lua_rlsb.rls_handle_subscribe(env_L->msg, parsed_wuri.user, parsed_wuri.host);
-	}
-	else
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_rls_handle_notify(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RLS))
-	{
-		LM_WARN("weird: rls function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=0)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_rlsb.rls_handle_notify(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_rls_Map [] = {
-	{"handle_subscribe",       lua_sr_rls_handle_subscribe},
-	{"handle_notify",          lua_sr_rls_handle_notify},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_alias_db_lookup(lua_State *L)
-{
-	int ret;
-	str param[1];
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_ALIAS_DB))
-	{
-		LM_WARN("weird: alias_db function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if(lua_gettop(L)!=1)
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -1);
-	param[0].len = strlen(param[0].s);
-
-	ret = _lua_alias_dbb.alias_db_lookup(env_L->msg, param[0]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_alias_db_Map [] = {
-	{"lookup",       lua_sr_alias_db_lookup},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_msilo_store(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if (!(_sr_lua_exp_reg_mods & SR_LUA_EXP_MOD_MSILO))
-	{
-		LM_WARN("weird: msilo function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if (env_L->msg == NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if (lua_gettop(L) == 0)
-	{
-		ret = _lua_msilob.m_store(env_L->msg, NULL);
-	}
-	else if (lua_gettop(L) == 1)
-	{
-		str owner;
-		owner.s = (char*)lua_tostring(L, -1);
-		if (owner.s == NULL)
-		{
-			return app_lua_return_error(L);
-		}
-		owner.len = strlen(owner.s);
-		ret = _lua_msilob.m_store(env_L->msg, &owner);
-	}
-	else
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_msilo_dump(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if (!(_sr_lua_exp_reg_mods & SR_LUA_EXP_MOD_MSILO))
-	{
-		LM_WARN("weird: msilo function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if (env_L->msg == NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if (lua_gettop(L) == 0)
-	{
-		ret = _lua_msilob.m_dump(env_L->msg, NULL);
-	}
-	else if (lua_gettop(L) == 1)
-	{
-		str owner;
-		owner.s = (char*)lua_tostring(L, -1);
-		if (owner.s == NULL)
-		{
-			return app_lua_return_error(L);
-		}
-		owner.len = strlen(owner.s);
-		ret = _lua_msilob.m_dump(env_L->msg, &owner);
-	}
-	else
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_msilo_Map [] = {
-	{"store",       lua_sr_msilo_store},
-	{"dump",        lua_sr_msilo_dump},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_uac_replace_x(lua_State *L, int htype)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-	str param[2];
-
-	env_L = sr_lua_env_get();
-
-	if (!(_sr_lua_exp_reg_mods & SR_LUA_EXP_MOD_UAC))
-	{
-		LM_WARN("weird:uac function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if (env_L->msg == NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	if (lua_gettop(L) == 1)
-	{
-		param[0].s = "";
-		param[0].len = 0;
-		param[1].s = (char *) lua_tostring(L, -1);
-		param[1].len = strlen(param[1].s);
-
-	}
-	else if (lua_gettop(L) == 2)
-	{
-		param[0].s = (char *) lua_tostring(L, -2);
-		param[0].len = strlen(param[0].s);
-		param[1].s = (char *) lua_tostring(L, -1);
-		param[1].len = strlen(param[1].s);
-	}
-	else
-	{
-		LM_ERR("incorrect number of arguments\n");
-		return app_lua_return_error(L);
-	}
-
-	if(htype==1) {
-		ret = _lua_uacb.replace_to(env_L->msg, &param[0], &param[1]);
-	} else {
-		ret = _lua_uacb.replace_from(env_L->msg, &param[0], &param[1]);
-	}
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_uac_replace_from(lua_State *L)
-{
-	return lua_sr_uac_replace_x(L, 0);
-}
-
-/**
- *
- */
-static int lua_sr_uac_replace_to(lua_State *L)
-{
-	return lua_sr_uac_replace_x(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_uac_req_send(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if (!(_sr_lua_exp_reg_mods & SR_LUA_EXP_MOD_UAC))
-	{
-		LM_WARN("weird:uac function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if (env_L->msg == NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_uacb.req_send();
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_uac_Map [] = {
-	{"replace_from",lua_sr_uac_replace_from},
-	{"replace_to",lua_sr_uac_replace_to},
-	{"uac_req_send",lua_sr_uac_req_send},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_sanity_check(lua_State *L)
-{
-	int msg_checks, uri_checks;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SANITY))
-	{
-		LM_WARN("weird: sanity function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-	msg_checks = lua_tointeger(L, -1);
-	uri_checks = lua_tointeger(L, -2);
-
-	ret = _lua_sanityb.check(env_L->msg, msg_checks, uri_checks);
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_sanity_Map [] = {
-	{"sanity_check",       lua_sr_sanity_check},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_cfgutils_lock(lua_State *L)
-{
-	int ret;
-	str lkey;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_CFGUTILS))
-	{
-		LM_WARN("weird: cfgutils function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	lkey.s = (char*)lua_tostring(L, -1);
-	lkey.len = strlen(lkey.s);
-	ret = _lua_cfgutilsb.mlock(&lkey);
-
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static int lua_sr_cfgutils_unlock(lua_State *L)
-{
-	int ret;
-	str lkey;
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_CFGUTILS))
-	{
-		LM_WARN("weird: cfgutils function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-	lkey.s = (char*)lua_tostring(L, -1);
-	lkey.len = strlen(lkey.s);
-	ret = _lua_cfgutilsb.munlock(&lkey);
-
-	return app_lua_return_int(L, ret);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_cfgutils_Map [] = {
-	{"lock",      lua_sr_cfgutils_lock},
-	{"unlock",    lua_sr_cfgutils_unlock},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_tmx_t_suspend(lua_State *L)
-{
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TMX))
-	{
-		LM_WARN("weird: tmx function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_error(L);
-	}
-
-	ret = _lua_tmxb.t_suspend(env_L->msg, NULL, NULL);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_tmx_Map [] = {
-	{"t_suspend", lua_sr_tmx_t_suspend},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_mq_add(lua_State *L)
-{
-	int ret;
-	str param[3];
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MQUEUE))
-	{
-		LM_WARN("weird: mqueue function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=3)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -3);
-	param[0].len = strlen(param[0].s);
-	param[1].s = (char *) lua_tostring(L, -2);
-	param[1].len = strlen(param[1].s);
-	param[2].s = (char *) lua_tostring(L, -1);
-	param[2].len = strlen(param[2].s);
-
-	ret = _lua_mqb.add(&param[0], &param[1], &param[2]);
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_mqueue_Map [] = {
-	{"add", lua_sr_mq_add},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_cmd_x(lua_State *L, int ctype)
-{
-	int ret = 0;
-	str param[6];
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_NDB_MONGODB))
-	{
-		LM_WARN("weird: ndb_mongodb function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=5)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -5);
-	param[0].len = strlen(param[0].s);
-	param[1].s = (char *) lua_tostring(L, -4);
-	param[1].len = strlen(param[1].s);
-	param[2].s = (char *) lua_tostring(L, -3);
-	param[2].len = strlen(param[2].s);
-	param[3].s = (char *) lua_tostring(L, -2);
-	param[3].len = strlen(param[3].s);
-	param[4].s = (char *) lua_tostring(L, -1);
-	param[4].len = strlen(param[4].s);
-
-	if(ctype==1) {
-		ret = _lua_ndb_mongodbb.cmd_simple(&param[0], &param[1], &param[2], &param[3], &param[4]);
-	} else if(ctype==2) {
-		ret = _lua_ndb_mongodbb.find(&param[0], &param[1], &param[2], &param[3], &param[4]);
-	} else if(ctype==3) {
-		ret = _lua_ndb_mongodbb.find_one(&param[0], &param[1], &param[2], &param[3], &param[4]);
-	} else {
-		ret = _lua_ndb_mongodbb.cmd(&param[0], &param[1], &param[2], &param[3], &param[4]);
-	}
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_cmd(lua_State *L)
-{
-	return lua_sr_ndb_mongodb_cmd_x(L, 0);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_cmd_simple(lua_State *L)
-{
-	return lua_sr_ndb_mongodb_cmd_x(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_find(lua_State *L)
-{
-	return lua_sr_ndb_mongodb_cmd_x(L, 2);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_find_one(lua_State *L)
-{
-	return lua_sr_ndb_mongodb_cmd_x(L, 3);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_next_reply(lua_State *L)
-{
-	int ret = 0;
-	str param[1];
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_NDB_MONGODB))
-	{
-		LM_WARN("weird: ndb_mongodb function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -1);
-	param[0].len = strlen(param[0].s);
-
-	ret = _lua_ndb_mongodbb.next_reply(&param[0]);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static int lua_sr_ndb_mongodb_free_reply(lua_State *L)
-{
-	int ret = 0;
-	str param[1];
-
-	if(!(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_NDB_MONGODB))
-	{
-		LM_WARN("weird: ndb_mongodb function executed but module not registered\n");
-		return app_lua_return_error(L);
-	}
-	if(lua_gettop(L)!=1)
-	{
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_error(L);
-	}
-
-	param[0].s = (char *) lua_tostring(L, -1);
-	param[0].len = strlen(param[0].s);
-
-	ret = _lua_ndb_mongodbb.free_reply(&param[0]);
-
-	return app_lua_return_int(L, ret);
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_ndb_mongodb_Map [] = {
-	{"cmd", lua_sr_ndb_mongodb_cmd},
-	{"cmd_simple", lua_sr_ndb_mongodb_cmd_simple},
-	{"find", lua_sr_ndb_mongodb_find},
-	{"find_one", lua_sr_ndb_mongodb_find_one},
-	{"next_reply", lua_sr_ndb_mongodb_next_reply},
-	{"free_reply", lua_sr_ndb_mongodb_free_reply},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-int lua_sr_exp_init_mod(void)
-{
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SL)
-	{
-		/* bind the SL API */
-		if (sl_load_api(&_lua_slb) < 0) {
-			LM_ERR("cannot bind to SL API\n");
-			return -1;
-		}
-		LM_DBG("loaded sl api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM)
-	{
-		/* bind the TM API */
-		if (tm_load_api(&_lua_tmb) < 0)
-		{
-			LM_ERR("cannot bind to TM API\n");
-			return -1;
-		}
-		LM_DBG("loaded tm api\n");
-		/* bind the TM XAPI */
-		if (tm_load_xapi(&_lua_xtmb) < 0)
-		{
-			LM_ERR("cannot bind to TM XAPI\n");
-			return -1;
-		}
-		LM_DBG("loaded tm xapi\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS)
-	{
-		/* bind the SQLOPS API */
-		if (sqlops_load_api(&_lua_sqlopsb) < 0)
-		{
-			LM_ERR("cannot bind to SQLOPS API\n");
-			return -1;
-		}
-		LM_DBG("loaded sqlops api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RR)
-	{
-		/* bind the RR API */
-		if (rr_load_api(&_lua_rrb) < 0)
-		{
-			LM_ERR("cannot bind to RR API\n");
-			return -1;
-		}
-		LM_DBG("loaded rr api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH)
-	{
-		/* bind the AUTH API */
-		if (auth_load_api(&_lua_authb) < 0)
-		{
-			LM_ERR("cannot bind to AUTH API\n");
-			return -1;
-		}
-		LM_DBG("loaded auth api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH_DB)
-	{
-		/* bind the AUTH_DB API */
-		if (auth_db_load_api(&_lua_auth_dbb) < 0)
-		{
-			LM_ERR("cannot bind to AUTH_DB API\n");
-			return -1;
-		}
-		LM_DBG("loaded auth_db api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MAXFWD)
-	{
-		/* bind the MAXFWD API */
-		if (maxfwd_load_api(&_lua_maxfwdb) < 0)
-		{
-			LM_ERR("cannot bind to MAXFWD API\n");
-			return -1;
-		}
-		LM_DBG("loaded maxfwd api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR)
-	{
-		/* bind the REGISTRAR API */
-		if (registrar_load_api(&_lua_registrarb) < 0)
-		{
-			LM_ERR("cannot bind to REGISTRAR API\n");
-			return -1;
-		}
-		LM_DBG("loaded registrar api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER)
-	{
-		/* bind the DISPATCHER API */
-		if (dispatcher_load_api(&_lua_dispatcherb) < 0)
-		{
-			LM_ERR("cannot bind to DISPATCHER API\n");
-			return -1;
-		}
-		LM_DBG("loaded dispatcher api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_XHTTP)
-	{
-		/* bind the XHTTP API */
-		if (xhttp_load_api(&_lua_xhttpb) < 0)
-		{
-			LM_ERR("cannot bind to XHTTP API\n");
-			return -1;
-		}
-		LM_DBG("loaded xhttp api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS)
-	{
-		/* bind the SDPOPS API */
-		if (sdpops_load_api(&_lua_sdpopsb) < 0)
-		{
-			LM_ERR("cannot bind to SDPOPS API\n");
-			return -1;
-		}
-		LM_DBG("loaded sdpops api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE)
-	{
-		/* bind the PRESENCE API */
-		if (presence_load_api(&_lua_presenceb) < 0)
-		{
-			LM_ERR("cannot bind to PRESENCE API\n");
-			return -1;
-		}
-		LM_DBG("loaded presence api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE)
-	{
-		/* bind the PRESENCE_XML API */
-		if (presence_xml_load_api(&_lua_presence_xmlb) < 0)
-		{
-			LM_ERR("cannot bind to PRESENCE_XML API\n");
-			return -1;
-		}
-		LM_DBG("loaded presence_xml api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TEXTOPS)
-	{
-		/* bind the TEXTOPS API */
-		if (load_textops_api(&_lua_textopsb) < 0)
-		{
-			LM_ERR("cannot bind to TEXTOPS API\n");
-			return -1;
-		}
-		LM_DBG("loaded textops api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PUA_USRLOC)
-	{
-		/* bind the PUA_USRLOC API */
-		if (pua_usrloc_load_api(&_lua_pua_usrlocb) < 0)
-		{
-			LM_ERR("cannot bind to PUA_USRLOC API\n");
-			return -1;
-		}
-		LM_DBG("loaded pua_usrloc api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SIPUTILS)
-	{
-		/* bind the SIPUTILS API */
-		if (siputils_load_api(&_lua_siputilsb) < 0)
-		{
-			LM_ERR("cannot bind to SIPUTILS API\n");
-			return -1;
-		}
-		LM_DBG("loaded siputils api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RLS)
-	{
-		/* bind the RLS API */
-		if (rls_load_api(&_lua_rlsb) < 0)
-		{
-			LM_ERR("cannot bind to RLS API\n");
-			return -1;
-		}
-		LM_DBG("loaded rls api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_ALIAS_DB)
-	{
-		/* bind the ALIAS_DB API */
-		if (alias_db_load_api(&_lua_alias_dbb) < 0)
-		{
-			LM_ERR("cannot bind to ALIAS_DB API\n");
-			return -1;
-		}
-		LM_DBG("loaded alias_db api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MSILO)
-	{
-		/* bind the MSILO API */
-		if (load_msilo_api(&_lua_msilob) < 0)
-		{
-			LM_ERR("cannot bind to MSILO API\n");
-			return -1;
-		}
-		LM_DBG("loaded msilo api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_UAC)
-	{
-		/* bind the UAC API */
-		if (load_uac_api(&_lua_uacb) < 0)
-		{
-			LM_ERR("cannot bind to UAC API\n");
-			return -1;
-		}
-		LM_DBG("loaded uac api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SANITY)
-	{
-		/* bind the SANITY API */
-		if (sanity_load_api(&_lua_sanityb) < 0)
-		{
-			LM_ERR("cannot bind to SANITY API\n");
-			return -1;
-		}
-		LM_DBG("loaded sanity api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_CFGUTILS)
-	{
-		/* bind the CFGUTILS API */
-		if (cfgutils_load_api(&_lua_cfgutilsb) < 0)
-		{
-			LM_ERR("cannot bind to CFGUTILS API\n");
-			return -1;
-		}
-		LM_DBG("loaded cfgutils api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TMX)
-	{
-		/* bind the TMX API */
-		if (load_tmx_api(&_lua_tmxb) < 0)
-		{
-			LM_ERR("cannot bind to TMX API\n");
-			return -1;
-		}
-		LM_DBG("loaded tmx api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MQUEUE)
-	{
-		/* bind the MQUEUE API */
-		if (load_mq_api(&_lua_mqb) < 0)
-		{
-			LM_ERR("cannot bind to MQUEUE API\n");
-			return -1;
-		}
-		LM_DBG("loaded mqueue api\n");
-	}
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_NDB_MONGODB)
-	{
-		/* bind the NDB_MONGODB API */
-		if (ndb_mongodb_load_api(&_lua_ndb_mongodbb) < 0)
-		{
-			LM_ERR("cannot bind to NDB_MONGODB API\n");
-			return -1;
-		}
-		LM_DBG("loaded ndb_mongodb api\n");
-	}
-
-	return 0;
-}
-
-/**
- *
- */
-int lua_sr_exp_register_mod(char *mname)
-{
-	int len;
-
-	len = strlen(mname);
-
-	if(len==2 && strcmp(mname, "sl")==0)
-	{
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_SL;
-		return 0;
-	} else 	if(len==2 && strcmp(mname, "tm")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_TM;
-		return 0;
-	} else 	if(len==6 && strcmp(mname, "sqlops")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_SQLOPS;
-		return 0;
-	} else 	if(len==2 && strcmp(mname, "rr")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_RR;
-		return 0;
-	} else 	if(len==4 && strcmp(mname, "auth")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_AUTH;
-		return 0;
-	} else 	if(len==7 && strcmp(mname, "auth_db")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_AUTH_DB;
-		return 0;
-	} else 	if(len==6 && strcmp(mname, "maxfwd")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_MAXFWD;
-		return 0;
-	} else 	if(len==9 && strcmp(mname, "registrar")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_REGISTRAR;
-		return 0;
-	} else 	if(len==10 && strcmp(mname, "dispatcher")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_DISPATCHER;
-		return 0;
-	} else 	if(len==5 && strcmp(mname, "xhttp")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_XHTTP;
-		return 0;
-	} else 	if(len==6 && strcmp(mname, "sdpops")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_SDPOPS;
-		return 0;
-	} else 	if(len==8 && strcmp(mname, "presence")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_PRESENCE;
-		return 0;
-	} else 	if(len==12 && strcmp(mname, "presence_xml")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_PRESENCE_XML;
-		return 0;
-	} else 	if(len==7 && strcmp(mname, "textops")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_TEXTOPS;
-		return 0;
-	} else 	if(len==10 && strcmp(mname, "pua_usrloc")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_PUA_USRLOC;
-		return 0;
-	} else 	if(len==8 && strcmp(mname, "siputils")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_SIPUTILS;
-		return 0;
-	} else 	if(len==3 && strcmp(mname, "rls")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_RLS;
-		return 0;
-	} else 	if(len==8 && strcmp(mname, "alias_db")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_ALIAS_DB;
-		return 0;
-	} else 	if(len==5 && strcmp(mname, "msilo")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_MSILO;
-		return 0;
-	} else 	if(len==3 && strcmp(mname, "uac")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_UAC;
-		return 0;
-	} else 	if(len==6 && strcmp(mname, "sanity")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_SANITY;
-		return 0;
-	} else 	if(len==8 && strcmp(mname, "cfgutils")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_CFGUTILS;
-		return 0;
-	} else 	if(len==3 && strcmp(mname, "tmx")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_TMX;
-		return 0;
-	} else 	if(len==6 && strcmp(mname, "mqueue")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_MQUEUE;
-		return 0;
-	} else 	if(len==11 && strcmp(mname, "ndb_mongodb")==0) {
-		_sr_lua_exp_reg_mods |= SR_LUA_EXP_MOD_NDB_MONGODB;
-		return 0;
-	}
-
-	return -1;
-}
-
-/**
- *
- */
-void lua_sr_exp_openlibs(lua_State *L)
-{
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SL)
-		luaL_openlib(L, "sr.sl",         _sr_sl_Map,          0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TM)
-		luaL_openlib(L, "sr.tm",         _sr_tm_Map,          0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SQLOPS)
-		luaL_openlib(L, "sr.sqlops",     _sr_sqlops_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RR)
-		luaL_openlib(L, "sr.rr",         _sr_rr_Map,          0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH)
-		luaL_openlib(L, "sr.auth",       _sr_auth_Map,        0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_AUTH_DB)
-		luaL_openlib(L, "sr.auth_db",    _sr_auth_db_Map,     0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MAXFWD)
-		luaL_openlib(L, "sr.maxfwd",     _sr_maxfwd_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_REGISTRAR)
-		luaL_openlib(L, "sr.registrar",  _sr_registrar_Map,   0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_DISPATCHER)
-		luaL_openlib(L, "sr.dispatcher", _sr_dispatcher_Map,  0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_XHTTP)
-		luaL_openlib(L, "sr.xhttp",      _sr_xhttp_Map,       0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SDPOPS)
-		luaL_openlib(L, "sr.sdpops",     _sr_sdpops_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE)
-		luaL_openlib(L, "sr.presence",     _sr_presence_Map,  0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PRESENCE_XML)
-		luaL_openlib(L, "sr.presence_xml", _sr_presence_xml_Map, 0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TEXTOPS)
-		luaL_openlib(L, "sr.textops", _sr_textops_Map,        0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_PUA_USRLOC)
-		luaL_openlib(L, "sr.pua_usrloc", _sr_pua_usrloc_Map,  0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SIPUTILS)
-		luaL_openlib(L, "sr.siputils", _sr_siputils_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_RLS)
-		luaL_openlib(L, "sr.rls", _sr_rls_Map,                0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_ALIAS_DB)
-		luaL_openlib(L, "sr.alias_db", _sr_alias_db_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MSILO)
-		luaL_openlib(L, "sr.msilo", _sr_msilo_Map,            0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_UAC)
-		luaL_openlib(L, "sr.uac", _sr_uac_Map,                0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_SANITY)
-		luaL_openlib(L, "sr.sanity", _sr_sanity_Map,          0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_CFGUTILS)
-		luaL_openlib(L, "sr.cfgutils", _sr_cfgutils_Map,      0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_TMX)
-		luaL_openlib(L, "sr.tmx", _sr_tmx_Map,                0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_MQUEUE)
-		luaL_openlib(L, "sr.mq", _sr_mqueue_Map,              0);
-	if(_sr_lua_exp_reg_mods&SR_LUA_EXP_MOD_NDB_MONGODB)
-		luaL_openlib(L, "sr.ndb_mongodb", _sr_ndb_mongodb_Map, 0);
-}
-

src/modules/app_lua/app_lua_exp.h

@@ -1,32 +0,0 @@
-/**
- * Copyright (C) 2010-2016 Daniel-Constantin Mierla (asipto.com)
- *
- * This file is part of Kamailio, a free SIP server.
- *
- * Kamailio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version
- *
- * Kamailio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#ifndef _APP_LUA_EXP_H_
-#define _APP_LUA_EXP_H_
-
-#include <lua.h>
-
-int lua_sr_exp_register_mod(char *mname);
-int lua_sr_exp_init_mod(void);
-void lua_sr_exp_openlibs(lua_State *L);
-
-#endif
-

src/modules/app_lua/app_lua_kemi_export.c

@@ -33,7 +33,7 @@
 
 #include "../../core/dprint.h"
 
-#include "app_lua_sr.h"
+#include "app_lua_api.h"
 #include "app_lua_kemi_export.h"
 
 

src/modules/app_lua/app_lua_mod.c

@@ -27,8 +27,6 @@
 #include "../../core/dprint.h"
 #include "../../core/ut.h"
 #include "../../core/mod_fix.h"
-#include "../../core/rpc.h"
-#include "../../core/rpc_lookup.h"
 #include "../../core/kemi.h"
 
 #include "app_lua_api.h"
@@ -43,8 +41,6 @@ static int  mod_init(void);
 static void mod_destroy(void);
 static int  child_init(int rank);
 
-static int app_lua_init_rpc(void);
-
 static int w_app_lua_dostring(struct sip_msg *msg, char *script, char *extra);
 static int w_app_lua_dofile(struct sip_msg *msg, char *script, char *extra);
 static int w_app_lua_runstring(struct sip_msg *msg, char *script, char *extra);
@@ -62,14 +58,12 @@ static int w_app_lua_run3(struct sip_msg *msg, char *func, char *p1, char *p2,
 static int fixup_lua_run(void** param, int param_no);
 
 int app_lua_load_param(modparam_t type, void *val);
-int app_lua_register_param(modparam_t type, void *val);
 int app_lua_reload_param(modparam_t type, void *val);
 
 int _ksr_app_lua_log_mode = 0;
 
 static param_export_t params[]={
 	{"load",     PARAM_STRING|USE_FUNC_PARAM, (void*)app_lua_load_param},
-	{"register", PARAM_STRING|USE_FUNC_PARAM, (void*)app_lua_register_param},
 	{"reload",   INT_PARAM|USE_FUNC_PARAM, (void*)app_lua_reload_param},
 	{"log_mode", PARAM_INT, &_ksr_app_lua_log_mode},
 	{0, 0, 0}
@@ -181,11 +175,11 @@ int sr_kemi_config_engine_lua(sip_msg_t *msg, int rtype, str *rname,
  */
 static int mod_init(void)
 {
-	if(lua_sr_init_mod()<0)
+	if(lua_sr_init_mod()<0) {
 		return -1;
+	}
 
-	if(app_lua_init_rpc()<0)
-	{
+	if(app_lua_init_rpc()<0) {
 		LM_ERR("failed to register RPC commands\n");
 		return -1;
 	}
@@ -199,13 +193,6 @@ static int child_init(int rank)
 	if(rank==PROC_MAIN || rank==PROC_TCP_MAIN)
 		return 0; /* do nothing for the main process */
 
-	if (rank==PROC_INIT)
-	{
-		/* do a probe before forking */
-		if(lua_sr_init_probe()!=0)
-			return -1;
-		return 0;
-	}
 	return lua_sr_init_child();
 }
 
@@ -548,13 +535,6 @@ int app_lua_load_param(modparam_t type, void *val)
 	return sr_lua_load_script((char*)val);
 }
 
-int app_lua_register_param(modparam_t type, void *val)
-{
-	if(val==NULL)
-		return -1;
-	return sr_lua_register_module((char*)val);
-}
-
 int app_lua_reload_param(modparam_t type, void *val)
 {
 	return sr_lua_reload_module((unsigned int)(long) (int *)val);
@@ -565,199 +545,6 @@ static int fixup_lua_run(void** param, int param_no)
 	return fixup_spve_null(param, 1);
 }
 
-/*** RPC implementation ***/
-
-static const char* app_lua_rpc_reload_doc[2] = {
-	"Reload lua script",
-	0
-};
-
-static const char* app_lua_rpc_list_doc[2] = {
-	"list lua scripts",
-	0
-};
-
-static void app_lua_rpc_reload(rpc_t* rpc, void* ctx)
-{
-	int pos = -1;
-
-	rpc->scan(ctx, "*d", &pos);
-	LM_DBG("selected index: %d\n", pos);
-	if(lua_sr_reload_script(pos)<0)
-		rpc->fault(ctx, 500, "Reload Failed");
-	return;
-}
-
-static void app_lua_rpc_list(rpc_t* rpc, void* ctx)
-{
-	int i;
-	sr_lua_load_t *list = NULL, *li;
-	if(lua_sr_list_script(&list)<0)
-	{
-		LM_ERR("Can't get loaded scripts\n");
-		return;
-	}
-	if(list)
-	{
-		li = list;
-		i = 0;
-		while(li)
-		{
-			rpc->rpl_printf(ctx, "%d: [%s]", i, li->script);
-			li = li->next;
-			i += 1;
-		}
-	}
-	else {
-		rpc->rpl_printf(ctx,"No scripts loaded");
-	}
-	return;
-}
-
-/**
- * only prototypes of special kemi exports in order to list via rpc
- */
-/* clang-format off */
-static sr_kemi_t sr_kemi_app_lua_rpc_exports[] = {
-	{ str_init("pv"), str_init("get"),
-		SR_KEMIP_STR, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("pv"), str_init("seti"),
-		SR_KEMIP_NONE, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_INT, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("pv"), str_init("sets"),
-		SR_KEMIP_NONE, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_STR, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("pv"), str_init("unset"),
-		SR_KEMIP_NONE, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("pv"), str_init("is_null"),
-		SR_KEMIP_BOOL, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("x"), str_init("modf"),
-		SR_KEMIP_INT, NULL,
-		{ SR_KEMIP_STR, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("x"), str_init("exit"),
-		SR_KEMIP_NONE, NULL,
-		{ SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-	{ str_init("x"), str_init("drop"),
-		SR_KEMIP_NONE, NULL,
-		{ SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE,
-			SR_KEMIP_NONE, SR_KEMIP_NONE, SR_KEMIP_NONE }
-	},
-
-	{ {0, 0}, {0, 0}, 0, NULL, { 0, 0, 0, 0, 0, 0 } }
-};
-
-static const char* app_lua_rpc_api_list_doc[2] = {
-	"list kemi exports to lua",
-	0
-};
-
-static void app_lua_rpc_api_list(rpc_t* rpc, void* ctx)
-{
-	int i;
-	int n;
-	sr_kemi_t *ket;
-	void* th;
-	void* sh;
-	void* ih;
-
-	if (rpc->add(ctx, "{", &th) < 0) {
-		rpc->fault(ctx, 500, "Internal error root reply");
-		return;
-	}
-
-	/* count the number of exported functions */
-	n = 0;
-	for(i=0; i<SR_KEMI_LUA_EXPORT_SIZE; i++) {
-		ket = sr_kemi_lua_export_get(i);
-		if(ket==NULL) continue;
-		n++;
-	}
-	for(i=0; sr_kemi_app_lua_rpc_exports[i].fname.s!=NULL; i++) {
-		n++;
-	}
-
-	if(rpc->struct_add(th, "d[",
-				"msize", n,
-				"methods",  &ih)<0)
-	{
-		rpc->fault(ctx, 500, "Internal error array structure");
-		return;
-	}
-	for(i=0; i<SR_KEMI_LUA_EXPORT_SIZE; i++) {
-		ket = sr_kemi_lua_export_get(i);
-		if(ket==NULL) continue;
-		if(rpc->struct_add(ih, "{", "func", &sh)<0) {
-			rpc->fault(ctx, 500, "Internal error internal structure");
-			return;
-		}
-		if(rpc->struct_add(sh, "SSSS",
-				"ret", sr_kemi_param_map_get_name(ket->rtype),
-				"module", &ket->mname,
-				"name", &ket->fname,
-				"params", sr_kemi_param_map_get_params(ket->ptypes))<0) {
-			LM_ERR("failed to add the structure with attributes (%d)\n", i);
-			rpc->fault(ctx, 500, "Internal error creating dest struct");
-			return;
-		}
-	}
-	for(i=0; sr_kemi_app_lua_rpc_exports[i].fname.s!=NULL; i++) {
-		ket = &sr_kemi_app_lua_rpc_exports[i];
-		if(rpc->struct_add(ih, "{", "func", &sh)<0) {
-			rpc->fault(ctx, 500, "Internal error internal structure");
-			return;
-		}
-		if(rpc->struct_add(sh, "SSSS",
-				"ret", sr_kemi_param_map_get_name(ket->rtype),
-				"module", &ket->mname,
-				"name", &ket->fname,
-				"params", sr_kemi_param_map_get_params(ket->ptypes))<0) {
-			LM_ERR("failed to add the structure with attributes (%d)\n", i);
-			rpc->fault(ctx, 500, "Internal error creating dest struct");
-			return;
-		}
-	}
-}
-
-rpc_export_t app_lua_rpc_cmds[] = {
-	{"app_lua.reload", app_lua_rpc_reload,
-		app_lua_rpc_reload_doc, 0},
-	{"app_lua.list", app_lua_rpc_list,
-		app_lua_rpc_list_doc, 0},
-	{"app_lua.api_list", app_lua_rpc_api_list,
-		app_lua_rpc_api_list_doc, 0},
-	{0, 0, 0, 0}
-};
-
-/**
- * register RPC commands
- */
-static int app_lua_init_rpc(void)
-{
-	if (rpc_register_array(app_lua_rpc_cmds)!=0)
-	{
-		LM_ERR("failed to register RPC commands\n");
-		return -1;
-	}
-	return 0;
-}
-
 /**
  *
  */

src/modules/app_lua/app_lua_sr.c

@@ -1,2534 +0,0 @@
-/**
- * Copyright (C) 2010-2016 Daniel-Constantin Mierla (asipto.com)
- *
- * This file is part of Kamailio, a free SIP server.
- *
- * Kamailio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version
- *
- * Kamailio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#include <stdio.h>
-#include <unistd.h>
-#include <stdlib.h>
-#include <sys/stat.h>
-
-#include "../../core/sr_module.h"
-#include "../../core/dprint.h"
-#include "../../core/route_struct.h"
-#include "../../core/action.h"
-#include "../../core/ut.h"
-#include "../../core/mem/mem.h"
-#include "../../core/data_lump.h"
-#include "../../core/data_lump_rpl.h"
-#include "../../core/forward.h"
-#include "../../core/flags.h"
-#include "../../core/dset.h"
-#include "../../core/parser/parse_uri.h"
-#include "../../core/strutils.h"
-#include "../../core/xavp.h"
-#include "../../core/kemi.h"
-
-#include "app_lua_api.h"
-#include "app_lua_kemi_export.h"
-#include "app_lua_sr.h"
-
-#define KSR_APP_LUA_LOG_EXPORTS (1<<0)
-
-extern int _ksr_app_lua_log_mode;
-
-/**
- *
- */
-static int lua_sr_probe (lua_State *L)
-{
-	LM_DBG("someone probing from lua\n");
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_dbg (lua_State *L)
-{
-	char *txt;
-	txt = (char*)lua_tostring(L, -1);
-	if(txt!=NULL)
-		LM_DBG("%s", txt);
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_err (lua_State *L)
-{
-	char *txt;
-	txt = (char*)lua_tostring(L, -1);
-	if(txt!=NULL)
-		LM_ERR("%s", txt);
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_log (lua_State *L)
-{
-	char *txt;
-	char *level;
-	level = (char*)lua_tostring(L, -2);
-	txt = (char*)lua_tostring(L, -1);
-	if(txt!=NULL)
-	{
-		if(level==NULL)
-		{
-			LM_ERR("%s", txt);
-		} else {
-			if(strcasecmp(level, "dbg")==0) {
-				LM_DBG("%s", txt);
-			} else if(strcasecmp(level, "info")==0) {
-				LM_INFO("%s", txt);
-			} else if(strcasecmp(level, "notice")==0) {
-				LM_NOTICE("%s", txt);
-			} else if(strcasecmp(level, "warn")==0) {
-				LM_WARN("%s", txt);
-			} else if(strcasecmp(level, "crit")==0) {
-				LM_CRIT("%s", txt);
-			} else {
-				LM_ERR("%s", txt);
-			}
-		}
-	}
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_modf (lua_State *L)
-{
-	int ret;
-	char *luav[MAX_ACTIONS];
-	char *argv[MAX_ACTIONS];
-	int argc;
-	int i;
-	int mod_type;
-	struct run_act_ctx ra_ctx;
-	struct action *act;
-	ksr_cmd_export_t* expf;
-	sr_lua_env_t *env_L;
-
-	ret = 1;
-	act = NULL;
-	argc = 0;
-	memset(luav, 0, MAX_ACTIONS*sizeof(char*));
-	memset(argv, 0, MAX_ACTIONS*sizeof(char*));
-	env_L = sr_lua_env_get();
-	if(env_L->msg==NULL)
-		goto error;
-
-#if 0
-	app_lua_dump_stack(L);
-#endif
-	argc = lua_gettop(L);
-	if(argc==0)
-	{
-		LM_ERR("name of module function not provided\n");
-		goto error;
-	}
-	if(argc>=MAX_ACTIONS)
-	{
-		LM_ERR("too many parameters\n");
-		goto error;
-	}
-	/* first is function name, then parameters */
-	for(i=1; i<=argc; i++)
-	{
-		if (!lua_isstring(L, i))
-		{
-			LM_ERR("invalid parameter type (%d)\n", i);
-			goto error;
-		}
-		luav[i-1] = (char*)lua_tostring(L, i);
-	}
-	/* pkg copy only parameters */
-	for(i=1; i<MAX_ACTIONS; i++)
-	{
-		if(luav[i]!=NULL)
-		{
-			argv[i] = (char*)pkg_malloc(strlen(luav[i])+1);
-			if(argv[i]==NULL)
-			{
-				PKG_MEM_ERROR;
-				goto error;
-			}
-			strcpy(argv[i], luav[i]);
-		}
-	}
-
-	expf = find_export_record(luav[0], argc-1, 0);
-	if (expf==NULL) {
-		LM_ERR("function '%s' is not available\n", luav[0]);
-		goto error;
-	}
-	/* check fixups */
-	if (expf->fixup!=NULL && expf->free_fixup==NULL) {
-		LM_ERR("function '%s' has fixup - cannot be used\n", luav[0]);
-		goto error;
-	}
-	switch(expf->param_no) {
-		case 0:
-			mod_type = MODULE0_T;
-			break;
-		case 1:
-			mod_type = MODULE1_T;
-			break;
-		case 2:
-			mod_type = MODULE2_T;
-			break;
-		case 3:
-			mod_type = MODULE3_T;
-			break;
-		case 4:
-			mod_type = MODULE4_T;
-			break;
-		case 5:
-			mod_type = MODULE5_T;
-			break;
-		case 6:
-			mod_type = MODULE6_T;
-			break;
-		case VAR_PARAM_NO:
-			mod_type = MODULEX_T;
-			break;
-		default:
-			LM_ERR("unknown/bad definition for function '%s' (%d params)\n",
-					luav[0], expf->param_no);
-			goto error;
-	}
-
-	act = mk_action(mod_type,  argc+1   /* number of (type, value) pairs */,
-					MODEXP_ST, expf,    /* function */
-					NUMBER_ST, argc-1,  /* parameter number */
-					STRING_ST, argv[1], /* param. 1 */
-					STRING_ST, argv[2], /* param. 2 */
-					STRING_ST, argv[3], /* param. 3 */
-					STRING_ST, argv[4], /* param. 4 */
-					STRING_ST, argv[5], /* param. 5 */
-					STRING_ST, argv[6]  /* param. 6 */
-			);
-
-	if (act==NULL) {
-		LM_ERR("action structure could not be created for '%s'\n", luav[0]);
-		goto error;
-	}
-
-	/* handle fixups */
-	if (expf->fixup) {
-		if(argc==1)
-		{ /* no parameters */
-			if(expf->fixup(0, 0)<0)
-			{
-				LM_ERR("Error in fixup (0) for '%s'\n", luav[0]);
-				goto error;
-			}
-		} else {
-			for(i=1; i<argc; i++)
-			{
-				if(expf->fixup(&(act->val[i+1].u.data), i)<0)
-				{
-					LM_ERR("Error in fixup (%d) for '%s'\n", i, luav[0]);
-					goto error;
-				}
-				act->val[i+1].type = MODFIXUP_ST;
-			}
-		}
-	}
-	init_run_actions_ctx(&ra_ctx);
-	ret = do_action(&ra_ctx, act, env_L->msg);
-
-	/* free fixups */
-	if (expf->fixup) {
-		for(i=1; i<argc; i++)
-		{
-			if ((act->val[i+1].type == MODFIXUP_ST) && (act->val[i+1].u.data))
-			{
-				expf->free_fixup(&(act->val[i+1].u.data), i);
-			}
-		}
-	}
-	pkg_free(act);
-	for(i=0; i<MAX_ACTIONS; i++)
-	{
-		if(argv[i]!=NULL) pkg_free(argv[i]);
-		argv[i] = 0;
-	}
-	lua_pushinteger(L, ret);
-	return 1;
-
-error:
-	if(act!=NULL)
-		pkg_free(act);
-	for(i=0; i<MAX_ACTIONS; i++)
-	{
-		if(argv[i]!=NULL) pkg_free(argv[i]);
-		argv[i] = 0;
-	}
-	lua_pushinteger(L, -1);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_is_myself (lua_State *L)
-{
-	str uri;
-	struct sip_uri puri;
-	int ret;
-
-	uri.s = (char*)lua_tostring(L, -1);
-	if(uri.s==NULL)
-	{
-		LM_ERR("invalid uri parameter\n");
-		return app_lua_return_false(L);
-	}
-	uri.len = strlen(uri.s);
-	if(uri.len>4 && (strncmp(uri.s, "sip:", 4)==0
-				|| strncmp(uri.s, "sips:", 5)==0))
-	{
-		if(parse_uri(uri.s, uri.len, &puri)!=0)
-		{
-			LM_ERR("failed to parse uri [%s]\n", uri.s);
-			return app_lua_return_false(L);
-		}
-		ret = check_self(&puri.host, (puri.port.s)?puri.port_no:0,
-				(puri.transport_val.s)?puri.proto:0);
-	} else {
-		ret = check_self(&uri, 0, 0);
-	}
-	if(ret==1)
-		return app_lua_return_true(L);
-	return app_lua_return_false(L);
-}
-
-/**
- *
- */
-static int lua_sr_setflag (lua_State *L)
-{
-	int flag;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	flag = lua_tointeger(L, -1);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	setflag(env_L->msg, flag);
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_resetflag (lua_State *L)
-{
-	int flag;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	flag = lua_tointeger(L, -1);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	resetflag(env_L->msg, flag);
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_isflagset (lua_State *L)
-{
-	int flag;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	flag = lua_tointeger(L, -1);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	ret = isflagset(env_L->msg, flag);
-	if(ret>0)
-		return app_lua_return_true(L);
-	return app_lua_return_false(L);
-}
-
-/**
- *
- */
-static int lua_sr_setbflag (lua_State *L)
-{
-	int flag;
-	int branch;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	if(lua_gettop(L)==1)
-	{
-		flag = lua_tointeger(L, -1);
-		branch = 0;
-	} else if(lua_gettop(L)==2) {
-		flag = lua_tointeger(L, -2);
-		branch = lua_tointeger(L, -1);
-	} else {
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	setbflag(branch, flag);
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_resetbflag (lua_State *L)
-{
-	int flag;
-	int branch;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	if(lua_gettop(L)==1)
-	{
-		flag = lua_tointeger(L, -1);
-		branch = 0;
-	} else if(lua_gettop(L)==2) {
-		flag = lua_tointeger(L, -2);
-		branch = lua_tointeger(L, -1);
-	} else {
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	resetbflag(branch, flag);
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_isbflagset (lua_State *L)
-{
-	int flag;
-	int branch;
-	int ret;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	if(lua_gettop(L)==1)
-	{
-		flag = lua_tointeger(L, -1);
-		branch = 0;
-	} else if(lua_gettop(L)==2) {
-		flag = lua_tointeger(L, -2);
-		branch = lua_tointeger(L, -1);
-	} else {
-		LM_WARN("invalid number of parameters from Lua\n");
-		return app_lua_return_false(L);
-	}
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (!flag_in_range(flag))
-	{
-		LM_ERR("invalid flag parameter %d\n", flag);
-		return app_lua_return_false(L);
-	}
-
-	ret = isbflagset(branch, flag);
-	if(ret>0)
-		return app_lua_return_true(L);
-	return app_lua_return_false(L);
-}
-
-/**
- *
- */
-static int lua_sr_seturi (lua_State *L)
-{
-	struct action  act;
-	struct run_act_ctx h;
-	str uri;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	uri.s = (char*)lua_tostring(L, -1);
-	if(uri.s==NULL)
-	{
-		LM_ERR("invalid uri parameter\n");
-		return app_lua_return_false(L);
-	}
-	uri.len = strlen(uri.s);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	memset(&act, 0, sizeof(act));
-	act.val[0].type = STRING_ST;
-	act.val[0].u.string = uri.s;
-	act.type = SET_URI_T;
-	init_run_actions_ctx(&h);
-	if (do_action(&h, &act, env_L->msg)<0)
-	{
-		LM_ERR("do action failed\n");
-		return app_lua_return_false(L);
-	}
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_setuser (lua_State *L)
-{
-	struct action  act;
-	struct run_act_ctx h;
-	str uri;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	uri.s = (char*)lua_tostring(L, -1);
-	if(uri.s==NULL)
-	{
-		LM_ERR("invalid uri parameter\n");
-		return app_lua_return_false(L);
-	}
-	uri.len = strlen(uri.s);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	memset(&act, 0, sizeof(act));
-	act.val[0].type = STRING_ST;
-	act.val[0].u.string = uri.s;
-	act.type = SET_USER_T;
-	init_run_actions_ctx(&h);
-	if (do_action(&h, &act, env_L->msg)<0)
-	{
-		LM_ERR("do action failed\n");
-		return app_lua_return_false(L);
-	}
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_sethost (lua_State *L)
-{
-	struct action  act;
-	struct run_act_ctx h;
-	str uri;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	uri.s = (char*)lua_tostring(L, -1);
-	if(uri.s==NULL)
-	{
-		LM_ERR("invalid uri parameter\n");
-		return app_lua_return_false(L);
-	}
-	uri.len = strlen(uri.s);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	memset(&act, 0, sizeof(act));
-	act.val[0].type = STRING_ST;
-	act.val[0].u.string = uri.s;
-	act.type = SET_HOST_T;
-	init_run_actions_ctx(&h);
-	if (do_action(&h, &act, env_L->msg)<0)
-	{
-		LM_ERR("do action failed\n");
-		return app_lua_return_false(L);
-	}
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_setdsturi (lua_State *L)
-{
-	str uri;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	uri.s = (char*)lua_tostring(L, -1);
-	if(uri.s==NULL)
-	{
-		LM_ERR("invalid uri parameter\n");
-		return app_lua_return_false(L);
-	}
-	uri.len = strlen(uri.s);
-
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	if (set_dst_uri(env_L->msg, &uri)<0)
-	{
-		LM_ERR("setting dst uri failed\n");
-		return app_lua_return_false(L);
-	}
-	return app_lua_return_true(L);
-}
-
-/**
- *
- */
-static int lua_sr_resetdsturi (lua_State *L)
-{
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-	if(env_L->msg==NULL)
-	{
-		LM_WARN("invalid parameters from Lua env\n");
-		return app_lua_return_false(L);
-	}
-
-	reset_dst_uri(env_L->msg);
-	return app_lua_return_true(L);
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_core_Map [] = {
-	{"probe",        lua_sr_probe},
-	{"dbg",          lua_sr_dbg},
-	{"err",          lua_sr_err},
-	{"log",          lua_sr_log},
-	{"modf",         lua_sr_modf},
-	{"is_myself",    lua_sr_is_myself},
-	{"setflag",      lua_sr_setflag},
-	{"resetflag",    lua_sr_resetflag},
-	{"isflagset",    lua_sr_isflagset},
-	{"setbflag",     lua_sr_setbflag},
-	{"resetbflag",   lua_sr_resetbflag},
-	{"isbflagset",   lua_sr_isbflagset},
-	{"seturi",       lua_sr_seturi},
-	{"setuser",      lua_sr_setuser},
-	{"sethost",      lua_sr_sethost},
-	{"setdsturi",    lua_sr_setdsturi},
-	{"resetdsturi",  lua_sr_resetdsturi},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-static int lua_sr_hdr_append (lua_State *L)
-{
-	struct lump* anchor;
-	struct hdr_field *hf;
-	char *txt;
-	int len;
-	char *hdr;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	txt = (char*)lua_tostring(L, -1);
-	if(txt==NULL || env_L->msg==NULL)
-		return 0;
-
-	LM_DBG("append hf: %s\n", txt);
-	if (parse_headers(env_L->msg, HDR_EOH_F, 0) == -1)
-	{
-		LM_ERR("error while parsing message\n");
-		return 0;
-	}
-
-	hf = env_L->msg->last_header;
-	len = strlen(txt);
-	hdr = (char*)pkg_malloc(len+1);
-	if(hdr==NULL)
-	{
-		PKG_MEM_ERROR;
-		return 0;
-	}
-	memcpy(hdr, txt, len);
-	anchor = anchor_lump(env_L->msg,
-				hf->name.s + hf->len - env_L->msg->buf, 0, 0);
-	if(anchor==NULL)
-	{
-		LM_ERR("unable to get the anchor\n");
-		pkg_free(hdr);
-		return 0;
-	}
-	if(insert_new_lump_before(anchor, hdr, len, 0) == 0)
-	{
-		LM_ERR("can't insert lump\n");
-		pkg_free(hdr);
-		return 0;
-	}
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_hdr_remove (lua_State *L)
-{
-	struct lump* anchor;
-	struct hdr_field *hf;
-	char *txt;
-	str hname;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	txt = (char*)lua_tostring(L, -1);
-	if(txt==NULL || env_L->msg==NULL)
-		return 0;
-
-	LM_DBG("remove hf: %s\n", txt);
-	if (parse_headers(env_L->msg, HDR_EOH_F, 0) == -1) {
-		LM_ERR("error while parsing message\n");
-		return 0;
-	}
-
-	hname.s = txt;
-	hname.len = strlen(txt);
-	for (hf=env_L->msg->headers; hf; hf=hf->next)
-	{
-		if (cmp_hdrname_str(&hf->name, &hname)==0)
-		{
-			anchor=del_lump(env_L->msg,
-					hf->name.s - env_L->msg->buf, hf->len, 0);
-			if (anchor==0)
-			{
-				LM_ERR("cannot remove hdr %s\n", txt);
-				return 0;
-			}
-		}
-	}
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_hdr_insert (lua_State *L)
-{
-	struct lump* anchor;
-	struct hdr_field *hf;
-	char *txt;
-	int len;
-	char *hdr;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	txt = (char*)lua_tostring(L, -1);
-	if(txt==NULL || env_L->msg==NULL)
-		return 0;
-
-	LM_DBG("insert hf: %s\n", txt);
-	hf = env_L->msg->headers;
-	len = strlen(txt);
-	hdr = (char*)pkg_malloc(len+1);
-	if(hdr==NULL)
-	{
-		PKG_MEM_ERROR;
-		return 0;
-	}
-	memcpy(hdr, txt, len);
-	anchor = anchor_lump(env_L->msg,
-				hf->name.s + hf->len - env_L->msg->buf, 0, 0);
-	if((anchor==NULL) || (insert_new_lump_before(anchor, hdr, len, 0) == 0))
-	{
-		LM_ERR("can't insert lump\n");
-		pkg_free(hdr);
-		return 0;
-	}
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_hdr_append_to_reply (lua_State *L)
-{
-	char *txt;
-	int len;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	txt = (char*)lua_tostring(L, -1);
-	if(txt==NULL || env_L->msg==NULL)
-		return 0;
-
-	LM_DBG("append to reply: %s\n", txt);
-	len = strlen(txt);
-
-	if(add_lump_rpl(env_L->msg, txt, len, LUMP_RPL_HDR)==0)
-	{
-		LM_ERR("unable to add reply lump\n");
-		return 0;
-	}
-
-	return 0;
-}
-
-
-/**
- *
- */
-static const luaL_Reg _sr_hdr_Map [] = {
-	{"append", lua_sr_hdr_append},
-	{"remove", lua_sr_hdr_remove},
-	{"insert", lua_sr_hdr_insert},
-	{"append_to_reply", lua_sr_hdr_append_to_reply},
-	{NULL, NULL}
-};
-
-
-/**
- *
- */
-static int lua_sr_pv_push_val_null (lua_State *L, int rmode)
-{
-	if(rmode==1) {
-		lua_pushlstring(L, "<<null>>", 8);
-	} else if(rmode==2) {
-		lua_pushlstring(L, "", 0);
-	} else {
-		lua_pushnil(L);
-	}
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_pv_push_valx (lua_State *L, int rmode, int vi, str *vs)
-{
-	if(rmode==1) {
-		lua_pushinteger(L, vi);
-	} else {
-		lua_pushlstring(L, vs->s, vs->len);
-	}
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_pv_get_val (lua_State *L, int rmode)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-
-	env_L = sr_lua_env_get();
-
-	pvn.s = (char*)lua_tostring(L, -1);
-	if(pvn.s==NULL || env_L->msg==NULL) {
-		return lua_sr_pv_push_val_null(L, rmode);
-	}
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv get: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len) {
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return lua_sr_pv_push_val_null(L, rmode);
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL) {
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return lua_sr_pv_push_val_null(L, rmode);
-	}
-	memset(&val, 0, sizeof(pv_value_t));
-	if(pv_get_spec_value(env_L->msg, pvs, &val) != 0) {
-		LM_ERR("unable to get pv value for [%s]\n", pvn.s);
-		return lua_sr_pv_push_val_null(L, rmode);
-	}
-	if(val.flags&PV_VAL_NULL) {
-		return lua_sr_pv_push_val_null(L, rmode);
-	}
-	if(val.flags&PV_TYPE_INT) {
-		lua_pushinteger(L, val.ri);
-		return 1;
-	}
-	lua_pushlstring(L, val.rs.s, val.rs.len);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_pv_get (lua_State *L)
-{
-	return lua_sr_pv_get_val(L, 0);
-}
-
-/**
- *
- */
-static int lua_sr_pv_getw (lua_State *L)
-{
-	return lua_sr_pv_get_val(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_pv_gete (lua_State *L)
-{
-	return lua_sr_pv_get_val(L, 2);
-}
-
-/**
- *
- */
-static int lua_sr_pv_get_valx (lua_State *L, int rmode)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-	int xival = 0;
-	str xsval = str_init("");
-
-	env_L = sr_lua_env_get();
-
-	if(lua_gettop(L)<2) {
-		LM_ERR("to few parameters [%d]\n", lua_gettop(L));
-		return lua_sr_pv_push_val_null(L, 0);
-	}
-	if(rmode==1) {
-		if(!lua_isnumber(L, -1)) {
-			LM_ERR("invalid int parameter\n");
-			return lua_sr_pv_push_val_null(L, 0);
-		}
-		xival = lua_tointeger(L, -1);
-	} else {
-		if(!lua_isstring(L, -1)) {
-			LM_ERR("invalid str parameter\n");
-			return lua_sr_pv_push_val_null(L, 0);
-		}
-		xsval.s = (char*)lua_tostring(L, -1);
-		xsval.len = strlen(xsval.s);
-	}
-
-	pvn.s = (char*)lua_tostring(L, -2);
-	if(pvn.s==NULL || env_L->msg==NULL)
-		return lua_sr_pv_push_valx(L, rmode, xival, &xsval);
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv set: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len) {
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return lua_sr_pv_push_valx(L, rmode, xival, &xsval);
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL) {
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return lua_sr_pv_push_valx(L, rmode, xival, &xsval);
-	}
-
-	memset(&val, 0, sizeof(pv_value_t));
-	if(pv_get_spec_value(env_L->msg, pvs, &val) != 0) {
-		LM_ERR("unable to get pv value for [%s]\n", pvn.s);
-		return lua_sr_pv_push_valx(L, rmode, xival, &xsval);
-	}
-	if(val.flags&PV_VAL_NULL) {
-		return lua_sr_pv_push_valx(L, rmode, xival, &xsval);
-	}
-	if(val.flags&PV_TYPE_INT) {
-		lua_pushinteger(L, val.ri);
-		return 1;
-	}
-	lua_pushlstring(L, val.rs.s, val.rs.len);
-	return 1;
-}
-
-/**
- *
- */
-static int lua_sr_pv_getvs (lua_State *L)
-{
-	return lua_sr_pv_get_valx(L, 0);
-}
-
-/**
- *
- */
-static int lua_sr_pv_getvn (lua_State *L)
-{
-	return lua_sr_pv_get_valx(L, 1);
-}
-
-/**
- *
- */
-static int lua_sr_pv_seti (lua_State *L)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-
-	env_L = sr_lua_env_get();
-
-	if(lua_gettop(L)<2)
-	{
-		LM_ERR("to few parameters [%d]\n", lua_gettop(L));
-		return 0;
-	}
-	if(!lua_isnumber(L, -1))
-	{
-		LM_ERR("invalid int parameter\n");
-		return 0;
-	}
-	memset(&val, 0, sizeof(pv_value_t));
-	val.ri = lua_tointeger(L, -1);
-	val.flags |= PV_TYPE_INT|PV_VAL_INT;
-
-	pvn.s = (char*)lua_tostring(L, -2);
-	if(pvn.s==NULL || env_L->msg==NULL)
-		return 0;
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv set: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len)
-	{
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return 0;
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL)
-	{
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return 0;
-	}
-	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)
-	{
-		LM_ERR("unable to set pv [%s]\n", pvn.s);
-		return 0;
-	}
-
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_pv_sets (lua_State *L)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-
-	env_L = sr_lua_env_get();
-
-	if(lua_gettop(L)<2)
-	{
-		LM_ERR("to few parameters [%d]\n",lua_gettop(L));
-		return 0;
-	}
-
-	if(!lua_isstring(L, -1))
-	{
-		LM_ERR("Cannot convert to a string when assigning value to variable: %s\n",
-				lua_tostring(L, -2));
-		return 0;
-	}
-
-	memset(&val, 0, sizeof(pv_value_t));
-	val.rs.s = (char*)lua_tostring(L, -1);
-	val.rs.len = strlen(val.rs.s);
-	val.flags |= PV_VAL_STR;
-
-	pvn.s = (char*)lua_tostring(L, -2);
-	if(pvn.s==NULL || env_L->msg==NULL)
-		return 0;
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv set: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len)
-	{
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return 0;
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL)
-	{
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return 0;
-	}
-	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)
-	{
-		LM_ERR("unable to set pv [%s]\n", pvn.s);
-		return 0;
-	}
-
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_pv_unset (lua_State *L)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-
-	env_L = sr_lua_env_get();
-
-	pvn.s = (char*)lua_tostring(L, -1);
-	if(pvn.s==NULL || env_L->msg==NULL)
-		return 0;
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv unset: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len)
-	{
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return 0;
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL)
-	{
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return 0;
-	}
-	memset(&val, 0, sizeof(pv_value_t));
-	val.flags |= PV_VAL_NULL;
-	if(pv_set_spec_value(env_L->msg, pvs, 0, &val)<0)
-	{
-		LM_ERR("unable to unset pv [%s]\n", pvn.s);
-		return 0;
-	}
-
-	return 0;
-}
-
-/**
- *
- */
-static int lua_sr_pv_is_null (lua_State *L)
-{
-	str pvn;
-	pv_spec_t *pvs;
-	pv_value_t val;
-	sr_lua_env_t *env_L;
-	int pl;
-
-	env_L = sr_lua_env_get();
-
-	pvn.s = (char*)lua_tostring(L, -1);
-	if(pvn.s==NULL || env_L->msg==NULL)
-		return 0;
-
-	pvn.len = strlen(pvn.s);
-	LM_DBG("pv is null test: %s\n", pvn.s);
-	pl = pv_locate_name(&pvn);
-	if(pl != pvn.len)
-	{
-		LM_ERR("invalid pv [%s] (%d/%d)\n", pvn.s, pl, pvn.len);
-		return 0;
-	}
-	pvs = pv_cache_get(&pvn);
-	if(pvs==NULL)
-	{
-		LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
-		return 0;
-	}
-	memset(&val, 0, sizeof(pv_value_t));
-	if(pv_get_spec_value(env_L->msg, pvs, &val) != 0)
-	{
-		LM_NOTICE("unable to get pv value for [%s]\n", pvn.s);
-		lua_pushboolean(L, 1);
-		return 1;
-	}
-	if(val.flags&PV_VAL_NULL)
-	{
-		lua_pushboolean(L, 1);
-	} else {
-		lua_pushboolean(L, 0);
-	}
-	return 1;
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_pv_Map [] = {
-	{"get",      lua_sr_pv_get},
-	{"getw",     lua_sr_pv_getw},
-	{"gete",     lua_sr_pv_gete},
-	{"getvn",    lua_sr_pv_getvn},
-	{"getvs",    lua_sr_pv_getvs},
-	{"seti",     lua_sr_pv_seti},
-	{"sets",     lua_sr_pv_sets},
-	{"unset",    lua_sr_pv_unset},
-	{"is_null",  lua_sr_pv_is_null},
-	{NULL, NULL}
-};
-
-
-/**
- * creates and push a table to the lua stack with
- * the elements of the list
- */
-static int lua_sr_push_str_list_table(lua_State *L, struct str_list *list) {
-	lua_Number i = 1;
-	struct str_list *k = list;
-
-	lua_newtable(L);
-	while(k!=NULL){
-		lua_pushnumber(L, i);
-		lua_pushlstring(L, k->s.s, k->s.len);
-		lua_settable(L, -3);
-		i++;
-		k = k->next;
-	}
-	return 1;
-}
-
-static int lua_sr_push_xavp_table(lua_State *L, sr_xavp_t *xavp, const int simple_flag);
-
-/**
- * creates and push a table for the key name in xavp
- * if simple_flag is != 0 it will return only the first value
- */
-static void lua_sr_push_xavp_name_table(lua_State *L, sr_xavp_t *xavp,
-	str name, const int simple_flag)
-{
-	lua_Number i = 1;
-	lua_Number elem = 1;
-	sr_xavp_t *avp = xavp;
-
-	while(avp!=NULL&&!STR_EQ(avp->name,name))
-	{
-		avp = avp->next;
-	}
-
-	if(simple_flag==0) lua_newtable(L);
-
-	while(avp!=NULL){
-		if(simple_flag==0) lua_pushnumber(L, elem);
-		switch(avp->val.type) {
-			case SR_XTYPE_NULL:
-				lua_pushnil(L);
-			break;
-			case SR_XTYPE_INT:
-				i = avp->val.v.i;
-				lua_pushnumber(L, i);
-			break;
-			case SR_XTYPE_STR:
-				lua_pushlstring(L, avp->val.v.s.s, avp->val.v.s.len);
-			break;
-			case SR_XTYPE_TIME:
-			case SR_XTYPE_LONG:
-			case SR_XTYPE_LLONG:
-			case SR_XTYPE_DATA:
-				lua_pushnil(L);
-				LM_WARN("XAVP type:%d value not supported\n", avp->val.type);
-			break;
-			case SR_XTYPE_XAVP:
-				if(!lua_sr_push_xavp_table(L,avp->val.v.xavp, simple_flag)){
-					LM_ERR("xavp:%.*s subtable error. Nil value added\n",
-						avp->name.len, avp->name.s);
-					lua_pushnil(L);
-				}
-			break;
-			default:
-				LM_ERR("xavp:%.*s unknown type: %d. Nil value added\n",
-					avp->name.len, avp->name.s, avp->val.type);
-				lua_pushnil(L);
-			break;
-		}
-		if(simple_flag==0)
-		{
-			lua_rawset(L, -3);
-			elem = elem + 1;
-			avp = xavp_get_next(avp);
-		}
-		else {
-			lua_setfield(L, -2, name.s);
-			avp = NULL;
-		}
-	}
-	if(simple_flag==0) lua_setfield(L, -2, name.s);
-}
-
-/**
- * creates and push a table to the lua stack with
- * the elements of the xavp
- */
-static int lua_sr_push_xavp_table(lua_State *L, sr_xavp_t *xavp, const int simple_flag) {
-	sr_xavp_t *avp = NULL;
-	struct str_list *keys;
-	struct str_list *k;
-
-	if(xavp->val.type!=SR_XTYPE_XAVP){
-		LM_ERR("%s not xavp?\n", xavp->name.s);
-		return 0;
-	}
-	avp = xavp->val.v.xavp;
-	keys = xavp_get_list_key_names(xavp);
-
-	lua_newtable(L);
-	if(keys!=NULL)
-	{
-		do
-		{
-			lua_sr_push_xavp_name_table(L, avp, keys->s, simple_flag);
-			k = keys;
-			keys = keys->next;
-			pkg_free(k);
-		}while(keys!=NULL);
-	}
-
-	return 1;
-}
-
-/**
- * puts a table with content of a xavp
- */
-static int lua_sr_xavp_get(lua_State *L)
-{
-	str xavp_name;
-	int indx = 0;
-	sr_lua_env_t *env_L;
-	sr_xavp_t *avp;
-	int num_param = 0;
-	int param = -1;
-	int all_flag = 0;
-	int simple_flag = 0;
-	lua_Number elem = 1;
-	int xavp_size = 0;
-
-	env_L = sr_lua_env_get();
-	num_param = lua_gettop(L);
-	if(num_param<2 && num_param>3)
-	{
-		LM_ERR("wrong number of parameters [%d]\n", num_param);
-		return 0;
-	}
-
-	if(num_param==3)
-	{
-		if(!lua_isnumber(L, param))
-		{
-			LM_ERR("invalid int parameter\n");
-			return 0;
-		}
-		simple_flag = lua_tointeger(L, param);
-		param = param - 1;
-	}
-
-	if(!lua_isnumber(L, param))
-	{
-		if(lua_isnil(L, param))
-		{
-			all_flag = 1;
-		}
-		else
-		{
-			LM_ERR("invalid parameter, must be int or nil\n");
-			return 0;
-		}
-	}
-	else
-	{
-		indx = lua_tointeger(L, param);
-	}
-	param = param - 1;
-	xavp_name.s = (char*)lua_tostring(L, param);
-	if(xavp_name.s==NULL || env_L->msg==NULL)
-	{
-		LM_ERR("No xavp name in %d param\n", param);
-		return 0;
-	}
-	xavp_name.len = strlen(xavp_name.s);
-	if(all_flag>0) {
-		indx = 0;
-		lua_newtable(L);
-	}
-	xavp_size = xavp_count(&xavp_name, NULL);
-	if(indx<0)
-	{
-		if((indx*-1)>xavp_size)
-		{
-			LM_ERR("can't get xavp:%.*s index:%d\n", xavp_name.len, xavp_name.s, indx);
-			lua_pushnil(L);
-			return 1;
-		}
-		indx = xavp_size + indx;
-	}
-
-	avp = xavp_get_by_index(&xavp_name, indx, NULL);
-	do
-	{
-		if(avp==NULL){
-			LM_ERR("can't get xavp:%.*s index:%d\n", xavp_name.len, xavp_name.s, indx);
-			lua_pushnil(L);
-			return 1;
-		}
-		if(all_flag!=0) {
-			lua_pushnumber(L, elem);
-			elem = elem + 1;
-		}
-		lua_sr_push_xavp_table(L, avp, simple_flag);
-		if(all_flag!=0) {
-			lua_rawset(L, -3);
-			indx = indx + 1;
-			avp = xavp_get_by_index(&xavp_name, indx, NULL);
-		}
-		else return 1;
-	}while(avp!=NULL);
-
-	return 1;
-}
-
-/**
- * puts a table with the list of keys of the xavp
- */
-static int lua_sr_xavp_get_keys (lua_State *L)
-{
-	str xavp_name;
-	int indx = 0;
-	sr_lua_env_t *env_L;
-	sr_xavp_t *avp;
-	struct str_list *keys, *k;
-
-	env_L = sr_lua_env_get();
-
-	if(lua_gettop(L)<2)
-	{
-		LM_ERR("to few parameters [%d]\n",lua_gettop(L));
-		return 0;
-	}
-
-	if(!lua_isnumber(L, -1))
-	{
-		LM_ERR("invalid int parameter\n");
-		return 0;
-	}
-	indx = lua_tointeger(L, -1);
-
-	xavp_name.s = (char*)lua_tostring(L, -2);
-	if(xavp_name.s==NULL || env_L->msg==NULL)
-		return 0;
-	xavp_name.len = strlen(xavp_name.s);
-
-	avp = xavp_get_by_index(&xavp_name, indx, NULL);
-	if(avp==NULL){
-		LM_ERR("can't get xavp:%.*s index:%d\n", xavp_name.len, xavp_name.s, indx);
-		lua_pushnil(L);
-		return 1;
-	}
-	keys = xavp_get_list_key_names(avp);
-	lua_sr_push_str_list_table(L, keys);
-	// free list
-	while(keys!=NULL){
-		k = keys;
-		keys = k->next;
-		pkg_free(k);
-	}
-	return 1;
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_xavp_Map [] = {
-	{"get", lua_sr_xavp_get},
-	{"get_keys",  lua_sr_xavp_get_keys},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-void lua_sr_core_openlibs(lua_State *L)
-{
-	luaL_openlib(L, "sr",      _sr_core_Map, 0);
-	luaL_openlib(L, "sr.hdr",  _sr_hdr_Map,  0);
-	luaL_openlib(L, "sr.pv",   _sr_pv_Map,   0);
-	luaL_openlib(L, "sr.xavp", _sr_xavp_Map, 0);
-}
-
-
-/**
- *
- */
-int sr_kemi_lua_return_int(lua_State* L, sr_kemi_t *ket, int rc)
-{
-	if(ket->rtype==SR_KEMIP_INT) {
-		lua_pushinteger(L, rc);
-		return 1;
-	}
-	if(ket->rtype==SR_KEMIP_BOOL && rc!=SR_KEMI_FALSE) {
-		return app_lua_return_true(L);
-	}
-	return app_lua_return_false(L);
-}
-
-/**
- *
- */
-int sr_kemi_lua_exec_func_ex(lua_State* L, sr_kemi_t *ket, int pdelta)
-{
-	int i;
-	int argc;
-	int ret;
-	str *fname;
-	str *mname;
-	sr_kemi_val_t vps[SR_KEMI_PARAMS_MAX];
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(env_L==NULL || env_L->msg==NULL || ket==NULL) {
-		LM_ERR("invalid Lua environment attributes or parameters\n");
-		return app_lua_return_false(L);
-	}
-
-	fname = &ket->fname;
-	mname = &ket->mname;
-
-	argc = lua_gettop(L);
-	if(argc==pdelta && ket->ptypes[0]==SR_KEMIP_NONE) {
-		ret = ((sr_kemi_fm_f)(ket->func))(env_L->msg);
-		return sr_kemi_lua_return_int(L, ket, ret);
-	}
-	if(argc==pdelta && ket->ptypes[0]!=SR_KEMIP_NONE) {
-		LM_ERR("invalid number of parameters for: %.*s.%.*s\n",
-				mname->len, mname->s, fname->len, fname->s);
-		return app_lua_return_false(L);
-	}
-
-	if(argc>=SR_KEMI_PARAMS_MAX+pdelta) {
-		LM_ERR("too many parameters for: %.*s.%.*s\n",
-				mname->len, mname->s, fname->len, fname->s);
-		return app_lua_return_false(L);
-	}
-
-	memset(vps, 0, SR_KEMI_PARAMS_MAX*sizeof(sr_kemi_val_t));
-	for(i=0; i<SR_KEMI_PARAMS_MAX; i++) {
-		if(ket->ptypes[i]==SR_KEMIP_NONE) {
-			break;
-		}
-		if(argc<i+pdelta+1) {
-			LM_ERR("not enough parameters for: %.*s.%.*s\n",
-					mname->len, mname->s, fname->len, fname->s);
-			return app_lua_return_false(L);
-		}
-		if(ket->ptypes[i]==SR_KEMIP_STR) {
-			vps[i].s.s = (char*)lua_tostring(L, i+pdelta+1);
-			if(vps[i].s.s!=NULL) {
-				if(lua_isstring(L, i+pdelta+1)) {
-#if LUA_VERSION_NUM > 501
-					vps[i].s.len = lua_rawlen(L, i+pdelta+1);
-#else
-					vps[i].s.len = lua_strlen(L, i+pdelta+1);
-#endif
-				} else {
-					vps[i].s.len = strlen(vps[i].s.s);
-				}
-			} else {
-				vps[i].s.len = 0;
-			}
-			LM_DBG("param[%d] for: %.*s is str: %.*s\n", i,
-				fname->len, fname->s, vps[i].s.len, vps[i].s.s);
-		} else if(ket->ptypes[i]==SR_KEMIP_INT) {
-			vps[i].n = lua_tointeger(L, i+pdelta+1);
-			LM_DBG("param[%d] for: %.*s is int: %d\n", i,
-				fname->len, fname->s, vps[i].n);
-		} else {
-			LM_ERR("unknown parameter type %d (%d)\n", ket->ptypes[i], i);
-			return app_lua_return_false(L);
-		}
-	}
-
-	switch(i) {
-		case 1:
-			if(ket->ptypes[0]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmn_f)(ket->func))(env_L->msg, vps[0].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fms_f)(ket->func))(env_L->msg, &vps[0].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n",
-						fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		case 2:
-			if(ket->ptypes[0]==SR_KEMIP_INT) {
-				if(ket->ptypes[1]==SR_KEMIP_INT) {
-					ret = ((sr_kemi_fmnn_f)(ket->func))(env_L->msg, vps[0].n, vps[1].n);
-					return sr_kemi_lua_return_int(L, ket, ret);
-				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
-					ret = ((sr_kemi_fmns_f)(ket->func))(env_L->msg, vps[0].n, &vps[1].s);
-					return sr_kemi_lua_return_int(L, ket, ret);
-				} else {
-					LM_ERR("invalid parameters for: %.*s\n",
-							fname->len, fname->s);
-					return app_lua_return_false(L);
-				}
-			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
-				if(ket->ptypes[1]==SR_KEMIP_INT) {
-					ret = ((sr_kemi_fmsn_f)(ket->func))(env_L->msg, &vps[0].s, vps[1].n);
-					return sr_kemi_lua_return_int(L, ket, ret);
-				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
-					ret = ((sr_kemi_fmss_f)(ket->func))(env_L->msg, &vps[0].s, &vps[1].s);
-					return sr_kemi_lua_return_int(L, ket, ret);
-				} else {
-					LM_ERR("invalid parameters for: %.*s\n",
-							fname->len, fname->s);
-					return app_lua_return_false(L);
-				}
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n",
-						fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		case 3:
-			if(ket->ptypes[0]==SR_KEMIP_INT) {
-				if(ket->ptypes[1]==SR_KEMIP_INT) {
-					if(ket->ptypes[2]==SR_KEMIP_INT) {
-						ret = ((sr_kemi_fmnnn_f)(ket->func))(env_L->msg,
-								vps[0].n, vps[1].n, vps[2].n);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
-						ret = ((sr_kemi_fmnns_f)(ket->func))(env_L->msg,
-								vps[0].n, vps[1].n, &vps[2].s);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else {
-						LM_ERR("invalid parameters for: %.*s\n",
-								fname->len, fname->s);
-						return app_lua_return_false(L);
-					}
-				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
-					if(ket->ptypes[2]==SR_KEMIP_INT) {
-						ret = ((sr_kemi_fmnsn_f)(ket->func))(env_L->msg,
-								vps[0].n, &vps[1].s, vps[2].n);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
-						ret = ((sr_kemi_fmnss_f)(ket->func))(env_L->msg,
-								vps[0].n, &vps[1].s, &vps[2].s);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else {
-						LM_ERR("invalid parameters for: %.*s\n",
-								fname->len, fname->s);
-						return app_lua_return_false(L);
-					}
-				} else {
-					LM_ERR("invalid parameters for: %.*s\n",
-							fname->len, fname->s);
-					return app_lua_return_false(L);
-				}
-			} else if(ket->ptypes[0]==SR_KEMIP_STR) {
-				if(ket->ptypes[1]==SR_KEMIP_INT) {
-					if(ket->ptypes[2]==SR_KEMIP_INT) {
-						ret = ((sr_kemi_fmsnn_f)(ket->func))(env_L->msg,
-								&vps[0].s, vps[1].n, vps[2].n);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
-						ret = ((sr_kemi_fmsns_f)(ket->func))(env_L->msg,
-								&vps[0].s, vps[1].n, &vps[2].s);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else {
-						LM_ERR("invalid parameters for: %.*s\n",
-								fname->len, fname->s);
-						return app_lua_return_false(L);
-					}
-				} else if(ket->ptypes[1]==SR_KEMIP_STR) {
-					if(ket->ptypes[2]==SR_KEMIP_INT) {
-						ret = ((sr_kemi_fmssn_f)(ket->func))(env_L->msg,
-								&vps[0].s, &vps[1].s, vps[2].n);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else if(ket->ptypes[2]==SR_KEMIP_STR) {
-						ret = ((sr_kemi_fmsss_f)(ket->func))(env_L->msg,
-								&vps[0].s, &vps[1].s, &vps[2].s);
-						return sr_kemi_lua_return_int(L, ket, ret);
-					} else {
-						LM_ERR("invalid parameters for: %.*s\n",
-								fname->len, fname->s);
-						return app_lua_return_false(L);
-					}
-				} else {
-					LM_ERR("invalid parameters for: %.*s\n",
-							fname->len, fname->s);
-					return app_lua_return_false(L);
-				}
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n",
-						fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		case 4:
-			if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmssss_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsssn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmssns_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmssnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnss_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnsn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnns_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnsss_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnssn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnsns_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnsnn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnss_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnsn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnns_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, &vps[3].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnnn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, vps[3].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n", fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		case 5:
-			if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsssss_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmssssn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsssns_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsssnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmssnss_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmssnsn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmssnns_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmssnnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, vps[2].n, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnsss_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnssn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnsns_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnsnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, &vps[2].s, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnnss_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnnsn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmsnnns_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmsnnnn_f)(ket->func))(env_L->msg,
-						&vps[0].s, vps[1].n, vps[2].n, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnssss_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnsssn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnssns_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnssnn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, &vps[2].s, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnsnss_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnsnsn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnsnns_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnsnnn_f)(ket->func))(env_L->msg,
-						vps[0].n, &vps[1].s, vps[2].n, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnsss_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnssn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnsns_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnsnn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, &vps[2].s, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnnss_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, &vps[3].s, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnnsn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, &vps[3].s, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmnnnns_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, vps[3].n, &vps[4].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else if(ket->ptypes[0]==SR_KEMIP_INT
-					&& ket->ptypes[1]==SR_KEMIP_INT
-					&& ket->ptypes[2]==SR_KEMIP_INT
-					&& ket->ptypes[3]==SR_KEMIP_INT
-					&& ket->ptypes[4]==SR_KEMIP_INT) {
-				ret = ((sr_kemi_fmnnnnn_f)(ket->func))(env_L->msg,
-						vps[0].n, vps[1].n, vps[2].n, vps[3].n, vps[4].n);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n", fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		case 6:
-			if(ket->ptypes[0]==SR_KEMIP_STR
-					&& ket->ptypes[1]==SR_KEMIP_STR
-					&& ket->ptypes[2]==SR_KEMIP_STR
-					&& ket->ptypes[3]==SR_KEMIP_STR
-					&& ket->ptypes[4]==SR_KEMIP_STR
-					&& ket->ptypes[5]==SR_KEMIP_STR) {
-				ret = ((sr_kemi_fmssssss_f)(ket->func))(env_L->msg,
-						&vps[0].s, &vps[1].s, &vps[2].s, &vps[3].s,
-						&vps[4].s, &vps[5].s);
-				return sr_kemi_lua_return_int(L, ket, ret);
-			} else {
-				LM_ERR("invalid parameters for: %.*s\n",
-						fname->len, fname->s);
-				return app_lua_return_false(L);
-			}
-		break;
-		default:
-			LM_ERR("invalid parameters for: %.*s\n",
-					fname->len, fname->s);
-			return app_lua_return_false(L);
-	}
-}
-
-/**
- *
- */
-int sr_kemi_exec_func(lua_State* L, str *mname, int midx, str *fname)
-{
-	int pdelta;
-	sr_kemi_t *ket = NULL;
-	sr_lua_env_t *env_L;
-
-	env_L = sr_lua_env_get();
-
-	if(env_L==NULL || env_L->msg==NULL) {
-		LM_ERR("invalid Lua environment attributes\n");
-		return app_lua_return_false(L);
-	}
-
-	ket = sr_kemi_lookup(mname, midx, fname);
-	if(ket==NULL) {
-		LM_ERR("cannot find function (%d): %.*s.%.*s\n", midx,
-				(mname && mname->len>0)?mname->len:0,
-				(mname && mname->len>0)?mname->s:"",
-				fname->len, fname->s);
-		return app_lua_return_false(L);
-	}
-	if(mname->len<=0) {
-		pdelta = 1;
-	} else {
-		pdelta = 3;
-	}
-	return sr_kemi_lua_exec_func_ex(L, ket, pdelta);
-}
-
-/**
- *
- */
-int sr_kemi_lua_exec_func(lua_State* L, int eidx)
-{
-	sr_kemi_t *ket;
-	int ret;
-	struct timeval tvb, tve;
-	struct timezone tz;
-	unsigned int tdiff;
-	lua_Debug dinfo;
-
-	ket = sr_kemi_lua_export_get(eidx);
-	if(unlikely(cfg_get(core, core_cfg, latency_limit_action)>0)
-			&& is_printable(cfg_get(core, core_cfg, latency_log))) {
-		gettimeofday(&tvb, &tz);
-	}
-
-	ret = sr_kemi_lua_exec_func_ex(L, ket, 0);
-
-	if(unlikely(cfg_get(core, core_cfg, latency_limit_action)>0)
-			&& is_printable(cfg_get(core, core_cfg, latency_log))) {
-		gettimeofday(&tve, &tz);
-		tdiff = (tve.tv_sec - tvb.tv_sec) * 1000000
-				   + (tve.tv_usec - tvb.tv_usec);
-		if(tdiff >= cfg_get(core, core_cfg, latency_limit_action)) {
-			memset(&dinfo, 0, sizeof(lua_Debug));
-			if(lua_getstack(L, 1, &dinfo)>0
-						&& lua_getinfo(L, "nSl", &dinfo)>0) {
-				LOG(cfg_get(core, core_cfg, latency_log),
-						"alert - action KSR.%s%s%s(...)"
-						" took too long [%u us] (%s:%d - %s [%s])\n",
-						(ket->mname.len>0)?ket->mname.s:"",
-						(ket->mname.len>0)?".":"", ket->fname.s,
-						tdiff,
-						(dinfo.short_src[0])?dinfo.short_src:"<unknown>",
-						dinfo.currentline,
-						(dinfo.name)?dinfo.name:"<unknown>",
-						(dinfo.what)?dinfo.what:"<unknown>");
-			} else {
-				LOG(cfg_get(core, core_cfg, latency_log),
-						"alert - action KSR.%s%s%s(...)"
-						" took too long [%u us]\n",
-						(ket->mname.len>0)?ket->mname.s:"",
-						(ket->mname.len>0)?".":"", ket->fname.s,
-						tdiff);
-			}
-		}
-	}
-
-	return ret;
-}
-
-/**
- *
- */
-static int sr_kemi_lua_exit (lua_State *L)
-{
-	str *s;
-
-	LM_DBG("script exit call\n");
-	s = sr_kemi_lua_exit_string_get();
-	lua_getglobal(L, "error");
-	lua_pushstring(L, s->s);
-	lua_call(L, 1, 0);
-	return 0;
-}
-
-/**
- *
- */
-static int sr_kemi_lua_drop (lua_State *L)
-{
-	str *s;
-
-	LM_DBG("script drop call\n");
-	sr_kemi_core_set_drop(NULL);
-	s = sr_kemi_lua_exit_string_get();
-	lua_getglobal(L, "error");
-	lua_pushstring(L, s->s);
-	lua_call(L, 1, 0);
-	return 0;
-}
-
-/**
- *
- */
-static const luaL_Reg _sr_kemi_x_Map [] = {
-	{"modf",      lua_sr_modf},
-	{"exit",      sr_kemi_lua_exit},
-	{"drop",      sr_kemi_lua_drop},
-	{NULL, NULL}
-};
-
-/**
- *
- */
-int sr_kemi_KSR_C(lua_State* L)
-{
-	str mname = str_init("");
-	str fname;
-
-	fname.s = (char*)lua_tostring(L, 1);
-	if(fname.s==NULL) {
-		LM_ERR("null function name");
-		return app_lua_return_false(L);
-	}
-	fname.len = strlen(fname.s);
-	LM_DBG("function execution of: %s\n", fname.s);
-	return sr_kemi_exec_func(L, &mname, 0, &fname);
-}
-
-/**
- *
- */
-int sr_kemi_KSR_MOD_C(lua_State* L)
-{
-	str mname;
-	int midx;
-	str fname;
-	mname.s = (char*)lua_tostring(L, 1);
-	midx = lua_tointeger(L, 2);
-	fname.s = (char*)lua_tostring(L, 3);
-	if(mname.s==NULL || fname.s==NULL) {
-		LM_ERR("null params: %p %p\n", mname.s, fname.s);
-		return app_lua_return_false(L);
-	}
-	mname.len = strlen(mname.s);
-	fname.len = strlen(fname.s);
-	LM_DBG("module function execution of: %s.%s (%d)\n",
-			mname.s, fname.s, midx);
-	return sr_kemi_exec_func(L, &mname, midx, &fname);
-}
-
-
-/**
- *
- */
-void lua_sr_kemi_register_core(lua_State *L)
-{
-	int ret;
-
-	lua_register(L, "KSR_C", sr_kemi_KSR_C);
-	lua_register(L, "KSR_MOD_C", sr_kemi_KSR_MOD_C);
-
-	ret = luaL_dostring(L,
-			"KSR = {}\n"
-			"KSR.__index = function (table, key)\n"
-			"  return function (...)\n"
-			"    return KSR_C(key, ...)\n"
-			"  end\n"
-			"end\n"
-			"setmetatable(KSR, KSR)\n"
-		);
-
-	/* special modules - pv.get(...) can return int or str */
-	luaL_openlib(L, "KSR.pv",   _sr_pv_Map,   0);
-	luaL_openlib(L, "KSR.x",   _sr_kemi_x_Map,   0);
-
-	LM_DBG("pushing lua KSR table definition returned %d\n", ret);
-}
-
-/**
- *
- */
-void lua_sr_kemi_register_module(lua_State *L, str *mname, int midx)
-{
-	int ret;
-#define LUA_SR_SBUF_SIZE	1024
-	char sbuf[LUA_SR_SBUF_SIZE];
-
-	ret = snprintf(sbuf, LUA_SR_SBUF_SIZE-1,
-			"KSR.%.*s = {}\n"
-			"KSR.%.*s.__index = function (table, key)\n"
-			"  return function (...)\n"
-			"    return KSR_MOD_C('%.*s', %d, key, ...)\n"
-			"  end\n"
-			"end\n"
-			"setmetatable(KSR.%.*s, KSR.%.*s)\n",
-			mname->len, mname->s,
-			mname->len, mname->s,
-			mname->len, mname->s,
-			midx,
-			mname->len, mname->s,
-			mname->len, mname->s
-		);
-	ret = luaL_dostring(L, sbuf);
-
-	LM_DBG("pushing lua KSR.%.*s table definition returned %d\n",
-			mname->len, mname->s, ret);
-}
-
-/**
- *
- */
-void lua_sr_kemi_register_modules(lua_State *L)
-{
-	int n;
-	int i;
-	sr_kemi_module_t *kmods;
-
-	n = sr_kemi_modules_size_get();
-	kmods = sr_kemi_modules_get();
-
-	for(i=1; i<n; i++) {
-		lua_sr_kemi_register_module(L, &kmods[i].mname, i);
-	}
-}
-
-
-/**
- *
- */
-luaL_Reg *_sr_KSRMethods = NULL;
-
-#define SR_LUA_KSR_MODULES_SIZE	256
-#define SR_LUA_KSR_METHODS_SIZE	(SR_KEMI_LUA_EXPORT_SIZE + SR_LUA_KSR_MODULES_SIZE)
-
-
-/**
- *
- */
-void lua_sr_kemi_register_libs(lua_State *L)
-{
-	luaL_Reg *_sr_crt_KSRMethods = NULL;
-	sr_kemi_module_t *emods = NULL;
-	int emods_size = 0;
-	int i;
-	int k;
-	int n;
-	char mname[128];
-
-#if 0
-	/* dynamic lookup on function name */
-	lua_sr_kemi_register_core(L);
-	lua_sr_kemi_register_modules(L);
-#endif
-
-	_sr_KSRMethods = malloc(SR_LUA_KSR_METHODS_SIZE * sizeof(luaL_Reg));
-	if(_sr_KSRMethods==NULL) {
-		LM_ERR("no more pkg memory\n");
-		return;
-	}
-	memset(_sr_KSRMethods, 0, SR_LUA_KSR_METHODS_SIZE * sizeof(luaL_Reg));
-
-	emods_size = sr_kemi_modules_size_get();
-	emods = sr_kemi_modules_get();
-
-	n = 0;
-	_sr_crt_KSRMethods = _sr_KSRMethods;
-	if(emods_size==0 || emods[0].kexp==NULL) {
-		LM_ERR("no kemi exports registered\n");
-		return;
-	}
-
-	for(i=0; emods[0].kexp[i].func!=NULL; i++) {
-		if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
-			LM_DBG("exporting KSR.%s(...)\n", emods[0].kexp[i].fname.s);
-		}
-		_sr_crt_KSRMethods[i].name = emods[0].kexp[i].fname.s;
-		_sr_crt_KSRMethods[i].func =
-			sr_kemi_lua_export_associate(&emods[0].kexp[i]);
-		if(_sr_crt_KSRMethods[i].func == NULL) {
-			LM_ERR("failed to associate kemi function with lua export\n");
-			free(_sr_KSRMethods);
-			_sr_KSRMethods = NULL;
-			return;
-		}
-		n++;
-	}
-
-	luaL_openlib(L, "KSR", _sr_crt_KSRMethods, 0);
-
-	/* special modules - pv.get(...) can return int or str */
-	luaL_openlib(L, "KSR.pv", _sr_pv_Map,     0);
-	luaL_openlib(L, "KSR.x",  _sr_kemi_x_Map, 0);
-
-	/* registered kemi modules */
-	if(emods_size>1) {
-		for(k=1; k<emods_size; k++) {
-			if(emods[k].kexp == sr_kemi_exports_get_pv()) {
-				LM_DBG("skip registering the core KSR.pv module\n");
-				continue;
-			}
-			n++;
-			_sr_crt_KSRMethods = _sr_KSRMethods + n;
-			snprintf(mname, 128, "KSR.%s", emods[k].kexp[0].mname.s);
-			for(i=0; emods[k].kexp[i].func!=NULL; i++) {
-				if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
-					LM_DBG("exporting %s.%s(...)\n", mname,
-							emods[k].kexp[i].fname.s);
-				}
-				_sr_crt_KSRMethods[i].name = emods[k].kexp[i].fname.s;
-				_sr_crt_KSRMethods[i].func =
-					sr_kemi_lua_export_associate(&emods[k].kexp[i]);
-				if(_sr_crt_KSRMethods[i].func == NULL) {
-					LM_ERR("failed to associate kemi function with func export\n");
-					free(_sr_KSRMethods);
-					_sr_KSRMethods = NULL;
-					return;
-				}
-				n++;
-			}
-			if(!lua_checkstack(L, i+8)) {
-				LM_ERR("not enough Lua stack capacity\n");
-				exit(-1);
-			}
-			luaL_openlib(L, mname, _sr_crt_KSRMethods, 0);
-			if(_ksr_app_lua_log_mode & KSR_APP_LUA_LOG_EXPORTS) {
-				LM_DBG("initializing kemi sub-module: %s (%s) (%d/%d/%d)\n",
-						mname, emods[k].kexp[0].mname.s, i, k, n);
-			}
-		}
-	}
-	LM_DBG("module 'KSR' has been initialized (%d/%d)\n", emods_size, n);
-}

src/modules/app_lua/app_lua_sr.h

@@ -1,33 +0,0 @@
-/**
- * Copyright (C) 2010-2016 Daniel-Constantin Mierla (asipto.com)
- *
- * This file is part of Kamailio, a free SIP server.
- *
- * Kamailio is free software; you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
- * (at your option) any later version
- *
- * Kamailio is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- *
- */
-
-#ifndef _APP_LUA_SR_H_
-#define _APP_LUA_SR_H_
-
-#include <lua.h>
-
-void lua_sr_core_openlibs(lua_State *L);
-void lua_sr_kemi_register_libs(lua_State *L);
-
-int sr_kemi_lua_exec_func(lua_State* L, int eidx);
-
-#endif
-