/* run reply route functions */
int run_reply_route(struct sip_msg *_rpl, struct cell *_t, int index)
{
avp_list_t *backup_uri_from, *backup_uri_to;
avp_list_t *backup_user_from, *backup_user_to;
avp_list_t *backup_domain_from, *backup_domain_to;
struct run_act_ctx ra_ctx;
if (!_t || (index < 0)) return -1;
/* set the avp_list the one from transaction */
backup_uri_from = set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &_t->uri_avps_from );
backup_uri_to = set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &_t->uri_avps_to );
backup_user_from = set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &_t->user_avps_from );
backup_user_to = set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &_t->user_avps_to );
backup_domain_from = set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &_t->domain_avps_from );
backup_domain_to = set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &_t->domain_avps_to );
init_run_actions_ctx(&ra_ctx);
if (run_actions(&ra_ctx, onreply_rt.rlist[index], _rpl)<0)
LOG(L_ERR, "ERROR: run_reply_route(): on_reply processing failed\n");
/* restore original avp list */
set_avp_list( AVP_TRACK_FROM | AVP_CLASS_URI, backup_uri_from );
set_avp_list( AVP_TRACK_TO | AVP_CLASS_URI, backup_uri_to );
set_avp_list( AVP_TRACK_FROM | AVP_CLASS_USER, backup_user_from );
set_avp_list( AVP_TRACK_TO | AVP_CLASS_USER, backup_user_to );
set_avp_list( AVP_TRACK_FROM | AVP_CLASS_DOMAIN, backup_domain_from );
set_avp_list( AVP_TRACK_TO | AVP_CLASS_DOMAIN, backup_domain_to );
return 0;
}
int nsq_consumer_fire_event(char *routename)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
LM_DBG("searching event_route[%s]\n", routename);
rt = route_get(&event_rt, routename);
if (rt < 0 || event_rt.rlist[rt] == NULL) {
LM_DBG("route %s does not exist\n", routename);
return -2;
}
LM_DBG("executing event_route[%s] (%d)\n", routename, rt);
if (faked_msg_init()<0) {
return -2;
}
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(rtb);
return 0;
}
void uac_req_run_event_route(sip_msg_t *msg, uac_send_info_t *tp, int rcode)
{
char *evrtname = "uac:reply";
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
rt = route_get(&event_rt, evrtname);
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("event_route[uac:reply] does not exist\n");
return;
}
uac_send_info_copy(tp, &_uac_req);
_uac_req.evcode = rcode;
if(msg==NULL)
{
_uac_req.evtype = 2;
fmsg = faked_msg_get_next();
} else {
_uac_req.evtype = 1;
fmsg = msg;
}
backup_rt = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
static int dbops_foreach_func(struct sip_msg* m, char* handle, char* route_no) {
int res;
db_rec_t* rec;
struct dbops_handle *a = (void *) handle;
struct run_act_ctx ra_ctx;
if ((long)route_no >= main_rt.idx) {
BUG("invalid routing table number #%ld of %d\n", (long) route_no, main_rt.idx);
return -1;
}
if (!main_rt.rlist[(long) route_no]) {
WARN(MODULE_NAME": route not declared (hash:%ld)\n", (long) route_no);
return -1;
}
res = check_query_opened(a, "for_each");
if (res < 0) return res;
res = -1;
a->cur_row_no = 0;
for(rec = db_first(a->result);
rec != NULL;
rec = db_next(a->result),
a->cur_row_no++) {
/* exec the routing script */
init_run_actions_ctx(&ra_ctx);
res = run_actions(&ra_ctx, main_rt.rlist[(long) route_no], m);
if (res <= 0) break;
}
if (!rec) a->cur_row_no = -1;
return res;
}
static void wsconn_run_route(ws_connection_t *wsc)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
LM_DBG("wsconn_run_route event_route[websocket:closed]\n");
rt = route_get(&event_rt, "websocket:closed");
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("route does not exist");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
wsc->rcv.proto_reserved1 = wsc->id;
fmsg->rcv = wsc->rcv;
backup_rt = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
static void tcpops_tcp_closed_run_route(struct tcp_connection *con)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
LM_DBG("tcp_closed_run_route event_route[tcp:closed]\n");
rt = route_get(&event_rt, "tcp:closed");
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
LM_DBG("route does not exist");
return;
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->rcv = con->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
int evapi_run_cfg_route(evapi_env_t *evenv, int rt)
{
int backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
sip_msg_t tmsg;
if(evenv==0 || evenv->eset==0) {
LM_ERR("evapi env not set\n");
return -1;
}
if(rt<0)
return 0;
fmsg = faked_msg_next();
memcpy(&tmsg, fmsg, sizeof(sip_msg_t));
fmsg = &tmsg;
evapi_set_msg_env(fmsg, evenv);
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
evapi_set_msg_env(fmsg, NULL);
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);
}
static int fire_init_event(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
LM_DBG("rank is (%d)\n", rank);
if (rank!=PROC_INIT)
return 0;
rt = route_get(&event_rt, "kazoo:mod-init");
if(rt>=0 && event_rt.rlist[rt]!=NULL) {
LM_DBG("executing event_route[kazoo:mod-init] (%d)\n", rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
if(ctx.run_flags&DROP_R_F)
{
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
set_route_type(rtb);
}
return 0;
}
static int xhttp_process_request(sip_msg_t* orig_msg,
char* new_buf, unsigned int new_len)
{
int ret;
sip_msg_t tmp_msg, *msg;
struct run_act_ctx ra_ctx;
ret=0;
if (new_buf && new_len)
{
memset(&tmp_msg, 0, sizeof(sip_msg_t));
tmp_msg.buf = new_buf;
tmp_msg.len = new_len;
tmp_msg.rcv = orig_msg->rcv;
tmp_msg.id = orig_msg->id;
tmp_msg.set_global_address = orig_msg->set_global_address;
tmp_msg.set_global_port = orig_msg->set_global_port;
if (parse_msg(new_buf, new_len, &tmp_msg) != 0)
{
LM_ERR("parse_msg failed\n");
goto error;
}
msg = &tmp_msg;
} else {
msg = orig_msg;
}
if ((msg->first_line.type != SIP_REQUEST) || (msg->via1 == 0) ||
(msg->via1->error != PARSE_OK))
{
LM_CRIT("strange message: %.*s\n", msg->len, msg->buf);
goto error;
}
if (exec_pre_script_cb(msg, REQUEST_CB_TYPE) == 0)
{
goto done;
}
init_run_actions_ctx(&ra_ctx);
if (run_actions(&ra_ctx, event_rt.rlist[xhttp_route_no], msg) < 0)
{
ret=-1;
LM_DBG("error while trying script\n");
goto done;
}
done:
exec_post_script_cb(msg, REQUEST_CB_TYPE);
if (msg != orig_msg)
{
free_sip_msg(msg);
}
return ret;
error:
return -1;
}
/**
* change the uri according to update mode
*/
static int update_new_uri(struct sip_msg *msg, int plen, str *d, int mode)
{
struct action act;
struct run_act_ctx ra_ctx;
if(msg==NULL || d==NULL)
{
LM_ERR("bad parameters\n");
return -1;
}
if(mode==0 || (mode==1 && pdt_prefix.len>0))
{
memset(&act, '\0', sizeof(act));
act.type = STRIP_T;
act.val[0].type = NUMBER_ST;
if(mode==0)
act.val[0].u.number = plen + pdt_prefix.len;
else
act.val[0].u.number = pdt_prefix.len;
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, msg) < 0)
{
LM_ERR("failed to remove prefix parameter\n");
return -1;
}
}
memset(&act, '\0', sizeof(act));
act.type = SET_HOSTALL_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = d->s;
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, msg) < 0)
{
LM_ERR("failed to change domain\n");
return -1;
}
LM_DBG("len=%d uri=%.*s\n", msg->new_uri.len,
msg->new_uri.len, msg->new_uri.s);
return 0;
}
static int attr2uri(struct sip_msg* msg, char* p1, char* p2)
{
int_str value;
avp_t* avp_entry;
struct action act;
struct run_act_ctx ra_ctx;
int pnr;
unsigned int u;
if (p2) {
pnr = ((fparam_t*)p2)->v.i;
} else {
pnr = SET_URI_T;
}
avp_entry = search_avp(((fparam_t*)p1)->v.avp, &value, NULL);
if (avp_entry == 0) {
ERR("attr2uri: AVP '%s' not found\n", ((fparam_t*)p1)->orig);
return -1;
}
memset(&act, 0, sizeof(act));
if ((pnr == STRIP_T) || (pnr == STRIP_TAIL_T)) {
/* we need integer value for these actions */
if (avp_entry->flags & AVP_VAL_STR) {
if (str2int(&value.s, &u)) {
ERR("not an integer value: %.*s\n",
value.s.len, value.s.s);
return -1;
}
act.val[0].u.number = u;
} else {
act.val[0].u.number = value.n;
}
act.val[0].type = NUMBER_ST;
} else {
/* we need string value */
if ((avp_entry->flags & AVP_VAL_STR) == 0) {
act.val[0].u.string = int2str(value.n, NULL);
} else {
act.val[0].u.string = value.s.s;
}
act.val[0].type = STRING_ST;
}
act.type = pnr;
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, msg) < 0) {
ERR("failed to change ruri part.\n");
return -1;
}
return 1;
}
static void wsconn_run_route(ws_connection_t *wsc)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
sr_kemi_eng_t *keng = NULL;
str evrtname = str_init("websocket:closed");
LM_DBG("wsconn_run_route event_route[websocket:closed]\n");
rt = route_lookup(&event_rt, evrtname.s);
if (rt < 0 || event_rt.rlist[rt] == NULL)
{
if(ws_event_callback.len<=0 || ws_event_callback.s==NULL) {
LM_DBG("event route does not exist");
return;
}
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_DBG("event route callback engine does not exist");
return;
} else {
rt = -1;
}
}
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
wsc->rcv.proto_reserved1 = wsc->id;
fmsg->rcv = wsc->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
if(rt<0) {
/* kemi script event route callback */
if(keng && keng->froute(fmsg, EVENT_ROUTE,
&ws_event_callback, &evrtname)<0) {
LM_ERR("error running event route kemi callback\n");
}
} else {
/* native cfg event route */
run_top_route(event_rt.rlist[rt], fmsg, 0);
}
set_route_type(backup_rt);
}
static int msrp_frame_received(void *data)
{
tcp_event_info_t *tev;
static msrp_frame_t mf;
sip_msg_t *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
tev = (tcp_event_info_t*)data;
if(tev==NULL || tev->buf==NULL || tev->len<=0)
{
LM_DBG("invalid parameters\n");
return -1;
}
memset(&mf, 0, sizeof(msrp_frame_t));
mf.buf.s = tev->buf;
mf.buf.len = tev->len;
mf.tcpinfo = tev;
if(msrp_parse_frame(&mf)<0)
{
LM_ERR("error parsing msrp frame\n");
return -1;
}
msrp_reset_env();
msrp_set_current_frame(&mf);
rt = route_get(&event_rt, "msrp:frame-in");
if(rt>=0 && event_rt.rlist[rt]!=NULL) {
LM_DBG("executing event_route[msrp:frame-in] (%d)\n", rt);
fmsg = msrp_fake_sipmsg(&mf);
if(fmsg!=NULL)
fmsg->rcv = *tev->rcv;
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
if(ctx.run_flags&DROP_R_F)
{
LM_DBG("exit due to 'drop' in event route\n");
}
set_route_type(rtb);
if(fmsg!=NULL)
free_sip_msg(fmsg);
}
msrp_reset_env();
msrp_destroy_frame(&mf);
return 0;
}
int nio_msg_received(void *data)
{
sip_msg_t msg;
str *obuf;
char *nbuf = NULL;
int_str avp_value;
struct usr_avp *avp;
struct run_act_ctx ra_ctx;
obuf = (str*)data;
if (obuf->len < nio_min_msg_len) {
return -1;
}
memset(&msg, 0, sizeof(sip_msg_t));
msg.buf = obuf->s;
msg.len = obuf->len;
nio_is_incoming = 1;
init_run_actions_ctx(&ra_ctx);
run_actions(&ra_ctx, event_rt.rlist[nio_route_no], &msg);
if(nio_msg_avp_name.n!=0) {
avp = NULL;
avp=search_first_avp(nio_msg_avp_type, nio_msg_avp_name,
&avp_value, 0);
if(avp!=NULL && is_avp_str_val(avp)) {
msg.buf = avp_value.s.s;
msg.len = avp_value.s.len;
nbuf = nio_msg_update(&msg, (unsigned int*)&obuf->len);
if(obuf->len>=BUF_SIZE) {
LM_ERR("new buffer overflow (%d)\n", obuf->len);
pkg_free(nbuf);
return -1;
}
memcpy(obuf->s, nbuf, obuf->len);
obuf->s[obuf->len] = '\0';
} else {
LM_WARN("no value set for AVP %.*s, using unmodified message\n",
nio_msg_avp_param.len, nio_msg_avp_param.s);
}
}
if(nbuf!=NULL)
pkg_free(nbuf);
free_sip_msg(&msg);
return 0;
}
/*! Run a request route block if it exists
*/
static int w_route_exists(struct sip_msg *msg, char *route)
{
struct run_act_ctx ctx;
int newroute, backup_rt, ret;
newroute = route_lookup(&main_rt, route);
if (newroute<0) {
return -1;
}
backup_rt = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
ret = run_top_route(main_rt.rlist[newroute], msg, &ctx);
set_route_type(backup_rt);
return ret;
}
/**
* Rewrite Request-URI
*/
static inline int rewrite_ruri(struct sip_msg* _m, char* _s)
{
struct action act;
struct run_act_ctx ra_ctx;
memset(&act, 0, sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = _s;
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, _m) < 0)
{
LM_ERR("do_action failed\n");
return -1;
}
return 0;
}
static int child_init(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
int i;
LM_DBG("rank is (%d)\n", rank);
if(rank==PROC_MAIN) {
if(ht_timer_procs>0) {
for(i=0; i<ht_timer_procs; i++) {
if(fork_sync_timer(PROC_TIMER, "HTable Timer", 1 /*socks flag*/,
ht_timer, (void*)(long)i, ht_timer_interval)<0) {
LM_ERR("failed to start timer routine as process\n");
return -1; /* error */
}
}
}
}
if (rank!=PROC_INIT)
return 0;
rt = route_get(&event_rt, "htable:mod-init");
if(rt>=0 && event_rt.rlist[rt]!=NULL) {
LM_DBG("executing event_route[htable:mod-init] (%d)\n", rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
if(ctx.run_flags&DROP_R_F)
{
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
set_route_type(rtb);
}
return 0;
}
int tls_run_event_routes(struct tcp_connection *c)
{
int backup_rt;
struct run_act_ctx ctx;
sip_msg_t tmsg;
if(_tls_evrt_connection_out<0)
return 0;
if(p_onsend==0 || p_onsend->msg==0)
return 0;
backup_rt = get_route_type();
set_route_type(LOCAL_ROUTE);
init_run_actions_ctx(&ctx);
tls_set_pv_con(c);
run_top_route(event_rt.rlist[_tls_evrt_connection_out], &tmsg, 0);
tls_set_pv_con(0);
set_route_type(backup_rt);
return 0;
}
int nio_msg_sent(void *data)
{
sip_msg_t msg;
str *obuf;
int_str avp_value;
struct usr_avp *avp;
struct run_act_ctx ra_ctx;
obuf = (str*)data;
if (obuf->len < nio_min_msg_len) {
return -1;
}
memset(&msg, 0, sizeof(sip_msg_t));
msg.buf = obuf->s;
msg.len = obuf->len;
nio_is_incoming = 0;
init_run_actions_ctx(&ra_ctx);
run_actions(&ra_ctx, event_rt.rlist[nio_route_no], &msg);
if(nio_msg_avp_name.n!=0) {
avp = NULL;
avp=search_first_avp(nio_msg_avp_type, nio_msg_avp_name,
&avp_value, 0);
if(avp!=NULL && is_avp_str_val(avp)) {
msg.buf = avp_value.s.s;
msg.len = avp_value.s.len;
obuf->s = nio_msg_update(&msg, (unsigned int*)&obuf->len);
} else {
LM_WARN("no value set for AVP %.*s, using unmodified message\n",
nio_msg_avp_param.len, nio_msg_avp_param.s);
}
}
free_sip_msg(&msg);
return 0;
}
/*! Run a request route block if it exists
*/
static int w_route_exists(struct sip_msg *msg, char *route)
{
struct run_act_ctx ctx;
int newroute, ret;
str s;
if (fixup_get_svalue(msg, (gparam_p) route, &s) != 0) {
LM_ERR("invalid route parameter\n");
return -1;
}
newroute = route_lookup(&main_rt, s.s);
if (newroute<0) {
return -1;
}
init_run_actions_ctx(&ctx);
ret=run_actions(&ctx, main_rt.rlist[newroute], msg);
if (ctx.run_flags & EXIT_R_F) {
return 0;
}
return ret;
}
static PyObject *
msg_rewrite_ruri(msgobject *self, PyObject *args)
{
char *ruri;
struct action act;
struct run_act_ctx ra_ctx;
if (self->msg == NULL) {
PyErr_SetString(PyExc_RuntimeError, "self->msg is NULL");
Py_INCREF(Py_None);
return Py_None;
}
if ((self->msg->first_line).type != SIP_REQUEST) {
PyErr_SetString(PyExc_RuntimeError, "Not a request message - "
"rewrite is not possible.\n");
Py_INCREF(Py_None);
return Py_None;
}
if(!PyArg_ParseTuple(args, "s:rewrite_ruri", &ruri))
return NULL;
memset(&act, '\0', sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STR_ST;
act.val[0].u.str.s = ruri;
act.val[0].u.str.len = strlen(ruri);
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, self->msg) < 0) {
LM_ERR("Error in do_action\n");
PyErr_SetString(PyExc_RuntimeError, "Error in do_action\n");
}
Py_INCREF(Py_None);
return Py_None;
}
static void tcpops_tcp_closed_run_route(tcp_closed_event_info_t *tev)
{
int rt, backup_rt;
struct run_act_ctx ctx;
sip_msg_t *fmsg;
rt = tcp_closed_routes[tev->reason];
if (rt == -1) return;
if (faked_msg_init() < 0)
{
LM_ERR("faked_msg_init() failed\n");
return;
}
fmsg = faked_msg_next();
fmsg->rcv = tev->con->rcv;
backup_rt = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
run_top_route(event_rt.rlist[rt], fmsg, 0);
set_route_type(backup_rt);
}
/**
* rewrites the request URI of msg after determining the
* new destination URI
*
* @param _msg the current SIP message
* @param _carrier the requested carrier
* @param _domain the requested routing domain
* @param _prefix_matching the user to be used for prefix matching
* @param _rewrite_user the localpart of the URI to be rewritten
* @param _hsrc the SIP header used for hashing
* @param _halg the hash algorithm used for hashing
* @param _dstavp the name of the destination AVP where the used host name is stored
*
* @return 1 on success, -1 on failure
*/
int cr_do_route(struct sip_msg * _msg, gparam_t *_carrier,
gparam_t *_domain, gparam_t *_prefix_matching,
gparam_t *_rewrite_user, enum hash_source _hsrc,
enum hash_algorithm _halg, gparam_t *_dstavp) {
int carrier_id, domain_id, ret = -1;
str rewrite_user, prefix_matching, dest;
flag_t flags;
struct route_data_t * rd;
struct carrier_data_t * carrier_data;
struct domain_data_t * domain_data;
struct action act;
struct run_act_ctx ra_ctx;
if (fixup_get_svalue(_msg, _rewrite_user, &rewrite_user)<0) {
LM_ERR("cannot print the rewrite_user\n");
return -1;
}
if (fixup_get_svalue(_msg, _prefix_matching, &prefix_matching)<0) {
LM_ERR("cannot print the prefix_matching\n");
return -1;
}
flags = _msg->flags;
do {
rd = get_data();
} while (rd == NULL);
carrier_id = cr_gp2id(_msg, _carrier, rd->carrier_map, rd->carrier_num);
if (carrier_id < 0) {
LM_ERR("invalid carrier id %d\n", carrier_id);
release_data(rd);
return -1;
}
domain_id = cr_gp2id(_msg, _domain, rd->domain_map, rd->domain_num);
if (domain_id < 0) {
LM_ERR("invalid domain id %d\n", domain_id);
release_data(rd);
return -1;
}
carrier_data=NULL;
if (carrier_id < 0) {
if (cfg_get(carrierroute, carrierroute_cfg, fallback_default)) {
LM_NOTICE("invalid tree id %i specified, using default tree\n", carrier_id);
carrier_data = get_carrier_data(rd, rd->default_carrier_id);
}
} else if (carrier_id == 0) {
carrier_data = get_carrier_data(rd, rd->default_carrier_id);
} else {
carrier_data = get_carrier_data(rd, carrier_id);
if (carrier_data == NULL) {
if (cfg_get(carrierroute, carrierroute_cfg, fallback_default)) {
LM_NOTICE("invalid tree id %i specified, using default tree\n", carrier_id);
carrier_data = get_carrier_data(rd, rd->default_carrier_id);
}
}
}
if (carrier_data == NULL) {
LM_ERR("cannot get carrier data\n");
goto unlock_and_out;
}
domain_data = get_domain_data(carrier_data, domain_id);
if (domain_data == NULL) {
LM_ERR("desired routing domain doesn't exist, prefix %.*s, carrier %d, domain %d\n",
prefix_matching.len, prefix_matching.s, carrier_id, domain_id);
goto unlock_and_out;
}
if (rewrite_uri_recursor(domain_data->tree, &prefix_matching, flags, &dest, _msg, &rewrite_user, _hsrc, _halg, _dstavp) != 0) {
/* this is not necessarily an error, rewrite_recursor does already some error logging */
LM_INFO("rewrite_uri_recursor doesn't complete, uri %.*s, carrier %d, domain %d\n", prefix_matching.len,
prefix_matching.s, carrier_id, domain_id);
goto unlock_and_out;
}
LM_INFO("uri %.*s was rewritten to %.*s, carrier %d, domain %d\n", rewrite_user.len, rewrite_user.s, dest.len, dest.s, carrier_id, domain_id);
memset(&act, 0, sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = dest.s;
init_run_actions_ctx(&ra_ctx);
ret = do_action(&ra_ctx, &act, _msg);
if (ret < 0) {
LM_ERR("Error in do_action()\n");
}
unlock_and_out:
release_data(rd);
return ret;
}
int uac_reg_request_to(struct sip_msg *msg, str *src, unsigned int mode)
{
char ruri[MAX_URI_SIZE];
struct sip_uri puri;
reg_uac_t *reg = NULL;
pv_value_t val;
struct action act;
struct run_act_ctx ra_ctx;
switch(mode)
{
case 0:
reg = reg_ht_get_byuuid(src);
break;
case 1:
if(reg_use_domain)
{
if (parse_uri(src->s, src->len, &puri)!=0)
{
LM_ERR("failed to parse uri\n");
return -2;
}
reg = reg_ht_get_byuser(&puri.user, &puri.host);
} else {
reg = reg_ht_get_byuser(src, NULL);
}
break;
default:
LM_ERR("unknown mode: %d\n", mode);
return -1;
}
if(reg==NULL)
{
LM_DBG("no user: %.*s\n", src->len, src->s);
return -1;
}
// Set uri ($ru)
snprintf(ruri, MAX_URI_SIZE, "sip:%.*s@%.*s",
reg->r_username.len, reg->r_username.s,
reg->r_domain.len, reg->r_domain.s);
memset(&act, 0, sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = ruri;
init_run_actions_ctx(&ra_ctx);
if (do_action(&ra_ctx, &act, msg) < 0) {
LM_ERR("error while setting request uri\n");
return -1;
}
// Set auth_proxy ($du)
if (set_dst_uri(msg, ®->auth_proxy) < 0) {
LM_ERR("error while setting outbound proxy\n");
return -1;
}
memset(&val, 0, sizeof(pv_value_t));
val.flags |= PV_VAL_STR;
// Set auth_realm
val.rs = reg->realm;
if(pv_set_spec_value(msg, &auth_realm_spec, 0, &val)!=0) {
LM_ERR("error while setting auth_realm\n");
return -1;
}
// Set auth_username
val.rs = reg->auth_username;
if(pv_set_spec_value(msg, &auth_username_spec, 0, &val)!=0) {
LM_ERR("error while setting auth_username\n");
return -1;
}
// Set auth_password
val.rs = reg->auth_password;
if(pv_set_spec_value(msg, &auth_password_spec, 0, &val)!=0) {
LM_ERR("error while setting auth_password\n");
return -1;
}
return 1;
}
static ticks_t timer_handler(ticks_t ticks, struct timer_ln* tl, void* data) {
/*?min length of first line of message is 16 char!?*/
#define MSG "GET /timer HTTP/0.9\n\n"
struct sip_msg* msg;
struct timer_action *a;
struct run_act_ctx ra_ctx;
a = data;
if (!a->disable_itself) {
DEBUG(MODULE_NAME": handler: called at %d ticks, timer: '%s', pid:%d\n", ticks, a->timer_name, getpid());
if (a->route_no >= main_rt.idx) {
BUG(MODULE_NAME": invalid routing table number #%d of %d\n", a->route_no, main_rt.idx);
goto err2;
}
if (!main_rt.rlist[a->route_no]) {
WARN(MODULE_NAME": route not declared (hash:%d)\n", a->route_no);
goto err2;
}
msg=pkg_malloc(sizeof(struct sip_msg));
if (msg==0) {
ERR(MODULE_NAME": handler: no mem for sip_msg\n");
goto err2;
}
timer_msg_no++;
memset(msg, 0, sizeof(struct sip_msg)); /* init everything to 0 */
msg->buf=MSG;
msg->len=sizeof(MSG)-1;
msg->rcv= rcv_info;
msg->id=timer_msg_no;
msg->set_global_address=default_global_address;
msg->set_global_port=default_global_port;
if (parse_msg(msg->buf, msg->len, msg)!=0){
ERR(MODULE_NAME": handler: parse_msg failed\n");
goto err;
}
/* ... clear branches from previous message */
clear_branches();
reset_static_buffer();
if (exec_pre_req_cb(msg)==0 )
goto end; /* drop the request */
/* exec the routing script */
timer_executed = a;
init_run_actions_ctx(&ra_ctx);
run_actions(&ra_ctx, main_rt.rlist[a->route_no], msg);
timer_executed = 0;
/* execute post request-script callbacks */
exec_post_req_cb(msg);
end:
reset_avps();
DEBUG(MODULE_NAME": handler: cleaning up\n");
err:
free_sip_msg(msg);
pkg_free(msg);
err2: ;
}
/* begin critical section */
if (a->disable_itself) {
timer_allow_del(a->link);
timer_del(a->link);
timer_reinit(a->link);
a->disable_itself = 0;
/* end critical section */
return 0; /* do no call more */
}
else
return (ticks_t)(-1); /* periodical */
}
int exec_str(struct sip_msg *msg, char *cmd, char *param, int param_len)
{
struct action act;
struct run_act_ctx ra_ctx;
int cmd_len;
FILE *pipe;
char *cmd_line;
int ret;
int l1;
static char uri_line[MAX_URI_SIZE + 1];
int uri_cnt;
str uri;
int exit_status;
/* pessimist: assume error by default */
ret = -1;
l1 = strlen(cmd);
if(param_len > 0)
cmd_len = l1 + param_len + 4;
else
cmd_len = l1 + 1;
cmd_line = pkg_malloc(cmd_len);
if(cmd_line == 0) {
ret = ser_error = E_OUT_OF_MEM;
LM_ERR("no pkg mem for command\n");
goto error00;
}
/* 'command parameter \0' */
memcpy(cmd_line, cmd, l1);
if(param_len > 0) {
cmd_line[l1] = ' ';
cmd_line[l1 + 1] = '\'';
memcpy(cmd_line + l1 + 2, param, param_len);
cmd_line[l1 + param_len + 2] = '\'';
cmd_line[l1 + param_len + 3] = 0;
} else {
cmd_line[l1] = 0;
}
pipe = popen(cmd_line, "r");
if(pipe == NULL) {
LM_ERR("cannot open pipe: %s\n", cmd_line);
ser_error = E_EXEC;
goto error01;
}
/* read now line by line */
uri_cnt = 0;
while(fgets(uri_line, MAX_URI_SIZE, pipe) != NULL) {
uri.s = uri_line;
uri.len = strlen(uri.s);
/* trim from right */
while(uri.len
&& (uri.s[uri.len - 1] == '\r' || uri.s[uri.len - 1] == '\n'
|| uri.s[uri.len - 1] == '\t'
|| uri.s[uri.len - 1] == ' ')) {
LM_DBG("rtrim\n");
uri.len--;
}
/* skip empty line */
if(uri.len == 0)
continue;
/* ZT */
uri.s[uri.len] = 0;
if(uri_cnt == 0) {
memset(&act, 0, sizeof(act));
act.type = SET_URI_T;
act.val[0].type = STRING_ST;
act.val[0].u.string = uri.s;
init_run_actions_ctx(&ra_ctx);
if(do_action(&ra_ctx, &act, msg) < 0) {
LM_ERR("the action for has failed\n");
ser_error = E_OUT_OF_MEM;
goto error02;
}
} else {
if(append_branch(msg, &uri, 0, 0, Q_UNSPECIFIED, 0, 0, 0, 0, 0, 0)
== -1) {
LM_ERR("append_branch failed; too many or too long URIs?\n");
goto error02;
}
}
uri_cnt++;
}
if(uri_cnt == 0) {
LM_ERR("no uri from %s\n", cmd_line);
goto error02;
}
/* success */
ret = 1;
error02:
if(ferror(pipe)) {
LM_ERR("in pipe: %s\n", strerror(errno));
ser_error = E_EXEC;
ret = -1;
}
exit_status = pclose(pipe);
if(WIFEXITED(exit_status)) { /* exited properly .... */
/* return false if script exited with non-zero status */
if(WEXITSTATUS(exit_status) != 0)
ret = -1;
} else { /* exited erroneously */
LM_ERR("cmd %s failed. exit_status=%d, errno=%d: %s\n", cmd,
exit_status, errno, strerror(errno));
ret = -1;
}
error01:
pkg_free(cmd_line);
error00:
return ret;
}
void async_cdp_uar_callback(int is_timeout, void *param, AAAMessage *uaa, long elapsed_msecs) {
struct run_act_ctx ra_ctx;
str server_name;
int *m_capab = 0, m_capab_cnt = 0;
int *o_capab = 0, o_capab_cnt = 0;
str *p_server_names = 0;
int p_server_names_cnt = 0;
int rc = -1, experimental_rc = -1;
saved_uar_transaction_t* data = (saved_uar_transaction_t*) param;
struct cell *t = 0;
int result = CSCF_RETURN_TRUE;
scscf_entry *list = 0;
if (tmb.t_lookup_ident(&t, data->tindex, data->tlabel) < 0) {
LM_ERR("ERROR: t_continue: transaction not found\n");
//result = CSCF_RETURN_ERROR;//not needed we set by default to error!
goto error;
}
if (is_timeout != 0) {
LM_ERR("Error timeout when sending message via CDP\n");
update_stat(stat_uar_timeouts, 1);
goto error;
}
//update stats on response time
update_stat(uar_replies_received, 1);
update_stat(uar_replies_response_time, elapsed_msecs);
if (!uaa) {
LM_ERR("Error sending message via CDP\n");
//result = CSCF_RETURN_ERROR;//not needed we set by default to error!
goto error;
}
server_name = cxdx_get_server_name(uaa);
if (!server_name.len) {
cxdx_get_capabilities(uaa, &m_capab, &m_capab_cnt, &o_capab,
&o_capab_cnt, &p_server_names, &p_server_names_cnt);
}
cxdx_get_result_code(uaa, &rc);
cxdx_get_experimental_result_code(uaa, &experimental_rc);
if (rc && !experimental_rc) {
LM_ERR("No result code or experimental result code - responding 480\n");
cscf_reply_transactional_async(t, t->uas.request, 480, MSG_480_DIAMETER_MISSING_AVP);
result = CSCF_RETURN_FALSE;
goto done;
}
switch (rc) {
case -1:
switch (experimental_rc) {
case RC_IMS_DIAMETER_ERROR_USER_UNKNOWN:
/* Check, if route is set: */
if (route_uar_user_unknown_no >= 0) {
/* exec routing script */
init_run_actions_ctx(&ra_ctx);
if (run_actions(&ra_ctx, main_rt.rlist[route_uar_user_unknown_no], t->uas.request) < 0) {
LM_DBG("ims_icscf: error while trying script\n");
}
} else {
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_USER_UNKNOWN);
}
LM_ERR("RC_IMS_DIAMETER_ERROR_USER_UNKNOWN\n");
result = CSCF_RETURN_FALSE;
goto done;
case RC_IMS_DIAMETER_ERROR_IDENTITIES_DONT_MATCH:
LM_ERR("RC_IMS_DIAMETER_ERROR_IDENTITIES_DONT_MATCH returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_IDENTITIES_DONT_MATCH);
result = CSCF_RETURN_FALSE;
goto done;
case RC_IMS_DIAMETER_ERROR_ROAMING_NOT_ALLOWED:
LM_ERR("RC_IMS_DIAMETER_ERROR_ROAMING_NOT_ALLOWED returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_ROAMING_NOT_ALLOWED);
result = CSCF_RETURN_FALSE;
goto done;
case RC_IMS_DIAMETER_ERROR_IDENTITY_NOT_REGISTERED:
LM_ERR("RC_IMS_DIAMETER_ERROR_IDENTITY_NOT_REGISTERED returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_IDENTITY_NOT_REGISTERED);
result = CSCF_RETURN_FALSE;
goto done;
case RC_IMS_DIAMETER_FIRST_REGISTRATION:
goto success;
case RC_IMS_DIAMETER_SUBSEQUENT_REGISTRATION:
goto success;
case RC_IMS_DIAMETER_SERVER_SELECTION:
goto success;
default:
LM_ERR("MSG_403_UNKOWN_EXPERIMENTAL_RC returning 500\n");
cscf_reply_transactional_async(t, t->uas.request, 500, MSG_500_UNKOWN_EXPERIMENTAL_RC);
result = CSCF_RETURN_FALSE;
goto done;
}
break;
case AAA_AUTHORIZATION_REJECTED:
LM_ERR("AAA_AUTHORIZATION_REJECTED returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_AUTHORIZATION_REJECTED);
result = CSCF_RETURN_FALSE;
goto done;
case AAA_UNABLE_TO_COMPLY:
LM_ERR("AAA_UNABLE_TO_COMPLY returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 500, MSG_500_UNABLE_TO_COMPLY);
result = CSCF_RETURN_FALSE;
goto done;
case AAA_SUCCESS:
goto success;
default:
LM_ERR("MSG_403_UNKOWN_RC returning 403\n");
cscf_reply_transactional_async(t, t->uas.request, 403, MSG_403_UNKOWN_RC);
result = CSCF_RETURN_FALSE;
goto done;
}
success:
LM_DBG("successful UAA response\n");
list = I_get_capab_ordered(server_name, m_capab, m_capab_cnt, o_capab, o_capab_cnt, p_server_names, p_server_names_cnt, 0);
if (!list) {
LM_ERR("Empty capability list returning 600\n");
cscf_reply_transactional_async(t, t->uas.request, 600, MSG_600_EMPTY_LIST);
result = CSCF_RETURN_FALSE;
goto done;
}
if (!data->callid.len || !add_scscf_list(data->callid, list)) {
LM_ERR("Error saving capability list 500\n");
cscf_reply_transactional_async(t, t->uas.request, 500, MSG_500_ERROR_SAVING_LIST);
result = CSCF_RETURN_FALSE;
goto done;
}
result = CSCF_RETURN_TRUE;
done:
//free capabilities if they exist
if (m_capab) shm_free(m_capab);
if (o_capab) shm_free(o_capab);
if (p_server_names) shm_free(p_server_names);
LM_DBG("DBG:UAR Async CDP callback: ... Done resuming transaction\n");
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_URI, &t->uri_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_URI, &t->uri_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_USER, &t->user_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_USER, &t->user_avps_to);
set_avp_list(AVP_TRACK_FROM | AVP_CLASS_DOMAIN, &t->domain_avps_from);
set_avp_list(AVP_TRACK_TO | AVP_CLASS_DOMAIN, &t->domain_avps_to);
create_uaa_return_code(result);
if (t)tmb.unref_cell(t);
//free memory
if (uaa) cdpb.AAAFreeMessage(&uaa);
tmb.t_continue(data->tindex, data->tlabel, data->act);
free_saved_uar_transaction_data(data);
return;
error:
if (t)tmb.unref_cell(t);
//free memory
if (uaa) cdpb.AAAFreeMessage(&uaa);
tmb.t_continue(data->tindex, data->tlabel, data->act);
free_saved_uar_transaction_data(data);
}
static int child_init(int rank)
{
struct sip_msg *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
int i;
sr_kemi_eng_t *keng = NULL;
str evname = str_init("htable:mod-init");
LM_DBG("rank is (%d)\n", rank);
if(rank==PROC_MAIN) {
if(ht_timer_procs>0) {
for(i=0; i<ht_timer_procs; i++) {
if(fork_sync_timer(PROC_TIMER, "HTable Timer", 1 /*socks flag*/,
ht_timer, (void*)(long)i, ht_timer_interval)<0) {
LM_ERR("failed to start timer routine as process\n");
return -1; /* error */
}
}
}
}
if (rank!=PROC_INIT)
return 0;
rt = -1;
if(ht_event_callback.s==NULL || ht_event_callback.len<=0) {
rt = route_lookup(&event_rt, evname.s);
if(rt<0 || event_rt.rlist[rt]==NULL) {
rt = -1;
}
} else {
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_DBG("event callback (%s) set, but no cfg engine\n",
ht_event_callback.s);
goto done;
}
}
if(rt>=0 || ht_event_callback.len>0) {
LM_DBG("executing event_route[%s] (%d)\n", evname.s, rt);
if(faked_msg_init()<0)
return -1;
fmsg = faked_msg_next();
rtb = get_route_type();
set_route_type(REQUEST_ROUTE);
init_run_actions_ctx(&ctx);
if(rt>=0) {
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
} else {
if(keng!=NULL) {
if(keng->froute(fmsg, EVENT_ROUTE,
&ht_event_callback, &evname)<0) {
LM_ERR("error running event route kemi callback\n");
return -1;
}
}
}
set_route_type(rtb);
if(ctx.run_flags&DROP_R_F) {
LM_ERR("exit due to 'drop' in event route\n");
return -1;
}
}
done:
return 0;
}
static int msrp_frame_received(sr_event_param_t *evp)
{
tcp_event_info_t *tev;
static msrp_frame_t mf;
sip_msg_t *fmsg;
struct run_act_ctx ctx;
int rtb, rt;
sr_kemi_eng_t *keng = NULL;
str evname = str_init("msrp:frame-in");
tev = (tcp_event_info_t*)evp->data;
if(tev==NULL || tev->buf==NULL || tev->len<=0)
{
LM_DBG("invalid parameters\n");
return -1;
}
memset(&mf, 0, sizeof(msrp_frame_t));
mf.buf.s = tev->buf;
mf.buf.len = tev->len;
mf.tcpinfo = tev;
if(msrp_parse_frame(&mf)<0)
{
LM_ERR("error parsing msrp frame\n");
return -1;
}
msrp_reset_env();
msrp_set_current_frame(&mf);
fmsg = msrp_fake_sipmsg(&mf);
if(fmsg != NULL)
fmsg->rcv = *tev->rcv;
rtb = get_route_type();
set_route_type(EVENT_ROUTE);
init_run_actions_ctx(&ctx);
if(msrp_event_callback.s == NULL || msrp_event_callback.len <= 0) {
/* native cfg script execution */
rt = route_get(&event_rt, evname.s);
LM_DBG("executing event_route[msrp:frame-in] (%d)\n", rt);
if(rt >= 0 && event_rt.rlist[rt] != NULL) {
run_top_route(event_rt.rlist[rt], fmsg, &ctx);
} else {
LM_ERR("empty event route block for msrp handling\n");
}
} else {
/* kemi script execution */
keng = sr_kemi_eng_get();
if(keng==NULL) {
LM_ERR("event callback (%s) set, but no cfg engine\n",
msrp_event_callback.s);
} else {
if(sr_kemi_ctx_route(keng, &ctx, fmsg, EVENT_ROUTE,
&msrp_event_callback, &evname)<0) {
LM_ERR("error running event route kemi callback\n");
}
}
}
if(ctx.run_flags & DROP_R_F) {
LM_DBG("exit due to 'drop' in event route\n");
}
set_route_type(rtb);
if(fmsg != NULL)
free_sip_msg(fmsg);
msrp_reset_env();
msrp_destroy_frame(&mf);
return 0;
}
