git.sip-router.org Git - sip-router/blob - modules/tm/tm.c

   1 /*
   2  * $Id$
   3  *
   4  * TM module
   5  *
   6  *
   7  * ***************************************************
   8  * * Jiri's Source Memorial                          *
   9  * *                                                 *
  10  * * Welcome, pilgrim ! This is the greatest place   *
  11  * * where dramatic changes happend. There are not   *
  12  * * many places with a history like this, as there  *
  13  * * are not so many people like Jiri, one of the    *
  14  * * ser's fathers, who brought everywhere the wind  *
  15  * * of change, the flood of clean-up. We all felt   *
  16  * * his fatherly eye watching over us day and night.*
  17  * *                                                 *
  18  * * Please, preserve this codework heritage, as     *
  19  * * it's unlikely for fresh, juicy pieces of code to  *
  20  * * arise to give him the again the chance to       *
  21  * * demonstrate his clean-up and improvement skills.*
  22  * *                                                 *
  23  * * Hereby, we solicit you to adopt this historical *
  24  * * piece of code. For $100, your name will be      *
  25  * * be printed in this banner and we will use       *
  26  * * collected funds to create and display an ASCII  *
  27  * * statue of Jiri  .                               *
  28  * ***************************************************
  29  *
  30  *
  31  * Copyright (C) 2001-2003 FhG Fokus
  32  *
  33  * This file is part of ser, a free SIP server.
  34  *
  35  * ser is free software; you can redistribute it and/or modify
  36  * it under the terms of the GNU General Public License as published by
  37  * the Free Software Foundation; either version 2 of the License, or
  38  * (at your option) any later version
  39  *
  40  * For a license to use the ser software under conditions
  41  * other than those described here, or to purchase support for this
  42  * software, please contact iptel.org by e-mail at the following addresses:
  43  *    info@iptel.org
  44  *
  45  * ser is distributed in the hope that it will be useful,
  46  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  48  * GNU General Public License for more details.
  49  *
  50  * You should have received a copy of the GNU General Public License
  51  * along with this program; if not, write to the Free Software
  52  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  53  */
  54 /*
  55  * History:
  56  * --------
  57  *  2003-02-18  added t_forward_nonack_{udp, tcp}, t_relay_to_{udp,tcp},
  58  *               t_replicate_{udp, tcp} (andrei)
  59  *  2003-02-19  added t_rely_{udp, tcp} (andrei)
  60  *  2003-03-06  voicemail changes accepted (jiri)
  61  *  2003-03-10  module export interface updated to the new format (andrei)
  62  *  2003-03-16  flags export parameter added (janakj)
  63  *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
  64  *  2003-03-30  set_kr for requests only (jiri)
  65  *  2003-04-05  s/reply_route/failure_route, onreply_route introduced (jiri)
  66  *  2003-04-14  use protocol from uri (jiri)
  67  *  2003-07-07  added t_relay_to_tls, t_replicate_tls, t_forward_nonack_tls
  68  *              added #ifdef USE_TCP, USE_TLS
  69  *              removed t_relay_{udp,tcp,tls} (andrei)
  70  *  2003-09-26  added t_forward_nonack_uri() - same as t_forward_nonack() but
  71  *              takes no parameters -> forwards to uri (bogdan)
  72  *  2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
  73  *  2004-02-18  t_reply exported via FIFO - imported from VM (bogdan)
  74  *  2004-10-01  added a new param.: restart_fr_on_each_reply (andrei)
  75  *  2005-11-14  new timer support, changed timer related module params (andrei)
  76  *  2005-12-09  fixup_hostport2proxy uses route_struct to access param #1
  77  *              when fixing param #2
  78  *  2005-12-09  added t_set_fr() (andrei)
  79  *  2006-02-07  named routes support (andrei)
  80  *  2006-09-28  added t_branch_replied, t_branch_timeout, t_any_replied,
  81  *               t_any_timeout, t_is_canceled (andrei)
  82  *  2006-10-16  added a new param.: aggregate challenges (andrei)
  83  *  2007-05-28  two new params: reparse_invite, ac_extra_hdrs
  84  *              added w_t_relay_cancel() (Miklos)
  85  *  2007-06-05  added t_set_auto_inv_100() and auto_inv_100 (param);
  86  *               t_set_max_lifetime(), max_{non}inv_lifetime  (andrei)
  87  *  2008-02-05  module config parameters use the configuration framework (Miklos)
  88  *  2008-02-29  added t_grep_status(code) (andrei)
  89  */
  90
  91
  92 #include "defs.h"
  93
  94
  95 #include <stdio.h>
  96 #include <string.h>
  97 #include <netdb.h>
  98
  99 #include "../../sr_module.h"
 100 #include "../../dprint.h"
 101 #include "../../error.h"
 102 #include "../../ut.h"
 103 #include "../../script_cb.h"
 104 #include "../../usr_avp.h"
 105 #include "../../mem/mem.h"
 106 #include "../../route_struct.h"
 107 #include "../../route.h"
 108 #include "../../cfg/cfg.h"
 109 #include "../../globals.h"
 110
 111 #include "config.h"
 112 #include "sip_msg.h"
 113 #include "h_table.h"
 114 #include "t_hooks.h"
 115 #include "tm_load.h"
 116 #include "ut.h"
 117 #include "t_reply.h"
 118 #include "uac.h"
 119 #include "t_fwd.h"
 120 #include "t_lookup.h"
 121 #include "t_stats.h"
 122 #include "callid.h"
 123 #include "t_cancel.h"
 124 #include "t_fifo.h"
 125 #include "timer.h"
 126 #include "t_msgbuilder.h"
 127 #include "select.h"
 128
 129 MODULE_VERSION
 130
 131 /* fixup functions */
 132 static int fixup_hostport2proxy(void** param, int param_no);
 133 static int fixup_proto_hostport2proxy(void** param, int param_no);
 134 static int fixup_on_failure(void** param, int param_no);
 135 static int fixup_on_reply(void** param, int param_no);
 136 static int fixup_on_branch(void** param, int param_no);
 137 static int fixup_t_reply(void** param, int param_no);
 138
 139
 140 /* init functions */
 141 static int mod_init(void);
 142 static int child_init(int rank);
 143
 144
 145 /* exported functions */
 146 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
 147 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2);
 148 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
 149 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
 150 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
 151                                 char* bar );
 152 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
 153 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
 154 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy,
 155                                  char *);
 156 #ifdef USE_TCP
 157 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
 158                                 char *);
 159 #endif
 160 #ifdef USE_TLS
 161 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
 162                                 char *);
 163 #endif
 164 inline static int w_t_relay_to(struct sip_msg* msg, char* str,char*);
 165 inline static int w_t_replicate( struct sip_msg  *p_msg ,
 166                                 char *proxy, /* struct proxy_l *proxy expected */
 167                                 char *_foo       /* nothing expected */ );
 168 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
 169                                 char *proxy, /* struct proxy_l *proxy expected */
 170                                 char *_foo       /* nothing expected */ );
 171 #ifdef USE_TCP
 172 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
 173                                 char *proxy, /* struct proxy_l *proxy expected */
 174                                 char *_foo       /* nothing expected */ );
 175 #endif
 176 #ifdef USE_TLS
 177 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
 178                                 char *proxy, /* struct proxy_l *proxy expected */
 179                                 char *_foo       /* nothing expected */ );
 180 #endif
 181 inline static int w_t_replicate_to(struct sip_msg* msg, char* str,char*);
 182 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
 183 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
 184 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
 185 #ifdef USE_TCP
 186 inline static int w_t_forward_nonack_tcp(struct sip_msg* msg, char* str,char*);
 187 #endif
 188 #ifdef USE_TLS
 189 inline static int w_t_forward_nonack_tls(struct sip_msg* msg, char* str,char*);
 190 #endif
 191 inline static int w_t_forward_nonack_to(struct sip_msg* msg, char* str,char*);
 192 inline static int w_t_relay_cancel(struct sip_msg *p_msg, char *_foo, char *_bar);
 193 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
 194 inline static int w_t_on_branch(struct sip_msg* msg, char *go_to, char *foo);
 195 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
 196 inline static int t_check_status(struct sip_msg* msg, char *match, char *foo);
 197 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo);
 198 static int t_set_fr_all(struct sip_msg* msg, char* fr_inv, char* fr);
 199 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar);
 200 static int w_t_set_retr(struct sip_msg* msg, char* retr_t1, char* retr_t2);
 201 static int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar);
 202 static int w_t_set_max_lifetime(struct sip_msg* msg, char* inv, char* noninv);
 203 static int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar);
 204 static int t_set_auto_inv_100(struct sip_msg* msg, char* on_off, char* foo);
 205 static int t_branch_timeout(struct sip_msg* msg, char*, char*);
 206 static int t_branch_replied(struct sip_msg* msg, char*, char*);
 207 static int t_any_timeout(struct sip_msg* msg, char*, char*);
 208 static int t_any_replied(struct sip_msg* msg, char*, char*);
 209 static int t_is_canceled(struct sip_msg* msg, char*, char*);
 210 static int t_grep_status(struct sip_msg* msg, char*, char*);
 211
 212
 213 /* by default the fr timers avps are not set, so that the avps won't be
 214  * searched for nothing each time a new transaction is created */
 215 static char *fr_timer_param = 0 /*FR_TIMER_AVP*/;
 216 static char *fr_inv_timer_param = 0 /*FR_INV_TIMER_AVP*/;
 217
 218 static rpc_export_t tm_rpc[];
 219
 220 static int fixup_t_check_status(void** param, int param_no);
 221
 222 static cmd_export_t cmds[]={
 223         {"t_newtran",          w_t_newtran,             0, 0,
 224                         REQUEST_ROUTE},
 225         {"t_lookup_request",   w_t_check,               0, 0,
 226                         REQUEST_ROUTE},
 227         {"t_lookup_cancel",    w_t_lookup_cancel,     0, 0,
 228                         REQUEST_ROUTE},
 229         {T_REPLY,              w_t_reply,               2, fixup_t_reply,
 230                         REQUEST_ROUTE | FAILURE_ROUTE },
 231         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
 232                         REQUEST_ROUTE},
 233         {"t_release",          w_t_release,             0, 0,
 234                         REQUEST_ROUTE},
 235         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
 236                         REQUEST_ROUTE|FAILURE_ROUTE},
 237 #ifdef USE_TCP
 238         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
 239                         REQUEST_ROUTE|FAILURE_ROUTE},
 240 #endif
 241 #ifdef USE_TLS
 242         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
 243                         REQUEST_ROUTE|FAILURE_ROUTE},
 244 #endif
 245         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
 246                         REQUEST_ROUTE},
 247         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
 248                         REQUEST_ROUTE},
 249 #ifdef USE_TCP
 250         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
 251                         REQUEST_ROUTE},
 252 #endif
 253 #ifdef USE_TLS
 254         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
 255                         REQUEST_ROUTE},
 256 #endif
 257         {"t_replicate_to", w_t_replicate_to,            2, fixup_proto_hostport2proxy,
 258                         REQUEST_ROUTE},
 259         {T_RELAY,              w_t_relay,               0, 0,
 260                         REQUEST_ROUTE | FAILURE_ROUTE },
 261         {"t_relay_to", w_t_relay_to,                    2, fixup_proto_hostport2proxy,
 262                         REQUEST_ROUTE},
 263         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
 264                         REQUEST_ROUTE},
 265         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
 266                         REQUEST_ROUTE},
 267         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
 268                         REQUEST_ROUTE},
 269 #ifdef USE_TCP
 270         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
 271                         REQUEST_ROUTE},
 272 #endif
 273 #ifdef USE_TLS
 274         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
 275                         REQUEST_ROUTE},
 276 #endif
 277         {"t_forward_nonack_to", w_t_forward_nonack_to,  2, fixup_proto_hostport2proxy,
 278                         REQUEST_ROUTE},
 279         {"t_relay_cancel",     w_t_relay_cancel,        0, 0,
 280                         REQUEST_ROUTE},
 281         {"t_on_failure",       w_t_on_negative,         1, fixup_on_failure,
 282                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
 283         {"t_on_reply",         w_t_on_reply,            1, fixup_on_reply,
 284                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
 285         {"t_on_branch",       w_t_on_branch,         1, fixup_on_branch,
 286                         REQUEST_ROUTE | FAILURE_ROUTE },
 287         {"t_check_status",     t_check_status,          1, fixup_t_check_status,
 288                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
 289         {"t_write_req",       t_write_req,              2, fixup_t_write,
 290                         REQUEST_ROUTE | FAILURE_ROUTE },
 291         {"t_write_unix",      t_write_unix,             2, fixup_t_write,
 292                         REQUEST_ROUTE | FAILURE_ROUTE },
 293         {"t_set_fr",          t_set_fr_inv,             1, fixup_var_int_1,
 294                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 295         {"t_set_fr",          t_set_fr_all,             2, fixup_var_int_12,
 296                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 297         {"t_reset_fr",        w_t_reset_fr,             0, 0,
 298                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 299         {"t_set_retr",        w_t_set_retr,               2, fixup_var_int_12,
 300                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 301         {"t_reset_retr",      w_t_reset_retr,           0, 0,
 302                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 303         {"t_set_max_lifetime", w_t_set_max_lifetime,      2, fixup_var_int_12,
 304                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 305         {"t_reset_max_lifetime", w_t_reset_max_lifetime, 0, 0,
 306                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 307         {"t_set_auto_inv_100", t_set_auto_inv_100,       1, fixup_var_int_1,
 308                                                                                                           REQUEST_ROUTE},
 309         {"t_branch_timeout",  t_branch_timeout,         0, 0,  FAILURE_ROUTE},
 310         {"t_branch_replied",  t_branch_replied,         0, 0,  FAILURE_ROUTE},
 311         {"t_any_timeout",     t_any_timeout,            0, 0,
 312                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 313         {"t_any_replied",     t_any_replied,            0, 0,
 314                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 315         {"t_is_canceled",     t_is_canceled,            0, 0,
 316                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 317         {"t_grep_status",     t_grep_status,            1, fixup_var_int_1,
 318                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
 319
 320         /* not applicable from the script */
 321         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
 322         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
 323         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
 324         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
 325         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
 326         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
 327         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
 328         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
 329         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
 330         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
 331         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
 332         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
 333         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
 334         {"update_dlg_uas",     (cmd_function)update_dlg_uas,    NO_SCRIPT,   0, 0},
 335         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
 336         {"set_dlg_target",     (cmd_function)set_dlg_target,    NO_SCRIPT,   0, 0},
 337         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
 338         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
 339         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0, 0},
 340         {"calculate_hooks",    (cmd_function)w_calculate_hooks, NO_SCRIPT,   0, 0},
 341         {"t_uac",              (cmd_function)t_uac,             NO_SCRIPT,   0, 0},
 342         {"t_uac_with_ids",     (cmd_function)t_uac_with_ids,    NO_SCRIPT,   0, 0},
 343         {"t_unref",            (cmd_function)t_unref,           NO_SCRIPT,   0, 0},
 344         {"run_failure_handlers", (cmd_function)run_failure_handlers, NO_SCRIPT,   0, 0},
 345         {"cancel_uacs",        (cmd_function)cancel_uacs,       NO_SCRIPT,   0, 0},
 346         {0,0,0,0,0}
 347 };
 348
 349
 350 static param_export_t params[]={
 351         {"ruri_matching",       PARAM_INT, &default_tm_cfg.ruri_matching         },
 352         {"via1_matching",       PARAM_INT, &default_tm_cfg.via1_matching         },
 353         {"fr_timer",            PARAM_INT, &default_tm_cfg.fr_timeout            },
 354         {"fr_inv_timer",        PARAM_INT, &default_tm_cfg.fr_inv_timeout        },
 355         {"wt_timer",            PARAM_INT, &default_tm_cfg.wait_timeout          },
 356         {"delete_timer",        PARAM_INT, &default_tm_cfg.delete_timeout        },
 357         {"retr_timer1",         PARAM_INT, &default_tm_cfg.rt_t1_timeout         },
 358         {"retr_timer2"  ,       PARAM_INT, &default_tm_cfg.rt_t2_timeout         },
 359         {"max_inv_lifetime",    PARAM_INT, &default_tm_cfg.tm_max_inv_lifetime   },
 360         {"max_noninv_lifetime", PARAM_INT, &default_tm_cfg.tm_max_noninv_lifetime},
 361         {"noisy_ctimer",        PARAM_INT, &default_tm_cfg.noisy_ctimer          },
 362         {"auto_inv_100",        PARAM_INT, &default_tm_cfg.tm_auto_inv_100       },
 363         {"unix_tx_timeout",     PARAM_INT, &default_tm_cfg.tm_unix_tx_timeout    },
 364         {"restart_fr_on_each_reply", PARAM_INT,
 365                                                                         &default_tm_cfg.restart_fr_on_each_reply},
 366         {"fr_timer_avp",        PARAM_STRING, &fr_timer_param                    },
 367         {"fr_inv_timer_avp",    PARAM_STRING, &fr_inv_timer_param                },
 368         {"tw_append",           PARAM_STRING|PARAM_USE_FUNC,
 369                                                                                                         (void*)parse_tw_append   },
 370         {"pass_provisional_replies", PARAM_INT,
 371                                                                         &default_tm_cfg.pass_provisional_replies },
 372         {"aggregate_challenges", PARAM_INT, &default_tm_cfg.tm_aggregate_auth    },
 373         {"unmatched_cancel",    PARAM_INT, &default_tm_cfg.unmatched_cancel      },
 374         {"default_code",        PARAM_INT, &default_tm_cfg.default_code          },
 375         {"default_reason",      PARAM_STRING, &default_tm_cfg.default_reason     },
 376         {"reparse_invite",      PARAM_INT, &default_tm_cfg.reparse_invite        },
 377         {"ac_extra_hdrs",       PARAM_STR, &default_tm_cfg.ac_extra_hdrs         },
 378         {"blst_503",            PARAM_INT, &default_tm_cfg.tm_blst_503           },
 379         {"blst_503_def_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_default   },
 380         {"blst_503_min_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_min       },
 381         {"blst_503_max_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_max       },
 382         {"blst_methods_add",    PARAM_INT, &default_tm_cfg.tm_blst_methods_add   },
 383         {"blst_methods_lookup", PARAM_INT, &default_tm_cfg.tm_blst_methods_lookup},
 384         {"cancel_b_method",     PARAM_INT, &default_tm_cfg.cancel_b_flags},
 385         {"reparse_on_dns_failover", PARAM_INT, &default_tm_cfg.reparse_on_dns_failover},
 386         {0,0,0}
 387 };
 388
 389 #ifdef STATIC_TM
 390 struct module_exports tm_exports = {
 391 #else
 392 struct module_exports exports= {
 393 #endif
 394         "tm",
 395         /* -------- exported functions ----------- */
 396         cmds,
 397         tm_rpc,    /* RPC methods */
 398         /* ------------ exported variables ---------- */
 399         params,
 400
 401         mod_init, /* module initialization function */
 402         (response_function) reply_received,
 403         (destroy_function) tm_shutdown,
 404         0, /* w_onbreak, */
 405         child_init /* per-child init function */
 406 };
 407
 408
 409
 410 /* helper for fixup_on_* */
 411 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
 412 {
 413         int i;
 414
 415         i=route_get(rt, (char*)*param);
 416         if (i==-1){
 417                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
 418                 return E_UNSPEC;
 419         }
 420         if (rt->rlist[i]==0){
 421                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
 422                                 r_type, (char*)*param);
 423         }
 424         *param=(void*)(long)i;
 425         return 0;
 426 }
 427
 428 static int fixup_t_reply(void** param, int param_no)
 429 {
 430         int ret;
 431
 432         if (param_no == 1) {
 433                 ret = fix_param(FPARAM_AVP, param);
 434                 if (ret <= 0) return ret;
 435             if (fix_param(FPARAM_INT, param) != 0) return -1;
 436         } else if (param_no == 2) {
 437                 return fixup_var_str_12(param, 2);
 438         }
 439     return 0;
 440 }
 441
 442 static int fixup_on_failure(void** param, int param_no)
 443 {
 444         if (param_no==1){
 445                 return fixup_routes("t_on_failure", &failure_rt, param);
 446         }
 447         return 0;
 448 }
 449
 450
 451
 452 static int fixup_on_reply(void** param, int param_no)
 453 {
 454         if (param_no==1){
 455                 return fixup_routes("t_on_reply", &onreply_rt, param);
 456         }
 457         return 0;
 458 }
 459
 460
 461
 462 static int fixup_on_branch(void** param, int param_no)
 463 {
 464         if (param_no==1){
 465                 return fixup_routes("t_on_branch", &branch_rt, param);
 466         }
 467         return 0;
 468 }
 469
 470
 471
 472 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
 473 static int fixup_hostport2proxy(void** param, int param_no)
 474 {
 475         unsigned int port;
 476         char *host;
 477         int err;
 478         struct proxy_l *proxy;
 479         action_u_t *a;
 480         str s;
 481
 482         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
 483         if (param_no==1){
 484                 return 0;
 485         } else if (param_no==2) {
 486                 a = fixup_get_param(param, param_no, 1);
 487                 host= a->u.string;
 488                 port=str2s(*param, strlen(*param), &err);
 489                 if (err!=0) {
 490                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
 491                                 (char*)(*param));
 492                          return E_UNSPEC;
 493                 }
 494                 s.s = host;
 495                 s.len = strlen(host);
 496                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
 497                 if (proxy==0) {
 498                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
 499                                 host );
 500                         return E_BAD_ADDRESS;
 501                 }
 502                 /* success -- fix the first parameter to proxy now ! */
 503
 504                 a->u.data=proxy;
 505                 return 0;
 506         } else {
 507                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
 508                 return E_BUG;
 509         }
 510 }
 511
 512 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
 513 static int fixup_proto_hostport2proxy(void** param, int param_no) {
 514         int ret;
 515
 516         ret = fix_param(FPARAM_AVP, param);
 517         if (ret <= 0) return ret;
 518 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
 519                 ret = fix_param(FPARAM_INT, param);
 520                 if (ret <= 0) return ret;
 521         } */
 522         if (fix_param(FPARAM_STRING, param) != 0) return -1;
 523         return 0;
 524 }
 525
 526
 527 static int fixup_t_check_status(void** param, int param_no)
 528 {
 529         int ret;
 530
 531         ret = fix_param(FPARAM_AVP, param);
 532         if (ret <= 0) return ret;
 533
 534         ret = fix_param(FPARAM_SELECT, param);
 535         if (ret <= 0) return ret;
 536
 537         if (fix_param(FPARAM_REGEX, param) != 0) return -1;
 538         return 0;
 539 }
 540
 541
 542 /***************************** init functions *****************************/
 543 static int w_t_unref( struct sip_msg *foo, void *bar)
 544 {
 545         return t_unref(foo);
 546 }
 547
 548
 549 static int script_init( struct sip_msg *foo, void *bar)
 550 {
 551         /* we primarily reset all private memory here to make sure
 552          * private values left over from previous message will
 553          * not be used again */
 554
 555         /* make sure the new message will not inherit previous
 556                 message's t_on_negative value
 557         */
 558         t_on_negative( 0 );
 559         t_on_reply(0);
 560         t_on_branch(0);
 561         /* reset the kr status */
 562         reset_kr(0);
 563         /* set request mode so that multiple-mode actions know
 564          * how to behave */
 565         rmode=MODE_REQUEST;
 566         return 1;
 567 }
 568
 569
 570 static int mod_init(void)
 571 {
 572         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
 573                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
 574
 575         /* checking if we have sufficient bitmap capacity for given
 576            maximum number of  branches */
 577         if (MAX_BRANCHES+1>31) {
 578                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
 579                         MAX_BRANCHES );
 580                 return -1;
 581         }
 582
 583         if (init_callid() < 0) {
 584                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
 585                 return -1;
 586         }
 587
 588         /* building the hash table*/
 589         if (!init_hash_table()) {
 590                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
 591                 return -1;
 592         }
 593
 594         /* init static hidden values */
 595         init_t();
 596
 597         if (tm_init_selects()==-1) {
 598                 LOG(L_ERR, "ERROR: mod_init: select init failed\n");
 599                 return -1;
 600         }
 601
 602         /* the default timer values must be fixed-up before
 603          * declaring the configuration (Miklos) */
 604         if (tm_init_timers()==-1) {
 605                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
 606                 return -1;
 607         }
 608
 609         /* the cancel branch flags must be fixed before declaring the
 610          * configuration */
 611         if (cancel_b_flags_get(&default_tm_cfg.cancel_b_flags,
 612                                                         default_tm_cfg.cancel_b_flags)<0){
 613                 LOG(L_ERR, "ERROR: mod_init: bad cancel branch method\n");
 614                 return -1;
 615         }
 616
 617 #ifdef USE_DNS_FAILOVER
 618         if (default_tm_cfg.reparse_on_dns_failover && mhomed) {
 619                 LOG(L_WARN, "WARNING: mod_init: "
 620                         "reparse_on_dns_failover is enabled on a "
 621                         "multihomed host -- check the readme of tm module!\n");
 622         }
 623 #endif
 624
 625         /* declare the configuration */
 626         if (cfg_declare("tm", tm_cfg_def, &default_tm_cfg, cfg_size(tm),
 627                          &tm_cfg)) {
 628                 LOG(L_ERR, "ERROR: mod_init: failed to declare the configuration\n");
 629                 return -1;
 630         }
 631
 632              /* First tm_stat initialization function only allocates the top level stat
 633               * structure in shared memory, the initialization will complete in child
 634               * init with init_tm_stats_child when the final value of estimated_process_count is
 635               * known
 636               */
 637         if (init_tm_stats() < 0) {
 638                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
 639                 return -1;
 640         }
 641
 642         if (uac_init()==-1) {
 643                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
 644                 return -1;
 645         }
 646
 647         if (init_tmcb_lists()!=1) {
 648                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
 649                 return -1;
 650         }
 651
 652         tm_init_tags();
 653         init_twrite_lines();
 654         if (init_twrite_sock() < 0) {
 655                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
 656                 return -1;
 657         }
 658
 659         /* register post-script clean-up function */
 660         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0 ) {
 661                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
 662                         "callback\n");
 663                 return -1;
 664         }
 665         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQ_TYPE_CB , 0)<0 ) {
 666                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
 667                         "callback\n");
 668                 return -1;
 669         }
 670
 671         if (init_avp_params( fr_timer_param, fr_inv_timer_param)<0 ){
 672                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process timer AVPs\n");
 673                 return -1;
 674         }
 675         tm_init = 1;
 676         return 0;
 677 }
 678
 679 static int child_init(int rank)
 680 {
 681         if (rank == PROC_INIT) {
 682                 /* we must init stats when rank==PROC_INIT: after mod_init we know
 683                  * the exact number of processes and we must init the shared structure
 684                  * before any other process is starting (or else some new process
 685                  * might try to use the stats before the stats array is allocated) */
 686                 if (init_tm_stats_child() < 0) {
 687                         ERR("Error while initializing tm statistics structures\n");
 688                         return -1;
 689                 }
 690         }else if (child_init_callid(rank) < 0) {
 691                 /* don't init callid for PROC_INIT*/
 692                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID"
 693                                 " generator\n");
 694                 return -2;
 695         }
 696         return 0;
 697 }
 698
 699
 700
 701
 702
 703 /**************************** wrapper functions ***************************/
 704 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
 705 {
 706         regmatch_t pmatch;
 707         struct cell *t;
 708         char *status, *s = NULL;
 709         char backup;
 710         int lowest_status, n;
 711         fparam_t* fp;
 712         regex_t* re = NULL;
 713         str tmp;
 714
 715         fp = (fparam_t*)p1;
 716
 717         /* first get the transaction */
 718         if (t_check(msg, 0 ) == -1) return -1;
 719         if ((t = get_t()) == 0) {
 720                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
 721                         "which has no T-state established\n");
 722                 goto error;
 723         }
 724         backup = 0;
 725
 726         switch(fp->type) {
 727         case FPARAM_REGEX:
 728                 re = fp->v.regex;
 729                 break;
 730
 731         default:
 732                 /* AVP or select, get the value and compile the regex */
 733                 if (get_str_fparam(&tmp, msg, fp) < 0) goto error;
 734                 s = pkg_malloc(tmp.len + 1);
 735                 if (s == NULL) {
 736                         ERR("Out of memory\n");
 737                         goto error;
 738                 }
 739                 memcpy(s, tmp.s, tmp.len);
 740                 s[tmp.len] = '\0';
 741
 742                 if ((re = pkg_malloc(sizeof(regex_t))) == 0) {
 743                         ERR("No memory left\n");
 744                         goto error;
 745                 }
 746
 747                 if (regcomp(re, s, REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
 748                         ERR("Bad regular expression '%s'\n", s);
 749                         goto error;
 750                 }
 751                 break;
 752         }
 753
 754         switch(rmode) {
 755         case MODE_REQUEST:
 756                 /* use the status of the last sent reply */
 757                 status = int2str( t->uas.status, 0);
 758                 break;
 759
 760         case MODE_ONREPLY:
 761                 /* use the status of the current reply */
 762                 status = msg->first_line.u.reply.status.s;
 763                 backup = status[msg->first_line.u.reply.status.len];
 764                 status[msg->first_line.u.reply.status.len] = 0;
 765                 break;
 766
 767         case MODE_ONFAILURE:
 768                 /* use the status of the winning reply */
 769                 if (t_pick_branch( -1, 0, t, &lowest_status)<0 ) {
 770                         LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
 771                                 " a final response in MODE_ONFAILURE\n");
 772                         goto error;
 773                 }
 774                 status = int2str( lowest_status , 0);
 775                 break;
 776
 777         default:
 778                 LOG(L_ERR,"ERROR:t_check_status: unsupported mode %d\n",rmode);
 779                 goto error;
 780         }
 781
 782         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
 783         /* do the checking */
 784         n = regexec(re, status, 1, &pmatch, 0);
 785
 786         if (backup) status[msg->first_line.u.reply.status.len] = backup;
 787         if (s) pkg_free(s);
 788         if ((fp->type != FPARAM_REGEX) && re) {
 789                 regfree(re);
 790                 pkg_free(re);
 791         }
 792
 793         if (n!=0) return -1;
 794         return 1;
 795
 796  error:
 797         if (s) pkg_free(s);
 798         if ((fp->type != FPARAM_REGEX) && re) {
 799                 regfree(re);
 800                 pkg_free(re);
 801         }
 802         return -1;
 803 }
 804
 805
 806 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
 807 {
 808         return t_check( msg , 0  ) ? 1 : -1;
 809 }
 810
 811 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
 812 {
 813         struct cell *ret;
 814         if (msg->REQ_METHOD==METHOD_CANCEL) {
 815                 ret = t_lookupOriginalT( msg );
 816                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
 817                 if (ret != T_NULL_CELL) {
 818                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
 819                         So we must unref it before returning. */
 820                         UNREF(ret);
 821                         set_t(T_UNDEFINED);
 822                         return 1;
 823                 }
 824                 set_t(T_UNDEFINED);
 825         } else {
 826                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
 827         }
 828         return -1;
 829 }
 830
 831 inline static int str2proto(char *s, int len) {
 832         if (len == 3 && !strncasecmp(s, "udp", 3))
 833                 return PROTO_UDP;
 834         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
 835                 return PROTO_TCP;
 836         else if (len == 3 && !strncasecmp(s, "tls", 3))
 837                 return PROTO_TLS;
 838         else
 839                 return PROTO_NONE;
 840 }
 841
 842 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
 843         struct proxy_l *proxy = 0;
 844         avp_t* avp;
 845         avp_value_t val;
 846         int proto, port, err;
 847         str s;
 848         char *c;
 849
 850         switch(((fparam_t *)proto_par)->type) {
 851         case FPARAM_AVP:
 852                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
 853                         proto = PROTO_NONE;
 854                 } else {
 855                         if (avp->flags & AVP_VAL_STR) {
 856                                 proto = str2proto(val.s.s, val.s.len);
 857                         }
 858                         else {
 859                                 proto = val.n;
 860                         }
 861                 }
 862                 break;
 863
 864         case FPARAM_INT:
 865                 proto = ((fparam_t *)proto_par)->v.i;
 866                 break;
 867         case FPARAM_STRING:
 868                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
 869                 break;
 870         default:
 871                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
 872                 return 0;
 873         }
 874
 875
 876         switch(((fparam_t *)addr_par)->type) {
 877         case FPARAM_AVP:
 878                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
 879                         s.len = 0;
 880                 } else {
 881                         if ((avp->flags & AVP_VAL_STR) == 0) {
 882                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
 883                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
 884                                 return 0;
 885                         }
 886                         s = val.s;
 887                 }
 888                 break;
 889
 890         case FPARAM_STRING:
 891                 s.s = ((fparam_t *) addr_par)->v.asciiz;
 892                 s.len = strlen(s.s);
 893                 break;
 894
 895         default:
 896                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
 897                 return 0;
 898         }
 899
 900         port = 5060;
 901         if (s.len) {
 902                 c = memchr(s.s, ':', s.len);
 903                 if (c) {
 904                         port = str2s(c+1, s.len-(c-s.s+1), &err);
 905                         if (err!=0) {
 906                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
 907                                         s.len, s.s);
 908                                  return 0;
 909                         }
 910                         s.len = c-s.s;
 911                 }
 912         }
 913         if (!s.len) {
 914                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
 915                 return 0;
 916         }
 917         proxy=mk_proxy(&s, port, proto);
 918         if (proxy==0) {
 919                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
 920                         s.len, s.s );
 921                 return 0;
 922         }
 923         return proxy;
 924 }
 925
 926 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
 927         int proto)
 928 {
 929         struct cell *t;
 930         if (t_check( msg , 0 )==-1) {
 931                 LOG(L_ERR, "ERROR: forward_nonack: "
 932                                 "can't forward when no transaction was set up\n");
 933                 return -1;
 934         }
 935         t=get_t();
 936         if ( t && t!=T_UNDEFINED ) {
 937                 if (msg->REQ_METHOD==METHOD_ACK) {
 938                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
 939                         return -1;
 940                 }
 941                 return t_forward_nonack(t, msg, proxy, proto );
 942         } else {
 943                 DBG("DEBUG: forward_nonack: no transaction found\n");
 944                 return -1;
 945         }
 946 }
 947
 948
 949 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
 950                                                                                 char* foo)
 951 {
 952         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
 953 }
 954
 955
 956 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
 957                                                                                                                                         char *bar)
 958 {
 959         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
 960 }
 961
 962
 963 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
 964                                                                                 char* foo)
 965 {
 966         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
 967 }
 968
 969
 970 #ifdef USE_TCP
 971 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
 972                                                                                 char* foo)
 973 {
 974         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
 975 }
 976 #endif
 977
 978
 979 #ifdef USE_TLS
 980 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
 981                                                                                 char* foo)
 982 {
 983         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
 984 }
 985 #endif
 986
 987 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
 988         char *proto_par,
 989         char *addr_par   )
 990 {
 991         struct proxy_l *proxy;
 992         int r = -1;
 993         proxy = t_protoaddr2proxy(proto_par, addr_par);
 994         if (proxy) {
 995                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);
 996                 free_proxy(proxy);
 997         }
 998         return r;
 999 }
1000
1001
1002 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
1003 {
1004         struct cell *t;
1005         int code, ret = -1;
1006         str reason;
1007         char* r;
1008
1009         if (msg->REQ_METHOD==METHOD_ACK) {
1010                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
1011                 return -1;
1012         }
1013         if (t_check( msg , 0 )==-1) return -1;
1014         t=get_t();
1015         if (!t) {
1016                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
1017                         "for which no T-state has been established\n");
1018                 return -1;
1019         }
1020
1021         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
1022             code = cfg_get(tm, tm_cfg, default_code);
1023         }
1024
1025         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
1026                 r = cfg_get(tm, tm_cfg, default_reason);
1027         } else {
1028                 r = as_asciiz(&reason);
1029                 if (r == NULL) r = cfg_get(tm, tm_cfg, default_reason);
1030         }
1031
1032         /* if called from reply_route, make sure that unsafe version
1033          * is called; we are already in a mutex and another mutex in
1034          * the safe version would lead to a deadlock
1035          */
1036
1037         if (rmode==MODE_ONFAILURE) {
1038                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
1039                 ret = t_reply_unsafe(t, msg, code, r);
1040         } else if (rmode==MODE_REQUEST) {
1041                 ret = t_reply( t, msg, code, r);
1042         } else {
1043                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
1044                 ret = -1;
1045         }
1046
1047         if (r && (r != cfg_get(tm, tm_cfg, default_reason))) pkg_free(r);
1048         return ret;
1049 }
1050
1051
1052 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
1053 {
1054         struct cell *t;
1055         int ret;
1056
1057         if (t_check( msg  , 0  )==-1) return -1;
1058         t=get_t();
1059         if ( t && t!=T_UNDEFINED ) {
1060                 ret = t_release_transaction( t );
1061                 t_unref(msg);
1062                 return ret;
1063         }
1064         return 1;
1065 }
1066
1067
1068 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
1069 {
1070         struct cell *t;
1071
1072
1073         if (t_check( p_msg  , 0 )==-1)
1074                 return 1;
1075         t=get_t();
1076         if (t) {
1077                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1078                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
1079                         return -1;
1080                 }
1081                 return t_retransmit_reply( t );
1082         } else
1083                 return -1;
1084 }
1085
1086
1087 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
1088 {
1089         /* t_newtran returns 0 on error (negative value means
1090            'transaction exists' */
1091         int ret;
1092         ret = t_newtran( p_msg );
1093         if (ret==E_SCRIPT) {
1094                 LOG(L_ERR, "ERROR: t_newtran: "
1095                         "transaction already in process %p\n", get_t() );
1096         }
1097         return ret;
1098 }
1099
1100
1101 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
1102 {
1103         t_on_negative( (unsigned int )(long) go_to );
1104         return 1;
1105 }
1106
1107 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
1108 {
1109         t_on_branch( (unsigned int )(long) go_to );
1110         return 1;
1111 }
1112
1113
1114 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
1115 {
1116         t_on_reply( (unsigned int )(long) go_to );
1117         return 1;
1118 }
1119
1120
1121
1122 inline static int _w_t_relay_to( struct sip_msg  *p_msg ,
1123         struct proxy_l *proxy )
1124 {
1125         struct cell *t;
1126
1127         if (rmode==MODE_ONFAILURE) {
1128                 t=get_t();
1129                 if (!t || t==T_UNDEFINED) {
1130                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
1131                         return -1;
1132                 }
1133                 if (t_forward_nonack(t, p_msg, proxy, PROTO_NONE)<=0 ) {
1134                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
1135                         return -1;
1136                 }
1137                 return 1;
1138         }
1139         if (rmode==MODE_REQUEST)
1140                 return t_relay_to( p_msg, proxy, PROTO_NONE,
1141                         0 /* no replication */ );
1142         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1143         return 0;
1144 }
1145
1146
1147 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
1148         char *proxy, /* struct proxy_l *proxy expected */
1149         char *_foo       /* nothing expected */ )
1150 {
1151         ((struct proxy_l *)proxy)->proto=PROTO_UDP;
1152         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1153 }
1154
1155
1156 #ifdef USE_TCP
1157 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
1158         char *proxy, /* struct proxy_l *proxy expected */
1159         char *_foo       /* nothing expected */ )
1160 {
1161         ((struct proxy_l *)proxy)->proto=PROTO_TCP;
1162         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1163 }
1164 #endif
1165
1166
1167 #ifdef USE_TLS
1168 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
1169         char *proxy, /* struct proxy_l *proxy expected */
1170         char *_foo       /* nothing expected */ )
1171 {
1172         ((struct proxy_l *)proxy)->proto=PROTO_TLS;
1173         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1174 }
1175 #endif
1176
1177 inline static int w_t_relay_to( struct sip_msg  *p_msg ,
1178         char *proto_par,
1179         char *addr_par   )
1180 {
1181         struct proxy_l *proxy;
1182         int r = -1;
1183         proxy = t_protoaddr2proxy(proto_par, addr_par);
1184         if (proxy) {
1185                 r = _w_t_relay_to(p_msg, proxy);
1186                 free_proxy(proxy);
1187         }
1188         return r;
1189 }
1190
1191
1192 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1193         char *proxy, /* struct proxy_l *proxy expected */
1194         char *_foo       /* nothing expected */ )
1195 {
1196         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1197 }
1198
1199 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1200         char *proxy, /* struct proxy_l *proxy expected */
1201         char *_foo       /* nothing expected */ )
1202 {
1203         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1204 }
1205
1206
1207 #ifdef USE_TCP
1208 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1209         char *proxy, /* struct proxy_l *proxy expected */
1210         char *_foo       /* nothing expected */ )
1211 {
1212         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1213 }
1214 #endif
1215
1216
1217 #ifdef USE_TLS
1218 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1219         char *proxy, /* struct proxy_l *proxy expected */
1220         char *_foo       /* nothing expected */ )
1221 {
1222         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1223 }
1224 #endif
1225
1226 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1227         char *proto_par,
1228         char *addr_par   )
1229 {
1230         struct proxy_l *proxy;
1231         int r = -1;
1232         proxy = t_protoaddr2proxy(proto_par, addr_par);
1233         if (proxy) {
1234                 r = t_replicate(p_msg, proxy, proxy->proto);
1235                 free_proxy(proxy);
1236         }
1237         return r;
1238 }
1239
1240 inline static int w_t_relay( struct sip_msg  *p_msg ,
1241                                                 char *_foo, char *_bar)
1242 {
1243         struct cell *t;
1244
1245         if (rmode==MODE_ONFAILURE) {
1246                 t=get_t();
1247                 if (!t || t==T_UNDEFINED) {
1248                         LOG(L_CRIT, "BUG: w_t_relay: undefined T\n");
1249                         return -1;
1250                 }
1251                 if (t_forward_nonack(t, p_msg, ( struct proxy_l *) 0, PROTO_NONE)<=0) {
1252                         LOG(L_ERR, "ERROR: w_t_relay (failure mode): forwarding failed\n");
1253                         return -1;
1254                 }
1255                 return 1;
1256         }
1257         if (rmode==MODE_REQUEST)
1258                 return t_relay_to( p_msg,
1259                 (struct proxy_l *) 0 /* no proxy */, PROTO_NONE,
1260                 0 /* no replication */ );
1261         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1262         return 0;
1263 }
1264
1265 /* relays CANCEL at the beginning of the script */
1266 inline static int w_t_relay_cancel( struct sip_msg  *p_msg ,
1267                                                 char *_foo, char *_bar)
1268 {
1269         if (p_msg->REQ_METHOD!=METHOD_CANCEL)
1270                 return 1;
1271
1272         /* it makes no sense to use this function without reparse_invite=1 */
1273         if (!cfg_get(tm, tm_cfg, reparse_invite))
1274                 LOG(L_WARN, "WARNING: t_relay_cancel is probably used with "
1275                         "wrong configuration, check the readme for details\n");
1276
1277         return t_relay_cancel(p_msg);
1278 }
1279
1280 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1281 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1282 {
1283     int fr, fr_inv;
1284
1285     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1286     if (p2) {
1287         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1288     } else {
1289         fr = 0;
1290     }
1291
1292     return t_set_fr(msg, fr_inv, fr);
1293 }
1294
1295 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1296 {
1297         return t_set_fr_all(msg, fr_inv, (char*)0);
1298 }
1299
1300 /* reset fr_timer and fr_inv_timer to the default values */
1301 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar)
1302 {
1303         return t_reset_fr();
1304 }
1305
1306 /* set retr. intervals per transaction; 0 means: use the default value */
1307 static int w_t_set_retr(struct sip_msg* msg, char* p1, char* p2)
1308 {
1309         int t1, t2;
1310
1311         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1312         if (p2) {
1313                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1314         } else {
1315                 t2 = 0;
1316         }
1317 #ifdef TM_DIFF_RT_TIMEOUT
1318         return t_set_retr(msg, t1, t2);
1319 #else
1320         ERR("w_t_set_retr: support for changing retransmission intervals on "
1321                         "the fly not compiled in (re-compile tm with"
1322                         " -DTM_DIFF_RT_TIMEOUT)\n");
1323         return -1;
1324 #endif
1325 }
1326
1327 /* reset retr. t1 and t2 to the default values */
1328 int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar)
1329 {
1330 #ifdef TM_DIFF_RT_TIMEOUT
1331         return t_reset_retr();
1332 #else
1333         ERR("w_t_reset_retr: support for changing retransmission intervals on "
1334                         "the fly not compiled in (re-compile tm with"
1335                         " -DTM_DIFF_RT_TIMEOUT)\n");
1336         return -1;
1337 #endif
1338 }
1339
1340 /* set maximum transaction lifetime for inv & noninv */
1341 static int w_t_set_max_lifetime(struct sip_msg* msg, char* p1, char* p2)
1342 {
1343         int t1, t2;
1344
1345         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1346         if (p2) {
1347                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1348         } else {
1349                 t2 = 0;
1350         }
1351         return t_set_max_lifetime(msg, t1, t2);
1352 }
1353
1354 /* reset maximum invite/non-invite lifetime to the default value */
1355 int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar)
1356 {
1357         return t_reset_max_lifetime();
1358 }
1359
1360 /* set automatically sending 100 replies on/off for the current or
1361  * next to be created transaction */
1362 static int t_set_auto_inv_100(struct sip_msg* msg, char* p1, char* p2)
1363 {
1364         int state;
1365         struct cell* t;
1366
1367         if (get_int_fparam(&state, msg, (fparam_t*)p1) < 0) return -1;
1368         t=get_t();
1369         /* in MODE_REPLY and MODE_ONFAILURE T will be set to current transaction;
1370          * in MODE_REQUEST T will be set only if the transaction was already
1371          * created; if not -> use the static variables */
1372         if (!t || t==T_UNDEFINED ){
1373                 if (state)
1374                         set_msgid_val(user_auto_inv_100, msg->id, int, 1); /* set */
1375                 else
1376                         set_msgid_val(user_auto_inv_100, msg->id, int, -1); /* reset */
1377         }else{
1378                 if (state)
1379                         t->flags|=T_AUTO_INV_100;
1380                 else
1381                         t->flags&=~T_AUTO_INV_100;
1382         }
1383         return 1;
1384 }
1385
1386
1387
1388 /* script function, FAILURE_ROUTE only, returns true if the
1389  * choosed "failure" branch failed because of a timeout,
1390  * -1 otherwise */
1391 int t_branch_timeout(struct sip_msg* msg, char* foo, char* bar)
1392 {
1393         return (msg->msg_flags & FL_TIMEOUT)?1:-1;
1394 }
1395
1396
1397
1398 /* script function, FAILURE_ROUTE only, returns true if the
1399  * choosed "failure" branch ever received a reply, -1 otherwise */
1400 int t_branch_replied(struct sip_msg* msg, char* foo, char* bar)
1401 {
1402         return (msg->msg_flags & FL_REPLIED)?1:-1;
1403 }
1404
1405
1406
1407 /* script function, returns: 1 if the transaction was canceled, -1 if not */
1408 int t_is_canceled(struct sip_msg* msg, char* foo, char* bar)
1409 {
1410         struct cell *t;
1411         int ret;
1412
1413
1414         if (t_check( msg , 0 )==-1) return -1;
1415         t=get_t();
1416         if ((t==0) || (t==T_UNDEFINED)){
1417                 LOG(L_ERR, "ERROR: t_is_canceled: cannot check a message "
1418                         "for which no T-state has been established\n");
1419                 ret=-1;
1420         }else{
1421                 ret=(t->flags & T_CANCELED)?1:-1;
1422         }
1423         return ret;
1424 }
1425
1426
1427
1428 /* script function, returns: 1 if any of the branches did timeout, -1 if not */
1429 int t_any_timeout(struct sip_msg* msg, char* foo, char* bar)
1430 {
1431         struct cell *t;
1432         int r;
1433
1434         if (t_check( msg , 0 )==-1) return -1;
1435         t=get_t();
1436         if ((t==0) || (t==T_UNDEFINED)){
1437                 LOG(L_ERR, "ERROR: t_any_timeout: cannot check a message "
1438                         "for which no T-state has been established\n");
1439                 return -1;
1440         }else{
1441                 for (r=0; r<t->nr_of_outgoings; r++){
1442                         if (t->uac[r].request.flags & F_RB_TIMEOUT)
1443                                 return 1;
1444                 }
1445         }
1446         return -1;
1447 }
1448
1449
1450
1451 /* script function, returns: 1 if any of the branches received at leat one
1452  * reply, -1 if not */
1453 int t_any_replied(struct sip_msg* msg, char* foo, char* bar)
1454 {
1455         struct cell *t;
1456         int r;
1457
1458         if (t_check( msg , 0 )==-1) return -1;
1459         t=get_t();
1460         if ((t==0) || (t==T_UNDEFINED)){
1461                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1462                         "for which no T-state has been established\n");
1463                 return -1;
1464         }else{
1465                 for (r=0; r<t->nr_of_outgoings; r++){
1466                         if (t->uac[r].request.flags & F_RB_REPLIED)
1467                                 return 1;
1468                 }
1469         }
1470         return -1;
1471 }
1472
1473
1474
1475 /* script function, returns: 1 if any of the branches received the
1476  *  reply code "status" */
1477 int t_grep_status(struct sip_msg* msg, char* status, char* bar)
1478 {
1479         struct cell *t;
1480         int r;
1481         int code;
1482
1483     if (get_int_fparam(&code, msg, (fparam_t*)status) < 0) return -1;
1484         if (t_check( msg , 0 )==-1) return -1;
1485         t=get_t();
1486         if ((t==0) || (t==T_UNDEFINED)){
1487                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1488                         "for which no T-state has been established\n");
1489                 return -1;
1490         }else{
1491                 for (r=0; r<t->nr_of_outgoings; r++){
1492                         if ((t->uac[r].last_received==code)  &&
1493                                         (t->uac[r].request.flags & F_RB_REPLIED))
1494                                 return 1;
1495                 }
1496         }
1497         return -1;
1498 }
1499
1500
1501
1502 static rpc_export_t tm_rpc[] = {
1503         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
1504         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
1505         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
1506         {"tm.hash_stats",  tm_rpc_hash_stats, tm_rpc_hash_stats_doc, 0},
1507         {0, 0, 0, 0}
1508 };
1509
1510 /* wrapper function needed after changes in w_t_reply */
1511 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1512 {
1513         fparam_t c;
1514         fparam_t r;
1515
1516         c.type = FPARAM_INT;
1517         c.orig = NULL; /* ? */
1518         c.v.i = code;
1519
1520         r.type = FPARAM_STRING;
1521         r.orig = NULL; /* ? */
1522         r.v.asciiz = txt;
1523
1524         return w_t_reply(m, (char *)&c, (char*)&r);
1525 }
1526