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); }