- e2ecancel is sent hop by hop (closes SER-68)
[sip-router] / 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  */
88
89
90 #include "defs.h"
91
92
93 #include <stdio.h>
94 #include <string.h>
95 #include <netdb.h>
96
97 #include "../../sr_module.h"
98 #include "../../dprint.h"
99 #include "../../error.h"
100 #include "../../ut.h"
101 #include "../../script_cb.h"
102 #include "../../usr_avp.h"
103 #include "../../mem/mem.h"
104 #include "../../route_struct.h"
105 #include "../../route.h"
106
107 #include "sip_msg.h"
108 #include "h_table.h"
109 #include "t_hooks.h"
110 #include "tm_load.h"
111 #include "ut.h"
112 #include "t_reply.h"
113 #include "uac.h"
114 #include "t_fwd.h"
115 #include "t_lookup.h"
116 #include "t_stats.h"
117 #include "callid.h"
118 #include "t_cancel.h"
119 #include "t_fifo.h"
120 #include "timer.h"
121 #include "t_msgbuilder.h"
122 #include "select.h"
123
124 MODULE_VERSION
125
126 /* fixup functions */
127 static int fixup_hostport2proxy(void** param, int param_no);
128 static int fixup_proto_hostport2proxy(void** param, int param_no);
129 static int fixup_on_failure(void** param, int param_no);
130 static int fixup_on_reply(void** param, int param_no);
131 static int fixup_on_branch(void** param, int param_no);
132 static int fixup_t_reply(void** param, int param_no);
133
134
135 /* init functions */
136 static int mod_init(void);
137 static int child_init(int rank);
138
139
140 /* exported functions */
141 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
142 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2);
143 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
144 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
145 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
146                                 char* bar );
147 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
148 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
149 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy,
150                                  char *);
151 #ifdef USE_TCP
152 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
153                                 char *);
154 #endif
155 #ifdef USE_TLS
156 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
157                                 char *);
158 #endif
159 inline static int w_t_relay_to(struct sip_msg* msg, char* str,char*);
160 inline static int w_t_replicate( struct sip_msg  *p_msg ,
161                                 char *proxy, /* struct proxy_l *proxy expected */
162                                 char *_foo       /* nothing expected */ );
163 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
164                                 char *proxy, /* struct proxy_l *proxy expected */
165                                 char *_foo       /* nothing expected */ );
166 #ifdef USE_TCP
167 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
168                                 char *proxy, /* struct proxy_l *proxy expected */
169                                 char *_foo       /* nothing expected */ );
170 #endif
171 #ifdef USE_TLS
172 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
173                                 char *proxy, /* struct proxy_l *proxy expected */
174                                 char *_foo       /* nothing expected */ );
175 #endif
176 inline static int w_t_replicate_to(struct sip_msg* msg, char* str,char*);
177 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
178 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
179 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
180 #ifdef USE_TCP
181 inline static int w_t_forward_nonack_tcp(struct sip_msg* msg, char* str,char*);
182 #endif
183 #ifdef USE_TLS
184 inline static int w_t_forward_nonack_tls(struct sip_msg* msg, char* str,char*);
185 #endif
186 inline static int w_t_forward_nonack_to(struct sip_msg* msg, char* str,char*);
187 inline static int w_t_relay_cancel(struct sip_msg *p_msg, char *_foo, char *_bar);
188 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
189 inline static int w_t_on_branch(struct sip_msg* msg, char *go_to, char *foo);
190 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
191 inline static int t_check_status(struct sip_msg* msg, char *regexp, char *foo);
192 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo);
193 static int t_set_fr_all(struct sip_msg* msg, char* fr_inv, char* fr);
194 static int w_t_set_retr(struct sip_msg* msg, char* retr_t1, char* retr_t2);
195 static int w_t_set_max_lifetime(struct sip_msg* msg, char* inv, char* noninv);
196 static int t_set_auto_inv_100(struct sip_msg* msg, char* on_off, char* foo);
197 static int t_branch_timeout(struct sip_msg* msg, char*, char*);
198 static int t_branch_replied(struct sip_msg* msg, char*, char*);
199 static int t_any_timeout(struct sip_msg* msg, char*, char*);
200 static int t_any_replied(struct sip_msg* msg, char*, char*);
201 static int t_is_canceled(struct sip_msg* msg, char*, char*);
202
203
204 /* by default the fr timers avps are not set, so that the avps won't be
205  * searched for nothing each time a new transaction is created */
206 static char *fr_timer_param = 0 /*FR_TIMER_AVP*/;
207 static char *fr_inv_timer_param = 0 /*FR_INV_TIMER_AVP*/;
208
209 static rpc_export_t tm_rpc[];
210
211 static int default_code = 500;
212 static str default_reason = STR_STATIC_INIT("Server Internal Error");
213
214
215 static cmd_export_t cmds[]={
216         {"t_newtran",          w_t_newtran,             0, 0,
217                         REQUEST_ROUTE},
218         {"t_lookup_request",   w_t_check,               0, 0,
219                         REQUEST_ROUTE},
220         {"t_lookup_cancel",    w_t_lookup_cancel,     0, 0,
221                         REQUEST_ROUTE},
222         {T_REPLY,              w_t_reply,               2, fixup_t_reply,
223                         REQUEST_ROUTE | FAILURE_ROUTE },
224         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
225                         REQUEST_ROUTE},
226         {"t_release",          w_t_release,             0, 0,
227                         REQUEST_ROUTE},
228         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
229                         REQUEST_ROUTE|FAILURE_ROUTE},
230 #ifdef USE_TCP
231         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
232                         REQUEST_ROUTE|FAILURE_ROUTE},
233 #endif
234 #ifdef USE_TLS
235         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
236                         REQUEST_ROUTE|FAILURE_ROUTE},
237 #endif
238         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
239                         REQUEST_ROUTE},
240         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
241                         REQUEST_ROUTE},
242 #ifdef USE_TCP
243         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
244                         REQUEST_ROUTE},
245 #endif
246 #ifdef USE_TLS
247         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
248                         REQUEST_ROUTE},
249 #endif
250         {"t_replicate_to", w_t_replicate_to,            2, fixup_proto_hostport2proxy,
251                         REQUEST_ROUTE},
252         {T_RELAY,              w_t_relay,               0, 0,
253                         REQUEST_ROUTE | FAILURE_ROUTE },
254         {"t_relay_to", w_t_relay_to,                    2, fixup_proto_hostport2proxy,
255                         REQUEST_ROUTE},
256         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
257                         REQUEST_ROUTE},
258         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
259                         REQUEST_ROUTE},
260         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
261                         REQUEST_ROUTE},
262 #ifdef USE_TCP
263         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
264                         REQUEST_ROUTE},
265 #endif
266 #ifdef USE_TLS
267         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
268                         REQUEST_ROUTE},
269 #endif
270         {"t_forward_nonack_to", w_t_forward_nonack_to,  2, fixup_proto_hostport2proxy,
271                         REQUEST_ROUTE},
272         {"t_relay_cancel",     w_t_relay_cancel,        0, 0,
273                         REQUEST_ROUTE},
274         {"t_on_failure",       w_t_on_negative,         1, fixup_on_failure,
275                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
276         {"t_on_reply",         w_t_on_reply,            1, fixup_on_reply,
277                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
278         {"t_on_branch",       w_t_on_branch,         1, fixup_on_branch,
279                         REQUEST_ROUTE | FAILURE_ROUTE },
280         {"t_check_status",     t_check_status,          1, fixup_regex_1,
281                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
282         {"t_write_req",       t_write_req,              2, fixup_t_write,
283                         REQUEST_ROUTE | FAILURE_ROUTE },
284         {"t_write_unix",      t_write_unix,             2, fixup_t_write,
285                         REQUEST_ROUTE | FAILURE_ROUTE },
286         {"t_set_fr",          t_set_fr_inv,             1, fixup_var_int_1,
287                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
288         {"t_set_fr",          t_set_fr_all,             2, fixup_var_int_12,
289                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
290         {"t_set_retr",        w_t_set_retr,               2, fixup_var_int_12,
291                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
292         {"t_set_max_lifetime", w_t_set_max_lifetime,      2, fixup_var_int_12,
293                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
294         {"t_set_auto_inv_100", t_set_auto_inv_100,       1, fixup_var_int_1,
295                                                                                                           REQUEST_ROUTE},
296         {"t_branch_timeout",  t_branch_timeout,         0, 0,  FAILURE_ROUTE},
297         {"t_branch_replied",  t_branch_replied,         0, 0,  FAILURE_ROUTE},
298         {"t_any_timeout",     t_any_timeout,            0, 0, 
299                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
300         {"t_any_replied",     t_any_replied,            0, 0, 
301                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
302         {"t_is_canceled",     t_is_canceled,            0, 0,
303                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
304
305         /* not applicable from the script */
306         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
307         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
308         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
309         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
310         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
311         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
312         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
313         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
314         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
315         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
316         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
317         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
318         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
319         {"update_dlg_uas",     (cmd_function)update_dlg_uas,    NO_SCRIPT,   0, 0},
320         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
321         {"set_dlg_target",     (cmd_function)set_dlg_target,    NO_SCRIPT,   0, 0},
322         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
323         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
324         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0, 0},
325         {"calculate_hooks",    (cmd_function)w_calculate_hooks, NO_SCRIPT,   0, 0},
326         {"t_uac",              (cmd_function)t_uac,             NO_SCRIPT,   0, 0},
327         {"t_uac_with_ids",     (cmd_function)t_uac_with_ids,    NO_SCRIPT,   0, 0},
328         {"t_unref",            (cmd_function)t_unref,           NO_SCRIPT,   0, 0},
329         {"run_failure_handlers", (cmd_function)run_failure_handlers, NO_SCRIPT,   0, 0},
330         {"cancel_uacs",        (cmd_function)cancel_uacs,       NO_SCRIPT,   0, 0},
331         {0,0,0,0,0}
332 };
333
334
335 static param_export_t params[]={
336         {"ruri_matching",       PARAM_INT, &ruri_matching                        },
337         {"via1_matching",       PARAM_INT, &via1_matching                        },
338         {"fr_timer",            PARAM_INT, &fr_timeout                           },
339         {"fr_inv_timer",        PARAM_INT, &fr_inv_timeout                       },
340         {"wt_timer",            PARAM_INT, &wait_timeout                         },
341         {"delete_timer",        PARAM_INT, &delete_timeout                       },
342         {"retr_timer1",         PARAM_INT, &rt_t1_timeout                        },
343         {"retr_timer2"  ,       PARAM_INT, &rt_t2_timeout                        },
344         {"max_inv_lifetime",    PARAM_INT, &tm_max_inv_lifetime                  },
345         {"max_noninv_lifetime", PARAM_INT, &tm_max_noninv_lifetime               },
346         {"noisy_ctimer",        PARAM_INT, &noisy_ctimer                         },
347         {"auto_inv_100",        PARAM_INT, &tm_auto_inv_100                      },
348         {"uac_from",            PARAM_STRING, &uac_from                          },
349         {"unix_tx_timeout",     PARAM_INT, &tm_unix_tx_timeout                   },
350         {"restart_fr_on_each_reply", PARAM_INT, &restart_fr_on_each_reply        },
351         {"fr_timer_avp",        PARAM_STRING, &fr_timer_param                    },
352         {"fr_inv_timer_avp",    PARAM_STRING, &fr_inv_timer_param                },
353         {"tw_append",           PARAM_STRING|PARAM_USE_FUNC, 
354                                                                                                         (void*)parse_tw_append   },
355         {"pass_provisional_replies", PARAM_INT, &pass_provisional_replies        },
356         {"aggregate_challenges", PARAM_INT, &tm_aggregate_auth                   },
357         {"unmatched_cancel",    PARAM_INT, &unmatched_cancel                     },
358         {"default_code",        PARAM_INT, &default_code                         },
359         {"default_reason",      PARAM_STR, &default_reason                       },
360         {"reparse_invite",      PARAM_INT, &reparse_invite                       },
361         {"ac_extra_hdrs",       PARAM_STR, &ac_extra_hdrs                        },
362         {0,0,0}
363 };
364
365 #ifdef STATIC_TM
366 struct module_exports tm_exports = {
367 #else
368 struct module_exports exports= {
369 #endif
370         "tm",
371         /* -------- exported functions ----------- */
372         cmds,
373         tm_rpc,    /* RPC methods */
374         /* ------------ exported variables ---------- */
375         params,
376
377         mod_init, /* module initialization function */
378         (response_function) reply_received,
379         (destroy_function) tm_shutdown,
380         0, /* w_onbreak, */
381         child_init /* per-child init function */
382 };
383
384
385
386 /* helper for fixup_on_* */
387 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
388 {
389         int i;
390         
391         i=route_get(rt, (char*)*param);
392         if (i==-1){
393                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
394                 return E_UNSPEC;
395         }
396         if (rt->rlist[i]==0){
397                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
398                                 r_type, (char*)*param);
399         }
400         *param=(void*)(long)i;
401         return 0;
402 }
403
404 static int fixup_t_reply(void** param, int param_no)
405 {
406         int ret;
407
408         if (param_no == 1) {
409                 ret = fix_param(FPARAM_AVP, param);
410                 if (ret <= 0) return ret;
411                 return fix_param(FPARAM_INT, param);
412         } else if (param_no == 2) {
413                 return fixup_var_str_12(param, 2);
414         }
415     return 0;
416 }
417
418 static int fixup_on_failure(void** param, int param_no)
419 {
420         if (param_no==1){
421                 return fixup_routes("t_on_failure", &failure_rt, param);
422         }
423         return 0;
424 }
425
426
427
428 static int fixup_on_reply(void** param, int param_no)
429 {
430         if (param_no==1){
431                 return fixup_routes("t_on_reply", &onreply_rt, param);
432         }
433         return 0;
434 }
435
436
437
438 static int fixup_on_branch(void** param, int param_no)
439 {
440         if (param_no==1){
441                 return fixup_routes("t_on_branch", &branch_rt, param);
442         }
443         return 0;
444 }
445
446
447
448 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
449 static int fixup_hostport2proxy(void** param, int param_no)
450 {
451         unsigned int port;
452         char *host;
453         int err;
454         struct proxy_l *proxy;
455         action_u_t *a;
456         str s;
457
458         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
459         if (param_no==1){
460                 return 0;
461         } else if (param_no==2) {
462                 a = fixup_get_param(param, param_no, 1);
463                 host= a->u.string;
464                 port=str2s(*param, strlen(*param), &err);
465                 if (err!=0) {
466                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
467                                 (char*)(*param));
468                          return E_UNSPEC;
469                 }
470                 s.s = host;
471                 s.len = strlen(host);
472                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
473                 if (proxy==0) {
474                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
475                                 host );
476                         return E_BAD_ADDRESS;
477                 }
478                 /* success -- fix the first parameter to proxy now ! */
479
480                 a->u.data=proxy;
481                 return 0;
482         } else {
483                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
484                 return E_BUG;
485         }
486 }
487
488 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
489 static int fixup_proto_hostport2proxy(void** param, int param_no) {
490         int ret;
491
492         ret = fix_param(FPARAM_AVP, param);
493         if (ret <= 0) return ret;
494 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
495                 ret = fix_param(FPARAM_INT, param);
496                 if (ret <= 0) return ret;
497         } */
498         return fix_param(FPARAM_STRING, param);
499 }
500
501
502 /***************************** init functions *****************************/
503 static int w_t_unref( struct sip_msg *foo, void *bar)
504 {
505         return t_unref(foo);
506 }
507
508
509 static int script_init( struct sip_msg *foo, void *bar)
510 {
511         /* we primarily reset all private memory here to make sure
512          * private values left over from previous message will
513          * not be used again */
514
515         /* make sure the new message will not inherit previous
516                 message's t_on_negative value
517         */
518         t_on_negative( 0 );
519         t_on_reply(0);
520         t_on_branch(0);
521         /* reset the kr status */
522         set_kr(0);
523         /* set request mode so that multiple-mode actions know
524          * how to behave */
525         rmode=MODE_REQUEST;
526         return 1;
527 }
528
529
530 static int mod_init(void)
531 {
532         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
533                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
534         /* checking if we have sufficient bitmap capacity for given
535            maximum number of  branches */
536         if (MAX_BRANCHES+1>31) {
537                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
538                         MAX_BRANCHES );
539                 return -1;
540         }
541
542         if (init_callid() < 0) {
543                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
544                 return -1;
545         }
546
547         /* building the hash table*/
548         if (!init_hash_table()) {
549                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
550                 return -1;
551         }
552
553         /* init static hidden values */
554         init_t();
555
556         if (tm_init_selects()==-1) {
557                 LOG(L_ERR, "ERROR: mod_init: select init failed\n");
558                 return -1;
559         }
560         
561         if (tm_init_timers()==-1) {
562                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
563                 return -1;
564         }
565
566              /* First tm_stat initialization function only allocates the top level stat
567               * structure in shared memory, the initialization will complete in child
568               * init with init_tm_stats_child when the final value of estimated_process_count is
569               * known
570               */
571         if (init_tm_stats() < 0) {
572                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
573                 return -1;
574         }
575
576         if (uac_init()==-1) {
577                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
578                 return -1;
579         }
580
581         if (init_tmcb_lists()!=1) {
582                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
583                 return -1;
584         }
585         
586         tm_init_tags();
587         init_twrite_lines();
588         if (init_twrite_sock() < 0) {
589                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
590                 return -1;
591         }
592
593         /* register post-script clean-up function */
594         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0 ) {
595                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
596                         "callback\n");
597                 return -1;
598         }
599         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQ_TYPE_CB , 0)<0 ) {
600                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
601                         "callback\n");
602                 return -1;
603         }
604
605         if (init_avp_params( fr_timer_param, fr_inv_timer_param)<0 ){
606                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process timer AVPs\n");
607                 return -1;
608         }
609
610         tm_init = 1;
611         return 0;
612 }
613
614 static int child_init(int rank) {
615         if (child_init_callid(rank) < 0) {
616                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID generator\n");
617                 return -2;
618         }
619
620         if (rank == 1) {
621                 if (init_tm_stats_child() < 0) {
622                         ERR("Error while initializing tm statistics structures\n");
623                         return -1;
624                 }
625         }
626
627         return 0;
628 }
629
630
631
632
633
634 /**************************** wrapper functions ***************************/
635 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
636 {
637         regmatch_t pmatch;
638         struct cell *t;
639         char *status;
640         char backup;
641         int lowest_status;
642         int n;
643
644         /* first get the transaction */
645         if (t_check( msg , 0 )==-1) return -1;
646         if ( (t=get_t())==0) {
647                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
648                         "which has no T-state established\n");
649                 return -1;
650         }
651         backup = 0;
652
653         switch (rmode) {
654                 case MODE_REQUEST:
655                         /* use the status of the last sent reply */
656                         status = int2str( t->uas.status, 0);
657                         break;
658                 case MODE_ONREPLY:
659                         /* use the status of the current reply */
660                         status = msg->first_line.u.reply.status.s;
661                         backup = status[msg->first_line.u.reply.status.len];
662                         status[msg->first_line.u.reply.status.len] = 0;
663                         break;
664                 case MODE_ONFAILURE:
665                         /* use the status of the winning reply */
666                         if (t_pick_branch( -1, 0, t, &lowest_status)<0 ) {
667                                 LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
668                                         " a final response in MODE_ONFAILURE\n");
669                                 return -1;
670                         }
671                         status = int2str( lowest_status , 0);
672                         break;
673                 default:
674                         LOG(L_ERR,"ERROR:t_check_status: unsupported mode %d\n",rmode);
675                         return -1;
676         }
677
678         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
679         /* do the checking */
680         n = regexec(((fparam_t*)p1)->v.regex, status, 1, &pmatch, 0);
681
682         if (backup) status[msg->first_line.u.reply.status.len] = backup;
683         if (n!=0) return -1;
684         return 1;
685 }
686
687
688 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
689 {
690         return t_check( msg , 0  ) ? 1 : -1;
691 }
692
693 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
694 {
695         struct cell *ret;
696         if (msg->REQ_METHOD==METHOD_CANCEL) {
697                 ret = t_lookupOriginalT( msg );
698                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
699                 if (ret != T_NULL_CELL) {
700                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
701                         So we must unref it before returning. */
702                         UNREF(ret);
703                         set_t(T_UNDEFINED);
704                         return 1;
705                 }
706                 set_t(T_UNDEFINED);
707         } else {
708                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
709         }
710         return -1;
711 }
712
713 inline static int str2proto(char *s, int len) {
714         if (len == 3 && !strncasecmp(s, "udp", 3))
715                 return PROTO_UDP;
716         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
717                 return PROTO_TCP;
718         else if (len == 3 && !strncasecmp(s, "tls", 3))
719                 return PROTO_TLS;       
720         else
721                 return PROTO_NONE;
722 }
723
724 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
725         struct proxy_l *proxy = 0;
726         avp_t* avp;
727         avp_value_t val;
728         int proto, port, err;
729         str s;
730         char *c;
731         
732         switch(((fparam_t *)proto_par)->type) {
733         case FPARAM_AVP:
734                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
735                         proto = PROTO_NONE;
736                 } else {
737                         if (avp->flags & AVP_VAL_STR) {
738                                 proto = str2proto(val.s.s, val.s.len);
739                         }
740                         else {
741                                 proto = val.n;
742                         }
743                 }
744                 break;
745
746         case FPARAM_INT:
747                 proto = ((fparam_t *)proto_par)->v.i;
748                 break;
749         case FPARAM_STRING:
750                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
751                 break;
752         default:
753                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
754                 return 0;
755         }
756
757
758         switch(((fparam_t *)addr_par)->type) {
759         case FPARAM_AVP:
760                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
761                         s.len = 0;
762                 } else {
763                         if ((avp->flags & AVP_VAL_STR) == 0) {
764                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
765                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
766                                 return 0;
767                         }
768                         s = val.s;
769                 }
770                 break;
771
772         case FPARAM_STRING:
773                 s.s = ((fparam_t *) addr_par)->v.asciiz;
774                 s.len = strlen(s.s);
775                 break;
776
777         default:
778                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
779                 return 0;
780         }
781
782         port = 5060;
783         if (s.len) {
784                 c = memchr(s.s, ':', s.len);
785                 if (c) {
786                         port = str2s(c+1, s.len-(c-s.s+1), &err);
787                         if (err!=0) {
788                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
789                                         s.len, s.s);
790                                  return 0;
791                         }
792                         s.len = c-s.s;
793                 }
794         }
795         if (!s.len) {
796                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
797                 return 0;
798         }
799         proxy=mk_proxy(&s, port, proto);
800         if (proxy==0) {
801                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
802                         s.len, s.s );
803                 return 0;
804         }
805         return proxy;
806 }
807
808 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
809         int proto)
810 {
811         struct cell *t;
812         if (t_check( msg , 0 )==-1) {
813                 LOG(L_ERR, "ERROR: forward_nonack: "
814                                 "can't forward when no transaction was set up\n");
815                 return -1;
816         }
817         t=get_t();
818         if ( t && t!=T_UNDEFINED ) {
819                 if (msg->REQ_METHOD==METHOD_ACK) {
820                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
821                         return -1;
822                 }
823                 return t_forward_nonack(t, msg, proxy, proto );
824         } else {
825                 DBG("DEBUG: forward_nonack: no transaction found\n");
826                 return -1;
827         }
828 }
829
830
831 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
832                                                                                 char* foo)
833 {
834         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
835 }
836
837
838 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
839                                                                                                                                         char *bar)
840 {
841         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
842 }
843
844
845 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
846                                                                                 char* foo)
847 {
848         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
849 }
850
851
852 #ifdef USE_TCP
853 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
854                                                                                 char* foo)
855 {
856         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
857 }
858 #endif
859
860
861 #ifdef USE_TLS
862 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
863                                                                                 char* foo)
864 {
865         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
866 }
867 #endif
868
869 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
870         char *proto_par, 
871         char *addr_par   )
872 {
873         struct proxy_l *proxy;
874         int r = -1;
875         proxy = t_protoaddr2proxy(proto_par, addr_par);
876         if (proxy) {
877                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);            
878                 free_proxy(proxy);
879         }
880         return r;
881 }
882
883
884 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
885 {
886         struct cell *t;
887         int code, ret = -1;
888         str reason;
889         char* r;
890
891         if (msg->REQ_METHOD==METHOD_ACK) {
892                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
893                 return -1;
894         }
895         if (t_check( msg , 0 )==-1) return -1;
896         t=get_t();
897         if (!t) {
898                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
899                         "for which no T-state has been established\n");
900                 return -1;
901         }
902
903         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
904             code = default_code;
905         }
906         
907         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
908             reason = default_reason;
909         }
910         
911         r = as_asciiz(&reason);
912         if (r == NULL) r = default_reason.s;
913         
914         /* if called from reply_route, make sure that unsafe version
915          * is called; we are already in a mutex and another mutex in
916          * the safe version would lead to a deadlock
917          */
918          
919         if (rmode==MODE_ONFAILURE) {
920                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
921                 ret = t_reply_unsafe(t, msg, code, r);
922         } else if (rmode==MODE_REQUEST) {
923                 ret = t_reply( t, msg, code, r);
924         } else {
925                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
926                 ret = -1;
927         }
928
929         if (r) pkg_free(r);
930         return ret;
931 }
932
933
934 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
935 {
936         struct cell *t;
937         int ret;
938         
939         if (t_check( msg  , 0  )==-1) return -1;
940         t=get_t();
941         if ( t && t!=T_UNDEFINED ) {
942                 ret = t_release_transaction( t );
943                 t_unref(msg);
944                 return ret;
945         }
946         return 1;
947 }
948
949
950 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
951 {
952         struct cell *t;
953
954
955         if (t_check( p_msg  , 0 )==-1)
956                 return 1;
957         t=get_t();
958         if (t) {
959                 if (p_msg->REQ_METHOD==METHOD_ACK) {
960                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
961                         return -1;
962                 }
963                 return t_retransmit_reply( t );
964         } else
965                 return -1;
966 }
967
968
969 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
970 {
971         /* t_newtran returns 0 on error (negative value means
972            'transaction exists' */
973         int ret;
974         ret = t_newtran( p_msg );
975         if (ret==E_SCRIPT) {
976                 LOG(L_ERR, "ERROR: t_newtran: "
977                         "transaction already in process %p\n", get_t() );
978         }
979         return ret;
980 }
981
982
983 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
984 {
985         t_on_negative( (unsigned int )(long) go_to );
986         return 1;
987 }
988
989 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
990 {
991         t_on_branch( (unsigned int )(long) go_to );
992         return 1;
993 }
994
995
996 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
997 {
998         t_on_reply( (unsigned int )(long) go_to );
999         return 1;
1000 }
1001
1002
1003
1004 inline static int _w_t_relay_to( struct sip_msg  *p_msg ,
1005         struct proxy_l *proxy )
1006 {
1007         struct cell *t;
1008
1009         if (rmode==MODE_ONFAILURE) {
1010                 t=get_t();
1011                 if (!t || t==T_UNDEFINED) {
1012                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
1013                         return -1;
1014                 }
1015                 if (t_forward_nonack(t, p_msg, proxy, PROTO_NONE)<=0 ) {
1016                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
1017                         return -1;
1018                 }
1019                 return 1;
1020         }
1021         if (rmode==MODE_REQUEST)
1022                 return t_relay_to( p_msg, proxy, PROTO_NONE,
1023                         0 /* no replication */ );
1024         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1025         return 0;
1026 }
1027
1028
1029 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
1030         char *proxy, /* struct proxy_l *proxy expected */
1031         char *_foo       /* nothing expected */ )
1032 {
1033         ((struct proxy_l *)proxy)->proto=PROTO_UDP;
1034         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1035 }
1036
1037
1038 #ifdef USE_TCP
1039 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
1040         char *proxy, /* struct proxy_l *proxy expected */
1041         char *_foo       /* nothing expected */ )
1042 {
1043         ((struct proxy_l *)proxy)->proto=PROTO_TCP;
1044         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1045 }
1046 #endif
1047
1048
1049 #ifdef USE_TLS
1050 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
1051         char *proxy, /* struct proxy_l *proxy expected */
1052         char *_foo       /* nothing expected */ )
1053 {
1054         ((struct proxy_l *)proxy)->proto=PROTO_TLS;
1055         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1056 }
1057 #endif
1058
1059 inline static int w_t_relay_to( struct sip_msg  *p_msg ,
1060         char *proto_par, 
1061         char *addr_par   )
1062 {
1063         struct proxy_l *proxy;
1064         int r = -1;
1065         proxy = t_protoaddr2proxy(proto_par, addr_par);
1066         if (proxy) {
1067                 r = _w_t_relay_to(p_msg, proxy);                
1068                 free_proxy(proxy);
1069         }
1070         return r;
1071 }
1072
1073
1074 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1075         char *proxy, /* struct proxy_l *proxy expected */
1076         char *_foo       /* nothing expected */ )
1077 {
1078         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1079 }
1080
1081 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1082         char *proxy, /* struct proxy_l *proxy expected */
1083         char *_foo       /* nothing expected */ )
1084 {
1085         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1086 }
1087
1088
1089 #ifdef USE_TCP
1090 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1091         char *proxy, /* struct proxy_l *proxy expected */
1092         char *_foo       /* nothing expected */ )
1093 {
1094         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1095 }
1096 #endif
1097
1098
1099 #ifdef USE_TLS
1100 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1101         char *proxy, /* struct proxy_l *proxy expected */
1102         char *_foo       /* nothing expected */ )
1103 {
1104         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1105 }
1106 #endif
1107
1108 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1109         char *proto_par, 
1110         char *addr_par   )
1111 {
1112         struct proxy_l *proxy;
1113         int r = -1;
1114         proxy = t_protoaddr2proxy(proto_par, addr_par);
1115         if (proxy) {
1116                 r = t_replicate(p_msg, proxy, proxy->proto);            
1117                 free_proxy(proxy);
1118         }
1119         return r;
1120 }
1121
1122 inline static int w_t_relay( struct sip_msg  *p_msg ,
1123                                                 char *_foo, char *_bar)
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: undefined T\n");
1131                         return -1;
1132                 }
1133                 if (t_forward_nonack(t, p_msg, ( struct proxy_l *) 0, PROTO_NONE)<=0) {
1134                         LOG(L_ERR, "ERROR: w_t_relay (failure mode): forwarding failed\n");
1135                         return -1;
1136                 }
1137                 return 1;
1138         }
1139         if (rmode==MODE_REQUEST)
1140                 return t_relay_to( p_msg,
1141                 (struct proxy_l *) 0 /* no proxy */, PROTO_NONE,
1142                 0 /* no replication */ );
1143         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1144         return 0;
1145 }
1146
1147 /* relays CANCEL at the beginning of the script */
1148 inline static int w_t_relay_cancel( struct sip_msg  *p_msg ,
1149                                                 char *_foo, char *_bar)
1150 {
1151         if (p_msg->REQ_METHOD!=METHOD_CANCEL)
1152                 return 1;
1153
1154         /* it makes no sense to use this function without reparse_invite=1 */
1155         if (!reparse_invite)
1156                 LOG(L_WARN, "WARNING: t_relay_cancel is probably used with "
1157                         "wrong configuration, check the readme for details\n");
1158
1159         return t_relay_cancel(p_msg);
1160 }
1161
1162 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1163 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1164 {
1165     int fr, fr_inv;
1166
1167     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1168     if (p2) {
1169         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1170     } else {
1171         fr = 0;
1172     }
1173
1174     return t_set_fr(msg, fr_inv, fr);
1175 }
1176
1177 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1178 {
1179         return t_set_fr_all(msg, fr_inv, (char*)0);
1180 }
1181
1182
1183
1184 /* set retr. intervals per transaction; 0 means: use the default value */
1185 static int w_t_set_retr(struct sip_msg* msg, char* p1, char* p2)
1186 {
1187         int t1, t2;
1188         
1189         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1190         if (p2) {
1191                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1192         } else {
1193                 t2 = 0;
1194         }
1195 #ifdef TM_DIFF_RT_TIMEOUT
1196         return t_set_retr(msg, t1, t2);
1197 #else
1198         ERR("w_t_set_retr: support for changing retransmission intervals on "
1199                         "the fly not compiled in (re-compile tm with"
1200                         " -DTM_DIFF_RT_TIMEOUT)\n");
1201         return -1;
1202 #endif
1203 }
1204
1205
1206
1207 /* set maximum transaction lifetime for inv & noninv */
1208 static int w_t_set_max_lifetime(struct sip_msg* msg, char* p1, char* p2)
1209 {
1210         int t1, t2;
1211         
1212         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1213         if (p2) {
1214                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1215         } else {
1216                 t2 = 0;
1217         }
1218         return t_set_max_lifetime(msg, t1, t2);
1219 }
1220
1221
1222
1223 /* set automatically sending 100 replies on/off for the current or
1224  * next to be created transaction */
1225 static int t_set_auto_inv_100(struct sip_msg* msg, char* p1, char* p2)
1226 {
1227         int state;
1228         struct cell* t;
1229         
1230         if (get_int_fparam(&state, msg, (fparam_t*)p1) < 0) return -1;
1231         t=get_t();
1232         /* in MODE_REPLY and MODE_ONFAILURE T will be set to current transaction;
1233          * in MODE_REQUEST T will be set only if the transaction was already
1234          * created; if not -> use the static variables */
1235         if (!t || t==T_UNDEFINED ){
1236                 if (state)
1237                         set_msgid_val(user_auto_inv_100, msg->id, int, 1); /* set */
1238                 else
1239                         set_msgid_val(user_auto_inv_100, msg->id, int, -1); /* reset */
1240         }else{
1241                 if (state)
1242                         t->flags|=T_AUTO_INV_100;
1243                 else
1244                         t->flags&=~T_AUTO_INV_100;
1245         }
1246         return 1;
1247 }
1248
1249
1250
1251 /* script function, FAILURE_ROUTE only, returns true if the 
1252  * choosed "failure" branch failed because of a timeout, 
1253  * -1 otherwise */
1254 int t_branch_timeout(struct sip_msg* msg, char* foo, char* bar)
1255 {
1256         return (msg->msg_flags & FL_TIMEOUT)?1:-1;
1257 }
1258
1259
1260
1261 /* script function, FAILURE_ROUTE only, returns true if the 
1262  * choosed "failure" branch ever received a reply, -1 otherwise */
1263 int t_branch_replied(struct sip_msg* msg, char* foo, char* bar)
1264 {
1265         return (msg->msg_flags & FL_REPLIED)?1:-1;
1266 }
1267
1268
1269
1270 /* script function, returns: 1 if the transaction was canceled, -1 if not */
1271 int t_is_canceled(struct sip_msg* msg, char* foo, char* bar)
1272 {
1273         struct cell *t;
1274         int ret;
1275         
1276         
1277         if (t_check( msg , 0 )==-1) return -1;
1278         t=get_t();
1279         if ((t==0) || (t==T_UNDEFINED)){
1280                 LOG(L_ERR, "ERROR: t_is_canceled: cannot check a message "
1281                         "for which no T-state has been established\n");
1282                 ret=-1;
1283         }else{
1284                 ret=(t->flags & T_CANCELED)?1:-1;
1285         }
1286         return ret;
1287 }
1288
1289
1290
1291 /* script function, returns: 1 if any of the branches did timeout, -1 if not */
1292 int t_any_timeout(struct sip_msg* msg, char* foo, char* bar)
1293 {
1294         struct cell *t;
1295         int r;
1296         
1297         if (t_check( msg , 0 )==-1) return -1;
1298         t=get_t();
1299         if ((t==0) || (t==T_UNDEFINED)){
1300                 LOG(L_ERR, "ERROR: t_any_timeout: cannot check a message "
1301                         "for which no T-state has been established\n");
1302                 return -1;
1303         }else{
1304                 for (r=0; r<t->nr_of_outgoings; r++){
1305                         if (t->uac[r].request.flags & F_RB_TIMEOUT)
1306                                 return 1;
1307                 }
1308         }
1309         return -1;
1310 }
1311
1312
1313
1314 /* script function, returns: 1 if any of the branches received at leat one
1315  * reply, -1 if not */
1316 int t_any_replied(struct sip_msg* msg, char* foo, char* bar)
1317 {
1318         struct cell *t;
1319         int r;
1320         
1321         if (t_check( msg , 0 )==-1) return -1;
1322         t=get_t();
1323         if ((t==0) || (t==T_UNDEFINED)){
1324                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1325                         "for which no T-state has been established\n");
1326                 return -1;
1327         }else{
1328                 for (r=0; r<t->nr_of_outgoings; r++){
1329                         if (t->uac[r].request.flags & F_RB_REPLIED)
1330                                 return 1;
1331                 }
1332         }
1333         return -1;
1334 }
1335
1336
1337
1338 static rpc_export_t tm_rpc[] = {
1339         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
1340         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
1341         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
1342         {0, 0, 0, 0}
1343 };
1344
1345 /* wrapper function needed after changes in w_t_reply */
1346 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1347 {
1348         fparam_t c;
1349         fparam_t r;
1350         
1351         c.type = FPARAM_INT;
1352         c.orig = NULL; /* ? */
1353         c.v.i = code;
1354         
1355         r.type = FPARAM_STRING;
1356         r.orig = NULL; /* ? */
1357         r.v.asciiz = txt;
1358
1359         return w_t_reply(m, (char *)&c, (char*)&r);
1360 }
1361