/**
* Adds the given failure route information to the failure routing domain identified by
* domain. scan_prefix, host, reply_code and flags identifies the number for which
* the information is and the next_domain parameter defines where to continue routing
* in case of a match.
*
* @param rd the route data to which the route shall be added
* @param carrier_id the carrier id of the route to be added
* @param domain_id the routing domain id of the new route
* @param scan_prefix the number prefix
* @param host the hostname last tried
* @param reply_code the reply code
* @param flags user defined flags
* @param mask for user defined flags
* @param next_domain_id continue routing with this domain id
* @param comment a comment for the failure route rule
*
* @return 0 on success, -1 on error in which case it LOGs a message.
*/
int add_failure_route(struct route_data_t * rd, int carrier_id, int domain_id,
const str * scan_prefix, const str * host, const str * reply_code,
flag_t flags, flag_t mask, int next_domain_id, const str * comment) {
struct carrier_data_t * carrier_data = NULL;
struct domain_data_t * domain_data = NULL;
LM_INFO("adding prefix %.*s, reply code %.*s\n", scan_prefix->len, scan_prefix->s, reply_code->len, reply_code->s);
if (reply_code->len!=3) {
LM_ERR("invalid reply_code '%.*s'!\n", reply_code->len, reply_code->s);
return -1;
}
if ((carrier_data = get_carrier_data(rd, carrier_id)) == NULL) {
LM_ERR("could not retrieve carrier data\n");
return -1;
}
if ((domain_data = get_domain_data_or_add(rd, carrier_data, domain_id)) == NULL) {
LM_ERR("could not retrieve domain data\n");
return -1;
}
LM_INFO("found carrier and domain, now adding failure route\n");
return add_failure_route_to_tree(domain_data->failure_tree, scan_prefix, scan_prefix, host, reply_code,
flags, mask, next_domain_id, comment);
}
/**
* Adds the given route information to the routing domain identified by
* domain. scan_prefix identifies the number for which the information
* is and the rewrite_* parameters define what to do in case of a match.
* prob gives the probability with which this rule applies if there are
* more than one for a given prefix.
*
* @param rd the route data to which the route shall be added
* @param carrier_id the carrier id of the route to be added
* @param domain_id the routing domain id of the new route
* @param scan_prefix the number prefix
* @param flags user defined flags
* @param mask mask for user defined flags
* @param max_targets the number of targets
* @param prob the weight of the rule
* @param rewrite_hostpart the rewrite_host of the rule
* @param strip the number of digits to be stripped off userpart before prepending prefix
* @param rewrite_local_prefix the rewrite prefix
* @param rewrite_local_suffix the rewrite suffix
* @param status the status of the rule
* @param hash_index the hash index of the rule
* @param backup indicates if the route is backed up by another. only
useful if status==0, if set, it is the hash value
of another rule
* @param backed_up an -1-termintated array of hash indices of the route
for which this route is backup
* @param comment a comment for the route rule
*
* @return 0 on success, -1 on error in which case it LOGs a message.
*/
int add_route(struct route_data_t * rd, int carrier_id,
int domain_id, const str * scan_prefix, flag_t flags, flag_t mask, int max_targets,
double prob, const str * rewrite_hostpart, int strip,
const str * rewrite_local_prefix, const str * rewrite_local_suffix,
int status, int hash_index, int backup, int * backed_up, const str * comment) {
struct carrier_data_t * carrier_data = NULL;
struct domain_data_t * domain_data = NULL;
LM_INFO("adding prefix %.*s, prob %f\n", scan_prefix->len, scan_prefix->s, prob);
if ((carrier_data = get_carrier_data(rd, carrier_id)) == NULL) {
LM_ERR("could not retrieve carrier data for carrier id %d\n", carrier_id);
return -1;
}
if ((domain_data = get_domain_data_or_add(rd, carrier_data, domain_id)) == NULL) {
LM_ERR("could not retrieve domain data\n");
return -1;
}
LM_INFO("found carrier and domain, now adding route\n");
return add_route_to_tree(domain_data->tree, scan_prefix, flags, mask, scan_prefix, max_targets, prob, rewrite_hostpart,
strip, rewrite_local_prefix, rewrite_local_suffix, status,
hash_index, backup, backed_up, comment);
}
/**
* Loads next domain from failure routing table and stores it in an AVP.
*
* @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 _host the host name to be used for rule matching
* @param _reply_code the reply code to be used for rule matching
* @param _dstavp the name of the destination AVP
*
* @return 1 on success, -1 on failure
*/
int cr_load_next_domain(struct sip_msg * _msg, gparam_t *_carrier,
gparam_t *_domain, gparam_t *_prefix_matching,
gparam_t *_host, gparam_t *_reply_code, gparam_t *_dstavp) {
int carrier_id, domain_id, ret = -1;
str prefix_matching, host, reply_code;
flag_t flags;
struct route_data_t * rd;
struct carrier_data_t * carrier_data;
struct domain_data_t * domain_data;
if (fixup_get_svalue(_msg, _prefix_matching, &prefix_matching)<0) {
LM_ERR("cannot print the prefix_matching\n");
return -1;
}
if (fixup_get_svalue(_msg, _host, &host)<0) {
LM_ERR("cannot print the host\n");
return -1;
}
if (fixup_get_svalue(_msg, _reply_code, &reply_code)<0) {
LM_ERR("cannot print the reply_code\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 (set_next_domain_recursor(domain_data->failure_tree, &prefix_matching, &host, &reply_code, flags, _dstavp) != 0) {
LM_INFO("set_next_domain_recursor doesn't complete, prefix '%.*s', carrier %d, domain %d\n", prefix_matching.len,
prefix_matching.s, carrier_id, domain_id);
goto unlock_and_out;
}
ret = 1;
unlock_and_out:
release_data(rd);
return ret;
}
/**
* 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;
}
