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;
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);
if(pv_parse_spec(&pvn, &pvs)<0)
{
LM_ERR("unable to parse pv [%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_ERR("unable to get pv value for [%s]\n", pvn.s);
return 0;
}
if(val.flags&PV_VAL_NULL)
{
lua_pushboolean(L, 1);
} else {
lua_pushboolean(L, 0);
}
return 1;
}
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;
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);
if(pv_parse_spec(&pvn, &pvs)<0)
{
LM_ERR("unable to parse pv [%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_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);
}
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);
}
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_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_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);
if(hdr==NULL)
{
LM_ERR("no pkg memory left\n");
return 0;
}
memcpy(hdr, txt, len);
anchor = anchor_lump(env_L->msg,
hf->name.s + hf->len - env_L->msg->buf, 0, 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_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);
}
/**
* 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 simple_flag = 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))
{
LM_ERR("invalid int parameter\n");
return 0;
}
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)
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;
}
if (simple_flag != 0)
{
lua_sr_push_xavp_table_simple(L, avp);
}
else
{
lua_sr_push_xavp_table(L, avp);
}
return 1;
}
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_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_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 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);
if(hdr==NULL)
{
LM_ERR("no pkg memory left\n");
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_pv_get (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 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 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_ERR("unable to get pv value for [%s]\n", pvn.s);
return 0;
}
if(val.flags&PV_VAL_NULL)
{
return 0;
}
if(val.flags&PV_TYPE_INT)
{
lua_pushinteger(L, val.ri);
return 1;
}
lua_pushlstring(L, val.rs.s, val.rs.len);
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 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 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_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 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_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;
unsigned modver;
struct action *act;
sr31_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)
{
LM_ERR("no more pkg\n");
goto error;
}
strcpy(argv[i], luav[i]);
}
}
expf = find_export_record(luav[0], argc-1, 0, &modver);
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;
}
/**
* 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;
}
int sr_kemi_exec_func(lua_State* L, str *mname, int midx, str *fname)
{
int i;
int pdelta;
int argc;
int ret;
sr_kemi_t *ket = NULL;
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) {
LM_ERR("invalid Lua environment attributes\n");
return app_lua_return_false(L);
}
ket = sr_kemi_lookup(mname, midx, fname);
if(ket==NULL) {
return app_lua_return_false(L);
}
if(mname->len<=0) {
pdelta = 1;
} else {
pdelta = 3;
}
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_return(L, ket, ret);
}
if(argc==pdelta && ket->ptypes[0]!=SR_KEMIP_NONE) {
LM_ERR("invalid number of parameters for: %.*s\n",
fname->len, fname->s);
return app_lua_return_false(L);
}
if(argc>=SR_KEMI_PARAMS_MAX+pdelta) {
LM_ERR("too many parameters for: %.*s\n",
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;
} else if(ket->ptypes[i]==SR_KEMIP_STR) {
vps[i].s.s = (char*)lua_tostring(L, i+pdelta+1);
vps[i].s.len = strlen(vps[i].s.s);
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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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_return(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);
}
return app_lua_return_false(L);
}
