/**
* Compile a string with pseudo variables substituted by their values.
* A string buffer is allocated. Deallocate afterwards!
*/
char *pv_sprintf(struct sip_msg *m, char *fmt) {
int buf_size = 4096;
pv_elem_t *model;
str s;
char *out = (char *)pkg_malloc(buf_size);
char *ret = NULL;
if (!out) {
LM_ERR("pv_sprintf: Memory exhausted!\n");
return NULL;
}
s.s = fmt; s.len = strlen(s.s);
if(pv_parse_format(&s, &model) < 0) {
LM_ERR("pv_sprintf: ERROR: wrong format[%s]!\n",
fmt);
return NULL;
}
if(pv_printf(m, model, out, &buf_size) < 0) {
ret = NULL;
} else {
ret = strdup(out);
}
pv_elem_free_all(model);
pkg_free(out);
return ret;
}
static int l_siplua_pseudoVar(lua_State *L)
{
struct sipapi_object *o;
const char *name;
str s;
pv_elem_t *model;
int buf_size = 4096;
char *out;
o = luaL_checkudata(L, 1, "siplua.api");
name = luaL_checkstring(L, 2);
s.s = (char *)name;
s.len = strlen(name);
if (pv_parse_format(&s, &model) < 0)
{
lua_pushnil(L);
return 1;
}
out = pkg_malloc(buf_size);
if (!out)
{
pv_elem_free_all(model);
return luaL_error(L, "Not enough memory");
}
if (pv_printf(o->msg, model, out, &buf_size) < 0)
lua_pushnil(L);
else
lua_pushstring(L, out);
pkg_free(out);
pv_elem_free_all(model);
return 1;
}
int xl_print_log(struct sip_msg* msg, pv_elem_p list, int *len)
{
if (log_buf == NULL)
if (buf_init())
{
LM_ERR("Cannot print message\n");
return -1;
}
return pv_printf(msg, list, log_buf, len);
}
void log_prefix_set(sip_msg_t *msg)
{
if(log_prefix_pvs == NULL)
return;
if(msg==NULL || !(IS_SIP(msg) || IS_SIP_REPLY(msg))) {
log_prefix_val = NULL;
return;
}
log_prefix_str.s = log_prefix_buf;
log_prefix_str.len = LOG_PREFIX_SIZE;
if(pv_printf(msg, log_prefix_pvs, log_prefix_str.s, &log_prefix_str.len)<0)
return;
if(log_prefix_str.len<=0)
return;
log_prefix_val = &log_prefix_str;
}
static int w_xcaps_put(sip_msg_t* msg, char* puri, char* ppath,
char* pbody)
{
str uri;
str path;
str body = {0, 0};
pv_elem_t *xm;
if(puri==0 || ppath==0 || pbody==0)
{
LM_ERR("invalid parameters\n");
goto error;
}
if(fixup_get_svalue(msg, (gparam_p)puri, &uri)!=0)
{
LM_ERR("unable to get uri\n");
goto error;
}
if(fixup_get_svalue(msg, (gparam_p)ppath, &path)!=0)
{
LM_ERR("unable to get path\n");
goto error;
}
xm = (pv_elem_t*)pbody;
body.len = xcaps_buf.len - 1;
if(pv_printf(msg, xm, xcaps_buf.s, &body.len)<0)
{
LM_ERR("unable to get body\n");
goto error;
}
body.s = xcaps_buf.s;
return ki_xcaps_put(msg, &uri, &path, &body);
error:
return -1;
}
int reginfo_subscribe_real(struct sip_msg* msg, pv_elem_t* uri, int expires) {
str uri_str = {0, 0};
char uri_buf[512];
int uri_buf_len = 512;
subs_info_t subs;
if (pv_printf(msg, uri, uri_buf, &uri_buf_len) < 0) {
LM_ERR("cannot print uri into the format\n");
return -1;
}
uri_str.s = uri_buf;
uri_str.len = uri_buf_len;
LM_DBG("Subscribing to %.*s\n", uri_str.len, uri_str.s);
memset(&subs, 0, sizeof(subs_info_t));
subs.remote_target = &uri_str;
subs.pres_uri= &uri_str;
subs.watcher_uri= &server_address;
subs.expires = expires;
subs.source_flag= REGINFO_SUBSCRIBE;
subs.event= REGINFO_EVENT;
subs.contact= &server_address;
if(outbound_proxy.s && outbound_proxy.len)
subs.outbound_proxy= &outbound_proxy;
subs.flag|= UPDATE_TYPE;
if(pua.send_subscribe(&subs)< 0) {
LM_ERR("while sending subscribe\n");
}
return 1;
}
/* @return : non-zero */
int ops_dbquery_avps(struct sip_msg* msg, pv_elem_t* query,
struct db_url *url, pvname_list_t* dest)
{
int printbuf_len;
int ret;
str qstr;
if(msg==NULL || query==NULL)
{
LM_ERR("bad parameters\n");
return -1;
}
printbuf_len = buf_size-1;
if(pv_printf(msg, query, printbuf, &printbuf_len)<0 || printbuf_len<=0)
{
LM_ERR("cannot print the query\n");
return -1;
}
qstr.s = printbuf;
qstr.len = printbuf_len;
LM_DBG("query [%.*s]\n", printbuf_len, printbuf);
ret = db_query_avp(url, msg, &qstr, dest);
//Empty return set
if(ret==1)
return -2;
//All other failures
if(ret!=0)
return -1;
//Have a return set
return 1;
}
int dialoginfo_set(struct sip_msg* msg, char* flag_pv, char* str2)
{
struct dlg_cell * dlg;
str peer_uri= {0, 0}; /* constructed from TO display name and RURI */
struct to_body* from, peer_to_body, FROM, *to;
str* ruri;
int len =0,ret=-1;
char flag= DLG_PUB_AB;
static char buf[256];
int buf_len= 255;
str flag_str;
char caller_buf[256], callee_buf[256];
pv_value_t tok;
peer_to_body.param_lst = FROM.param_lst = NULL;
if (msg->REQ_METHOD != METHOD_INVITE)
return 1;
if(dlg_api.create_dlg(msg,0)< 0)
{
LM_ERR("Failed to create dialog\n");
return -1;
}
dlg = dlg_api.get_dlg();
LM_DBG("new INVITE dialog created: from=%.*s\n",
dlg->from_uri.len, dlg->from_uri.s);
from = get_from(msg);
/* if defined overwrite */
if(caller_spec_param.s) /* if parameter defined */
{
memset(&tok, 0, sizeof(pv_value_t));
if(pv_get_spec_value(msg, &caller_spec, &tok) < 0) /* if value set */
{
LM_ERR("Failed to get caller value\n");
return -1;
}
if(tok.flags&PV_VAL_STR)
{
str caller_str;
if(tok.rs.len + CRLF_LEN > buf_len)
{
LM_ERR("Buffer overflow");
return -1;
}
trim(&tok.rs);
memcpy(caller_buf, tok.rs.s, tok.rs.len);
len = tok.rs.len;
if(strncmp(tok.rs.s+len-CRLF_LEN, CRLF, CRLF_LEN))
{
memcpy(caller_buf + len, CRLF, CRLF_LEN);
len+= CRLF_LEN;
}
parse_to(caller_buf, caller_buf+len , &FROM);
if(FROM.error != PARSE_OK)
{
LM_ERR("Failed to parse caller specification - not a valid uri\n");
goto end;
}
from = &FROM;
caller_str.s = caller_buf;
caller_str.len = len;
LM_DBG("caller: %*s- len= %d\n", len, caller_buf, len);
/* store caller in a dlg variable */
if(dlg_api.store_dlg_value(dlg, &entity_dlg_var, &caller_str)< 0)
{
LM_ERR("Failed to store dialog ruri\n");
goto end;
}
}
}
peer_uri.s = callee_buf;
if(callee_spec_param.s)
{
memset(&tok, 0, sizeof(pv_value_t));
if(pv_get_spec_value(msg, &callee_spec, &tok) < 0)
{
LM_ERR("Failed to get callee value\n");
goto end;
}
if(tok.flags&PV_VAL_STR)
{
if(tok.rs.len + CRLF_LEN > buf_len)
{
LM_ERR("Buffer overflow");
goto end;
}
trim(&tok.rs);
memcpy(peer_uri.s, tok.rs.s, tok.rs.len);
len = tok.rs.len;
if(strncmp(tok.rs.s+len-CRLF_LEN, CRLF, CRLF_LEN))
{
memcpy(peer_uri.s + len, CRLF, CRLF_LEN);
len+= CRLF_LEN;
}
peer_uri.len = len;
}
else
goto default_callee;
}
else
{
default_callee:
ruri = GET_RURI(msg);
to = get_to(msg);
len= to->display.len + 2 + ruri->len + CRLF_LEN;
if(len > buf_len)
{
LM_ERR("Buffer overflow\n");
goto end;
}
len = 0;
if(to->display.len && to->display.s)
{
memcpy(peer_uri.s, to->display.s, to->display.len);
peer_uri.s[to->display.len]='<';
len = to->display.len + 1;
}
memcpy(peer_uri.s + len, ruri->s, ruri->len);
len+= ruri->len;
if(to->display.len)
{
peer_uri.s[len++]='>';
}
memcpy(peer_uri.s + len, CRLF, CRLF_LEN);
len+= CRLF_LEN;
peer_uri.len = len;
}
LM_DBG("Peer uri = %.*s\n", peer_uri.len, peer_uri.s);
parse_to(peer_uri.s, peer_uri.s+peer_uri.len, &peer_to_body);
if(peer_to_body.error != PARSE_OK)
{
LM_ERR("Failed to peer uri [%.*s]\n", peer_uri.len, peer_uri.s);
goto end;
}
/* store peer uri in dialog structure */
if(dlg_api.store_dlg_value(dlg, &peer_dlg_var, &peer_uri)< 0)
{
LM_ERR("Failed to store dialog ruri\n");
goto end;
}
/* store flag, if defined */
if(flag_pv)
{
if(pv_printf(msg, (pv_elem_t*)flag_pv, buf, &buf_len)<0)
{
LM_ERR("cannot print the format\n");
goto end;
}
if(!check_flag(buf, buf_len))
{
LM_ERR("Wrong value for flag\n");
goto end;
}
flag = buf[0];
flag_str.s = buf;
flag_str.len = buf_len;
if(dlg_api.store_dlg_value(dlg, &flag_dlg_var, &flag_str)< 0)
{
LM_ERR("Failed to store dialog ruri\n");
goto end;
}
}
/* register dialog callbacks which triggers sending PUBLISH */
if (dlg_api.register_dlgcb(dlg,
DLGCB_FAILED| DLGCB_CONFIRMED | DLGCB_TERMINATED | DLGCB_EXPIRED |
DLGCB_RESPONSE_WITHIN | DLGCB_EARLY,
__dialog_sendpublish, 0, 0) != 0) {
LM_ERR("cannot register callback for interesting dialog types\n");
goto end;
}
#ifdef PUA_DIALOGINFO_DEBUG
/* dialog callback testing (registered last to be executed first) */
if (dlg_api.register_dlgcb(dlg,
DLGCB_FAILED| DLGCB_CONFIRMED | DLGCB_REQ_WITHIN | DLGCB_TERMINATED |
DLGCB_EXPIRED | DLGCB_EARLY | DLGCB_RESPONSE_FWDED |
DLGCB_RESPONSE_WITHIN | DLGCB_MI_CONTEXT | DLGCB_DESTROY,
__dialog_cbtest, NULL, NULL) != 0) {
LM_ERR("cannot register callback for all dialog types\n");
goto end;
}
#endif
if(publish_on_trying) {
if(flag == DLG_PUB_A || flag == DLG_PUB_AB)
dialog_publish("trying", from, &peer_to_body, &(dlg->callid), 1, DEFAULT_CREATED_LIFETIME, 0, 0);
if(flag == DLG_PUB_B || flag == DLG_PUB_AB)
dialog_publish("trying", &peer_to_body, from, &(dlg->callid), 0, DEFAULT_CREATED_LIFETIME, 0, 0);
}
ret=1;
end:
if (peer_to_body.param_lst)
free_to_params(&peer_to_body);
if (FROM.param_lst)
free_to_params(&FROM);
return ret;
}
/* Function that inserts a new b2b_logic record - the lock remains taken */
b2bl_tuple_t* b2bl_insert_new(struct sip_msg* msg,
unsigned int hash_index, b2b_scenario_t* scenario,
str* args[], str* body, str* custom_hdrs, int local_index, str** b2bl_key_s)
{
b2bl_tuple_t * it, *prev_it;
b2bl_tuple_t* tuple;
str* b2bl_key;
int i;
static char buf[256];
int buf_len= 255;
int size;
str extra_headers={0, 0};
str local_contact= server_address;
if(msg)
{
if(get_local_contact(msg, &local_contact)< 0)
{
LM_ERR("Failed to get received address\n");
local_contact= server_address;
}
}
size = sizeof(b2bl_tuple_t) + local_contact.len;
if(body && (use_init_sdp || (scenario && scenario->use_init_sdp)))
{
size+= body->len;
}
tuple = (b2bl_tuple_t*)shm_malloc(size);
if(tuple == NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
memset(tuple, 0, size);
size = sizeof(b2bl_tuple_t);
if(body && (use_init_sdp || (scenario && scenario->use_init_sdp)))
{
tuple->sdp.s = (char*)tuple + sizeof(b2bl_tuple_t);
memcpy(tuple->sdp.s, body->s, body->len);
tuple->sdp.len = body->len;
size += body->len;
}
tuple->local_contact.s = (char*)tuple + size;
memcpy(tuple->local_contact.s, local_contact.s, local_contact.len);
tuple->local_contact.len = local_contact.len;
tuple->scenario = scenario;
if(msg)
{
if(b2b_extra_headers(msg, NULL, custom_hdrs, &extra_headers)< 0)
{
LM_ERR("Failed to create extra headers\n");
goto error;
}
if(extra_headers.s)
{
tuple->extra_headers = (str*)shm_malloc(sizeof(str) + extra_headers.len);
if(tuple->extra_headers == NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
tuple->extra_headers->s = (char*)tuple->extra_headers + sizeof(str);
memcpy(tuple->extra_headers->s, extra_headers.s, extra_headers.len);
tuple->extra_headers->len = extra_headers.len;
pkg_free(extra_headers.s);
}
}
/* copy the function parameters that customize the scenario */
memset(tuple->scenario_params, 0, MAX_SCENARIO_PARAMS* sizeof(str));
if(scenario && args)
{
for(i = 0; i< scenario->param_no; i++)
{
if(args[i]==NULL)
{
LM_DBG("Fewer parameters, expected [%d] received [%d]\n",
scenario->param_no, i);
break;
}
/* must print the value of the argument */
if(msg && b2bl_caller != CALLER_MODULE)
{
buf_len= 255;
if(pv_printf(msg, (pv_elem_t*)args[i], buf, &buf_len)<0)
{
LM_ERR("cannot print the format\n");
goto error;
}
tuple->scenario_params[i].s = (char*)shm_malloc(buf_len);
if(tuple->scenario_params[i].s == NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
memcpy(tuple->scenario_params[i].s, buf, buf_len);
tuple->scenario_params[i].len = buf_len;
LM_DBG("Printed parameter [%.*s]\n", buf_len, buf);
}
else
{
if(args[i]->s==NULL || args[i]->len==0)
{
LM_DBG("Fewer parameters, expected [%d] received [%d]\n",
scenario->param_no, i);
break;
}
tuple->scenario_params[i].s = (char*)shm_malloc(args[i]->len);
if(tuple->scenario_params[i].s == NULL)
{
LM_ERR("No more shared memory\n");
goto error;
}
memcpy(tuple->scenario_params[i].s, args[i]->s, args[i]->len);
tuple->scenario_params[i].len = args[i]->len;
}
}
}
tuple->scenario_state = B2B_NOTDEF_STATE;
lock_get(&b2bl_htable[hash_index].lock);
if(local_index>= 0) /* a local index specified */
{
tuple->id = local_index;
if(b2bl_htable[hash_index].first == NULL)
{
b2bl_htable[hash_index].first = tuple;
tuple->prev = tuple->next = NULL;
}
else
{
prev_it = 0;
/*insert it in the proper place */
for(it = b2bl_htable[hash_index].first; it && it->id<local_index; it=it->next)
{
prev_it = it;
}
if(!prev_it)
{
b2bl_htable[hash_index].first = tuple;
tuple->prev = 0;
tuple->next = it;
it->prev = tuple;
}
else
{
tuple->prev = prev_it;
prev_it->next = tuple;
tuple->next = it;
if(it)
it->prev = tuple;
}
}
}
else
{
it = b2bl_htable[hash_index].first;
if(it == NULL)
{
b2bl_htable[hash_index].first = tuple;
tuple->prev = tuple->next = NULL;
tuple->id = 0;
}
else
{
while(it)
{
prev_it = it;
it = it->next;
}
prev_it->next = tuple;
tuple->prev = prev_it;
tuple->id = prev_it->id +1;
}
}
LM_DBG("for hi[%d]:\n", hash_index);
for(it = b2bl_htable[hash_index].first; it; it=it->next)
{
LM_DBG("%d->", it->id);
}
LM_DBG("\n");
b2bl_key = b2bl_generate_key(hash_index, tuple->id);
if(b2bl_key == NULL)
{
LM_ERR("failed to generate b2b logic key\n");
lock_release(&b2bl_htable[hash_index].lock);
return NULL;
}
tuple->key = b2bl_key;
*b2bl_key_s = b2bl_key;
tuple->db_flag = INSERTDB_FLAG;
LM_DBG("new tuple [%p]->[%.*s]\n", tuple, b2bl_key->len, b2bl_key->s);
return tuple;
error:
lock_release(&b2bl_htable[hash_index].lock);
return 0;
}
int cmd_erlang_rex(struct sip_msg* msg, char *cn , char *mo, char *fu, char *ar, char *_ret_pv) {
#define AVP_PRINTBUF_SIZE 1024
static char printbuf[AVP_PRINTBUF_SIZE];
int printbuf_len, bytessent;
ei_x_buff argbuf;
struct nodes_list* node;
struct erlang_cmd *erl_cmd;
erlang_pid erl_pid;
str conname, regproc;
str mod, fun;
int retcode = -1;
if(msg==NULL) {
LM_ERR("cmd_erlang_rex: received null msg\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)cn, &conname)<0) {
LM_ERR("cmd_erlang_rex: cannot get the connection name\n");
return -1;
}
for(node=nodes_lst;node;node=node->next) {
LM_DBG("matching %s with %.*s\n",node->name,conname.len,conname.s);
if(strcmp(node->name, conname.s)==0) break;
}
if(node==0){
LM_ERR("cmd_erlang_rex: no such connection %.*s\n",conname.len,conname.s);
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)mo, &mod)<0) {
LM_ERR("cmd_erlang_rex: cannot get the mod name\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)fu, &fun)<0) {
LM_ERR("cmd_erlang_rex: cannot get the fun name\n");
return -1;
}
printbuf_len = AVP_PRINTBUF_SIZE-1;
if(pv_printf(msg, (pv_elem_p)ar, printbuf, &printbuf_len)<0 || printbuf_len<=0)
{
LM_ERR("erlang_cmd_rex: cannot expand args expression.\n");
return -1;
}
erl_cmd=shm_malloc(sizeof(struct erlang_cmd));
if(!erl_cmd) {
LM_ERR("no shm");
return -1;
}
memset(erl_cmd,0,sizeof(struct erlang_cmd));
erl_cmd->erlbuf=shm_malloc(AVP_PRINTBUF_SIZE);
if (!erl_cmd->erlbuf) {
LM_ERR("no shm memory\n\n");
goto error;
}
erl_cmd->ret_pv = (pv_spec_t*)shm_malloc(sizeof(pv_spec_t));
if (!erl_cmd->ret_pv) {
LM_ERR("no shm memory\n\n");
goto error;
}
memcpy(erl_cmd->ret_pv, (pv_spec_t *)_ret_pv, sizeof(pv_spec_t));
if(lock_init(&(erl_cmd->lock))==NULL) {
LM_ERR("cannot init the lock\n");
goto error;
}
regproc.s="rex";
regproc.len=3;
erl_cmd->reg_name=shm_strdup(®proc);
if (!erl_cmd->reg_name) {
LM_ERR("no shm memory\n\n");
goto error;
}
LM_DBG("cmd_erlang_rex: %.*s rex %.*s\n",conname.len,conname.s,
printbuf_len,printbuf);
erl_cmd->cmd=ERLANG_REX;
erl_cmd->node=node;
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=AVP_PRINTBUF_SIZE-1;
argbuf.index=0;
ei_x_encode_version(&argbuf);
//User passed term will be second element of tuple, first is our (hacked) erlang pid
ei_x_encode_tuple_header(&argbuf, 2);
// we are hacking erlang pid so we can have worker system pid here
memcpy(&erl_pid,ei_self(&(node->ec)),sizeof(erlang_pid));
erl_pid.num=getpid();
ei_x_encode_pid(&argbuf, &erl_pid);
erl_cmd->num=erl_pid.num;
erl_cmd->serial=erl_pid.serial;
//so much for pid, now encode rex call tuple {call, mod, fun, arg, user}
ei_x_encode_tuple_header(&argbuf, 5);
ei_x_encode_atom(&argbuf,"call");
ei_x_encode_atom_len(&argbuf, mod.s, mod.len);
ei_x_encode_atom_len(&argbuf, fun.s, fun.len);
if(ei_x_format_wo_ver(&argbuf, printbuf)!=0) {
LM_ERR("cannot fromat erlang binary from arg string\n");
goto error;
}
ei_x_encode_atom(&argbuf,"user");
erl_cmd->erlbuf_len=argbuf.index;
lock_get(&(erl_cmd->lock));
bytessent=write(pipe_fds[1], &erl_cmd, sizeof(erl_cmd));
LM_DBG("cmd_erlang_call: locked, sent %d %d %s %d %p %p, waiting for release\n",bytessent,
erl_cmd->cmd,erl_cmd->reg_name,erl_cmd->erlbuf_len,erl_cmd->erlbuf, erl_cmd);
lock_get(&(erl_cmd->lock));
LM_DBG("after lock\n");
if (erl_cmd->retcode <0) {
retcode=erl_cmd->retcode;
LM_DBG("cmd_erlang_call: failed %d\n",retcode);
goto error;
}
//reuse
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=erl_cmd->erlbuf_len;
argbuf.index=erl_cmd->decode_index;
fill_retpv(erl_cmd->ret_pv,&argbuf,&(argbuf.index));
retcode=1;
error:
if(erl_cmd) {
if(erl_cmd->ret_pv) shm_free(erl_cmd->ret_pv);
if(erl_cmd->erlbuf) shm_free(erl_cmd->erlbuf);
if(erl_cmd->reg_name) shm_free(erl_cmd->reg_name);
shm_free(erl_cmd);
}
return retcode;
}
int cmd_erlang_info(struct sip_msg* msg, char *cn, char *rp, char *ar) {
#define AVP_PRINTBUF_SIZE 1024
static char printbuf[AVP_PRINTBUF_SIZE];
int printbuf_len, bytessent;
ei_x_buff argbuf;
struct nodes_list* node;
struct erlang_cmd *erl_cmd;
erlang_pid erl_pid;
str conname, regproc;
int retcode = -1;
if(msg==NULL) {
LM_ERR("cmd_erlang_info: received null msg\n");
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)cn, &conname)<0) {
LM_ERR("cmd_erlang_info: cannot get the connection name\n");
return -1;
}
for(node=nodes_lst;node;node=node->next) {
LM_DBG("cmd_erlang_info: matching %s with %.*s\n",node->name,conname.len,conname.s);
if(strcmp(node->name, conname.s)==0) break;
}
if(node==0){
LM_ERR("cmd_erlang_info: no such connection %.*s\n",conname.len,conname.s);
return -1;
}
if(fixup_get_svalue(msg, (gparam_p)rp, ®proc)<0) {
LM_ERR("cmd_erlang_info: cannot get the regproc name\n");
return -1;
}
printbuf_len = AVP_PRINTBUF_SIZE-1;
if(pv_printf(msg, (pv_elem_p)ar, printbuf, &printbuf_len)<0 || printbuf_len<=0)
{
LM_ERR("cmd_erlang_info: cannot expand erlang message body\n");
return -1;
}
erl_cmd=shm_malloc(sizeof(struct erlang_cmd));
if(!erl_cmd) {
LM_ERR("no shm");
return -1;
}
memset(erl_cmd,0,sizeof(struct erlang_cmd));
erl_cmd->erlbuf=shm_malloc(AVP_PRINTBUF_SIZE);
if (!erl_cmd->erlbuf) {
LM_ERR("no shm memory\n\n");
goto error;
}
if(lock_init(&(erl_cmd->lock))==NULL) {
LM_ERR("cannot init the lock\n");
goto error;
}
erl_cmd->reg_name=shm_strdup(®proc);
if (!erl_cmd->reg_name) {
LM_ERR("no shm memory\n\n");
goto error;
}
LM_DBG("cmd_erlang_info: %.*s %.*s %.*s\n",conname.len,conname.s,
regproc.len,regproc.s, printbuf_len,printbuf);
erl_cmd->cmd=ERLANG_INFO;
erl_cmd->node=node;
argbuf.buff=erl_cmd->erlbuf;
argbuf.buffsz=AVP_PRINTBUF_SIZE-1;
argbuf.index=0;
ei_x_encode_version(&argbuf);
//User passed term will be sedond element of tuple, first is our erlang pid
ei_x_encode_tuple_header(&argbuf, 2);
// we are hacking erlang pid so we can have worker system pid here
memcpy(&erl_pid,ei_self(&(node->ec)),sizeof(erlang_pid));
erl_pid.num=getpid();
ei_x_encode_pid(&argbuf, &erl_pid);
//so much for pid, now encode term
if(ei_x_format_wo_ver(&argbuf, printbuf)!=0) {
LM_ERR("cannot fromat erlang binary from arg string\n");
goto error;
}
// ei_x_encode_atom(&argbuf,"user");
erl_cmd->erlbuf_len=argbuf.index;
lock_get(&(erl_cmd->lock));
bytessent=write(pipe_fds[1], &erl_cmd, sizeof(erl_cmd));
LM_DBG("cmd_erlang_info: locked, sent %d %d %s %d %p %p, waiting for release\n",bytessent,
erl_cmd->cmd,erl_cmd->reg_name,erl_cmd->erlbuf_len,erl_cmd->erlbuf, erl_cmd);
lock_get(&(erl_cmd->lock));
LM_DBG("after lock\n");
if (erl_cmd->retcode <0) {
retcode=erl_cmd->retcode;
LM_DBG("cmd_erlang_info: failed %d\n",retcode);
goto error;
}
retcode=1;
error:
if(erl_cmd) {
if(erl_cmd->erlbuf) shm_free(erl_cmd->erlbuf);
if(erl_cmd->reg_name) shm_free(erl_cmd->reg_name);
shm_free(erl_cmd);
}
return retcode;
}
static int
mmg_lookup_cmd(struct sip_msg *msg, char *_fields_pv, char *_ipaddr_pv, char *_dst_spec)
{
pv_elem_t *fields_pv=(pv_elem_t*)_fields_pv, *ipaddr_pv=(pv_elem_t*)_ipaddr_pv;
pv_spec_t *dst_spec=(pv_spec_t*)_dst_spec;
GeoIPRecord *gir=0;
str field_str, ipaddr_str;
char rslt_buf[256], ipaddr_buf[256], field_buf[256];
char *token=0, *saveptr=0;
int dst_name=-1;
int_str rslt=(int_str)0;
unsigned short dstType=0;
/* Sanity checks */
if(!(ipaddr_pv && fields_pv && dst_spec)) {
LM_ERR("Missing argument(s).\n");
return -1;
}
if(dst_spec->type != PVT_AVP) {
LM_ERR("Invalid destination spec -- expected AVP.\n");
return -1;
}
if(pv_get_avp_name(msg, &(dst_spec->pvp), &dst_name, &dstType)!=0) {
LM_ERR("Internal error getting AVP name.\n");
return -1;
}
/* Expand input args: lookup field list and IP address.*/
*ipaddr_buf=0;
ipaddr_str.s=ipaddr_buf;
ipaddr_str.len=sizeof ipaddr_buf;
if(pv_printf(msg, ipaddr_pv, ipaddr_buf, &ipaddr_str.len) || ipaddr_str.len==0) {
LM_ERR("Internal error parsing IP address.\n");
return -1;
}
*field_buf=0;
field_str.s=field_buf;
field_str.len=sizeof field_buf;
if(pv_printf(msg, fields_pv, field_buf, &field_str.len) || field_str.len==0) {
LM_ERR("Internal error parsing lookup fields.\n");
return -1;
}
/* Attempt lookup */
if(!(gir=GeoIP_record_by_name (MMG_gi,ipaddr_buf))){
LM_DBG("'%s'--> 'Unknown'.\n", *ipaddr_buf?ipaddr_buf:"Undefined");
return -1;
}
/* Construct return data. Know fields are: */
/* lat - latitude */
/* lon - longitude */
/* cont - continent */
/* cc - country code */
/* reg - region */
/* city - city */
/* pc - postal code */
/* dma - dma code */
/* ac - area code */
/* tz - timezone */
#define MMG_FAIL_EXIT if(gir) GeoIPRecord_delete(gir); return -1
LM_DBG("ipaddr:'%.*s'; fields:'%.*s'.\n",
ipaddr_str.len, ipaddr_str.s, field_str.len, field_str.s);
*rslt_buf=0;
rslt.s.s=rslt_buf;
token=strtok_r(field_buf,MMG_OP_DELIMS,&saveptr);
while (token) {
if(!strcmp(token,"lat")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%f",gir->latitude); }
else if(!strcmp(token,"lon")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%f",gir->longitude); }
else if(!strcmp(token,"cont")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->continent_code); }
else if(!strcmp(token,"cc")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->country_code); }
else if(!strcmp(token,"reg")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->region); }
else if(!strcmp(token,"city")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->city); }
else if(!strcmp(token,"pc")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%s",gir->postal_code); }
else if(!strcmp(token,"dma")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%d",gir->dma_code); }
else if(!strcmp(token,"ac")) { rslt.s.len=snprintf(rslt_buf,sizeof rslt_buf,"%d",gir->area_code); }
else if(!strcmp(token,"rbc")) {
rslt.s.len=snprintf(
rslt_buf,sizeof rslt_buf,"%s",GeoIP_region_name_by_code(gir->country_code, gir->region));
}
else if(!strcmp(token,"tz")) {
rslt.s.len=snprintf(
rslt_buf,sizeof rslt_buf,"%s",GeoIP_time_zone_by_country_and_region(gir->country_code, gir->region));
} else {
LM_ERR("unknown field:'%s'\n",token);
MMG_FAIL_EXIT;
}
if(rslt.s.len<0 || rslt.s.len>sizeof rslt_buf ||
add_avp(dstType|AVP_VAL_STR,dst_name,rslt)==-1 ) {
LM_ERR("Internal error processing field/IP '%s/%s'.\n",
token,ipaddr_buf);
MMG_FAIL_EXIT;
}
LM_DBG("field %s[%s] %.*s\n",ipaddr_buf,token,rslt.s.len,rslt.s.s);
token=strtok_r(0,MMG_OP_DELIMS,&saveptr);
}
GeoIPRecord_delete(gir);
return 1;
}
/** Get the function parameter value as string or/and integer (if possible).
* @return 0 - Success
* -1 - Cannot get value
*/
int get_is_fparam(int* i_dst, str* s_dst, struct sip_msg* msg, fparam_t* param, unsigned int *flags)
{
int_str val;
int ret;
avp_t* avp;
str tmp;
pv_value_t pv_val;
*flags = 0;
switch(param->type) {
case FPARAM_INT:
*i_dst = param->v.i;
*flags |= PARAM_INT;
return 0;
case FPARAM_REGEX:
case FPARAM_UNSPEC:
case FPARAM_STRING:
s_dst->s = param->v.asciiz;
s_dst->len = strlen(param->v.asciiz);
*flags |= PARAM_STR;
break;
case FPARAM_STR:
*s_dst = param->v.str;
*flags |= PARAM_STR;
break;
case FPARAM_AVP:
avp = search_first_avp(param->v.avp.flags, param->v.avp.name,
&val, 0);
if (unlikely(!avp)) {
LM_DBG("Could not find AVP from function parameter '%s'\n",
param->orig);
return -1;
}
if (avp->flags & AVP_VAL_STR) {
*s_dst = val.s;
*flags |= PARAM_STR;
if (str2int(&val.s, (unsigned int*)i_dst) < 0) {
LM_ERR("Could not convert AVP string value to int\n");
return -1;
}
} else {
*i_dst = val.n;
*flags |= PARAM_INT;
}
break;
case FPARAM_SELECT:
ret = run_select(&tmp, param->v.select, msg);
if (unlikely(ret < 0 || ret > 0)) return -1;
if (unlikely(str2int(&tmp, (unsigned int*)i_dst) < 0)) {
LM_ERR("Could not convert select result to int\n");
return -1;
}
*flags |= PARAM_INT;
break;
case FPARAM_PVS:
if (likely(pv_get_spec_value(msg, param->v.pvs, &pv_val)==0)) {
if ((pv_val.flags&(PV_VAL_NULL|PV_VAL_INT))==PV_VAL_INT){
*i_dst=pv_val.ri;
*flags |= PARAM_INT;
}
if ((pv_val.flags&(PV_VAL_NULL|PV_VAL_STR))==PV_VAL_STR){
*s_dst=pv_val.rs;
*flags |= PARAM_STR;
}
}else{
LM_ERR("Could not get PV\n");
return -1;
}
break;
case FPARAM_PVE:
s_dst->s=pv_get_buffer();
s_dst->len=pv_get_buffer_size();
if (unlikely(pv_printf(msg, param->v.pve, s_dst->s, &s_dst->len)!=0)){
LM_ERR("Could not convert the PV-formated string to str\n");
s_dst->len=0;
return -1;
}
*flags |= PARAM_STR;
break;
}
/* Let's convert to int, if possible */
if (!(*flags & PARAM_INT) && (*flags & PARAM_STR) && str2sint(s_dst, i_dst) == 0)
*flags |= PARAM_INT;
if (!*flags) return -1;
return 0;
}
/** Get the function parameter value as string.
* @return 0 - Success
* -1 - Cannot get value
*/
int get_str_fparam(str* dst, struct sip_msg* msg, fparam_t* param)
{
int_str val;
int ret;
avp_t* avp;
pv_value_t pv_val;
switch(param->type) {
case FPARAM_REGEX:
case FPARAM_UNSPEC:
case FPARAM_INT:
return -1;
case FPARAM_STRING:
dst->s = param->v.asciiz;
dst->len = strlen(param->v.asciiz);
break;
case FPARAM_STR:
*dst = param->v.str;
break;
case FPARAM_AVP:
avp = search_first_avp(param->v.avp.flags, param->v.avp.name,
&val, 0);
if (unlikely(!avp)) {
LM_DBG("Could not find AVP from function parameter '%s'\n",
param->orig);
return -1;
}
if (likely(avp->flags & AVP_VAL_STR)) {
*dst = val.s;
} else {
/* The caller does not know of what type the AVP will be so
* convert int AVPs into string here
*/
dst->s = int2str(val.n, &dst->len);
}
break;
case FPARAM_SELECT:
ret = run_select(dst, param->v.select, msg);
if (unlikely(ret < 0 || ret > 0)) return -1;
break;
case FPARAM_PVS:
if (likely((pv_get_spec_value(msg, param->v.pvs, &pv_val)==0) &&
((pv_val.flags&(PV_VAL_NULL|PV_VAL_STR))==PV_VAL_STR))){
*dst=pv_val.rs;
}else{
LM_ERR("Could not convert PV to str\n");
return -1;
}
break;
case FPARAM_PVE:
dst->s=pv_get_buffer();
dst->len=pv_get_buffer_size();
if (unlikely(pv_printf(msg, param->v.pve, dst->s, &dst->len)!=0)){
LM_ERR("Could not convert the PV-formated string to str\n");
dst->len=0;
return -1;
};
break;
}
return 0;
}
int reginfo_subscribe_real(struct sip_msg* msg, pv_elem_t* uri, str* service_routes, int expires) {
str uri_str = {0, 0};
char uri_buf[512];
int uri_buf_len = 512;
//subs_info_t subs;
str p_asserted_identity_header;
reginfo_event_t *new_event;
str *subs_outbound_proxy = 0;
int len = strlen(P_ASSERTED_IDENTITY_HDR_PREFIX) + pcscf_uri.len + 1 + CRLF_LEN;
p_asserted_identity_header.s = (char *)pkg_malloc( len );
if ( p_asserted_identity_header.s == NULL ) {
LM_ERR( "insert_asserted_identity: pkg_malloc %d bytes failed", len );
goto error;
}
memcpy(p_asserted_identity_header.s, P_ASSERTED_IDENTITY_HDR_PREFIX, strlen(P_ASSERTED_IDENTITY_HDR_PREFIX));
p_asserted_identity_header.len = strlen(P_ASSERTED_IDENTITY_HDR_PREFIX);
memcpy(p_asserted_identity_header.s + p_asserted_identity_header.len, pcscf_uri.s, pcscf_uri.len);
p_asserted_identity_header.len += pcscf_uri.len;
*(p_asserted_identity_header.s + p_asserted_identity_header.len) = '>';
p_asserted_identity_header.len ++;
memcpy( p_asserted_identity_header.s + p_asserted_identity_header.len, CRLF, CRLF_LEN );
p_asserted_identity_header.len += CRLF_LEN;
if (pv_printf(msg, uri, uri_buf, &uri_buf_len) < 0) {
LM_ERR("cannot print uri into the format\n");
goto error;
}
uri_str.s = uri_buf;
uri_str.len = uri_buf_len;
LM_DBG("p_asserted_identity_header: [%.*s]", p_asserted_identity_header.len, p_asserted_identity_header.s);
LM_DBG("Subscribing to %.*s\n", uri_str.len, uri_str.s);
if(force_icscf_uri.s && force_icscf_uri.len) {
subs_outbound_proxy= &force_icscf_uri;
}
new_event = new_reginfo_event(REG_EVENT_SUBSCRIBE, 0, 0, 0, &uri_str, &pcscf_uri, &pcscf_uri,
subs_outbound_proxy, expires, UPDATE_TYPE, REGINFO_SUBSCRIBE, REGINFO_EVENT, &p_asserted_identity_header, &uri_str);
if (!new_event) {
LM_ERR("Unable to create event for cdp callback\n");
goto error;
}
//push the new event onto the stack (FIFO)
push_reginfo_event(new_event);
if (p_asserted_identity_header.s) {
pkg_free(p_asserted_identity_header.s);
}
return 1;
error:
if (p_asserted_identity_header.s) {
pkg_free(p_asserted_identity_header.s);
}
return -1;
}
int xl_print_log(struct sip_msg* msg, pv_elem_p list, char *buf, int *len)
{
return pv_printf(msg, list, buf, len);
}
static int w_xcaps_put(sip_msg_t* msg, char* puri, char* ppath,
char* pbody)
{
struct sip_uri turi;
str uri;
str path;
str body = {0, 0};
str etag;
str etag_hdr;
str tbuf;
str nbuf = {0, 0};
str allow = {0, 0};
pv_elem_t *xm;
xcap_uri_t xuri;
if(puri==0 || ppath==0 || pbody==0)
{
LM_ERR("invalid parameters\n");
goto error;
}
if(fixup_get_svalue(msg, (gparam_p)puri, &uri)!=0)
{
LM_ERR("unable to get uri\n");
goto error;
}
if(uri.s==NULL || uri.len == 0)
{
LM_ERR("invalid uri parameter\n");
goto error;
}
if(fixup_get_svalue(msg, (gparam_p)ppath, &path)!=0)
{
LM_ERR("unable to get path\n");
goto error;
}
if(path.s==NULL || path.len == 0)
{
LM_ERR("invalid path parameter\n");
return -1;
}
if(parse_uri(uri.s, uri.len, &turi)!=0)
{
LM_ERR("parsing uri parameter\n");
goto error;
}
if(xcap_parse_uri(&path, &xcaps_root, &xuri)<0)
{
LM_ERR("cannot parse xcap uri [%.*s]\n",
path.len, path.s);
goto error;
}
switch(xuri.type)
{
case DIRECTORY:
case XCAP_CAPS:
allow.s = xcaps_hdr_buf;
allow.len = snprintf(allow.s, XCAPS_HDR_SIZE, "Allow: GET\r\n");
xcaps_send_reply(msg, 405, &xcaps_str_notallowed, &allow, NULL, NULL);
break;
case SEARCH:
allow.s = xcaps_hdr_buf;
allow.len = snprintf(allow.s, XCAPS_HDR_SIZE, "Allow: POST\r\n");
xcaps_send_reply(msg, 405, &xcaps_str_notallowed, &allow, NULL, NULL);
break;
default:
xm = (pv_elem_t*)pbody;
body.len = xcaps_buf.len - 1;
if(pv_printf(msg, xm, xcaps_buf.s, &body.len)<0)
{
LM_ERR("unable to get body\n");
goto error;
}
if(body.len <= 0)
{
LM_ERR("invalid body parameter\n");
goto error;
}
body.s = (char*)pkg_malloc(body.len+1);
if(body.s==NULL)
{
LM_ERR("no more pkg\n");
goto error;
}
memcpy(body.s, xcaps_buf.s, body.len);
body.s[body.len] = '\0';
xcaps_get_db_etag(&turi.user, &turi.host, &xuri, &etag);
if(check_preconditions(msg, etag)!=1)
{
xcaps_send_reply(msg, 412, &xcaps_str_precon, NULL, NULL, NULL);
pkg_free(body.s);
return -2;
}
if(xuri.nss!=NULL && xuri.node.len>0)
{
/* partial document upload
* - fetch, update, delete and store
*/
if(xcaps_get_db_doc(&turi.user, &turi.host, &xuri, &tbuf) != 0)
{
LM_ERR("could not fetch xcap document\n");
goto error;
}
if(xcaps_xpath_hack(&tbuf, 0)<0)
{
LM_ERR("could not hack xcap document\n");
goto error;
}
if(xcaps_xpath_set(&tbuf, &xuri.node, &body, &nbuf)<0)
{
LM_ERR("could not update xcap document\n");
goto error;
}
if(nbuf.len<=0)
{
LM_ERR("no new content\n");
goto error;
}
pkg_free(body.s);
body = nbuf;
if(xcaps_xpath_hack(&body, 1)<0)
{
LM_ERR("could not hack xcap document\n");
goto error;
}
}
if(xcaps_generate_etag_hdr(&etag_hdr)<0)
{
LM_ERR("could not generate etag\n");
goto error;
}
etag.s = etag_hdr.s + 7; /* 'ETag: "' */
etag.len = etag_hdr.len - 10; /* 'ETag: " "\r\n' */
if(xcaps_put_db(&turi.user, &turi.host,
&xuri, &etag, &body)<0)
{
LM_ERR("could not store document\n");
goto error;
}
xcaps_send_reply(msg, 200, &xcaps_str_ok, &etag_hdr,
NULL, NULL);
if(body.s!=NULL)
pkg_free(body.s);
break;
}
return 1;
error:
xcaps_send_reply(msg, 500, &xcaps_str_srverr, NULL, NULL, NULL);
if(body.s!=NULL)
pkg_free(body.s);
return -1;
}
int ops_async_dbquery(struct sip_msg* msg, async_resume_module **rfunc,
void **rparam, pv_elem_t *query, struct db_url *url, pvname_list_t *dest)
{
int printbuf_len;
int rc, read_fd;
query_async_param *param;
str qstr;
void *_tmp_db_param;
if (!msg || !query)
{
LM_ERR("bad parameters\n");
return -1;
}
printbuf_len = buf_size - 1;
if (pv_printf(msg, query, printbuf, &printbuf_len) < 0 || printbuf_len <= 0)
{
LM_ERR("cannot print the query\n");
return -1;
}
LM_DBG("query [%s]\n", printbuf);
qstr.s = printbuf;
qstr.len = printbuf_len;
/* No async capabilities - just run it in blocking mode */
if (!DB_CAPABILITY(url->dbf, DB_CAP_ASYNC_RAW_QUERY))
{
rc = db_query_avp(url, msg, &qstr, dest);
LM_DBG("sync query \"%.*s\" returned: %d\n", qstr.len, qstr.s, rc);
*rparam = NULL;
*rfunc = NULL;
async_status = ASYNC_NO_IO;
/* Empty_set / Other_errors / Success */
return rc == 1 ? -2 : (rc != 0 ? -1 : 1);
}
read_fd = url->dbf.async_raw_query(url->hdl, &qstr, &_tmp_db_param);
if (read_fd < 0)
{
*rparam = NULL;
*rfunc = NULL;
return -1;
}
param = pkg_malloc(sizeof *param);
if (!param)
{
LM_ERR("no more pkg mem\n");
return E_OUT_OF_MEM;
}
memset(param, '\0', sizeof *param);
*rparam = param;
*rfunc = resume_async_dbquery;
param->output_avps = dest;
param->hdl = url->hdl;
param->dbf = &url->dbf;
param->db_param = _tmp_db_param;
async_status = read_fd;
return 1;
}
int pv_printf_s(struct sip_msg* msg, pv_elem_p list, str *s)
{
s->s = pv_get_buffer();
s->len = pv_get_buffer_size();
return pv_printf( msg, list, s->s, &s->len);
}
