int pv_get_tm_reply_ruid(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; int branch; if(msg==NULL || res==NULL) return -1; /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ res->rs = _empty_str; } else { switch (get_route_type()) { case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the reason of the winning reply */ if ( (branch=_tmx_tmb.t_get_picked_branch())<0 ) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return -1; } res->rs = t->uac[branch].ruid; break; default: LM_ERR("unsupported route_type %d\n", get_route_type()); return -1; } } LM_DBG("reply ruid is [%.*s]\n", res->rs.len, res->rs.s); res->flags = PV_VAL_STR; return 0; }
int pv_get_tm_reply_code(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; int code; int branch; if(msg==NULL || res==NULL) return -1; /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ code = 0; } else { switch (get_route_type()) { case REQUEST_ROUTE: case BRANCH_ROUTE: /* use the status of the last sent reply */ code = t->uas.status; break; case CORE_ONREPLY_ROUTE: /* t_check() above has the side effect of setting T and REFerencing T => we must unref and unset it for the main/core onreply_route. */ _tmx_tmb.t_unref(msg); /* no break */ case TM_ONREPLY_ROUTE: /* use the status of the current reply */ code = msg->first_line.u.reply.statuscode; break; case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the status of the winning reply */ if ( (branch=_tmx_tmb.t_get_picked_branch())<0 ) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); code = 0; } else { code = t->uac[branch].last_received; } break; default: LM_ERR("unsupported route_type %d\n", get_route_type()); code = 0; } } LM_DBG("reply code is <%d>\n",code); res->rs.s = int2str( code, &res->rs.len); res->ri = code; res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT; return 0; }
int pv_get_tm_reply_code(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; int code; int branch; if(msg==NULL || res==NULL) return -1; switch (get_route_type()) { case CORE_ONREPLY_ROUTE: case TM_ONREPLY_ROUTE: /* use the status of the current reply */ code = msg->first_line.u.reply.statuscode; goto done; } /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ code = 0; } else { switch (get_route_type()) { case REQUEST_ROUTE: case BRANCH_ROUTE: /* use the status of the last sent reply */ code = t->uas.status; break; case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the status of the winning reply */ if ( (branch=_tmx_tmb.t_get_picked_branch())<0 ) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); code = 0; } else { code = t->uac[branch].last_received; } break; default: LM_INFO("unsupported route_type %d - code set to 0\n", get_route_type()); code = 0; } } done: LM_DBG("reply code is <%d>\n", code); return pv_get_sintval(msg, param, res, code); return 0; }
int pv_get_t_branch(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { tm_ctx_t *tcx = 0; tm_cell_t *t; int branch; if ((msg == NULL) || (param == NULL)) return -1; t = _tmx_tmb.t_gett(); if ((t == NULL) || (t == T_UNDEFINED)) { /* no T */ return pv_get_null(msg, param, res); } switch(param->pvn.u.isname.name.n) { case 5: /* $T_branch(flags) */ switch (get_route_type()) { case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the reason of the winning reply */ if ((branch=_tmx_tmb.t_get_picked_branch()) < 0) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return pv_get_null(msg, param, res); } res->ri = t->uac[branch].branch_flags; res->flags = PV_VAL_INT; LM_DBG("branch flags is [%u]\n", res->ri); break; default: LM_ERR("unsupported route_type %d\n", get_route_type()); return pv_get_null(msg, param, res); } break; case 6: /* $T_branch(uri) */ if (get_route_type() != TM_ONREPLY_ROUTE) { LM_ERR("$T_branch(uri) - unsupported route_type %d\n", get_route_type()); return pv_get_null(msg, param, res); } tcx = _tmx_tmb.tm_ctx_get(); if(tcx == NULL) { return pv_get_null(msg, param, res); } branch = tcx->branch_index; if(branch<0 || branch>=t->nr_of_outgoings) { return pv_get_null(msg, param, res); } return pv_get_strval(msg, param, res, &t->uac[branch].uri); } return 0; }
int pv_get_tm_reply_reason(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; struct sip_msg *reply; int branch; if(msg==NULL || res==NULL) return -1; /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ return pv_get_strempty(msg, param, res); } else { switch (get_route_type()) { case CORE_ONREPLY_ROUTE: /* t_check() above has the side effect of setting T and REFerencing T => we must unref and unset it for the main/core onreply_route. */ _tmx_tmb.t_unref(msg); /* no break */ case TM_ONREPLY_ROUTE: /* use the reason of the current reply */ res->rs.s = msg->first_line.u.reply.reason.s; res->rs.len = msg->first_line.u.reply.reason.len; break; case FAILURE_ROUTE: /* use the reason of the winning reply */ if ( (branch=_tmx_tmb.t_get_picked_branch())<0 ) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return -1; } reply = t->uac[branch].reply; if (reply == FAKED_REPLY) { res->rs.s = error_text(t->uac[branch].last_received); res->rs.len = strlen(res->rs.s); } else { res->rs.s = reply->first_line.u.reply.reason.s; res->rs.len = reply->first_line.u.reply.reason.len; } break; default: LM_ERR("unsupported route_type %d\n", get_route_type()); return -1; } } LM_DBG("reply reason is [%.*s]\n", res->rs.len, res->rs.s); res->flags = PV_VAL_STR; return 0; }
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; }
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 ht_expired_run_event_route(char *route) { int rt, backup_rt; sip_msg_t *fmsg; if (route == NULL) { LM_ERR("bad route\n"); } LM_DBG("ht_expired_run_event_route event_route[%s]\n", route); rt = route_get(&event_rt, route); 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->parsed_orig_ruri_ok = 0; backup_rt = get_route_type(); set_route_type(EVENT_ROUTE); run_top_route(event_rt.rlist[rt], fmsg, 0); set_route_type(backup_rt); }
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 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); }
/*! * \brief Cleanup a profile * \param msg SIP message * \param flags unused * \param param unused * \return 1 */ int profile_cleanup( struct sip_msg *msg, unsigned int flags, void *param ) { dlg_cell_t *dlg; if(get_route_type()==LOCAL_ROUTE) { return 1; } current_dlg_msg_id = 0; current_dlg_msg_pid = 0; dlg = dlg_get_ctx_dialog(); if (dlg!=NULL) { if(dlg->dflags & DLG_FLAG_TM) { dlg_unref(dlg, 1); } else { /* dialog didn't make it to tm */ dlg_unref(dlg, 2); } } if (current_pending_linkers) { destroy_linkers(current_pending_linkers); current_pending_linkers = NULL; } /* need to return non-zero - 0 will break the exec of the request */ return 1; }
void ht_expired_run_event_route(int routeid) { int backup_rt; sip_msg_t *fmsg; if (routeid < 0 || event_rt.rlist[routeid] == NULL) { LM_DBG("route does not exist\n"); return; } if (faked_msg_init() < 0) { LM_ERR("faked_msg_init() failed\n"); return; } fmsg = faked_msg_next(); fmsg->parsed_orig_ruri_ok = 0; backup_rt = get_route_type(); set_route_type(EVENT_ROUTE); run_top_route(event_rt.rlist[routeid], fmsg, 0); set_route_type(backup_rt); }
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; }
void rpc_evr_run(rpc_t *rpc, void *c) { str evr_name = STR_NULL; str evr_data = STR_NULL; int ret = 0; int evr_id = -1; sr_kemi_eng_t *keng = NULL; sip_msg_t *fmsg = NULL; int rtbk = 0; char evr_buf[2]; ret = rpc->scan(c, "s*s", &evr_name.s, &evr_data.s); if(ret<1) { LM_ERR("failed getting the parameters"); rpc->fault(c, 500, "Invalid parameters"); return; } evr_name.len = strlen(evr_name.s); if(ret<2) { evr_buf[0] = '\0'; evr_data.s = evr_buf; evr_data.len = 0; } else { evr_data.len = strlen(evr_data.s); } pv_evr_data = &evr_data; keng = sr_kemi_eng_get(); if(keng==NULL) { evr_id = route_lookup(&event_rt, evr_name.s); if(evr_id == -1) { pv_evr_data = NULL; LM_ERR("event route not found: %.*s\n", evr_name.len, evr_name.s); rpc->fault(c, 500, "Event route not found"); return; } } else { evr_id = -1; } fmsg = faked_msg_next(); rtbk = get_route_type(); set_route_type(LOCAL_ROUTE); if(evr_id>=0) { if(event_rt.rlist[evr_id]!=NULL) { run_top_route(event_rt.rlist[evr_id], fmsg, 0); } else { LM_WARN("empty event route block [%.*s]\n", evr_name.len, evr_name.s); } } else { if(sr_kemi_route(keng, fmsg, EVENT_ROUTE, &evr_name, &evr_data)<0) { LM_ERR("error running event route kemi callback\n"); } } set_route_type(rtbk); pv_evr_data = NULL; }
int pv_get_tm_reply_ruid(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; tm_ctx_t *tcx = 0; int branch; if(msg==NULL || res==NULL) return -1; /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ return pv_get_strempty(msg, param, res); } else { switch (get_route_type()) { case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the reason of the winning reply */ if ( (branch=_tmx_tmb.t_get_picked_branch())<0 ) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return pv_get_strempty(msg, param, res); } LM_DBG("reply ruid is [%.*s]\n", t->uac[branch].ruid.len, t->uac[branch].ruid.s); return pv_get_strval(msg, param, res, &t->uac[branch].ruid); break; case TM_ONREPLY_ROUTE: tcx = _tmx_tmb.tm_ctx_get(); if(tcx == NULL) { return pv_get_strempty(msg, param, res); } branch = tcx->branch_index; if(branch<0 || branch>=t->nr_of_outgoings) { return pv_get_strempty(msg, param, res); } LM_DBG("reply ruid is [%.*s]\n", t->uac[branch].ruid.len, t->uac[branch].ruid.s); return pv_get_strval(msg, param, res, &t->uac[branch].ruid); default: LM_ERR("unsupported route_type %d\n", get_route_type()); return pv_get_strempty(msg, param, res); } } }
int pv_get_tm_reply_last_received(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { struct cell *t; tm_ctx_t *tcx = 0; int code; if(msg==NULL || res==NULL) return -1; /* Only for TM reply route */ if (get_route_type() != TM_ONREPLY_ROUTE) { LM_ERR("unsupported route_type %d\n", get_route_type()); return -1; } /* first get the transaction */ if (_tmx_tmb.t_check( msg , 0 )==-1) return -1; if ( (t=_tmx_tmb.t_gett())==0) { /* no T */ LM_ERR("could not get transaction\n"); return -1; } /* get the current branch index */ tcx = _tmx_tmb.tm_ctx_get(); if(tcx == NULL) { LM_ERR("could not get tm context\n"); return -1; } /* get the last received reply code */ code = t->uac[tcx->branch_index].last_received; LM_DBG("reply code is <%d>\n",code); res->rs.s = int2str( code, &res->rs.len); res->ri = code; res->flags = PV_VAL_STR|PV_VAL_INT|PV_TYPE_INT; return 0; }
int pv_get_t(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { tm_cell_t *t; if(msg==NULL || param==NULL) return -1; /* aliases to old TM pvs */ switch(param->pvn.u.isname.name.n) { case 2: return pv_get_tm_reply_code(msg, param, res); case 4: return pv_get_tm_branch_idx(msg, param, res); } t = _tmx_tmb.t_gett(); if(t==NULL || t==T_UNDEFINED) { /* no T */ if(param->pvn.u.isname.name.n==8 || param->pvn.u.isname.name.n==9) { /* id_label_n or id_index_n - attempt to create transaction */ if(_tmx_tmb.t_newtran(msg)<0) { LM_ERR("cannot create the transaction\n"); return pv_get_null(msg, param, res); } t = _tmx_tmb.t_gett(); if (t==NULL || t==T_UNDEFINED) { return pv_get_null(msg, param, res); } } else { return pv_get_null(msg, param, res); } } switch(param->pvn.u.isname.name.n) { case 1: return pv_get_uintval(msg, param, res, t->hash_index); case 3: if(get_route_type()==FAILURE_ROUTE) { if(_tmx_tmb.t_get_picked_branch()<0 ) return pv_get_uintval(msg, param, res, 0); if(t->uac[_tmx_tmb.t_get_picked_branch()].reply==FAKED_REPLY) return pv_get_uintval(msg, param, res, 1); } return pv_get_uintval(msg, param, res, 0); case 8: return pv_get_uintval(msg, param, res, t->label); case 9: return pv_get_uintval(msg, param, res, t->hash_index); default: return pv_get_uintval(msg, param, res, t->label); } }
/** * Creates new "main" branch by making copy of branch-failure branch. * Currently the following branch attributes are included: * request-uri, ruid, path, instance, and branch flags. */ static int w_t_reuse_branch(sip_msg_t* msg, char *p1, char *p2) { tm_cell_t *t; int branch; if (msg == NULL) return -1; /* first get the transaction */ if (_tmx_tmb.t_check(msg, 0) == -1) return -1; if ((t = _tmx_tmb.t_gett()) == 0) { LM_ERR("no transaction\n"); return -1; } switch (get_route_type()) { case BRANCH_FAILURE_ROUTE: /* use the reason of the winning reply */ if ((branch = _tmx_tmb.t_get_picked_branch()) < 0) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return -1; } if(rewrite_uri(msg, &(t->uac[branch].uri))<0) { LM_WARN("failed to rewrite the r-uri\n"); } set_ruid(msg, &(t->uac[branch].ruid)); if (t->uac[branch].path.len) { if(set_path_vector(msg, &(t->uac[branch].path))<0) { LM_WARN("failed to set the path vector\n"); } } else { reset_path_vector(msg); } setbflagsval(0, t->uac[branch].branch_flags); set_instance(msg, &(t->uac[branch].instance)); return 1; default: LM_ERR("unsupported route_type %d\n", get_route_type()); return -1; } }
void ht_handle_expired_record(ht_t *ht, ht_cell_t *cell) { int backup_rt; sip_msg_t *fmsg; sr_kemi_eng_t *keng = NULL; if(ht_event_callback.s==NULL || ht_event_callback.len<=0) { if (ht->evex_index < 0 || event_rt.rlist[ht->evex_index] == NULL) { LM_DBG("route does not exist\n"); return; } } else { keng = sr_kemi_eng_get(); if(keng==NULL) { LM_DBG("event callback (%s) set, but no cfg engine\n", ht_event_callback.s); return; } } LM_DBG("running event_route[htable:expired:%.*s]\n", ht->name.len, ht->name.s); if (faked_msg_init() < 0) { LM_ERR("faked_msg_init() failed\n"); return; } ht_expired_cell = cell; fmsg = faked_msg_next(); fmsg->parsed_orig_ruri_ok = 0; backup_rt = get_route_type(); set_route_type(EVENT_ROUTE); if(ht->evex_index >= 0) { run_top_route(event_rt.rlist[ht->evex_index], fmsg, 0); } else { if(keng!=NULL) { if(keng->froute(fmsg, EVENT_ROUTE, &ht_event_callback, &ht->evex_name)<0) { LM_ERR("error running event route kemi callback\n"); } } } set_route_type(backup_rt); ht_expired_cell = NULL; }
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 pv_get_t_branch(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { tm_cell_t *t; int branch; if ((msg == NULL) || (param == NULL)) return -1; t = _tmx_tmb.t_gett(); if ((t == NULL) || (t == T_UNDEFINED)) { /* no T */ return pv_get_null(msg, param, res); } switch(param->pvn.u.isname.name.n) { case 5: switch (get_route_type()) { case FAILURE_ROUTE: case BRANCH_FAILURE_ROUTE: /* use the reason of the winning reply */ if ((branch=_tmx_tmb.t_get_picked_branch()) < 0) { LM_CRIT("no picked branch (%d) for a final response" " in MODE_ONFAILURE\n", branch); return -1; } res->ri = t->uac[branch].branch_flags; res->flags = PV_VAL_INT; LM_INFO("branch flags is [%u]\n", res->ri); break; default: LM_ERR("unsupported route_type %d\n", get_route_type()); return -1; } } 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; }
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; }
/*! * \brief Execute event routes based on new state * */ void dlg_run_event_route(dlg_cell_t *dlg, sip_msg_t *msg, int ostate, int nstate) { sip_msg_t *fmsg; int rt; int bkroute; if(dlg==NULL) return; if(ostate==nstate) return; rt = -1; if(nstate==DLG_STATE_CONFIRMED_NA) { rt = dlg_event_rt[DLG_EVENTRT_START]; } else if(nstate==DLG_STATE_DELETED) { if(ostate==DLG_STATE_CONFIRMED || ostate==DLG_STATE_CONFIRMED_NA) rt = dlg_event_rt[DLG_EVENTRT_END]; else if(ostate==DLG_STATE_UNCONFIRMED || ostate==DLG_STATE_EARLY) rt = dlg_event_rt[DLG_EVENTRT_FAILED]; } if(rt==-1 || event_rt.rlist[rt]==NULL) return; if(msg==NULL) fmsg = faked_msg_next(); else fmsg = msg; if (exec_pre_script_cb(fmsg, LOCAL_CB_TYPE)>0) { dlg_ref(dlg, 1); dlg_set_ctx_iuid(dlg); LM_DBG("executing event_route %d on state %d\n", rt, nstate); bkroute = get_route_type(); set_route_type(LOCAL_ROUTE); run_top_route(event_rt.rlist[rt], fmsg, 0); dlg_reset_ctx_iuid(); exec_post_script_cb(fmsg, LOCAL_CB_TYPE); dlg_unref(dlg, 1); set_route_type(bkroute); } }
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; }
/** * wrapper for record_route(msg, params) */ static int w_record_route(struct sip_msg *msg, char *key, char *bar) { str s; if (msg->msg_flags & FL_RR_ADDED) { LM_ERR("Double attempt to record-route\n"); return -1; } if (key && pv_printf_s(msg, (pv_elem_t*)key, &s)<0) { LM_ERR("failed to print the format\n"); return -1; } if ( record_route( msg, key?&s:0 )<0 ) return -1; if(get_route_type()!=BRANCH_ROUTE) msg->msg_flags |= FL_RR_ADDED; return 1; }
int pv_get_t(struct sip_msg *msg, pv_param_t *param, pv_value_t *res) { tm_cell_t *t; if(msg==NULL || param==NULL) return -1; /* aliases to old TM pvs */ switch(param->pvn.u.isname.name.n) { case 2: return pv_get_tm_reply_code(msg, param, res); case 4: return pv_get_tm_branch_idx(msg, param, res); } t = _tmx_tmb.t_gett(); if(t==NULL || t==T_UNDEFINED) { /* no T */ return pv_get_null(msg, param, res); } switch(param->pvn.u.isname.name.n) { case 1: return pv_get_uintval(msg, param, res, t->hash_index); case 3: if(get_route_type()==FAILURE_ROUTE) { if(_tmx_tmb.t_get_picked_branch()<0 ) return pv_get_uintval(msg, param, res, 0); if(t->uac[_tmx_tmb.t_get_picked_branch()].reply==FAKED_REPLY) return pv_get_uintval(msg, param, res, 1); } return pv_get_uintval(msg, param, res, 0); default: return pv_get_uintval(msg, param, res, t->label); } }
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); }