void destroy_rule(dpl_node_t * rule){
if(!rule)
return;
LM_DBG("destroying rule with priority %i\n",
rule->pr);
if(rule->match_comp)
shm_free(rule->match_comp);
if(rule->subst_comp)
shm_free(rule->subst_comp);
/*destroy repl_exp*/
if(rule->repl_comp)
repl_expr_free(rule->repl_comp);
if(rule->match_exp.s)
shm_free(rule->match_exp.s);
if(rule->subst_exp.s)
shm_free(rule->subst_exp.s);
if(rule->repl_exp.s)
shm_free(rule->repl_exp.s);
if(rule->attrs.s)
shm_free(rule->attrs.s);
}
struct subst_expr* repl_exp_parse(str subst)
{
struct replace_with rw[MAX_REPLACE_WITH];
int rw_no;
struct subst_expr * se;
int replace_all;
char * p, *end, *repl, *repl_end;
int max_pmatch, r;
se = 0;
replace_all = 0;
p = subst.s;
end = p + subst.len;
rw_no = 0;
repl = p;
if((rw_no = parse_repl(rw, &p, end, &max_pmatch, WITHOUT_SEP))< 0)
goto error;
repl_end=p;
/* construct the subst_expr structure */
se = shm_malloc(sizeof(struct subst_expr)+
((rw_no)?(rw_no-1)*sizeof(struct replace_with):0));
/* 1 replace_with structure is already included in subst_expr */
if (se==0){
LM_ERR("out of shm memory (subst_expr)\n");
goto error;
}
memset((void*)se, 0, sizeof(struct subst_expr));
se->replacement.len=repl_end-repl;
if (!(se->replacement.s=shm_malloc(se->replacement.len * sizeof(char))) ){
LM_ERR("out of shm memory \n");
goto error;
}
if(!rw_no){
replace_all = 1;
}
/* start copying */
memcpy(se->replacement.s, repl, se->replacement.len);
se->re=0;
se->replace_all=replace_all;
se->n_escapes=rw_no;
se->max_pmatch=max_pmatch;
/*replace_with is a simple structure, no shm alloc needed*/
for (r=0; r<rw_no; r++) se->replace[r]=rw[r];
return se;
error:
if (se) { repl_expr_free(se);}
return NULL;
}
/*compile the expressions, and if ok, build the rule */
dpl_node_t * build_rule(db_val_t * values)
{
pcre *match_comp, *subst_comp;
struct subst_expr *repl_comp;
dpl_node_t * new_rule;
str match_exp, subst_exp, repl_exp, attrs;
int matchop;
int cap_cnt=0;
unsigned int tflags=0;
matchop = VAL_INT(values+2);
if((matchop != DP_REGEX_OP) && (matchop!=DP_EQUAL_OP)
&& (matchop!=DP_FNMATCH_OP)){
LM_ERR("invalid value for match operator\n");
return NULL;
}
match_comp = subst_comp = 0;
repl_comp = 0;
new_rule = 0;
GET_STR_VALUE(match_exp, values, 3);
if(matchop == DP_REGEX_OP){
if(unlikely(dp_match_dynamic==1)) {
if(dpl_check_pv(&match_exp)==0) {
tflags |= DP_TFLAGS_PV_MATCH;
}
}
if(!(tflags&DP_TFLAGS_PV_MATCH)) {
match_comp = reg_ex_comp(match_exp.s, &cap_cnt, 0);
if(!match_comp){
LM_ERR("failed to compile match expression %.*s\n",
match_exp.len, match_exp.s);
goto err;
}
}
}
GET_STR_VALUE(repl_exp, values, 6);
if(repl_exp.len && repl_exp.s){
repl_comp = repl_exp_parse(repl_exp);
if(!repl_comp){
LM_ERR("failed to compile replacing expression %.*s\n",
repl_exp.len, repl_exp.s);
goto err;
}
}
cap_cnt = 0;
GET_STR_VALUE(subst_exp, values, 5);
if(subst_exp.s && subst_exp.len){
if(unlikely(dp_match_dynamic==1)) {
if(dpl_check_pv(&subst_exp)==0) {
tflags |= DP_TFLAGS_PV_SUBST;
}
}
if(!(tflags&DP_TFLAGS_PV_SUBST)) {
subst_comp = reg_ex_comp(subst_exp.s, &cap_cnt, 0);
if(!subst_comp){
LM_ERR("failed to compile subst expression %.*s\n",
subst_exp.len, subst_exp.s);
goto err;
}
if (cap_cnt > MAX_REPLACE_WITH) {
LM_ERR("subst expression %.*s has too many sub-expressions\n",
subst_exp.len, subst_exp.s);
goto err;
}
}
}
LM_DBG("building rule for [%d:%.*s/%.*s/%.*s]\n", matchop,
match_exp.len, ZSW(match_exp.s), subst_exp.len, ZSW(subst_exp.s),
repl_exp.len, ZSW(repl_exp.s));
if (!(tflags&(DP_TFLAGS_PV_SUBST|DP_TFLAGS_PV_MATCH)) &&
repl_comp && (cap_cnt < repl_comp->max_pmatch) &&
(repl_comp->max_pmatch != 0))
{
LM_ERR("repl_exp %.*s refers to %d sub-expressions, but "
"subst_exp %.*s has only %d\n",
repl_exp.len, repl_exp.s, repl_comp->max_pmatch,
subst_exp.len, subst_exp.s, cap_cnt);
goto err;
}
new_rule = (dpl_node_t *)shm_malloc(sizeof(dpl_node_t));
if(!new_rule){
LM_ERR("out of shm memory(new_rule)\n");
goto err;
}
memset(new_rule, 0, sizeof(dpl_node_t));
if(dpl_str_to_shm(match_exp, &new_rule->match_exp,
tflags&DP_TFLAGS_PV_MATCH)!=0)
goto err;
if(dpl_str_to_shm(subst_exp, &new_rule->subst_exp,
tflags&DP_TFLAGS_PV_SUBST)!=0)
goto err;
if(dpl_str_to_shm(repl_exp, &new_rule->repl_exp, 0)!=0)
goto err;
/*set the rest of the rule fields*/
new_rule->dpid = VAL_INT(values);
new_rule->pr = VAL_INT(values+1);
new_rule->matchlen = VAL_INT(values+4);
new_rule->matchop = matchop;
GET_STR_VALUE(attrs, values, 7);
if(dpl_str_to_shm(attrs, &new_rule->attrs, 0)!=0)
goto err;
LM_DBG("attrs are: '%.*s'\n", new_rule->attrs.len, new_rule->attrs.s);
new_rule->match_comp = match_comp;
new_rule->subst_comp = subst_comp;
new_rule->repl_comp = repl_comp;
new_rule->tflags = tflags;
return new_rule;
err:
if(match_comp) shm_free(match_comp);
if(subst_comp) shm_free(subst_comp);
if(repl_comp) repl_expr_free(repl_comp);
if(new_rule) destroy_rule(new_rule);
return NULL;
}
/*compile the expressions, and if ok, build the rule */
dpl_node_t * build_rule(db_val_t * values)
{
tmrec_t *parsed_timerec;
pcre * match_comp, *subst_comp;
struct subst_expr * repl_comp;
dpl_node_t * new_rule;
str match_exp, subst_exp, repl_exp, attrs, timerec;
int matchop;
int namecount;
matchop = VAL_INT(values+2);
if((matchop != REGEX_OP) && (matchop!=EQUAL_OP)){
LM_ERR("invalid value for match operator\n");
return NULL;
}
parsed_timerec = 0;
match_comp = subst_comp = 0;
repl_comp = 0;
new_rule = 0;
GET_STR_VALUE(match_exp, values, 3, 0);
if(matchop == REGEX_OP){
LM_DBG("Compiling %.*s expression with flag: %d\n",
match_exp.len, match_exp.s, VAL_INT(values+4));
match_comp = wrap_pcre_compile(match_exp.s, VAL_INT(values+4));
if(!match_comp){
LM_ERR("failed to compile match expression \"%.*s\"\n",
match_exp.len, match_exp.s);
goto err;
}
}
LM_DBG("building subst rule\n");
GET_STR_VALUE(subst_exp, values, 5, 1);
if(!VAL_NULL(values+5) && subst_exp.s && subst_exp.len){
/* subst regexp */
subst_comp = wrap_pcre_compile(subst_exp.s, VAL_INT(values+4));
if(subst_comp == NULL){
LM_ERR("failed to compile subst expression \"%.*s\"\n",
subst_exp.len, subst_exp.s);
goto err;
}
}
/* replace exp */
GET_STR_VALUE(repl_exp, values, 6, 1);
if(!VAL_NULL(values+6) && repl_exp.len && repl_exp.s){
repl_comp = repl_exp_parse(repl_exp);
if(!repl_comp){
LM_ERR("failed to compile replacing expression \"%.*s\"\n",
repl_exp.len, repl_exp.s);
goto err;
}
}
pcre_fullinfo(
subst_comp, /* the compiled pattern */
NULL, /* no extra data - we didn't study the pattern */
PCRE_INFO_CAPTURECOUNT, /* number of named substrings */
&namecount); /* where to put the answer */
LM_DBG("references:%d , max:%d\n",namecount,
repl_comp?repl_comp->max_pmatch:0);
if ( (repl_comp!=NULL) && (namecount<repl_comp->max_pmatch) &&
(repl_comp->max_pmatch!=0) ){
LM_ERR("repl_exp uses a non existing subexpression\n");
goto err;
}
new_rule = (dpl_node_t *)shm_malloc(sizeof(dpl_node_t));
if(!new_rule){
LM_ERR("out of shm memory(new_rule)\n");
goto err;
}
memset(new_rule, 0, sizeof(dpl_node_t));
if(str_to_shm(match_exp, &new_rule->match_exp)!=0)
goto err;
if (subst_comp)
if(str_to_shm(subst_exp, &new_rule->subst_exp)!=0)
goto err;
if (repl_comp)
if(str_to_shm(repl_exp, &new_rule->repl_exp)!=0)
goto err;
/*set the rest of the rule fields*/
new_rule->dpid = VAL_INT(values);
new_rule->pr = VAL_INT(values+1);
new_rule->match_flags = VAL_INT(values+4);
new_rule->matchop = matchop;
/* attributes */
GET_STR_VALUE(attrs, values, 7, 1);
if( !VAL_NULL(values+7) && attrs.len && attrs.s) {
if(str_to_shm(attrs, &new_rule->attrs)!=0)
goto err;
LM_DBG("attrs are %.*s\n",
new_rule->attrs.len, new_rule->attrs.s);
}
/* Retrieve and Parse Timerec Matching Pattern */
GET_STR_VALUE(timerec, values, 8, 1);
if( !VAL_NULL(values+8) && timerec.len && timerec.s) {
parsed_timerec = parse_time_def(timerec.s);
if(!parsed_timerec) {
LM_ERR("failed to parse timerec pattern %.*s\n",
timerec.len, timerec.s);
goto err;
}
if(str_to_shm(timerec, &new_rule->timerec) != 0)
goto err;
new_rule->parsed_timerec = parsed_timerec;
LM_DBG("timerecs are %.*s\n",
new_rule->timerec.len, new_rule->timerec.s);
}
if (match_comp)
new_rule->match_comp = match_comp;
if (subst_comp)
new_rule->subst_comp = subst_comp;
if (repl_comp)
new_rule->repl_comp = repl_comp;
return new_rule;
err:
if(parsed_timerec) shm_free(parsed_timerec);
if(match_comp) wrap_pcre_free(match_comp);
if(subst_comp) wrap_pcre_free(subst_comp);
if(repl_comp) repl_expr_free(repl_comp);
if(new_rule) destroy_rule(new_rule);
return NULL;
}
/*compile the expressions, and if ok, build the rule */
dpl_node_t * build_rule(db_val_t * values)
{
pcre * match_comp, *subst_comp;
struct subst_expr * repl_comp;
dpl_node_t * new_rule;
str match_exp, subst_exp, repl_exp, attrs;
int matchop;
int namecount;
matchop = VAL_INT(values+2);
if((matchop != REGEX_OP) && (matchop!=EQUAL_OP)){
LM_ERR("invalid value for match operator\n");
return NULL;
}
match_comp = subst_comp =0;
repl_comp = 0;
new_rule = 0;
GET_STR_VALUE(match_exp, values, 3);
if(matchop == REGEX_OP){
match_comp = wrap_pcre_compile(match_exp.s);
if(!match_comp){
LM_ERR("failed to compile match expression %.*s\n",
match_exp.len, match_exp.s);
goto err;
}
}
LM_DBG("building subst rule\n");
GET_STR_VALUE(subst_exp, values, 5);
if(subst_exp.s && subst_exp.len){
/* subst regexp */
subst_comp = wrap_pcre_compile(subst_exp.s);
if(subst_comp == NULL){
LM_ERR("failed to compile subst expression\n");
goto err;
}
}
/* replace exp */
GET_STR_VALUE(repl_exp, values, 6);
if(repl_exp.len && repl_exp.s){
repl_comp = repl_exp_parse(repl_exp);
if(!repl_comp){
LM_ERR("failed to compile replacing expression %.*s\n",
repl_exp.len, repl_exp.s);
goto err;
}
}
pcre_fullinfo(
subst_comp, /* the compiled pattern */
NULL, /* no extra data - we didn't study the pattern */
PCRE_INFO_CAPTURECOUNT, /* number of named substrings */
&namecount); /* where to put the answer */
LM_DBG("references:%d , max:%d\n",namecount,
repl_comp?repl_comp->max_pmatch:0);
if ( (repl_comp!=NULL) && (namecount<repl_comp->max_pmatch) &&
(repl_comp->max_pmatch!=0) ){
LM_ERR("repl_exp uses a non existing subexpression\n");
goto err;
}
new_rule = (dpl_node_t *)shm_malloc(sizeof(dpl_node_t));
if(!new_rule){
LM_ERR("out of shm memory(new_rule)\n");
goto err;
}
memset(new_rule, 0, sizeof(dpl_node_t));
if(str_to_shm(match_exp, &new_rule->match_exp)!=0)
goto err;
if (subst_comp)
if(str_to_shm(subst_exp, &new_rule->subst_exp)!=0)
goto err;
if (repl_comp)
if(str_to_shm(repl_exp, &new_rule->repl_exp)!=0)
goto err;
/*set the rest of the rule fields*/
new_rule->dpid = VAL_INT(values);
new_rule->pr = VAL_INT(values+1);
new_rule->matchlen = VAL_INT(values+4);
new_rule->matchop = matchop;
GET_STR_VALUE(attrs, values, 7);
if(str_to_shm(attrs, &new_rule->attrs)!=0)
goto err;
LM_DBG("attrs are %.*s\n",
new_rule->attrs.len, new_rule->attrs.s);
if (match_comp)
new_rule->match_comp = match_comp;
if (subst_comp)
new_rule->subst_comp = subst_comp;
if (repl_comp)
new_rule->repl_comp = repl_comp;
return new_rule;
err:
if(subst_comp) wrap_pcre_free(subst_comp);
if(repl_comp) repl_expr_free(repl_comp);
if(new_rule) destroy_rule(new_rule);
return NULL;
}
