static int mod_init(void)
{
if(register_mi_mod(exports.name, mi_cmds)!=0)
{
LM_ERR("failed to register MI commands\n");
return -1;
}
if(dialplan_init_rpc()!=0)
{
LM_ERR("failed to register RPC commands\n");
return -1;
}
LM_DBG("db_url=%s/%d/%p\n", ZSW(dp_db_url.s), dp_db_url.len,dp_db_url.s);
if(attr_pvar_s.s && attr_pvar_s.len>0) {
attr_pvar = pv_cache_get(&attr_pvar_s);
if( (attr_pvar==NULL) ||
((attr_pvar->type != PVT_AVP) &&
(attr_pvar->type != PVT_XAVP) &&
(attr_pvar->type!=PVT_SCRIPTVAR))) {
LM_ERR("invalid pvar name\n");
return -1;
}
}
default_par2 = (dp_param_p)shm_malloc(sizeof(dp_param_t));
if(default_par2 == NULL){
LM_ERR("no shm more memory\n");
return -1;
}
memset(default_par2, 0, sizeof(dp_param_t));
/* emulate "$rU/$rU" as second parameter for dp_translate() */
default_param_s.len = strlen(default_param_s.s);
default_par2->v.sp[0] = pv_cache_get(&default_param_s);
if (default_par2->v.sp[0]==NULL) {
LM_ERR("input pv is invalid\n");
return -1;
}
default_param_s.len = strlen(default_param_s.s);
default_par2->v.sp[1] = pv_cache_get(&default_param_s);
if (default_par2->v.sp[1]==NULL) {
LM_ERR("output pv is invalid\n");
return -1;
}
if(dp_fetch_rows<=0)
dp_fetch_rows = 1000;
if(init_data() != 0) {
LM_ERR("could not initialize data\n");
return -1;
}
return 0;
}
int ki_pv_evalx(sip_msg_t *msg, str *dst, str *fmt)
{
pv_value_t val;
pv_spec_t *ispec=NULL;
if(dst==NULL || dst->s==NULL || dst->len<=0) {
LM_ERR("invalid destination var name\n");
return -1;
}
ispec = pv_cache_get(dst);
if(ispec==NULL) {
LM_ERR("cannot get pv spec for [%.*s]\n", dst->len, dst->s);
return -1;
}
memset(&val, 0, sizeof(pv_value_t));
if(pv_eval_str(msg, &val.rs, fmt)<0) {
LM_ERR("cannot eval reparsed value of second parameter\n");
return -1;
}
val.flags = PV_VAL_STR;
if(ispec->setf(msg, &ispec->pvp, EQ_T, &val)<0) {
LM_ERR("setting PV failed\n");
goto error;
}
return 1;
error:
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 w_sdp_get(sip_msg_t* msg, char *avp)
{
sdp_info_t *sdp = NULL;
int_str avp_val;
int_str avp_name;
static unsigned short avp_type = 0;
str s;
pv_spec_t *avp_spec = NULL;
int sdp_missing=1;
s.s = avp; s.len = strlen(s.s);
if (pv_locate_name(&s) != s.len)
{
LM_ERR("invalid parameter\n");
return -1;
}
if (((avp_spec = pv_cache_get(&s)) == NULL)
|| avp_spec->type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", avp);
return -1;
}
if(pv_get_avp_name(0, &avp_spec->pvp, &avp_name, &avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", avp);
return -1;
}
sdp_missing = parse_sdp(msg);
if(sdp_missing < 0) {
LM_ERR("Unable to parse sdp\n");
return -1;
}
sdp = (sdp_info_t*)msg->body;
if (sdp==NULL) {
LM_DBG("No SDP\n");
return -2;
}
avp_val.s.s = sdp->raw_sdp.s;
avp_val.s.len = sdp->raw_sdp.len;
LM_DBG("Found SDP %.*s\n", sdp->raw_sdp.len, sdp->raw_sdp.s);
if (add_avp(AVP_VAL_STR | avp_type, avp_name, avp_val) != 0)
{
LM_ERR("Failed to add SDP avp");
return -1;
}
return 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 sr_mono_pv_sets (MonoString *pv, MonoString *sv)
{
str pvn = {0};
pv_spec_t *pvs;
pv_value_t val;
int pl;
sr_mono_env_t *env_M;
env_M = sr_mono_env_get();
pvn.s = mono_string_to_utf8(pv);
if(pvn.s==NULL || env_M->msg==NULL)
goto error;
memset(&val, 0, sizeof(pv_value_t));
val.rs.s = mono_string_to_utf8(sv);
if(val.rs.s == NULL)
goto error;
val.rs.len = strlen(val.rs.s);
val.flags |= PV_VAL_STR;
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);
goto error;
}
pvs = pv_cache_get(&pvn);
if(pvs==NULL)
{
LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
goto error;
}
if(pv_set_spec_value(env_M->msg, pvs, 0, &val)<0)
{
LM_ERR("unable to set pv [%s]\n", pvn.s);
return -1;
}
mono_free(pvn.s);
return 0;
error:
if(pvn.s!=NULL)
mono_free(pvn.s);
return -1;
}
static SQInteger sqlang_sr_pv_sets (HSQUIRRELVM J)
{
str pvn;
pv_spec_t *pvs;
pv_value_t val;
sr_sqlang_env_t *env_J;
int pl;
env_J = sqlang_sr_env_get();
if(sqlang_gettop(J)<2) {
LM_ERR("too few parameters [%d]\n", sqlang_gettop(J));
return 0;
}
if(!sqlang_isstring(J, 1)) {
LM_ERR("invalid str parameter\n");
return 0;
}
pvn.s = (char*)sqlang_to_string(J, 0);
if(pvn.s==NULL || env_J->msg==NULL)
return 0;
memset(&val, 0, sizeof(pv_value_t));
val.rs.s = (char*)sqlang_to_string(J, 1);
val.rs.len = strlen(val.rs.s);
val.flags |= PV_VAL_STR;
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_J->msg, pvs, 0, &val)<0) {
LM_ERR("unable to set pv [%s]\n", pvn.s);
return 0;
}
return 0;
}
static int sr_mono_pv_geti (MonoString *pv)
{
str pvn = {0};
pv_spec_t *pvs;
pv_value_t val;
int pl;
sr_mono_env_t *env_M;
env_M = sr_mono_env_get();
pvn.s = mono_string_to_utf8(pv);
if(pvn.s==NULL || env_M->msg==NULL)
goto error;
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);
goto error;
}
pvs = pv_cache_get(&pvn);
if(pvs==NULL)
{
LM_ERR("cannot get pv spec for [%s]\n", pvn.s);
goto error;
}
memset(&val, 0, sizeof(pv_value_t));
if(pv_get_spec_value(env_M->msg, pvs, &val) != 0)
{
LM_ERR("unable to get pv value for [%s]\n", pvn.s);
goto error;
}
if((val.flags&PV_VAL_NULL) || !(val.flags&PV_TYPE_INT))
{
mono_free(pvn.s);
return 0;
}
mono_free(pvn.s);
return val.ri;
error:
if(pvn.s!=NULL)
mono_free(pvn.s);
return 0;
}
static int ki_jansson_get(sip_msg_t *msg, str *spath, str *sdoc, str *spv)
{
pv_spec_t *pvs = NULL;
pvs = pv_cache_get(spv);
if(pvs==NULL) {
LM_ERR("cannot get pv spec for [%.*s]\n", spv->len, spv->s);
return -1;
}
if(pvs->setf==NULL) {
LM_ERR("read only output var [%.*s]\n", spv->len, spv->s);
return -1;
}
return janssonmod_get_helper(msg, spath, sdoc, pvs);
}
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;
}
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 SQInteger sqlang_sr_pv_get(HSQUIRRELVM J)
{
str pvn;
pv_spec_t *pvs;
pv_value_t val;
sr_sqlang_env_t *env_J;
int pl;
env_J = sqlang_sr_env_get();
pvn.s = (char*)sqlang_to_string(J, 0);
if(pvn.s==NULL || env_J->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_J->msg, pvs, &val) != 0) {
LM_ERR("unable to get pv value for [%s]\n", pvn.s);
return 0;
}
if(val.flags&PV_VAL_NULL) {
sqlang_pushstring(J, NULL);
return 1;
}
if(val.flags&PV_TYPE_INT) {
sq_pushinteger(J, (SQInteger)val.ri);
return 1;
}
sqlang_pushlstring(J, val.rs.s, val.rs.len);
return 1;
}
str *pv_get_mq_name(sip_msg_t *msg, str *in)
{
str *queue;
if (in->s[0] != '$')
queue = in;
else
{
pv_spec_t *pvs;
pv_value_t pvv;
if (pv_locate_name(in) != in->len)
{
LM_ERR("invalid pv [%.*s]\n", in->len, in->s);
return NULL;
}
if ((pvs = pv_cache_get(in)) == NULL)
{
LM_ERR("failed to get pv spec for [%.*s]\n", in->len, in->s);
return NULL;
}
memset(&pvv, 0, sizeof(pv_value_t));
if (msg==NULL && faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return NULL;
}
if (pv_get_spec_value((msg)?msg:faked_msg_next(), pvs, &pvv) != 0)
{
LM_ERR("failed to get pv value for [%.*s]\n", in->len, in->s);
return NULL;
}
queue = &pvv.rs;
}
return queue;
}
static SQInteger sqlang_sr_pv_is_null (HSQUIRRELVM J)
{
str pvn;
pv_spec_t *pvs;
pv_value_t val;
sr_sqlang_env_t *env_J;
int pl;
env_J = sqlang_sr_env_get();
pvn.s = (char*)sqlang_to_string(J, 0);
if(pvn.s==NULL || env_J->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_J->msg, pvs, &val) != 0) {
LM_NOTICE("unable to get pv value for [%s]\n", pvn.s);
sq_pushbool(J, 1);
return 1;
}
if(val.flags&PV_VAL_NULL) {
sq_pushbool(J, 1);
} else {
sq_pushbool(J, 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 ki_xavp_params_implode(sip_msg_t *msg, str *sxname, str *svname)
{
pv_spec_t *vspec=NULL;
pv_value_t val;
if(sxname==NULL || sxname->s==NULL || sxname->len<=0) {
LM_ERR("invalid xavp name\n");
return -1;
}
if(svname==NULL || svname->s==NULL || svname->len<=0) {
LM_ERR("invalid output var name\n");
return -1;
}
vspec = pv_cache_get(svname);
if(vspec==NULL) {
LM_ERR("cannot get pv spec for [%.*s]\n", svname->len, svname->s);
return -1;
}
if(vspec->setf==NULL) {
LM_ERR("read only output variable [%.*s]\n", svname->len, svname->s);
return -1;
}
val.rs.s = pv_get_buffer();
val.rs.len = xavp_serialize_fields(sxname, val.rs.s, pv_get_buffer_size());
if(val.rs.len<=0) {
return -1;
}
val.flags = PV_VAL_STR;
if(vspec->setf(msg, &vspec->pvp, EQ_T, &val)<0) {
LM_ERR("setting PV failed [%.*s]\n", svname->len, svname->s);
return -1;
}
return 1;
}
static SQInteger sqlang_sr_pv_unset (HSQUIRRELVM J)
{
str pvn;
pv_spec_t *pvs;
pv_value_t val;
sr_sqlang_env_t *env_J;
int pl;
env_J = sqlang_sr_env_get();
pvn.s = (char*)sqlang_to_string(J, 0);
if(pvn.s==NULL || env_J->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_J->msg, pvs, 0, &val)<0)
{
LM_ERR("unable to unset pv [%s]\n", pvn.s);
return 0;
}
return 0;
}
static uint8_t *fetch_payload(struct sip_msg *_m, char *pname, int *len)
{
pv_spec_t *pv;
pv_value_t pt;
int rc;
str s;
s.s = pname;
s.len = strlen(pname);
pv = pv_cache_get(&s);
if (!pv) {
LM_ERR("Can't get %s\n", s.s);
return NULL;
}
rc = pv->getf(_m, &pv->pvp, &pt);
if (rc < 0) {
LM_ERR("Can't getf rc=%d\n", rc);
return NULL;
}
*len = pt.rs.len;
return (uint8_t *) pt.rs.s;
}
/**
* @brief assigns common media transport (if any) of 'm' lines to pv argument
* @return -1 - error; 0 - not found; 1 - found
*/
static int w_sdp_transport(sip_msg_t* msg, char *avp)
{
int_str avp_val;
int_str avp_name;
static unsigned short avp_type = 0;
str s;
pv_spec_t *avp_spec = NULL;
int sdp_session_num;
int sdp_stream_num;
sdp_session_cell_t* sdp_session;
sdp_stream_cell_t* sdp_stream;
str *transport;
s.s = avp; s.len = strlen(s.s);
if (pv_locate_name(&s) != s.len) {
LM_ERR("invalid avp parameter %s\n", avp);
return -1;
}
if (((avp_spec = pv_cache_get(&s)) == NULL)
|| avp_spec->type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s\n", avp);
return -1;
}
if (pv_get_avp_name(0, &avp_spec->pvp, &avp_name, &avp_type) != 0) {
LM_ERR("invalid AVP definition %s\n", avp);
return -1;
}
if(parse_sdp(msg) < 0) {
LM_ERR("unable to parse sdp\n");
return -1;
}
sdp_session_num = 0;
transport = (str *)NULL;
for (;;) {
sdp_session = get_sdp_session(msg, sdp_session_num);
if (!sdp_session) break;
sdp_stream_num = 0;
for (;;) {
sdp_stream = get_sdp_stream(msg, sdp_session_num,
sdp_stream_num);
if (!sdp_stream) break;
LM_DBG("stream %d of %d - transport [%.*s]\n",
sdp_stream_num, sdp_session_num,
sdp_stream->transport.len, sdp_stream->transport.s);
if (transport) {
if (transport->len != sdp_stream->transport.len
|| strncasecmp(sdp_stream->transport.s, transport->s,
transport->len) != 0) {
LM_DBG("no common transport\n");
return -2;
}
} else {
transport = &sdp_stream->transport;
}
sdp_stream_num++;
}
sdp_session_num++;
}
if (transport) {
avp_val.s.s = transport->s;
avp_val.s.len = transport->len;
LM_DBG("found common transport '%.*s'\n",
transport->len, transport->s);
if (add_avp(AVP_VAL_STR | avp_type, avp_name, avp_val) != 0) {
LM_ERR("failed to add transport avp");
return -1;
}
}
return 1;
}
/* first param: DPID: type: INT, AVP, XAVP, SVAR
* second param: SRC type: any psedo variable type
* second param: DST type: RURI, RURI_USERNAME, AVP, XAVP, SVAR, N/A
* default value for the second param: $ru.user/$ru.user
*/
static int dp_trans_fixup(void ** param, int param_no){
int dpid;
dp_param_p dp_par= NULL;
char *p, *s=NULL;
str lstr;
if(param_no!=1 && param_no!=2)
return 0;
p = (char*)*param;
if(!p || (*p == '\0')){
LM_DBG("null param %i\n", param_no);
return E_CFG;
}
LM_DBG("param_no is %i\n", param_no);
dp_par = (dp_param_p)pkg_malloc(sizeof(dp_param_t));
if(dp_par == NULL){
LM_ERR("no more pkg memory\n");
return E_OUT_OF_MEM;
}
memset(dp_par, 0, sizeof(dp_param_t));
if(param_no == 1) {
if(*p != '$') {
dp_par->type = DP_VAL_INT;
lstr.s = *param; lstr.len = strlen(*param);
if(str2sint(&lstr, &dpid) != 0) {
LM_ERR("bad number <%s>\n",(char *)(*param));
pkg_free(dp_par);
return E_CFG;
}
dp_par->type = DP_VAL_INT;
dp_par->v.id = dpid;
}else{
lstr.s = p; lstr.len = strlen(p);
dp_par->v.sp[0] = pv_cache_get(&lstr);
if (dp_par->v.sp[0]==NULL)
goto error;
verify_par_type(param_no, dp_par->v.sp[0]);
dp_par->type = DP_VAL_SPEC;
}
} else {
if (((s = strchr(p, '/')) != 0) && (*(s+1)=='\0'))
goto error;
if (s != 0) {
*s = '\0'; s++;
}
lstr.s = p; lstr.len = strlen(p);
dp_par->v.sp[0] = pv_cache_get(&lstr);
if(dp_par->v.sp[0]==NULL)
goto error;
if (s != 0) {
lstr.s = s; lstr.len = strlen(s);
dp_par->v.sp[1] = pv_cache_get(&lstr);
if (dp_par->v.sp[1]==NULL)
goto error;
verify_par_type(param_no, dp_par->v.sp[1]);
}
dp_par->type = DP_VAL_SPEC;
}
*param = (void *)dp_par;
return 0;
error:
LM_ERR("failed to parse param %i\n", param_no);
return E_INVALID_PARAMS;
}
static int w_sdp_get_line_startswith(sip_msg_t *msg, char *avp, char *s_line)
{
sdp_info_t *sdp = NULL;
str body = {NULL, 0};
str line = {NULL, 0};
char* p = NULL;
str s;
str sline;
int_str avp_val;
int_str avp_name;
pv_spec_t *avp_spec = NULL;
static unsigned short avp_type = 0;
int sdp_missing=1;
if (s_line == NULL || strlen(s_line) <= 0)
{
LM_ERR("Search string is null or empty\n");
return -1;
}
sline.s = s_line;
sline.len = strlen(s_line);
sdp_missing = parse_sdp(msg);
if(sdp_missing < 0) {
LM_ERR("Unable to parse sdp\n");
return -1;
}
sdp = (sdp_info_t *)msg->body;
if (sdp_missing || sdp == NULL)
{
LM_DBG("No SDP\n");
return -2;
}
body.s = sdp->raw_sdp.s;
body.len = sdp->raw_sdp.len;
if (body.s==NULL) {
LM_ERR("failed to get the message body\n");
return -1;
}
body.len = msg->len - (body.s - msg->buf);
if (body.len==0) {
LM_DBG("message body has zero length\n");
return -1;
}
if (avp == NULL || strlen(avp) <= 0)
{
LM_ERR("avp variable is null or empty\n");
return -1;
}
s.s = avp;
s.len = strlen(s.s);
if (pv_locate_name(&s) != s.len)
{
LM_ERR("invalid parameter\n");
return -1;
}
if (((avp_spec = pv_cache_get(&s)) == NULL)
|| avp_spec->type!=PVT_AVP) {
LM_ERR("malformed or non AVP %s AVP definition\n", avp);
return -1;
}
if(pv_get_avp_name(0, &avp_spec->pvp, &avp_name, &avp_type)!=0)
{
LM_ERR("[%s]- invalid AVP definition\n", avp);
return -1;
}
p = find_sdp_line(body.s, body.s+body.len, sline.s[0]);
while (p != NULL)
{
if (sdp_locate_line(msg, p, &line) != 0)
{
LM_ERR("sdp_locate_line fail\n");
return -1;
}
if (strncmp(line.s, sline.s, sline.len) == 0)
{
avp_val.s.s = line.s;
avp_val.s.len = line.len;
/* skip ending \r\n if exists */
if (avp_val.s.s[line.len-2] == '\r' && avp_val.s.s[line.len-1] == '\n')
{
/* add_avp() clones to shm and adds 0-terminating char */
avp_val.s.len -= 2;
}
if (add_avp(AVP_VAL_STR | avp_type, avp_name, avp_val) != 0)
{
LM_ERR("Failed to add SDP line avp");
return -1;
}
return 1;
}
p = find_sdp_line(line.s + line.len, body.s + body.len, sline.s[0]);
}
return -1;
}
