git.sip-router.org Git - sip-router/blob - route.c

   1 /*
   2  * $Id$
   3  *
   4  * SIP routing engine
   5  *
   6  *
   7  * Copyright (C) 2001-2003 FhG Fokus
   8  *
   9  * This file is part of ser, a free SIP server.
  10  *
  11  * ser is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version
  15  *
  16  * For a license to use the ser software under conditions
  17  * other than those described here, or to purchase support for this
  18  * software, please contact iptel.org by e-mail at the following addresses:
  19  *    info@iptel.org
  20  *
  21  * ser is distributed in the hope that it will be useful,
  22  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  23  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  24  * GNU General Public License for more details.
  25  *
  26  * You should have received a copy of the GNU General Public License
  27  * along with this program; if not, write to the Free Software
  28  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  *
  30  * History:
  31  * --------
  32  *  2003-01-28  scratchpad removed, src_port introduced (jiri)
  33  *  2003-02-28  scratchpad compatibility abandoned (jiri)
  34  *  2003-03-10  updated to the new module exports format (andrei)
  35  *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
  36  *  2003-04-01  added dst_port, proto, af; renamed comp_port to comp_no,
  37  *               inlined all the comp_* functions (andrei)
  38  *  2003-04-05  s/reply_route/failure_route, onreply_route introduced (jiri)
  39  *  2003-05-23  comp_ip fixed, now it will resolve its operand and compare
  40  *              the ip with all the addresses (andrei)
  41  *  2003-10-10  added more operators support to comp_* (<,>,<=,>=,!=) (andrei)
  42  *  2004-10-19  added from_uri & to_uri (andrei)
  43  *  2005-12-12  added retcode support (anrei)
  44  *  2005-12-19  select framework (mma)
  45  *  2006-01-30  removed rec. protection from eval_expr (andrei)
  46  *  2006-02-06  added named route tables (andrei)
  47  *  2008-04-14  (expr1 != expr2) is evaluated true if at least one of
  48  *              the expressions does not exist (Miklos)
  49  *  2008-04-23  errors are treated as false during expression evaluation
  50  *              unless the operator is DIFF_OP (Miklos)
  51  *  2008-12-03  fixups for rvalues in assignments (andrei)
  52  *  2009-05-04  switched IF_T to rval_expr (andrei)
  53  */
  54
  55
  56 /*!
  57  * \file
  58  * \brief SIP-router core ::
  59  * \ingroup core
  60  * Module: \ref core
  61  */
  62
  63 #include <stdlib.h>
  64 #include <sys/types.h>
  65 #include <regex.h>
  66 #include <netdb.h>
  67 #include <string.h>
  68 #include <sys/socket.h>
  69 #include <netinet/in.h>
  70 #include <arpa/inet.h>
  71 #include <netdb.h>
  72
  73 #include "route.h"
  74 #include "forward.h"
  75 #include "dprint.h"
  76 #include "proxy.h"
  77 #include "action.h"
  78 #include "lvalue.h"
  79 #include "rvalue.h"
  80 #include "sr_module.h"
  81 #include "ip_addr.h"
  82 #include "resolve.h"
  83 #include "socket_info.h"
  84 #include "parser/parse_uri.h"
  85 #include "parser/parse_from.h"
  86 #include "parser/parse_to.h"
  87 #include "mem/mem.h"
  88 #include "select.h"
  89 #include "onsend.h"
  90 #include "str_hash.h"
  91 #include "ut.h"
  92 #include "rvalue.h"
  93 #include "switch.h"
  94
  95 #define RT_HASH_SIZE    8 /* route names hash */
  96
  97 /* main routing script table  */
  98 struct route_list main_rt;
  99 struct route_list onreply_rt;
 100 struct route_list failure_rt;
 101 struct route_list branch_rt;
 102 struct route_list onsend_rt;
 103 struct route_list event_rt;
 104
 105 int route_type = REQUEST_ROUTE;
 106
 107 /** script optimization level, useful for debugging.
 108  *  0 - no optimization
 109  *  1 - optimize rval expressions
 110  *  2 - optimize expr elems
 111  */
 112 int scr_opt_lev=9;
 113
 114 inline static void destroy_rlist(struct route_list* rt)
 115 {
 116         struct str_hash_entry* e;
 117         struct str_hash_entry* tmp;
 118
 119         if (rt->rlist){
 120                 pkg_free(rt->rlist);
 121                 rt->rlist=0;
 122                 rt->entries=0;
 123         }
 124         if (rt->names.table){
 125                 clist_foreach_safe(rt->names.table, e, tmp, next){
 126                         pkg_free(e);
 127                 }
 128                 pkg_free(rt->names.table);
 129                 rt->names.table=0;
 130                 rt->names.size=0;
 131         }
 132 }
 133
 134
 135
 136 void destroy_routes()
 137 {
 138         destroy_rlist(&main_rt);
 139         destroy_rlist(&onreply_rt);
 140         destroy_rlist(&failure_rt);
 141         destroy_rlist(&branch_rt);
 142         destroy_rlist(&event_rt);
 143 }
 144
 145
 146
 147 /* adds route name -> i mapping
 148  * WARNING: it doesn't check for pre-existing routes
 149  * return -1 on error, route index on success
 150  */
 151 static int route_add(struct route_list* rt, char* name, int i)
 152 {
 153         struct str_hash_entry* e;
 154
 155         e=pkg_malloc(sizeof(struct str_hash_entry));
 156         if (e==0){
 157                 LOG(L_CRIT, "ERROR: route_add: out of memory\n");
 158                 goto error;
 159         }
 160         e->key.s=name;
 161         e->key.len=strlen(name);
 162         e->flags=0;
 163         e->u.n=i;
 164         str_hash_add(&rt->names, e);
 165         return 0;
 166 error:
 167         return -1;
 168 }
 169
 170
 171
 172 /* returns -1 on error, 0 on success */
 173 inline  static int init_rlist(char* r_name, struct route_list* rt,
 174                                                                 int n_entries, int hash_size)
 175 {
 176                 rt->rlist=pkg_malloc(sizeof(struct action*)*n_entries);
 177                 if (rt->rlist==0){
 178                         LOG(L_CRIT, "ERROR: failed to allocate \"%s\" route tables: "
 179                                         "out of memory\n", r_name);
 180                         goto error;
 181                 }
 182                 memset(rt->rlist, 0 , sizeof(struct action*)*n_entries);
 183                 rt->idx=1; /* idx=0 == default == reserved */
 184                 rt->entries=n_entries;
 185                 if (str_hash_alloc(&rt->names, hash_size)<0){
 186                         LOG(L_CRIT, "ERROR: \"%s\" route table: failed to alloc hash\n",
 187                                         r_name);
 188                         goto error;
 189                 }
 190                 str_hash_init(&rt->names);
 191                 route_add(rt, "0", 0);  /* default route */
 192
 193                 return 0;
 194 error:
 195                 return -1;
 196 }
 197
 198
 199
 200 /* init route tables */
 201 int init_routes()
 202 {
 203         if (init_rlist("main", &main_rt, RT_NO, RT_HASH_SIZE)<0)
 204                 goto error;
 205         if (init_rlist("on_reply", &onreply_rt, ONREPLY_RT_NO, RT_HASH_SIZE)<0)
 206                 goto error;
 207         if (init_rlist("failure", &failure_rt, FAILURE_RT_NO, RT_HASH_SIZE)<0)
 208                 goto error;
 209         if (init_rlist("branch", &branch_rt, BRANCH_RT_NO, RT_HASH_SIZE)<0)
 210                 goto error;
 211         if (init_rlist("on_send", &onsend_rt, ONSEND_RT_NO, RT_HASH_SIZE)<0)
 212                 goto error;
 213         if (init_rlist("event", &event_rt, EVENT_RT_NO, RT_HASH_SIZE)<0)
 214                 goto error;
 215         return 0;
 216 error:
 217         destroy_routes();
 218         return -1;
 219 }
 220
 221
 222
 223 static inline int route_new_list(struct route_list* rt)
 224 {
 225         int ret;
 226         struct action** tmp;
 227
 228         ret=-1;
 229         if (rt->idx >= rt->entries){
 230                 tmp=pkg_realloc(rt->rlist, 2*rt->entries*sizeof(struct action*));
 231                 if (tmp==0){
 232                         LOG(L_CRIT, "ERROR: route_new_list: out of memory\n");
 233                         goto end;
 234                 }
 235                 /* init the newly allocated memory chunk */
 236                 memset(&tmp[rt->entries], 0, rt->entries*sizeof(struct action*));
 237                 rt->rlist=tmp;
 238                 rt->entries*=2;
 239         }
 240         if (rt->idx<rt->entries){
 241                 ret=rt->idx;
 242                 rt->idx++;
 243         }
 244 end:
 245         return ret;
 246 }
 247
 248
 249
 250
 251 /*
 252  * if the "name" route already exists, return its index, else
 253  * create a new empty route
 254  * return route index in rt->rlist or -1 on error
 255  */
 256 int route_get(struct route_list* rt, char* name)
 257 {
 258         int len;
 259         struct str_hash_entry* e;
 260         int i;
 261
 262         len=strlen(name);
 263         /* check if exists an non empty*/
 264         e=str_hash_get(&rt->names, name, len);
 265         if (e){
 266                 i=e->u.n;
 267         }else{
 268                 i=route_new_list(rt);
 269                 if (i==-1) goto error;
 270                 if (route_add(rt, name, i)<0){
 271                         goto error;
 272                 }
 273         }
 274         return i;
 275 error:
 276         return -1;
 277 }
 278
 279
 280
 281 /*
 282  * if the "name" route already exists, return its index, else
 283  * return error
 284  * return route index in rt->rlist or -1 on error
 285  */
 286 int route_lookup(struct route_list* rt, char* name)
 287 {
 288         int len;
 289         struct str_hash_entry* e;
 290
 291         len=strlen(name);
 292         /* check if exists an non empty*/
 293         e=str_hash_get(&rt->names, name, len);
 294         if (e){
 295                 return e->u.n;
 296         }else{
 297                 return -1;
 298         }
 299 }
 300
 301
 302
 303 int fix_actions(struct action* a); /*fwd declaration*/
 304
 305
 306 /** optimize the left side of a struct expr.
 307  *  @return 1 if optimized, 0 if not and -1 on error
 308  */
 309 static int exp_optimize_left(struct expr* exp)
 310 {
 311         struct rval_expr* rve;
 312         struct rvalue* rval;
 313         int old_ltype, old_rtype, old_op;
 314         int ret;
 315
 316         ret=0;
 317         if (exp->type!=ELEM_T)
 318                 return 0;
 319         old_ltype=exp->l_type;
 320         old_rtype=exp->r_type;
 321         old_op=exp->op;
 322         if (exp->l_type==RVEXP_O){
 323                 rve=exp->l.param;
 324                 /* rve should be previously fixed/optimized */
 325                 /* optimize exp (rval(val)) -> exp(val) */
 326                 if (rve->op==RVE_RVAL_OP){
 327                         rval=&rve->left.rval;
 328                         switch(rval->type){
 329                                 case RV_INT:
 330                                         if (exp->op==NO_OP){
 331                                                 exp->l_type=NUMBER_O;
 332                                                 exp->l.param=0;
 333                                                 exp->r_type=NUMBER_ST;
 334                                                 exp->r.numval=rval->v.l;
 335                                                 rval_destroy(rval);
 336                                                 pkg_free(rve);
 337                                                 ret=1;
 338                                         }
 339                                         break;
 340                                 case RV_STR:
 341                                         /* string evaluated in expression context - not
 342                                            supported */
 343                                         break;
 344                                 case RV_BEXPR:
 345                                         if (exp->op==NO_OP){
 346                                                 /* replace the current expr. */
 347                                                 *exp=*(rval->v.bexpr);
 348                                                 rval_destroy(rval);
 349                                                 pkg_free(rve);
 350                                                 ret=1;
 351                                         };
 352                                         break;
 353                                 case RV_ACTION_ST:
 354                                         if (exp->op==NO_OP){
 355                                                 exp->l_type=ACTION_O;
 356                                                 exp->l.param=0;
 357                                                 exp->r_type=ACTION_ST;
 358                                                 exp->r.param=rval->v.action;
 359                                                 rval_destroy(rval);
 360                                                 pkg_free(rve);
 361                                                 ret=1;
 362                                         }
 363                                         break;
 364                                 case RV_SEL:
 365                                         exp->l.select=pkg_malloc(sizeof(*exp->l.select));
 366                                         if (exp->l.select){
 367                                                 exp->l_type=SELECT_O;
 368                                                 *exp->l.select=rval->v.sel;
 369                                                 rval_destroy(rval);
 370                                                 pkg_free(rve);
 371                                                 ret=1;
 372                                         }else
 373                                                 ret=-1;
 374                                         break;
 375                                 case RV_AVP:
 376                                         exp->l.attr=pkg_malloc(sizeof(*exp->l.attr));
 377                                         if (exp->l.attr){
 378                                                 exp->l_type=AVP_O;
 379                                                 *exp->l.attr=rval->v.avps;
 380                                                 rval_destroy(rval);
 381                                                 pkg_free(rve);
 382                                                 ret=1;
 383                                         }else
 384                                                 ret=-1;
 385                                         break;
 386                                 case RV_PVAR:
 387                                         exp->l.param=pkg_malloc(sizeof(pv_spec_t));
 388                                         if (exp->l.param){
 389                                                 exp->l_type=PVAR_O;
 390                                                 *((pv_spec_t*)exp->l.param)=rval->v.pvs;
 391                                                 rval_destroy(rval);
 392                                                 pkg_free(rve);
 393                                                 ret=1;
 394                                         }else
 395                                                 ret=-1;
 396                                         break;
 397                                 case RV_NONE:
 398                                         break;
 399                         }
 400                 }
 401         }
 402         if (ret>0)
 403                 DBG("left EXP optimized: op%d(_O%d_, ST%d) => op%d(_O%d_, ST%d)\n",
 404                         old_op, old_ltype, old_rtype, exp->op, exp->l_type, exp->r_type);
 405         return ret;
 406 }
 407
 408
 409
 410 /** optimize the left side of a struct expr.
 411  *  @return 1 if optimized, 0 if not and -1 on error
 412  */
 413 static int exp_optimize_right(struct expr* exp)
 414 {
 415         struct rval_expr* rve;
 416         struct rvalue* rval;
 417         int old_ltype, old_rtype, old_op;
 418         int ret;
 419
 420         ret=0;
 421         if ((exp->type!=ELEM_T) ||(exp->op==NO_OP))
 422                 return 0;
 423         old_ltype=exp->l_type;
 424         old_rtype=exp->r_type;
 425         old_op=exp->op;
 426         if (exp->r_type==RVE_ST){
 427                 rve=exp->r.param;
 428                 /* rve should be previously fixed/optimized */
 429                 /* optimize exp (rval(val)) -> exp(val) */
 430                 if (rve->op==RVE_RVAL_OP){
 431                         rval=&rve->left.rval;
 432                         switch(rval->type){
 433                                 case RV_INT:
 434                                         exp->r_type=NUMBER_ST;
 435                                         exp->r.numval=rval->v.l;
 436                                         rval_destroy(rval);
 437                                         pkg_free(rve);
 438                                         ret=1;
 439                                         break;
 440                                 case RV_STR:
 441                                         exp->r.str.s=pkg_malloc(rval->v.s.len+1);
 442                                         if (exp->r.str.s){
 443                                                 exp->r.str.len=rval->v.s.len;
 444                                                 memcpy(exp->r.str.s, rval->v.s.s, rval->v.s.len);
 445                                                 exp->r.str.s[exp->r.str.len]=0;
 446                                                 exp->r_type=STRING_ST;
 447                                                 rval_destroy(rval);
 448                                                 pkg_free(rve);
 449                                                 ret=1;
 450                                         }else
 451                                                 ret=-1;
 452                                         break;
 453                                 case RV_BEXPR:
 454                                         /* cannot be optimized further, is an exp_elem
 455                                            which is not constant */
 456                                         break;
 457                                 case RV_ACTION_ST:
 458                                         /* cannot be optimized further, is not constant and
 459                                           eval_elem() does not support ACTION_ST for op!=NO_OP*/
 460                                         break;
 461                                 case RV_SEL:
 462                                         exp->r.select=pkg_malloc(sizeof(*exp->l.select));
 463                                         if (exp->r.select){
 464                                                 exp->r_type=SELECT_ST;
 465                                                 *exp->r.select=rval->v.sel;
 466                                                 rval_destroy(rval);
 467                                                 pkg_free(rve);
 468                                                 ret=1;
 469                                         }else
 470                                                 ret=-1;
 471                                         break;
 472                                 case RV_AVP:
 473                                         exp->r.attr=pkg_malloc(sizeof(*exp->l.attr));
 474                                         if (exp->r.attr){
 475                                                 exp->r_type=AVP_ST;
 476                                                 *exp->r.attr=rval->v.avps;
 477                                                 rval_destroy(rval);
 478                                                 pkg_free(rve);
 479                                                 ret=1;
 480                                         }else
 481                                                 ret=-1;
 482                                         break;
 483                                 case RV_PVAR:
 484                                         exp->r.param=pkg_malloc(sizeof(pv_spec_t));
 485                                         if (exp->r.param){
 486                                                 exp->r_type=PVAR_ST;
 487                                                 *((pv_spec_t*)exp->r.param)=rval->v.pvs;
 488                                                 rval_destroy(rval);
 489                                                 pkg_free(rve);
 490                                                 ret=1;
 491                                         }else
 492                                                 ret=-1;
 493                                         break;
 494                                 case RV_NONE:
 495                                         ret=-1;
 496                                         break;
 497                         }
 498                 }
 499         }
 500         if (ret>0)
 501                 DBG("right EXP optimized: op%d(O%d, _ST%d_) => op%d(O%d, _ST%d_)\n",
 502                         old_op, old_ltype, old_rtype, exp->op, exp->l_type, exp->r_type);
 503         return ret;
 504 }
 505
 506
 507
 508 /* traverses an expr tree and compiles the REs where necessary)
 509  * returns: 0 for ok, <0 if errors */
 510 int fix_expr(struct expr* exp)
 511 {
 512         regex_t* re;
 513         int ret;
 514         int len;
 515
 516         ret=E_BUG;
 517         if (exp==0){
 518                 LOG(L_CRIT, "BUG: fix_expr: null pointer\n");
 519                 return E_BUG;
 520         }
 521         if (exp->type==EXP_T){
 522                 switch(exp->op){
 523                         case LOGAND_OP:
 524                         case LOGOR_OP:
 525                                                 if ((ret=fix_expr(exp->l.expr))!=0)
 526                                                         return ret;
 527                                                 ret=fix_expr(exp->r.expr);
 528                                                 break;
 529                         case NOT_OP:
 530                                                 ret=fix_expr(exp->l.expr);
 531                                                 break;
 532                         default:
 533                                                 LOG(L_CRIT, "BUG: fix_expr: unknown op %d\n",
 534                                                                 exp->op);
 535                 }
 536         }else if (exp->type==ELEM_T){
 537                         /* first calculate lengths of strings  (only right side, since
 538                           left side can never be a string) */
 539                         if (exp->r_type==STRING_ST) {
 540                                 if (exp->r.string) len = strlen(exp->r.string);
 541                                 else len = 0;
 542                                 exp->r.str.s = exp->r.string;
 543                                 exp->r.str.len = len;
 544                         }
 545                         /* then fix & optimize rve/rvals (they might be optimized
 546                            to non-rvals, e.g. string, avp a.s.o and needs to be done
 547                            before MATCH_OP and other fixups) */
 548                         if (exp->l_type==RVEXP_O){
 549                                 if ((ret=fix_rval_expr(&exp->l.param))<0){
 550                                         ERR("Unable to fix left rval expression\n");
 551                                         return ret;
 552                                 }
 553                                 if (scr_opt_lev>=2)
 554                                         exp_optimize_left(exp);
 555                         }
 556                         if (exp->r_type==RVE_ST){
 557                                 if ((ret=fix_rval_expr(&exp->r.param))<0){
 558                                         ERR("Unable to fix right rval expression\n");
 559                                         return ret;
 560                                 }
 561                                 if (scr_opt_lev>=2)
 562                                         exp_optimize_right(exp);
 563                         }
 564
 565
 566                         if (exp->op==MATCH_OP){
 567                                      /* right side either has to be string, in which case
 568                                       * we turn it into regular expression, or it is regular
 569                                       * expression already. In that case we do nothing
 570                                       */
 571                                 if (exp->r_type==STRING_ST){
 572                                         re=(regex_t*)pkg_malloc(sizeof(regex_t));
 573                                         if (re==0){
 574                                                 LOG(L_CRIT, "ERROR: fix_expr: memory allocation"
 575                                                                 " failure\n");
 576                                                 return E_OUT_OF_MEM;
 577                                         }
 578                                         if (regcomp(re, (char*) exp->r.param,
 579                                                                 REG_EXTENDED|REG_NOSUB|REG_ICASE) ){
 580                                                 LOG(L_CRIT, "ERROR: fix_expr : bad re \"%s\"\n",
 581                                                                         (char*) exp->r.param);
 582                                                 pkg_free(re);
 583                                                 return E_BAD_RE;
 584                                         }
 585                                         /* replace the string with the re */
 586                                         pkg_free(exp->r.param);
 587                                         exp->r.re=re;
 588                                         exp->r_type=RE_ST;
 589                                 }else if (exp->r_type!=RE_ST && exp->r_type != AVP_ST
 590                                                 && exp->r_type != SELECT_ST && exp->r_type!= RVE_ST
 591                                                 && exp->r_type != PVAR_ST){
 592                                         LOG(L_CRIT, "BUG: fix_expr : invalid type for match\n");
 593                                         return E_BUG;
 594                                 }
 595                         }
 596                         if (exp->l_type==ACTION_O){
 597                                 ret=fix_actions((struct action*)exp->r.param);
 598                                 if (ret!=0){
 599                                         LOG(L_CRIT, "ERROR: fix_expr : fix_actions error\n");
 600                                         return ret;
 601                                 }
 602                         }
 603                         if (exp->l_type==SELECT_O) {
 604                                 if ((ret=resolve_select(exp->l.select)) < 0) {
 605                                         BUG("Unable to resolve select\n");
 606                                         print_select(exp->l.select);
 607                                         return ret;
 608                                 }
 609                         }
 610                         if ((exp->r_type==SELECT_O)||(exp->r_type==SELECT_ST)) {
 611                                 if ((ret=resolve_select(exp->r.select)) < 0) {
 612                                         BUG("Unable to resolve select\n");
 613                                         print_select(exp->l.select);
 614                                         return ret;
 615                                 }
 616                         }
 617                         /* PVAR don't need fixing */
 618                         ret=0;
 619         }
 620         return ret;
 621 }
 622
 623
 624
 625 /* adds the proxies in the proxy list & resolves the hostnames */
 626 /* returns 0 if ok, <0 on error */
 627 int fix_actions(struct action* a)
 628 {
 629         struct action *t;
 630         struct proxy_l* p;
 631         char *tmp;
 632         int ret;
 633         int i;
 634         union cmd_export_u* cmd;
 635         str s;
 636         struct hostent* he;
 637         struct ip_addr ip;
 638         struct socket_info* si;
 639         struct lvalue* lval;
 640         struct rval_expr* rve;
 641         struct rval_expr* err_rve;
 642         enum rval_type rve_type, err_type, expected_type;
 643
 644
 645         char buf[30]; /* tmp buffer needed for module param fixups */
 646
 647         if (a==0){
 648                 LOG(L_CRIT,"BUG: fix_actions: null pointer\n");
 649                 return E_BUG;
 650         }
 651         for(t=a; t!=0; t=t->next){
 652                 switch(t->type){
 653                         case FORWARD_T:
 654                         case FORWARD_TLS_T:
 655                         case FORWARD_TCP_T:
 656                         case FORWARD_SCTP_T:
 657                         case FORWARD_UDP_T:
 658                         case SEND_T:
 659                         case SEND_TCP_T:
 660                                         switch(t->val[0].type){
 661                                                 case IP_ST:
 662                                                         tmp=strdup(ip_addr2a(
 663                                                                                 (struct ip_addr*)t->val[0].u.data));
 664                                                         if (tmp==0){
 665                                                                 LOG(L_CRIT, "ERROR: fix_actions:"
 666                                                                                 "memory allocation failure\n");
 667                                                                 ret = E_OUT_OF_MEM;
 668                                                                 goto error;
 669                                                         }
 670                                                         t->val[0].type=STRING_ST;
 671                                                         t->val[0].u.string=tmp;
 672                                                         /* no break */
 673                                                 case STRING_ST:
 674                                                         s.s = t->val[0].u.string;
 675                                                         s.len = strlen(s.s);
 676                                                         p=add_proxy(&s, t->val[1].u.number, 0); /* FIXME proto*/
 677                                                         if (p==0) { ret =E_BAD_ADDRESS; goto error; }
 678                                                         t->val[0].u.data=p;
 679                                                         t->val[0].type=PROXY_ST;
 680                                                         break;
 681                                                 case URIHOST_ST:
 682                                                         break;
 683                                                 default:
 684                                                         LOG(L_CRIT, "BUG: fix_actions: invalid type"
 685                                                                         "%d (should be string or number)\n",
 686                                                                                 t->type);
 687                                                         ret = E_BUG;
 688                                                         goto error;
 689                                         }
 690                                         break;
 691                         case IF_T:
 692                                 if (t->val[0].type!=RVE_ST){
 693                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 694                                                                 "%d for if (should be rval expr)\n",
 695                                                                 t->val[0].type);
 696                                         ret = E_BUG;
 697                                         goto error;
 698                                 }else if( (t->val[1].type!=ACTIONS_ST) &&
 699                                                         (t->val[1].type!=NOSUBTYPE) ){
 700                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 701                                                                 "%d for if() {...} (should be action)\n",
 702                                                                 t->val[1].type);
 703                                         ret = E_BUG;
 704                                         goto error;
 705                                 }else if( (t->val[2].type!=ACTIONS_ST) &&
 706                                                         (t->val[2].type!=NOSUBTYPE) ){
 707                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 708                                                                 "%d for if() {} else{...}(should be action)\n",
 709                                                                 t->val[2].type);
 710                                         ret = E_BUG;
 711                                         goto error;
 712                                 }
 713                                 rve=(struct rval_expr*)t->val[0].u.data;
 714                                 if (rve){
 715                                         err_rve=0;
 716                                         if (!rve_check_type(&rve_type, rve, &err_rve,
 717                                                                                         &err_type, &expected_type)){
 718                                                 if (err_rve)
 719                                                         LOG(L_ERR, "fix_actions: invalid expression "
 720                                                                         "(%d,%d): subexpression (%d,%d) has type"
 721                                                                         " %s,  but %s is expected\n",
 722                                                                         rve->fpos.s_line, rve->fpos.s_col,
 723                                                                         err_rve->fpos.s_line, err_rve->fpos.s_col,
 724                                                                         rval_type_name(err_type),
 725                                                                         rval_type_name(expected_type) );
 726                                                 else
 727                                                         LOG(L_ERR, "fix_actions: invalid expression "
 728                                                                         "(%d,%d): type mismatch?",
 729                                                                         rve->fpos.s_line, rve->fpos.s_col);
 730                                                 ret = E_UNSPEC;
 731                                                 goto error;
 732                                         }
 733                                         /* it's not an error anymore to have non-int in an if,
 734                                            only a script warning (to allow backward compat. stuff
 735                                            like if (@ruri)
 736                                         if (rve_type!=RV_INT && rve_type!=RV_NONE){
 737                                                 LOG(L_ERR, "fix_actions: invalid expression (%d,%d):"
 738                                                                 " bad type, integer expected\n",
 739                                                                 rve->fpos.s_line, rve->fpos.s_col);
 740                                                 return E_UNSPEC;
 741                                         }
 742                                         */
 743                                         if ((ret=fix_rval_expr(&t->val[0].u.data))<0)
 744                                                 goto error;
 745                                 }
 746                                 if ( (t->val[1].type==ACTIONS_ST)&&(t->val[1].u.data) ){
 747                                         if ((ret=fix_actions((struct action*)t->val[1].u.data))<0)
 748                                                 goto error;
 749                                 }
 750                                 if ( (t->val[2].type==ACTIONS_ST)&&(t->val[2].u.data) ){
 751                                                 if ((ret=fix_actions((struct action*)t->val[2].u.data))
 752                                                                 <0)
 753                                                 goto error;
 754                                 }
 755                                 break;
 756                         case SWITCH_T:
 757                                 if (t->val[0].type!=RVE_ST){
 758                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 759                                                                 "%d for switch() (should be expr)\n",
 760                                                                 t->val[0].type);
 761                                         ret = E_BUG;
 762                                         goto error;
 763                                 }else if (t->val[1].type!=CASE_ST){
 764                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 765                                                                 "%d for switch(...){...}(should be case)\n",
 766                                                                 t->val[1].type);
 767                                         ret = E_BUG;
 768                                         goto error;
 769                                 }
 770                                 if (t->val[0].u.data){
 771                                         if ((ret=fix_rval_expr(&t->val[0].u.data))<0)
 772                                                 goto error;
 773                                 }else{
 774                                         LOG(L_CRIT, "BUG: fix_actions: null switch()"
 775                                                         " expression\n");
 776                                         ret = E_BUG;
 777                                         goto error;
 778                                 }
 779                                 if ((ret=fix_switch(t))<0)
 780                                         goto error;
 781                                 break;
 782                         case WHILE_T:
 783                                 if (t->val[0].type!=RVE_ST){
 784                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 785                                                                 "%d for while() (should be expr)\n",
 786                                                                 t->val[0].type);
 787                                         ret = E_BUG;
 788                                         goto error;
 789                                 }else if (t->val[1].type!=ACTIONS_ST){
 790                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 791                                                                 "%d for while(...){...}(should be action)\n",
 792                                                                 t->val[1].type);
 793                                         ret = E_BUG;
 794                                         goto error;
 795                                 }
 796                                 rve=(struct rval_expr*)t->val[0].u.data;
 797                                 if (rve){
 798                                         err_rve=0;
 799                                         if (!rve_check_type(&rve_type, rve, &err_rve,
 800                                                                                         &err_type, &expected_type)){
 801                                                 if (err_rve)
 802                                                         LOG(L_ERR, "fix_actions: invalid expression "
 803                                                                         "(%d,%d): subexpression (%d,%d) has type"
 804                                                                         " %s,  but %s is expected\n",
 805                                                                         rve->fpos.s_line, rve->fpos.s_col,
 806                                                                         err_rve->fpos.s_line, err_rve->fpos.s_col,
 807                                                                         rval_type_name(err_type),
 808                                                                         rval_type_name(expected_type) );
 809                                                 else
 810                                                         LOG(L_ERR, "fix_actions: invalid expression "
 811                                                                         "(%d,%d): type mismatch?",
 812                                                                         rve->fpos.s_line, rve->fpos.s_col);
 813                                                 ret = E_UNSPEC;
 814                                                 goto error;
 815                                         }
 816                                         if (rve_type!=RV_INT && rve_type!=RV_NONE){
 817                                                 LOG(L_ERR, "fix_actions: invalid expression (%d,%d):"
 818                                                                 " bad type, integer expected\n",
 819                                                                 rve->fpos.s_line, rve->fpos.s_col);
 820                                                 ret = E_UNSPEC;
 821                                                 goto error;
 822                                         }
 823                                         if ((ret=fix_rval_expr(&t->val[0].u.data))<0)
 824                                                 goto error;
 825                                 }else{
 826                                         LOG(L_CRIT, "BUG: fix_actions: null while()"
 827                                                         " expression\n");
 828                                         ret = E_BUG;
 829                                         goto error;
 830                                 }
 831                                 if ( t->val[1].u.data &&
 832                                         ((ret= fix_actions((struct action*)t->val[1].u.data))<0)){
 833                                         goto error;
 834                                 }
 835                                 break;
 836                         case DROP_T:
 837                                 /* only RVEs need fixing for drop/return/break */
 838                                 if (t->val[0].type!=RVE_ST)
 839                                         break;
 840                                 rve=(struct rval_expr*)t->val[0].u.data;
 841                                 if (rve){
 842                                         err_rve=0;
 843                                         if (!rve_check_type(&rve_type, rve, &err_rve,
 844                                                                                         &err_type, &expected_type)){
 845                                                 if (err_rve)
 846                                                         LOG(L_ERR, "fix_actions: invalid expression "
 847                                                                         "(%d,%d): subexpression (%d,%d) has type"
 848                                                                         " %s,  but %s is expected\n",
 849                                                                         rve->fpos.s_line, rve->fpos.s_col,
 850                                                                         err_rve->fpos.s_line, err_rve->fpos.s_col,
 851                                                                         rval_type_name(err_type),
 852                                                                         rval_type_name(expected_type) );
 853                                                 else
 854                                                         LOG(L_ERR, "fix_actions: invalid expression "
 855                                                                         "(%d,%d): type mismatch?",
 856                                                                         rve->fpos.s_line, rve->fpos.s_col);
 857                                                 ret = E_UNSPEC;
 858                                                 goto error;
 859                                         }
 860                                         if (rve_type!=RV_INT && rve_type!=RV_NONE){
 861                                                 LOG(L_ERR, "fix_actions: invalid expression (%d,%d):"
 862                                                                 " bad type, integer expected\n",
 863                                                                 rve->fpos.s_line, rve->fpos.s_col);
 864                                                 ret = E_UNSPEC;
 865                                                 goto error;
 866                                         }
 867                                         if ((ret=fix_rval_expr(&t->val[0].u.data))<0)
 868                                                 goto error;
 869                                 }else{
 870                                         LOG(L_CRIT, "BUG: fix_actions: null drop/return"
 871                                                         " expression\n");
 872                                         ret = E_BUG;
 873                                         goto error;
 874                                 }
 875                                 break;
 876                         case ASSIGN_T:
 877                         case ADD_T:
 878                                 if (t->val[0].type !=LVAL_ST) {
 879                                         LOG(L_CRIT, "BUG: fix_actions: Invalid left side of"
 880                                                                 " assignment\n");
 881                                         ret = E_BUG;
 882                                         goto error;
 883                                 }
 884                                 if (t->val[1].type !=RVE_ST) {
 885                                         LOG(L_CRIT, "BUG: fix_actions: Invalid right side of"
 886                                                                 " assignment (%d)\n", t->val[1].type);
 887                                         ret = E_BUG;
 888                                         goto error;
 889                                 }
 890                                 lval=t->val[0].u.data;
 891                                 if (lval->type==LV_AVP){
 892                                         if (lval->lv.avps.type & AVP_CLASS_DOMAIN) {
 893                                                 LOG(L_ERR, "ERROR: You cannot change domain"
 894                                                                         " attributes from the script, they are"
 895                                                                         " read-only\n");
 896                                                 ret = E_BUG;
 897                                                 goto error;
 898                                         } else if (lval->lv.avps.type & AVP_CLASS_GLOBAL) {
 899                                                 LOG(L_ERR, "ERROR: You cannot change global"
 900                                                                    " attributes from the script, they are"
 901                                                                    "read-only\n");
 902                                                 ret = E_BUG;
 903                                                 goto error;
 904                                         }
 905                                 }
 906                                 if ((ret=fix_rval_expr(&t->val[1].u.data))<0)
 907                                         goto error;
 908                                 break;
 909
 910                         case MODULE_T:
 911                         case MODULE3_T:
 912                         case MODULE4_T:
 913                         case MODULE5_T:
 914                         case MODULE6_T:
 915                         case MODULEX_T:
 916                                 cmd = t->val[0].u.data;
 917                                 if (cmd && cmd->c.fixup) {
 918                                         DBG("fixing %s()\n", cmd->c.name);
 919                                         if (t->val[1].u.number==0) {
 920                                                 ret = cmd->c.fixup(0, 0);
 921                                                 if (ret < 0)
 922                                                         goto error;
 923                                         }
 924                                         /* type cast NUMBER to STRING, old modules may expect
 925                                          * all STRING params during fixup */
 926                                         for (i=0; i<t->val[1].u.number; i++) {
 927                                                 if (t->val[i+2].type == NUMBER_ST) {
 928                                                         snprintf(buf, sizeof(buf)-1, "%ld",
 929                                                                                 t->val[i+2].u.number);
 930                                                         /* fixup currently requires string pkg_malloced*/
 931                                                         t->val[i+2].u.string = pkg_malloc(strlen(buf)+1);
 932                                                         if (!t->val[i+2].u.string) {
 933                                                                 LOG(L_CRIT, "ERROR: cannot translate NUMBER"
 934                                                                                         " to STRING\n");
 935                                                                 ret = E_OUT_OF_MEM;
 936                                                                 goto error;
 937                                                         }
 938                                                         strcpy(t->val[i+2].u.string, buf);
 939                                                         t->val[i+2].type = STRING_ST;
 940                                                 }
 941                                         }
 942                                         for (i=0; i<t->val[1].u.number; i++) {
 943                                                 void *p;
 944                                                 p = t->val[i+2].u.data;
 945                                                 ret = cmd->c.fixup(&t->val[i+2].u.data, i+1);
 946                                                 if (t->val[i+2].u.data != p)
 947                                                         t->val[i+2].type = MODFIXUP_ST;
 948                                                 if (ret < 0)
 949                                                         goto error;
 950                                         }
 951                                 }
 952                                 break;
 953                         case FORCE_SEND_SOCKET_T:
 954                                 if (t->val[0].type!=SOCKID_ST){
 955                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 956                                                                 "%d for force_send_socket\n",
 957                                                                 t->val[0].type);
 958                                         ret = E_BUG;
 959                                         goto error;
 960                                 }
 961                                 he=resolvehost(
 962                                                 ((struct socket_id*)t->val[0].u.data)->addr_lst->name
 963                                                 );
 964                                 if (he==0){
 965                                         LOG(L_ERR, "ERROR: fix_actions: force_send_socket:"
 966                                                                 " could not resolve %s\n",
 967                                                 ((struct socket_id*)t->val[0].u.data)->addr_lst->name);
 968                                         ret = E_BAD_ADDRESS;
 969                                         goto error;
 970                                 }
 971                                 hostent2ip_addr(&ip, he, 0);
 972                                 si=find_si(&ip, ((struct socket_id*)t->val[0].u.data)->port,
 973                                                                 ((struct socket_id*)t->val[0].u.data)->proto);
 974                                 if (si==0){
 975                                         LOG(L_ERR, "ERROR: fix_actions: bad force_send_socket"
 976                                                         " argument: %s:%d (ser doesn't listen on it)\n",
 977                                                 ((struct socket_id*)t->val[0].u.data)->addr_lst->name,
 978                                                         ((struct socket_id*)t->val[0].u.data)->port);
 979                                         ret = E_BAD_ADDRESS;
 980                                         goto error;
 981                                 }
 982                                 t->val[0].u.data=si;
 983                                 t->val[0].type=SOCKETINFO_ST;
 984                                 break;
 985                         case UDP_MTU_TRY_PROTO_T:
 986                                 if (t->val[0].type!=NUMBER_ST){
 987                                         LOG(L_CRIT, "BUG: fix_actions: invalid subtype"
 988                                                                 "%d for udp_mtu_try_proto\n",
 989                                                                 t->val[0].type);
 990                                         ret = E_BUG;
 991                                         goto error;
 992                                 }
 993                                 switch(t->val[0].u.number){
 994                                         case PROTO_UDP:
 995                                                 t->val[0].u.number=0;
 996                                                 break;
 997                                         case PROTO_TCP:
 998                                                 t->val[0].u.number=FL_MTU_TCP_FB;
 999                                                 break;
1000                                         case PROTO_TLS:
1001                                                 t->val[0].u.number=FL_MTU_TLS_FB;
1002                                                 break;
1003                                         case PROTO_SCTP:
1004                                                 t->val[0].u.number=FL_MTU_SCTP_FB;
1005                                                 break;
1006                                         default:
1007                                                 LOG(L_CRIT, "BUG: fix actions: invalid argument for"
1008                                                                         " udp_mtu_try_proto (%d)\n",
1009                                                                         (unsigned int)t->val[0].u.number);
1010                                 }
1011                                 break;
1012                         case APPEND_BRANCH_T:
1013                                 if (t->val[0].type!=STRING_ST){
1014                                         BUG("invalid subtype%d for append_branch_t\n",
1015                                                                 t->val[0].type);
1016                                         ret = E_BUG;
1017                                         goto error;
1018                                 }
1019                                 s.s=t->val[0].u.string;
1020                                 s.len=(s.s)?strlen(s.s):0;
1021                                 t->val[0].u.str=s;
1022                                 t->val[0].type=STR_ST;
1023                                 break;
1024                         default:
1025                                 /* no fixup required for the rest */
1026                                 break;
1027                 }
1028         }
1029         return 0;
1030
1031 error:
1032         LM_ERR("fixing failed (code=%d) at cfg:%s:%d\n", ret,
1033                         (t->cfile)?t->cfile:"", t->cline);
1034         return ret;
1035 }
1036
1037
1038 /* Compare parameters as ordinary numbers
1039  *
1040  * Left and right operands can be either numbers or
1041  * attributes. If either of the attributes if of string type then the length of
1042  * its value will be used.
1043  */
1044 inline static int comp_num(int op, long left, int rtype, union exp_op* r,
1045                                                         struct sip_msg* msg, struct run_act_ctx* h)
1046 {
1047         int_str val;
1048         pv_value_t pval;
1049         avp_t* avp;
1050         int right;
1051
1052         if (unlikely(op==NO_OP)) return !(!left);
1053         switch(rtype){
1054                 case AVP_ST:
1055                         avp = search_avp_by_index(r->attr->type, r->attr->name,
1056                                                                                 &val, r->attr->index);
1057                         if (avp && !(avp->flags & AVP_VAL_STR)) right = val.n;
1058                         else return (op == DIFF_OP);
1059                         break;
1060                 case NUMBER_ST:
1061                         right = r->numval;
1062                         break;
1063                 case RVE_ST:
1064                         if (unlikely(rval_expr_eval_int(h, msg, &right, r->param)<0))
1065                                 return (op == DIFF_OP); /* not found/invalid */
1066                         break;
1067                 case PVAR_ST:
1068                         memset(&pval, 0, sizeof(pv_value_t));
1069                         if (unlikely(pv_get_spec_value(msg, r->param, &pval)!=0)){
1070                                 return (op == DIFF_OP); /* error, not found => false */
1071                         }
1072                         if (likely(pval.flags & (PV_TYPE_INT|PV_VAL_INT))){
1073                                 right=pval.ri;
1074                                 pv_value_destroy(&pval);
1075                         }else{
1076                                 pv_value_destroy(&pval);
1077                                 return (op == DIFF_OP); /* not found or invalid type */
1078                         }
1079                         break;
1080                 default:
1081                         LOG(L_CRIT, "BUG: comp_num: Invalid right operand (%d)\n", rtype);
1082                         return E_BUG;
1083         }
1084
1085         switch (op){
1086                 case EQUAL_OP: return (long)left == (long)right;
1087                 case DIFF_OP:  return (long)left != (long)right;
1088                 case GT_OP:    return (long)left >  (long)right;
1089                 case LT_OP:    return (long)left <  (long)right;
1090                 case GTE_OP:   return (long)left >= (long)right;
1091                 case LTE_OP:   return (long)left <= (long)right;
1092                 default:
1093                         LOG(L_CRIT, "BUG: comp_num: unknown operator: %d\n", op);
1094                         return E_BUG;
1095         }
1096         return E_BUG;
1097 }
1098
1099 /*
1100  * Compare given string "left" with right side of expression
1101  */
1102 inline static int comp_str(int op, str* left, int rtype,
1103                                                         union exp_op* r, struct sip_msg* msg,
1104                                                         struct run_act_ctx* h)
1105 {
1106         str* right;
1107         int_str val;
1108         str v;
1109         avp_t* avp;
1110         int ret;
1111         char backup;
1112         regex_t* re;
1113         unsigned int l;
1114         struct rvalue* rv;
1115         struct rval_cache rv_cache;
1116         pv_value_t pval;
1117         int destroy_pval;
1118
1119         right=0; /* warning fix */
1120         rv=0;
1121         destroy_pval=0;
1122         if (unlikely(op==NO_OP)) return (left->s!=0);
1123         switch(rtype){
1124                 case AVP_ST:
1125                         avp = search_avp_by_index(r->attr->type, r->attr->name,
1126                                                                                 &val, r->attr->index);
1127                         if (likely(avp && (avp->flags & AVP_VAL_STR))) right = &val.s;
1128                         else return (op == DIFF_OP);
1129                         break;
1130                 case SELECT_ST:
1131                         ret = run_select(&v, r->select, msg);
1132                         if (unlikely(ret != 0))
1133                                 return (op == DIFF_OP); /* Not found or error */
1134                         right = &v;
1135                         break;
1136                 case RVE_ST:
1137                         rval_cache_init(&rv_cache);
1138                         rv=rval_expr_eval(h, msg, r->param);
1139                         if (unlikely (rv==0))
1140                                 return (op==DIFF_OP); /* not found or error*/
1141                         if (unlikely(rval_get_tmp_str(h, msg, &v, rv, 0, &rv_cache)<0)){
1142                                 goto error;
1143                         }
1144                         right = &v;
1145                         break;
1146                 case PVAR_ST:
1147                         memset(&pval, 0, sizeof(pv_value_t));
1148                         if (unlikely(pv_get_spec_value(msg, r->param, &pval)!=0)){
1149                                 return (op == DIFF_OP); /* error, not found => false */
1150                         }
1151                         destroy_pval=1;
1152                         if (likely(pval.flags & PV_VAL_STR)){
1153                                 right=&pval.rs;
1154                         }else{
1155                                 pv_value_destroy(&pval);
1156                                 return (op == DIFF_OP); /* not found or invalid type */
1157                         }
1158                         break;
1159                 case RE_ST:
1160                         if (unlikely(op != MATCH_OP)){
1161                                 LOG(L_CRIT, "BUG: comp_str: Bad operator %d,"
1162                                                         " ~= expected\n", op);
1163                                 goto error;
1164                         }
1165                         break;
1166                 case STRING_ST:
1167                         right=&r->str;
1168                         break;
1169                 case NUMBER_ST:
1170                         /* "123" > 100 is not allowed by cfg.y rules
1171                          * but can happen as @select or $avp evaluation
1172                          * $test > 10
1173                          * the right operator MUST be number to do the conversion
1174                          */
1175                         if (str2int(left,&l) < 0)
1176                                 goto error;
1177                         return comp_num(op, l, rtype, r, msg, h);
1178                 default:
1179                         LOG(L_CRIT, "BUG: comp_str: Bad type %d, "
1180                                                 "string or RE expected\n", rtype);
1181                         goto error;
1182         }
1183
1184         ret=-1;
1185         switch(op){
1186                 case EQUAL_OP:
1187                         if (left->len != right->len) return 0;
1188                         ret=(strncasecmp(left->s, right->s, left->len)==0);
1189                         break;
1190                 case DIFF_OP:
1191                         if (left->len != right->len) return 1;
1192                         ret = (strncasecmp(left->s, right->s, left->len)!=0);
1193                         break;
1194                 case MATCH_OP:
1195                         /* this is really ugly -- we put a temporary zero-terminating
1196                          * character in the original string; that's because regexps
1197                          * take 0-terminated strings and our messages are not
1198                          * zero-terminated; it should not hurt as long as this function
1199                          * is applied to content of pkg mem, which is always the case
1200                          * with calls from route{}; the same goes for fline in
1201                          * reply_route{};
1202                          *
1203                          * also, the received function should always give us an extra
1204                          * character, into which we can put the 0-terminator now;
1205                          * an alternative would be allocating a new piece of memory,
1206                          * which might be too slow
1207                          * -jiri
1208                          *
1209                          * janakj: AVPs are zero terminated too so this is not problem
1210                          * either
1211                          */
1212                         backup=left->s[left->len];
1213                         left->s[left->len]='\0';
1214                         switch(rtype){
1215                                 case AVP_ST:
1216                                 case SELECT_ST:
1217                                 case RVE_ST:
1218                                 case PVAR_ST:
1219                                         /* we need to compile the RE on the fly */
1220                                         re=(regex_t*)pkg_malloc(sizeof(regex_t));
1221                                         if (re==0){
1222                                                 LOG(L_CRIT, "ERROR: comp_strstr: memory allocation"
1223                                                                          " failure\n");
1224                                                 left->s[left->len] = backup;
1225                                                 goto error;
1226                                         }
1227                                         if (regcomp(re, right->s,
1228                                                                 REG_EXTENDED|REG_NOSUB|REG_ICASE)) {
1229                                                 pkg_free(re);
1230                                                 left->s[left->len] = backup;
1231                                                 goto error;
1232                                         }
1233                                         ret=(regexec(re, left->s, 0, 0, 0)==0);
1234                                         regfree(re);
1235                                         pkg_free(re);
1236                                         break;
1237                                 case RE_ST:
1238                                         ret=(regexec(r->re, left->s, 0, 0, 0)==0);
1239                                         break;
1240                                 case STRING_ST:
1241                                 default:
1242                                         LOG(L_CRIT, "BUG: comp_str: Bad operator type %d, "
1243                                                                 "for ~= \n", rtype);
1244                                         goto error;
1245                         }
1246                         left->s[left->len] = backup;
1247                         break;
1248                 default:
1249                         LOG(L_CRIT, "BUG: comp_str: unknown op %d\n", op);
1250                         goto error;
1251         }
1252         if (rv){
1253                 rval_cache_clean(&rv_cache);
1254                 rval_destroy(rv);
1255         }
1256         if (destroy_pval)
1257                 pv_value_destroy(&pval);
1258         return ret;
1259
1260 error:
1261         if (rv){
1262                 rval_cache_clean(&rv_cache);
1263                 rval_destroy(rv);
1264         }
1265         if (destroy_pval)
1266                 pv_value_destroy(&pval);
1267         return (op == DIFF_OP) ? 1 : -1;
1268 }
1269
1270
1271 /* eval_elem helping function, returns str op param */
1272 inline static int comp_string(int op, char* left, int rtype, union exp_op* r,
1273                                                                 struct sip_msg* msg, struct run_act_ctx* h)
1274 {
1275         str s;
1276
1277         s.s=left;
1278         s.len=strlen(left);
1279         return comp_str(op, &s, rtype, r, msg, h);
1280 }
1281
1282
1283 inline static int comp_avp(int op, avp_spec_t* spec, int rtype,
1284                                                         union exp_op* r, struct sip_msg* msg,
1285                                                         struct run_act_ctx* h)
1286 {
1287         avp_t* avp;
1288         int_str val;
1289         union exp_op num_val;
1290         str tmp;
1291         unsigned int uval;
1292
1293         if (spec->type & AVP_INDEX_ALL) {
1294                 avp = search_first_avp(spec->type & ~AVP_INDEX_ALL, spec->name,
1295                                                                 NULL, NULL);
1296                 return (avp!=0);
1297         }
1298         avp = search_avp_by_index(spec->type, spec->name, &val, spec->index);
1299         if (!avp) return (op == DIFF_OP);
1300
1301         if (op==NO_OP){
1302                 if (avp->flags & AVP_VAL_STR) {
1303                         return val.s.len!=0;
1304                 } else {
1305                         return val.n != 0;
1306                 }
1307         }
1308         if (avp->flags & AVP_VAL_STR) {
1309                 return comp_str(op, &val.s, rtype, r, msg, h);
1310         } else {
1311                 switch(rtype){
1312                         case NUMBER_ST:
1313                         case AVP_ST:
1314                         case RVE_ST:
1315                         case PVAR_ST:
1316                                 return comp_num(op, val.n, rtype, r, msg, h);
1317                                 break;
1318                         case STRING_ST:
1319                                 tmp.s=r->string;
1320                                 tmp.len=strlen(r->string);
1321                                 if (str2int(&tmp, &uval)<0){
1322                                         LOG(L_WARN, "WARNING: comp_avp: cannot convert"
1323                                                                 " string value to int (%s)\n",
1324                                                                 ZSW(r->string));
1325                                         goto error;
1326                                 }
1327                                 num_val.numval=uval;
1328                                 return comp_num(op, val.n, NUMBER_ST, &num_val, msg, h);
1329                         case STR_ST:
1330                                 if (str2int(&r->str, &uval)<0){
1331                                         LOG(L_WARN, "WARNING: comp_avp: cannot convert str value"
1332                                                                 " to int (%.*s)\n", r->str.len, ZSW(r->str.s));
1333                                         goto error;
1334                                 }
1335                                 num_val.numval=uval;
1336                                 return comp_num(op, val.n, NUMBER_ST, &num_val, msg, h);
1337                         default:
1338                                 LOG(L_CRIT, "BUG: comp_avp: invalid type for numeric avp "
1339                                                         "comparison (%d)\n", rtype);
1340                                 goto error;
1341                 }
1342         }
1343 error:
1344         return (op == DIFF_OP) ? 1 : -1;
1345 }
1346
1347 /*
1348  * Left side of expression was select
1349  */
1350 inline static int comp_select(int op, select_t* sel, int rtype,
1351                                                                 union exp_op* r, struct sip_msg* msg,
1352                                                                 struct run_act_ctx* h)
1353 {
1354         int ret;
1355         str val;
1356         char empty_str=0;
1357
1358         ret = run_select(&val, sel, msg);
1359         if (ret != 0) return (op == DIFF_OP);
1360
1361         if (op==NO_OP) return (val.len>0);
1362         if (unlikely(val.len==0)) {
1363                 /* make sure the string pointer uses accessible memory range
1364                  * the comp_str function might dereference it
1365                  */
1366                 val.s=&empty_str;
1367         }
1368         return comp_str(op, &val, rtype, r, msg, h);
1369 }
1370
1371
1372 inline static int comp_rve(int op, struct rval_expr* rve, int rtype,
1373                                                         union exp_op* r, struct sip_msg* msg,
1374                                                         struct run_act_ctx* h)
1375 {
1376         int i;
1377         struct rvalue* rv;
1378         struct rvalue* rv1;
1379         struct rval_cache c1;
1380
1381         rval_cache_init(&c1);
1382         if (unlikely(rval_expr_eval_rvint(h,  msg, &rv, &i, rve, &c1)<0)){
1383                 ERR("failure evaluating expression: bad type\n");
1384                 i=0; /* false */
1385                 goto int_expr;
1386         }
1387         if (unlikely(rv)){
1388                 /* no int => str */
1389                 rv1=rval_convert(h, msg, RV_STR, rv, &c1);
1390                 i=comp_str(op, &rv1->v.s, rtype, r, msg, h);
1391                 rval_destroy(rv1);
1392                 rval_destroy(rv);
1393                 rval_cache_clean(&c1);
1394                 return i;
1395         }
1396         /* expr evaluated to int */
1397 int_expr:
1398         rval_cache_clean(&c1);
1399         if (op==NO_OP)
1400                 return !(!i); /* transform it into { 0, 1 } */
1401         return comp_num(op, i, rtype, r, msg, h);
1402 }
1403
1404
1405
1406 inline static int comp_pvar(int op, pv_spec_t* pvs, int rtype,
1407                                                         union exp_op* r, struct sip_msg* msg,
1408                                                         struct run_act_ctx* h)
1409 {
1410         pv_value_t pval;
1411         int ret;
1412
1413         ret=0;
1414         memset(&pval, 0, sizeof(pv_value_t));
1415         if (unlikely(pv_get_spec_value(msg, r->param, &pval)!=0)){
1416                 return 0; /* error, not found => false */
1417         }
1418         if (likely(pval.flags & PV_TYPE_INT)){
1419                 if (op==NO_OP)
1420                         ret=!(!pval.ri);
1421                 else
1422                         ret=comp_num(op, pval.ri, rtype, r, msg, h);
1423         }else if ((pval.flags==PV_VAL_NONE) ||
1424                         (pval.flags & (PV_VAL_NULL|PV_VAL_EMPTY))){
1425                 if (op==NO_OP)
1426                         ret=0;
1427                 else
1428                         ret=comp_num(op, 0, rtype, r, msg, h);
1429         }else{
1430                 ret=pval.rs.len!=0;
1431                 if (op!=NO_OP)
1432                         ret=comp_num(op, ret, rtype, r, msg, h);
1433         }
1434         pv_value_destroy(&pval);
1435         return ret;
1436 }
1437
1438
1439
1440 /* check_self wrapper -- it checks also for the op */
1441 inline static int check_self_op(int op, str* s, unsigned short p)
1442 {
1443         int ret;
1444
1445         ret=check_self(s, p, 0);
1446         switch(op){
1447                 case EQUAL_OP:
1448                 case MATCH_OP:
1449                         break;
1450                 case DIFF_OP:
1451                         ret=(ret > 0) ? 0 : 1;
1452                         break;
1453                 default:
1454                         LOG(L_CRIT, "BUG: check_self_op: invalid operator %d\n", op);
1455                         ret=-1;
1456         }
1457         return ret;
1458 }
1459
1460
1461 /* eval_elem helping function, returns an op param */
1462 inline static int comp_ip(int op, struct ip_addr* ip, int rtype,
1463                                                         union exp_op* r, struct sip_msg* msg,
1464                                                         struct run_act_ctx *ctx )
1465 {
1466         struct hostent* he;
1467         char ** h;
1468         int ret;
1469         str tmp;
1470
1471         ret=-1;
1472         switch(rtype){
1473                 case NET_ST:
1474                         switch(op){
1475                                 case EQUAL_OP:
1476                                         ret=(matchnet(ip, r->net)==1);
1477                                         break;
1478                                 case DIFF_OP:
1479                                         ret=(matchnet(ip, r->net)!=1);
1480                                         break;
1481                                 default:
1482                                         goto error_op;
1483                         }
1484                         break;
1485                 case AVP_ST:
1486                 case STRING_ST:
1487                 case RE_ST:
1488                 case RVE_ST:
1489                 case SELECT_ST:
1490                         switch(op){
1491                                 case EQUAL_OP:
1492                                 case MATCH_OP:
1493                                         /* 1: compare with ip2str*/
1494                                         ret=comp_string(op, ip_addr2a(ip), rtype, r, msg, ctx);
1495                                         if (likely(ret==1)) break;
1496                                         /* 2: resolve (name) & compare w/ all the ips */
1497                                         if (rtype==STRING_ST){
1498                                                 he=resolvehost(r->str.s);
1499                                                 if (he==0){
1500                                                         DBG("comp_ip: could not resolve %s\n",
1501                                                             r->str.s);
1502                                                 }else if (he->h_addrtype==ip->af){
1503                                                         for(h=he->h_addr_list;(ret!=1)&& (*h); h++){
1504                                                                 ret=(memcmp(ip->u.addr, *h, ip->len)==0);
1505                                                         }
1506                                                         if (ret==1) break;
1507                                                 }
1508                                         }
1509                                         /* 3: (slow) rev dns the address
1510                                         * and compare with all the aliases
1511                                         * !!??!! review: remove this? */
1512                                         if (unlikely((received_dns & DO_REV_DNS) &&
1513                                                         ((he=rev_resolvehost(ip))!=0) )){
1514                                                 /*  compare with primary host name */
1515                                                 ret=comp_string(op, he->h_name, rtype, r, msg, ctx);
1516                                                 /* compare with all the aliases */
1517                                                 for(h=he->h_aliases; (ret!=1) && (*h); h++){
1518                                                         ret=comp_string(op, *h, rtype, r, msg, ctx);
1519                                                 }
1520                                         }else{
1521                                                 ret=0;
1522                                         }
1523                                         break;
1524                                 case DIFF_OP:
1525                                         ret=(comp_ip(EQUAL_OP, ip, rtype, r, msg, ctx) > 0) ?0:1;
1526                                         break;
1527                                 default:
1528                                         goto error_op;
1529                         }
1530                         break;
1531                 case MYSELF_ST: /* check if it's one of our addresses*/
1532                         tmp.s=ip_addr2a(ip);
1533                         tmp.len=strlen(tmp.s);
1534                         ret=check_self_op(op, &tmp, 0);
1535                         break;
1536                 default:
1537                         LOG(L_CRIT, "BUG: comp_ip: invalid type for "
1538                                                 " src_ip or dst_ip (%d)\n", rtype);
1539                         ret=-1;
1540         }
1541         return ret;
1542 error_op:
1543         LOG(L_CRIT, "BUG: comp_ip: invalid operator %d\n", op);
1544         return -1;
1545 }
1546
1547
1548
1549 /* returns: 0/1 (false/true) or -1 on error */
1550 inline static int eval_elem(struct run_act_ctx* h, struct expr* e,
1551                                                                 struct sip_msg* msg)
1552 {
1553         struct sip_uri uri;
1554         int ret;
1555         struct onsend_info* snd_inf;
1556         struct ip_addr ip;
1557         ret=E_BUG;
1558
1559         if (e->type!=ELEM_T){
1560                 LOG(L_CRIT," BUG: eval_elem: invalid type\n");
1561                 goto error;
1562         }
1563         switch(e->l_type){
1564         case METHOD_O:
1565                 ret=comp_str(e->op, &msg->first_line.u.request.method,
1566                                                 e->r_type, &e->r, msg, h);
1567                 break;
1568         case URI_O:
1569                 if(msg->new_uri.s) {
1570                         if (e->r_type==MYSELF_ST){
1571                                 if (parse_sip_msg_uri(msg)<0) ret=-1;
1572                                 else ret=check_self_op(e->op, &msg->parsed_uri.host,
1573                                                        msg->parsed_uri.port_no?
1574                                                        msg->parsed_uri.port_no:SIP_PORT);
1575                         }else{
1576                                 ret=comp_str(e->op, &msg->new_uri,
1577                                                                 e->r_type, &e->r, msg, h);
1578                         }
1579                 }else{
1580                         if (e->r_type==MYSELF_ST){
1581                                 if (parse_sip_msg_uri(msg)<0) ret=-1;
1582                                 else ret=check_self_op(e->op, &msg->parsed_uri.host,
1583                                                        msg->parsed_uri.port_no?
1584                                                        msg->parsed_uri.port_no:SIP_PORT);
1585                         }else{
1586                                 ret=comp_str(e->op, &msg->first_line.u.request.uri,
1587                                                                 e->r_type, &e->r, msg, h);
1588                         }
1589                 }
1590                 break;
1591
1592         case FROM_URI_O:
1593                 if (parse_from_header(msg)!=0){
1594                         LOG(L_ERR, "ERROR: eval_elem: bad or missing"
1595                             " From: header\n");
1596                         goto error;
1597                 }
1598                 if (e->r_type==MYSELF_ST){
1599                         if (parse_uri(get_from(msg)->uri.s, get_from(msg)->uri.len,
1600                                       &uri) < 0){
1601                                 LOG(L_ERR, "ERROR: eval_elem: bad uri in From:\n");
1602                                 goto error;
1603                         }
1604                         ret=check_self_op(e->op, &uri.host,
1605                                           uri.port_no?uri.port_no:SIP_PORT);
1606                 }else{
1607                         ret=comp_str(e->op, &get_from(msg)->uri,
1608                                                         e->r_type, &e->r, msg, h);
1609                 }
1610                 break;
1611
1612         case TO_URI_O:
1613                 if ((msg->to==0) && ((parse_headers(msg, HDR_TO_F, 0)==-1) ||
1614                                      (msg->to==0))){
1615                         LOG(L_ERR, "ERROR: eval_elem: bad or missing"
1616                             " To: header\n");
1617                         goto error;
1618                 }
1619                      /* to content is parsed automatically */
1620                 if (e->r_type==MYSELF_ST){
1621                         if (parse_uri(get_to(msg)->uri.s, get_to(msg)->uri.len,
1622                                       &uri) < 0){
1623                                 LOG(L_ERR, "ERROR: eval_elem: bad uri in To:\n");
1624                                 goto error;
1625                         }
1626                         ret=check_self_op(e->op, &uri.host,
1627                                           uri.port_no?uri.port_no:SIP_PORT);
1628                 }else{
1629                         ret=comp_str(e->op, &get_to(msg)->uri,
1630                                                         e->r_type, &e->r, msg, h);
1631                 }
1632                 break;
1633
1634         case SRCIP_O:
1635                 ret=comp_ip(e->op, &msg->rcv.src_ip, e->r_type, &e->r, msg, h);
1636                 break;
1637
1638         case DSTIP_O:
1639                 ret=comp_ip(e->op, &msg->rcv.dst_ip, e->r_type, &e->r, msg, h);
1640                 break;
1641
1642         case SNDIP_O:
1643                 snd_inf=get_onsend_info();
1644                 if (likely(snd_inf && snd_inf->send_sock)){
1645                         ret=comp_ip(e->op, &snd_inf->send_sock->address,
1646                                                 e->r_type, &e->r, msg, h);
1647                 }else{
1648                         BUG("eval_elem: snd_ip unknown (not in a onsend_route?)\n");
1649                 }
1650                 break;
1651
1652         case TOIP_O:
1653                 snd_inf=get_onsend_info();
1654                 if (likely(snd_inf && snd_inf->to)){
1655                         su2ip_addr(&ip, snd_inf->to);
1656                         ret=comp_ip(e->op, &ip, e->r_type, &e->r, msg, h);
1657                 }else{
1658                         BUG("eval_elem: to_ip unknown (not in a onsend_route?)\n");
1659                 }
1660                 break;
1661
1662         case NUMBER_O:
1663                 ret=!(!e->r.numval); /* !! to transform it in {0,1} */
1664                 break;
1665
1666         case ACTION_O:
1667                 ret=run_actions(h, (struct action*)e->r.param, msg);
1668                 if (ret<=0) ret=0;
1669                 else ret=1;
1670                 break;
1671
1672         case SRCPORT_O:
1673                 ret=comp_num(e->op, (int)msg->rcv.src_port, e->r_type, &e->r, msg, h);
1674                 break;
1675
1676         case DSTPORT_O:
1677                 ret=comp_num(e->op, (int)msg->rcv.dst_port, e->r_type, &e->r, msg, h);
1678                 break;
1679
1680         case SNDPORT_O:
1681                 snd_inf=get_onsend_info();
1682                 if (likely(snd_inf && snd_inf->send_sock)){
1683                         ret=comp_num(e->op, (int)snd_inf->send_sock->port_no,
1684                                                         e->r_type, &e->r, msg, h);
1685                 }else{
1686                         BUG("eval_elem: snd_port unknown (not in a onsend_route?)\n");
1687                 }
1688                 break;
1689
1690         case TOPORT_O:
1691                 snd_inf=get_onsend_info();
1692                 if (likely(snd_inf && snd_inf->to)){
1693                         ret=comp_num(e->op, (int)su_getport(snd_inf->to),
1694                                                                 e->r_type, &e->r, msg, h);
1695                 }else{
1696                         BUG("eval_elem: to_port unknown (not in a onsend_route?)\n");
1697                 }
1698                 break;
1699
1700         case PROTO_O:
1701                 ret=comp_num(e->op, msg->rcv.proto, e->r_type, &e->r, msg, h);
1702                 break;
1703
1704         case SNDPROTO_O:
1705                 snd_inf=get_onsend_info();
1706                 if (likely(snd_inf && snd_inf->send_sock)){
1707                         ret=comp_num(e->op, snd_inf->send_sock->proto,
1708                                                         e->r_type, &e->r, msg, h);
1709                 }else{
1710                         BUG("eval_elem: snd_proto unknown (not in a onsend_route?)\n");
1711                 }
1712                 break;
1713
1714         case AF_O:
1715                 ret=comp_num(e->op, (int)msg->rcv.src_ip.af, e->r_type, &e->r, msg, h);
1716                 break;
1717
1718         case SNDAF_O:
1719                 snd_inf=get_onsend_info();
1720                 if (likely(snd_inf && snd_inf->send_sock)){
1721                         ret=comp_num(e->op, snd_inf->send_sock->address.af,
1722                                                         e->r_type, &e->r, msg, h);
1723                 }else{
1724                         BUG("eval_elem: snd_af unknown (not in a onsend_route?)\n");
1725                 }
1726                 break;
1727
1728         case MSGLEN_O:
1729                 if ((snd_inf=get_onsend_info())!=0){
1730                         ret=comp_num(e->op, (int)snd_inf->len, e->r_type, &e->r, msg, h);
1731                 }else{
1732                         ret=comp_num(e->op, (int)msg->len, e->r_type, &e->r, msg, h);
1733                 }
1734                 break;
1735
1736         case RETCODE_O:
1737                 ret=comp_num(e->op, h->last_retcode, e->r_type, &e->r, msg, h);
1738                 break;
1739
1740         case AVP_O:
1741                 ret = comp_avp(e->op, e->l.attr, e->r_type, &e->r, msg, h);
1742                 break;
1743
1744         case SELECT_O:
1745                 ret = comp_select(e->op, e->l.select, e->r_type, &e->r, msg, h);
1746                 break;
1747
1748         case RVEXP_O:
1749                 ret = comp_rve(e->op, e->l.param, e->r_type, &e->r, msg, h);
1750                 break;
1751
1752         case PVAR_O:
1753                 ret=comp_pvar(e->op, e->l.param, e->r_type, &e->r, msg, h);
1754                 break;
1755 /*
1756         default:
1757                 LOG(L_CRIT, "BUG: eval_elem: invalid operand %d\n",
1758                     e->l_type);
1759 */
1760         }
1761         return ret;
1762 error:
1763         return (e->op == DIFF_OP) ? 1 : -1;
1764 }
1765
1766
1767
1768 /* ret= 1/0 (true/false) ,  -1 on error (evaluates as false)*/
1769 int eval_expr(struct run_act_ctx* h, struct expr* e, struct sip_msg* msg)
1770 {
1771         int ret;
1772
1773         if (e->type==ELEM_T){
1774                 ret=eval_elem(h, e, msg);
1775         }else if (e->type==EXP_T){
1776                 switch(e->op){
1777                         case LOGAND_OP:
1778                                 ret=eval_expr(h, e->l.expr, msg);
1779                                 /* if error or false stop evaluating the rest */
1780                                 if (ret <= 0) break;
1781                                 ret=eval_expr(h, e->r.expr, msg); /*ret1 is 1*/
1782                                 break;
1783                         case LOGOR_OP:
1784                                 ret=eval_expr(h, e->l.expr, msg);
1785                                 /* if true stop evaluating the rest */
1786                                 if (ret > 0) break;
1787                                 ret=eval_expr(h, e->r.expr, msg); /* ret1 is 0 */
1788                                 break;
1789                         case NOT_OP:
1790                                 ret=eval_expr(h, e->l.expr, msg);
1791                                 ret=(ret > 0) ? 0 : 1;
1792                                 break;
1793                         default:
1794                                 LOG(L_CRIT, "BUG: eval_expr: unknown op %d\n", e->op);
1795                                 ret=-1;
1796                 }
1797         }else{
1798                 LOG(L_CRIT, "BUG: eval_expr: unknown type %d\n", e->type);
1799                 ret=-1;
1800         }
1801         return ret;
1802 }
1803
1804
1805 /* adds an action list to head; a must be null terminated (last a->next=0))*/
1806 void push(struct action* a, struct action** head)
1807 {
1808         struct action *t;
1809         if (*head==0){
1810                 *head=a;
1811                 return;
1812         }
1813         for (t=*head; t->next;t=t->next);
1814         t->next=a;
1815 }
1816
1817
1818
1819
1820 int add_actions(struct action* a, struct action** head)
1821 {
1822         int ret;
1823
1824         LOG(L_DBG, "add_actions: fixing actions...\n");
1825         if ((ret=fix_actions(a))!=0) goto error;
1826         push(a,head);
1827         return 0;
1828
1829 error:
1830         return ret;
1831 }
1832
1833
1834
1835 static int fix_rl(struct route_list* rt)
1836 {
1837         int i;
1838         int ret;
1839
1840         for(i=0;i<rt->idx; i++){
1841                 if(rt->rlist[i]){
1842                         if ((ret=fix_actions(rt->rlist[i]))!=0){
1843                                 return ret;
1844                         }
1845                 }
1846         }
1847         return 0;
1848 }
1849
1850
1851
1852 /* fixes all action tables */
1853 /* returns 0 if ok , <0 on error */
1854 int fix_rls()
1855 {
1856         int ret;
1857
1858         if ((ret=fix_rl(&main_rt))!=0)
1859                 return ret;
1860         if ((ret=fix_rl(&onreply_rt))!=0)
1861                 return ret;
1862         if ((ret=fix_rl(&failure_rt))!=0)
1863                 return ret;
1864         if ((ret=fix_rl(&branch_rt))!=0)
1865                 return ret;
1866         if ((ret=fix_rl(&onsend_rt))!=0)
1867                 return ret;
1868         if ((ret=fix_rl(&event_rt))!=0)
1869                 return ret;
1870
1871         return 0;
1872 }
1873
1874
1875
1876 static void print_rl(struct route_list* rt, char* name)
1877 {
1878         int j;
1879
1880         for(j=0; j<rt->entries; j++){
1881                 if (rt->rlist[j]==0){
1882                         if ((j==0) && (rt==&main_rt))
1883                                 DBG("WARNING: the main routing table is empty\n");
1884                         continue;
1885                 }
1886                 DBG("%s routing table %d:\n", name, j);
1887                 print_actions(rt->rlist[j]);
1888                 DBG("\n");
1889         }
1890 }
1891
1892
1893 /* debug function, prints routing tables */
1894 void print_rls()
1895 {
1896         print_rl(&main_rt, "");
1897         print_rl(&onreply_rt, "onreply");
1898         print_rl(&failure_rt, "failure");
1899         print_rl(&branch_rt, "branch");
1900         print_rl(&onsend_rt, "onsend");
1901         print_rl(&event_rt, "event");
1902 }