ca3a73af8c4815435b6b6ce229e2ce6be2fd3274
[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 SIP-router, a free SIP server.
34  *
35  * SIP-router 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  * SIP-router is distributed in the hope that it will be useful,
41  * but WITHOUT ANY WARRANTY; without even the implied warranty of
42  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
43  * GNU General Public License for more details.
44  *
45  * You should have received a copy of the GNU General Public License
46  * along with this program; if not, write to the Free Software
47  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
48  */
49 /*
50  * History:
51  * --------
52  *  2003-02-18  added t_forward_nonack_{udp, tcp}, t_relay_to_{udp,tcp},
53  *               t_replicate_{udp, tcp} (andrei)
54  *  2003-02-19  added t_rely_{udp, tcp} (andrei)
55  *  2003-03-06  voicemail changes accepted (jiri)
56  *  2003-03-10  module export interface updated to the new format (andrei)
57  *  2003-03-16  flags export parameter added (janakj)
58  *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
59  *  2003-03-30  set_kr for requests only (jiri)
60  *  2003-04-05  s/reply_route/failure_route, onreply_route introduced (jiri)
61  *  2003-04-14  use protocol from uri (jiri)
62  *  2003-07-07  added t_relay_to_tls, t_replicate_tls, t_forward_nonack_tls
63  *              added #ifdef USE_TCP, USE_TLS
64  *              removed t_relay_{udp,tcp,tls} (andrei)
65  *  2003-09-26  added t_forward_nonack_uri() - same as t_forward_nonack() but
66  *              takes no parameters -> forwards to uri (bogdan)
67  *  2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
68  *  2004-02-18  t_reply exported via FIFO - imported from VM (bogdan)
69  *  2004-10-01  added a new param.: restart_fr_on_each_reply (andrei)
70  *  2005-11-14  new timer support, changed timer related module params (andrei)
71  *  2005-12-09  fixup_hostport2proxy uses route_struct to access param #1
72  *              when fixing param #2
73  *  2005-12-09  added t_set_fr() (andrei)
74  *  2006-02-07  named routes support (andrei)
75  *  2006-09-28  added t_branch_replied, t_branch_timeout, t_any_replied, 
76  *               t_any_timeout, t_is_canceled (andrei)
77  *  2006-10-16  added a new param.: aggregate challenges (andrei)
78  *  2007-05-28  two new params: reparse_invite, ac_extra_hdrs
79  *              added w_t_relay_cancel() (Miklos)
80  *  2007-06-05  added t_set_auto_inv_100() and auto_inv_100 (param);
81  *               t_set_max_lifetime(), max_{non}inv_lifetime  (andrei)
82  *  2008-02-05  module config parameters use the configuration framework (Miklos)
83  *  2008-02-29  added t_grep_status(code) (andrei)
84  *  2008-05-15  added t_relay(host, port) (similar to forward(host, port)) &
85  *               t_relay_to_{udp,tcp,tls}(<no param>) (force protocol, but 
86  *               forward to uri)  (andrei)
87  *  2008-08-11  sctp support: t_relay_to_sctp, t_replicate_sctp,
88  *               t_forward_nonack_sctp (andrei)
89  *  2009-03-18  added a new param: auto_inv_100_reason (aheise) 
90  */
91
92 /*!
93  * \file 
94  * \brief TM :: Module API (core)
95  * \ingroup tm
96  */
97
98 /*!
99  * \defgroup tm TM :: Transaction stateful proxy support
100  *
101    The TM module enables stateful processing of SIP transactions. The main use
102    of stateful logic, which is costly in terms of memory and CPU, is some
103    services that inherently need state. 
104
105    For example, transaction-based accounting (module acc) needs to process 
106    transaction state as opposed to individual messages, and any kinds of 
107    forking must be implemented statefully. Other use of stateful processing 
108    is it trading CPU caused by retransmission processing for memory. 
109    That however only makes sense if CPU consumption per request is huge. 
110    For example, if you want to avoid costly DNS resolution for every 
111    retransmission of a request to an unresolvable destination, use stateful 
112    mode. Then, only the initial message burdens server by DNS queries, 
113    subsequent retransmissions will be dropped and will not result in more 
114    processes blocked by DNS resolution. The price is more memory consumption 
115    and higher processing latency.
116
117  *
118 \code
119  * ***************************************************
120  * * Jiri's Source Memorial                          *
121  * *                                                 *
122  * * Welcome, pilgrim ! This is the greatest place   *
123  * * where dramatic changes happend. There are not   *
124  * * many places with a history like this, as there  *
125  * * are not so many people like Jiri, one of the    *
126  * * ser's fathers, who brought everywhere the wind  *
127  * * of change, the flood of clean-up. We all felt   *
128  * * his fatherly eye watching over us day and night.*
129  * *                                                 *
130  * * Please, preserve this codework heritage, as     *
131  * * it's unlikely for fresh, juicy pieces of code to  *
132  * * arise to give him the again the chance to       *
133  * * demonstrate his clean-up and improvement skills.*
134  * *                                                 *
135  * * Hereby, we solicit you to adopt this historical *
136  * * piece of code. For $100, your name will be      *
137  * * be printed in this banner and we will use       *
138  * * collected funds to create and display an ASCII  *
139  * * statue of Jiri  .                               *
140  * ***************************************************
141 \endcode
142  */
143
144
145 #include "defs.h"
146
147
148 #include <stdio.h>
149 #include <string.h>
150 #include <netdb.h>
151
152 #include "../../sr_module.h"
153 #include "../../dprint.h"
154 #include "../../error.h"
155 #include "../../ut.h"
156 #include "../../script_cb.h"
157 #include "../../usr_avp.h"
158 #include "../../mem/mem.h"
159 #include "../../route_struct.h"
160 #include "../../route.h"
161 #include "../../cfg/cfg.h"
162 #include "../../globals.h"
163 #include "../../timer_ticks.h"
164
165 #include "config.h"
166 #include "sip_msg.h"
167 #include "h_table.h"
168 #include "t_hooks.h"
169 #include "tm_load.h"
170 #include "ut.h"
171 #include "t_reply.h"
172 #include "uac.h"
173 #include "t_fwd.h"
174 #include "t_lookup.h"
175 #include "t_stats.h"
176 #include "callid.h"
177 #include "t_cancel.h"
178 #include "t_fifo.h"
179 #include "timer.h"
180 #include "t_msgbuilder.h"
181 #include "select.h"
182 #include "t_serial.h"
183 #include "rpc_uac.h"
184
185 MODULE_VERSION
186
187 /* fixup functions */
188 static int fixup_hostport2proxy(void** param, int param_no);
189 static int fixup_proto_hostport2proxy(void** param, int param_no);
190 static int fixup_on_failure(void** param, int param_no);
191 static int fixup_on_reply(void** param, int param_no);
192 static int fixup_on_branch(void** param, int param_no);
193 static int fixup_t_reply(void** param, int param_no);
194 static int fixup_on_sl_reply(modparam_t type, void* val);
195
196 /* init functions */
197 static int mod_init(void);
198 static int child_init(int rank);
199
200
201 /* exported functions */
202 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
203 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2);
204 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
205 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
206 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
207                                 char* bar );
208 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
209 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
210 inline static int w_t_relay2( struct sip_msg  *p_msg , char *proxy, char*);
211 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy,
212                                  char *);
213 inline static int w_t_relay_to_udp_uri( struct sip_msg  *p_msg , char*, char*);
214 #ifdef USE_TCP
215 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
216                                 char *);
217 inline static int w_t_relay_to_tcp_uri( struct sip_msg  *p_msg , char*, char*);
218 #endif
219 #ifdef USE_TLS
220 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
221                                 char *);
222 inline static int w_t_relay_to_tls_uri( struct sip_msg  *p_msg , char*, char*);
223 #endif
224 #ifdef USE_SCTP
225 inline static int w_t_relay_to_sctp( struct sip_msg  *p_msg , char *proxy,
226                                 char *);
227 inline static int w_t_relay_to_sctp_uri( struct sip_msg*, char*, char*);
228 #endif
229 inline static int w_t_relay_to_avp(struct sip_msg* msg, char* str,char*);
230 inline static int w_t_replicate( struct sip_msg  *p_msg ,
231                                 char *proxy, /* struct proxy_l *proxy expected */
232                                 char *_foo       /* nothing expected */ );
233 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
234                                 char *proxy, /* struct proxy_l *proxy expected */
235                                 char *_foo       /* nothing expected */ );
236 #ifdef USE_TCP
237 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
238                                 char *proxy, /* struct proxy_l *proxy expected */
239                                 char *_foo       /* nothing expected */ );
240 #endif
241 #ifdef USE_TLS
242 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
243                                 char *proxy, /* struct proxy_l *proxy expected */
244                                 char *_foo       /* nothing expected */ );
245 #endif
246 #ifdef USE_SCTP
247 inline static int w_t_replicate_sctp( struct sip_msg  *p_msg ,
248                                 char *proxy, /* struct proxy_l *proxy expected */
249                                 char *_foo       /* nothing expected */ );
250 #endif
251 inline static int w_t_replicate_to(struct sip_msg* msg, char* str,char*);
252 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
253 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
254 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
255 #ifdef USE_TCP
256 inline static int w_t_forward_nonack_tcp(struct sip_msg*, char* str,char*);
257 #endif
258 #ifdef USE_TLS
259 inline static int w_t_forward_nonack_tls(struct sip_msg*, char* str,char*);
260 #endif
261 #ifdef USE_SCTP
262 inline static int w_t_forward_nonack_sctp(struct sip_msg*, char* str,char*);
263 #endif
264 inline static int w_t_forward_nonack_to(struct sip_msg* msg, char* str,char*);
265 inline static int w_t_relay_cancel(struct sip_msg *p_msg, char *_foo, char *_bar);
266 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
267 inline static int w_t_on_branch(struct sip_msg* msg, char *go_to, char *foo);
268 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
269 inline static int t_check_status(struct sip_msg* msg, char *match, char *foo);
270 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo);
271 static int t_set_fr_all(struct sip_msg* msg, char* fr_inv, char* fr);
272 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar);
273 static int w_t_set_retr(struct sip_msg* msg, char* retr_t1, char* retr_t2);
274 static int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar);
275 static int w_t_set_max_lifetime(struct sip_msg* msg, char* inv, char* noninv);
276 static int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar);
277 static int t_set_auto_inv_100(struct sip_msg* msg, char* on_off, char* foo);
278 static int t_set_disable_6xx(struct sip_msg* msg, char* on_off, char* foo);
279 static int t_set_disable_failover(struct sip_msg* msg, char* on_off, char* f);
280 static int t_branch_timeout(struct sip_msg* msg, char*, char*);
281 static int t_branch_replied(struct sip_msg* msg, char*, char*);
282 static int t_any_timeout(struct sip_msg* msg, char*, char*);
283 static int t_any_replied(struct sip_msg* msg, char*, char*);
284 static int t_is_canceled(struct sip_msg* msg, char*, char*);
285 static int t_is_expired(struct sip_msg* msg, char*, char*);
286 static int t_grep_status(struct sip_msg* msg, char*, char*);
287 static int w_t_drop_replies(struct sip_msg* msg, char* foo, char* bar);
288 static int w_t_save_lumps(struct sip_msg* msg, char* foo, char* bar);
289 static int t_check_trans(struct sip_msg* msg, char* foo, char* bar);
290
291
292 /* by default the fr timers avps are not set, so that the avps won't be
293  * searched for nothing each time a new transaction is created */
294 static char *fr_timer_param = 0 /*FR_TIMER_AVP*/;
295 static char *fr_inv_timer_param = 0 /*FR_INV_TIMER_AVP*/;
296 static char *contacts_avp_param = 0;
297
298 static rpc_export_t tm_rpc[];
299
300 static int fixup_t_check_status(void** param, int param_no);
301
302 static cmd_export_t cmds[]={
303         {"t_newtran",          w_t_newtran,             0, 0,
304                         REQUEST_ROUTE},
305         {"t_lookup_request",   w_t_check,               0, 0,
306                         REQUEST_ROUTE},
307         {"t_lookup_cancel",    w_t_lookup_cancel,       0, 0,
308                         REQUEST_ROUTE},
309         {"t_lookup_cancel",    w_t_lookup_cancel,       1, fixup_int_1,
310                         REQUEST_ROUTE},
311         {T_REPLY,              w_t_reply,               2, fixup_t_reply,
312                         REQUEST_ROUTE | FAILURE_ROUTE },
313         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
314                         REQUEST_ROUTE},
315         {"t_release",          w_t_release,             0, 0,
316                         REQUEST_ROUTE},
317         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
318                         REQUEST_ROUTE|FAILURE_ROUTE},
319         {T_RELAY_TO_UDP,       w_t_relay_to_udp_uri,    0, 0,
320                         REQUEST_ROUTE|FAILURE_ROUTE},
321 #ifdef USE_TCP
322         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
323                         REQUEST_ROUTE|FAILURE_ROUTE},
324         {T_RELAY_TO_TCP,       w_t_relay_to_tcp_uri,    0, 0,
325                         REQUEST_ROUTE|FAILURE_ROUTE},
326 #endif
327 #ifdef USE_TLS
328         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
329                         REQUEST_ROUTE|FAILURE_ROUTE},
330         {T_RELAY_TO_TLS,       w_t_relay_to_tls_uri,    0, 0,
331                         REQUEST_ROUTE|FAILURE_ROUTE},
332 #endif
333 #ifdef USE_SCTP
334         {T_RELAY_TO_SCTP,       w_t_relay_to_sctp,       2, fixup_hostport2proxy,
335                         REQUEST_ROUTE|FAILURE_ROUTE},
336         {T_RELAY_TO_SCTP,       w_t_relay_to_sctp_uri,    0, 0,
337                         REQUEST_ROUTE|FAILURE_ROUTE},
338 #endif
339         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
340                         REQUEST_ROUTE},
341         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
342                         REQUEST_ROUTE},
343 #ifdef USE_TCP
344         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
345                         REQUEST_ROUTE},
346 #endif
347 #ifdef USE_TLS
348         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
349                         REQUEST_ROUTE},
350 #endif
351 #ifdef USE_SCTP
352         {"t_replicate_sctp",    w_t_replicate_sctp,     2, fixup_hostport2proxy,
353                         REQUEST_ROUTE},
354 #endif
355         {"t_replicate_to", w_t_replicate_to,            2, fixup_proto_hostport2proxy,
356                         REQUEST_ROUTE},
357         {T_RELAY,              w_t_relay,               0, 0,
358                         REQUEST_ROUTE | FAILURE_ROUTE },
359         {T_RELAY,              w_t_relay2,              2, fixup_hostport2proxy,
360                         REQUEST_ROUTE | FAILURE_ROUTE },
361         {"t_relay_to_avp", w_t_relay_to_avp,            2, fixup_proto_hostport2proxy,
362                         REQUEST_ROUTE},
363         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
364                         REQUEST_ROUTE},
365         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
366                         REQUEST_ROUTE},
367         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
368                         REQUEST_ROUTE},
369 #ifdef USE_TCP
370         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
371                         REQUEST_ROUTE},
372 #endif
373 #ifdef USE_TLS
374         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
375                         REQUEST_ROUTE},
376 #endif
377 #ifdef USE_SCTP
378         {T_FORWARD_NONACK_SCTP, w_t_forward_nonack_sctp, 2, fixup_hostport2proxy,
379                         REQUEST_ROUTE},
380 #endif
381         {"t_forward_nonack_to", w_t_forward_nonack_to,  2, fixup_proto_hostport2proxy,
382                         REQUEST_ROUTE},
383         {"t_relay_cancel",     w_t_relay_cancel,        0, 0,
384                         REQUEST_ROUTE},
385         {"t_on_failure",       w_t_on_negative,         1, fixup_on_failure,
386                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
387         {"t_on_reply",         w_t_on_reply,            1, fixup_on_reply,
388                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
389         {"t_on_branch",       w_t_on_branch,         1, fixup_on_branch,
390                         REQUEST_ROUTE | FAILURE_ROUTE },
391         {"t_check_status",     t_check_status,          1, fixup_t_check_status,
392                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
393         {"t_write_req",       t_write_req,              2, fixup_t_write,
394                         REQUEST_ROUTE | FAILURE_ROUTE },
395         {"t_write_unix",      t_write_unix,             2, fixup_t_write,
396                         REQUEST_ROUTE | FAILURE_ROUTE },
397         {"t_set_fr",          t_set_fr_inv,             1, fixup_var_int_1,
398                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
399         {"t_set_fr",          t_set_fr_all,             2, fixup_var_int_12,
400                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
401         {"t_reset_fr",        w_t_reset_fr,             0, 0,
402                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
403         {"t_set_retr",        w_t_set_retr,               2, fixup_var_int_12,
404                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
405         {"t_reset_retr",      w_t_reset_retr,           0, 0,
406                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
407         {"t_set_max_lifetime", w_t_set_max_lifetime,      2, fixup_var_int_12,
408                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
409         {"t_reset_max_lifetime", w_t_reset_max_lifetime, 0, 0,
410                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
411         {"t_set_auto_inv_100", t_set_auto_inv_100,       1, fixup_var_int_1,
412                                                                                                           REQUEST_ROUTE},
413         {"t_set_disable_6xx", t_set_disable_6xx,         1, fixup_var_int_1,
414                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
415         {"t_set_disable_failover", t_set_disable_failover, 1, fixup_var_int_1,
416                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
417         {"t_branch_timeout",  t_branch_timeout,         0, 0,  FAILURE_ROUTE},
418         {"t_branch_replied",  t_branch_replied,         0, 0,  FAILURE_ROUTE},
419         {"t_any_timeout",     t_any_timeout,            0, 0, 
420                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
421         {"t_any_replied",     t_any_replied,            0, 0, 
422                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
423         {"t_is_canceled",     t_is_canceled,            0, 0,
424                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
425         {"t_is_expired",      t_is_expired,             0, 0,
426                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
427         {"t_grep_status",     t_grep_status,            1, fixup_var_int_1, 
428                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
429         {"t_drop_replies",    w_t_drop_replies,         0, 0,
430                         FAILURE_ROUTE},
431         {"t_save_lumps",      w_t_save_lumps,           0, 0,
432                         REQUEST_ROUTE},
433         {"t_check_trans",       t_check_trans,                          0, 0,
434                         REQUEST_ROUTE|ONREPLY_ROUTE|BRANCH_ROUTE },
435
436         {"t_load_contacts", t_load_contacts,            0, 0,
437                         REQUEST_ROUTE | FAILURE_ROUTE},
438         {"t_next_contacts", t_next_contacts,            0, 0,
439                         REQUEST_ROUTE | FAILURE_ROUTE},
440
441         /* not applicable from the script */
442         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
443         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
444         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
445         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
446         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
447         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
448         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
449         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
450         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
451         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
452         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
453         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
454         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
455         {"update_dlg_uas",     (cmd_function)update_dlg_uas,    NO_SCRIPT,   0, 0},
456         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
457         {"set_dlg_target",     (cmd_function)set_dlg_target,    NO_SCRIPT,   0, 0},
458         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
459         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
460         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0, 0},
461         {"calculate_hooks",    (cmd_function)w_calculate_hooks, NO_SCRIPT,   0, 0},
462         {"t_uac",              (cmd_function)t_uac,             NO_SCRIPT,   0, 0},
463         {"t_uac_with_ids",     (cmd_function)t_uac_with_ids,    NO_SCRIPT,   0, 0},
464         {"t_unref",            (cmd_function)t_unref,           NO_SCRIPT,   0, 0},
465         {"run_failure_handlers", (cmd_function)run_failure_handlers, NO_SCRIPT,   0, 0},
466         {"cancel_uacs",        (cmd_function)cancel_uacs,       NO_SCRIPT,   0, 0},
467         {"cancel_all_uacs",    (cmd_function)cancel_all_uacs,        NO_SCRIPT,   0, 0},
468 #ifdef WITH_AS_SUPPORT
469         {"ack_local_uac",      (cmd_function)ack_local_uac,     NO_SCRIPT,   0, 0},
470         {"t_get_canceled_ident",   (cmd_function)t_get_canceled_ident,  NO_SCRIPT,
471                         0, 0},
472 #endif
473         {"t_suspend",          (cmd_function)t_suspend,         NO_SCRIPT,   0, 0},
474         {"t_continue",         (cmd_function)t_continue,        NO_SCRIPT,   0, 0},
475         {0,0,0,0,0}
476 };
477
478
479 static param_export_t params[]={
480         {"ruri_matching",       PARAM_INT, &default_tm_cfg.ruri_matching         },
481         {"via1_matching",       PARAM_INT, &default_tm_cfg.via1_matching         },
482         {"fr_timer",            PARAM_INT, &default_tm_cfg.fr_timeout            },
483         {"fr_inv_timer",        PARAM_INT, &default_tm_cfg.fr_inv_timeout        },
484         {"fr_inv_timer_next",   PARAM_INT, &default_tm_cfg.fr_inv_timeout_next   },
485         {"wt_timer",            PARAM_INT, &default_tm_cfg.wait_timeout          },
486         {"delete_timer",        PARAM_INT, &default_tm_cfg.delete_timeout        },
487         {"retr_timer1",         PARAM_INT, &default_tm_cfg.rt_t1_timeout         },
488         {"retr_timer2"  ,       PARAM_INT, &default_tm_cfg.rt_t2_timeout         },
489         {"max_inv_lifetime",    PARAM_INT, &default_tm_cfg.tm_max_inv_lifetime   },
490         {"max_noninv_lifetime", PARAM_INT, &default_tm_cfg.tm_max_noninv_lifetime},
491         {"noisy_ctimer",        PARAM_INT, &default_tm_cfg.noisy_ctimer          },
492         {"auto_inv_100",        PARAM_INT, &default_tm_cfg.tm_auto_inv_100       },
493         {"auto_inv_100_reason", PARAM_STRING, &default_tm_cfg.tm_auto_inv_100_r  },
494         {"unix_tx_timeout",     PARAM_INT, &default_tm_cfg.tm_unix_tx_timeout    },
495         {"restart_fr_on_each_reply", PARAM_INT,
496                                                                         &default_tm_cfg.restart_fr_on_each_reply},
497         {"fr_timer_avp",        PARAM_STRING, &fr_timer_param                    },
498         {"fr_inv_timer_avp",    PARAM_STRING, &fr_inv_timer_param                },
499         {"tw_append",           PARAM_STRING|PARAM_USE_FUNC, 
500                                                                                                         (void*)parse_tw_append   },
501         {"pass_provisional_replies", PARAM_INT, 
502                                                                         &default_tm_cfg.pass_provisional_replies },
503         {"aggregate_challenges", PARAM_INT, &default_tm_cfg.tm_aggregate_auth    },
504         {"unmatched_cancel",    PARAM_INT, &default_tm_cfg.unmatched_cancel      },
505         {"default_code",        PARAM_INT, &default_tm_cfg.default_code          },
506         {"default_reason",      PARAM_STRING, &default_tm_cfg.default_reason     },
507         {"reparse_invite",      PARAM_INT, &default_tm_cfg.reparse_invite        },
508         {"ac_extra_hdrs",       PARAM_STR, &default_tm_cfg.ac_extra_hdrs         },
509         {"blst_503",            PARAM_INT, &default_tm_cfg.tm_blst_503           },
510         {"blst_503_def_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_default   },
511         {"blst_503_min_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_min       },
512         {"blst_503_max_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_max       },
513         {"blst_methods_add",    PARAM_INT, &default_tm_cfg.tm_blst_methods_add   },
514         {"blst_methods_lookup", PARAM_INT, &default_tm_cfg.tm_blst_methods_lookup},
515         {"cancel_b_method",     PARAM_INT, &default_tm_cfg.cancel_b_flags},
516         {"reparse_on_dns_failover", PARAM_INT, &default_tm_cfg.reparse_on_dns_failover},
517         {"on_sl_reply",         PARAM_STRING|PARAM_USE_FUNC, fixup_on_sl_reply   },
518         {"contacts_avp",        PARAM_STRING, &contacts_avp_param                },
519         {"disable_6xx_block",   PARAM_INT, &default_tm_cfg.disable_6xx           },
520         {"local_ack_mode",      PARAM_INT, &default_tm_cfg.local_ack_mode        },
521         {0,0,0}
522 };
523
524 #ifdef STATIC_TM
525 struct module_exports tm_exports = {
526 #else
527 struct module_exports exports= {
528 #endif
529         "tm",
530         /* -------- exported functions ----------- */
531         cmds,
532         tm_rpc,    /* RPC methods */
533         /* ------------ exported variables ---------- */
534         params,
535
536         mod_init, /* module initialization function */
537         (response_function) reply_received,
538         (destroy_function) tm_shutdown,
539         0, /* w_onbreak, */
540         child_init /* per-child init function */
541 };
542
543
544
545 /* helper for fixup_on_* */
546 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
547 {
548         int i;
549         
550         i=route_get(rt, (char*)*param);
551         if (i==-1){
552                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
553                 return E_UNSPEC;
554         }
555         if (r_type && rt->rlist[i]==0){
556                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
557                                 r_type, (char*)*param);
558         }
559         *param=(void*)(long)i;
560         return 0;
561 }
562
563 static int fixup_t_reply(void** param, int param_no)
564 {
565         if (param_no == 1) {
566                 if (fixup_var_int_12(param, 1) != 0) return -1;
567         } else if (param_no == 2) {
568                 return fixup_var_str_12(param, 2);
569         }
570     return 0;
571 }
572
573 static int fixup_on_failure(void** param, int param_no)
574 {
575         if (param_no==1){
576                 return fixup_routes("t_on_failure", &failure_rt, param);
577         }
578         return 0;
579 }
580
581
582
583 static int fixup_on_reply(void** param, int param_no)
584 {
585         if (param_no==1){
586                 return fixup_routes("t_on_reply", &onreply_rt, param);
587         }
588         return 0;
589 }
590
591
592
593 static int fixup_on_branch(void** param, int param_no)
594 {
595         if (param_no==1){
596                 return fixup_routes("t_on_branch", &branch_rt, param);
597         }
598         return 0;
599 }
600
601 static int fixup_on_sl_reply(modparam_t type, void* val)
602 {
603         if ((type & PARAM_STRING) == 0) {
604                 LOG(L_ERR, "ERROR: tm: fixup_on_sl_reply: not a string parameter\n");
605                 return -1;
606         }
607
608         if (fixup_routes(0, &onreply_rt, &val))
609                 return -1;
610
611         goto_on_sl_reply = (int)(long)val;
612         return 0;
613 }
614
615
616
617 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
618 static int fixup_hostport2proxy(void** param, int param_no)
619 {
620         unsigned int port;
621         char *host;
622         int err;
623         struct proxy_l *proxy;
624         action_u_t *a;
625         str s;
626
627         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
628         if (param_no==1){
629                 return 0;
630         } else if (param_no==2) {
631                 a = fixup_get_param(param, param_no, 1);
632                 host= a->u.string;
633                 port=str2s(*param, strlen(*param), &err);
634                 if (err!=0) {
635                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
636                                 (char*)(*param));
637                          return E_UNSPEC;
638                 }
639                 s.s = host;
640                 s.len = strlen(host);
641                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
642                 if (proxy==0) {
643                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
644                                 host );
645                         return E_BAD_ADDRESS;
646                 }
647                 /* success -- fix the first parameter to proxy now ! */
648
649                 a->u.data=proxy;
650                 return 0;
651         } else {
652                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
653                 return E_BUG;
654         }
655 }
656
657 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
658 static int fixup_proto_hostport2proxy(void** param, int param_no) {
659         int ret;
660
661         ret = fix_param(FPARAM_AVP, param);
662         if (ret <= 0) return ret;
663 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
664                 ret = fix_param(FPARAM_INT, param);
665                 if (ret <= 0) return ret;
666         } */
667         if (fix_param(FPARAM_STRING, param) != 0) return -1;
668         return 0;
669 }
670
671
672 static int fixup_t_check_status(void** param, int param_no)
673 {
674         int ret;
675
676         ret = fix_param(FPARAM_AVP, param);
677         if (ret <= 0) return ret;
678
679         ret = fix_param(FPARAM_SELECT, param);
680         if (ret <= 0) return ret;
681
682         if (fix_param(FPARAM_REGEX, param) != 0) return -1;
683         return 0;
684 }
685
686
687 /***************************** init functions *****************************/
688 static int w_t_unref( struct sip_msg *foo, unsigned int flags, void *bar)
689 {
690         return t_unref(foo);
691 }
692
693
694 static int script_init( struct sip_msg *foo, unsigned int flags, void *bar)
695 {
696         /* we primarily reset all private memory here to make sure
697          * private values left over from previous message will
698          * not be used again */
699
700         /* make sure the new message will not inherit previous
701                 message's t_on_negative value
702         */
703         t_on_negative( 0 );
704         t_on_reply(0);
705         t_on_branch(0);
706         /* reset the kr status */
707         reset_kr(0);
708         /* set request mode so that multiple-mode actions know
709          * how to behave */
710         set_route_type(REQUEST_ROUTE);
711
712 #ifdef POSTPONE_MSG_CLONING
713         lumps_are_cloned = 0;
714 #endif
715         return 1;
716 }
717
718
719 static int mod_init(void)
720 {
721         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
722                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
723
724         /* checking if we have sufficient bitmap capacity for given
725            maximum number of  branches */
726         if (MAX_BRANCHES+1>31) {
727                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
728                         MAX_BRANCHES );
729                 return -1;
730         }
731
732         if (init_callid() < 0) {
733                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
734                 return -1;
735         }
736
737         /* building the hash table*/
738         if (!init_hash_table()) {
739                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
740                 return -1;
741         }
742
743         /* init static hidden values */
744         init_t();
745
746         if (tm_init_selects()==-1) {
747                 LOG(L_ERR, "ERROR: mod_init: select init failed\n");
748                 return -1;
749         }
750
751         /* the default timer values must be fixed-up before
752          * declaring the configuration (Miklos) */
753         if (tm_init_timers()==-1) {
754                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
755                 return -1;
756         }
757         
758         /* the cancel branch flags must be fixed before declaring the 
759          * configuration */
760         if (cancel_b_flags_get(&default_tm_cfg.cancel_b_flags, 
761                                                         default_tm_cfg.cancel_b_flags)<0){
762                 LOG(L_ERR, "ERROR: mod_init: bad cancel branch method\n");
763                 return -1;
764         }
765
766 #ifdef USE_DNS_FAILOVER
767         if (default_tm_cfg.reparse_on_dns_failover && mhomed) {
768                 LOG(L_WARN, "WARNING: mod_init: "
769                         "reparse_on_dns_failover is enabled on a "
770                         "multihomed host -- check the readme of tm module!\n");
771         }
772 #endif
773
774         /* declare the configuration */
775         if (cfg_declare("tm", tm_cfg_def, &default_tm_cfg, cfg_sizeof(tm),
776                          &tm_cfg)) {
777                 LOG(L_ERR, "ERROR: mod_init: failed to declare the configuration\n");
778                 return -1;
779         }
780
781              /* First tm_stat initialization function only allocates the top level stat
782               * structure in shared memory, the initialization will complete in child
783               * init with init_tm_stats_child when the final value of estimated_process_count is
784               * known
785               */
786         if (init_tm_stats() < 0) {
787                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
788                 return -1;
789         }
790
791         if (uac_init()==-1) {
792                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
793                 return -1;
794         }
795
796         if (init_tmcb_lists()!=1) {
797                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
798                 return -1;
799         }
800         
801         tm_init_tags();
802         init_twrite_lines();
803         if (init_twrite_sock() < 0) {
804                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
805                 return -1;
806         }
807
808         /* register post-script clean-up function */
809         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQUEST_CB, 0)<0 ) {
810                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
811                         "callback\n");
812                 return -1;
813         }
814         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQUEST_CB , 0)<0 ) {
815                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
816                         "callback\n");
817                 return -1;
818         }
819
820         if (init_avp_params( fr_timer_param, fr_inv_timer_param,
821                                                  contacts_avp_param)<0 ){
822                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process AVP params\n");
823                 return -1;
824         }
825 #ifdef WITH_EVENT_LOCAL_REQUEST
826         goto_on_local_req=route_lookup(&event_rt, "tm:local-request");
827         if (goto_on_local_req>=0 && event_rt.rlist[goto_on_local_req]==0)
828                 goto_on_local_req=-1; /* disable */
829 #endif /* WITH_EVENT_LOCAL_REQUEST */
830         if (goto_on_sl_reply && onreply_rt.rlist[goto_on_sl_reply]==0)
831                 WARN("empty/non existing on_sl_reply route\n");
832         tm_init = 1;
833         return 0;
834 }
835
836 static int child_init(int rank)
837 {
838         if (rank == PROC_INIT) {
839                 /* we must init stats when rank==PROC_INIT: after mod_init we know
840                  * the exact number of processes and we must init the shared structure
841                  * before any other process is starting (or else some new process
842                  * might try to use the stats before the stats array is allocated) */
843                 if (init_tm_stats_child() < 0) {
844                         ERR("Error while initializing tm statistics structures\n");
845                         return -1;
846                 }
847         }else if (child_init_callid(rank) < 0) { 
848                 /* don't init callid for PROC_INIT*/
849                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID"
850                                 " generator\n");
851                 return -2;
852         }
853         return 0;
854 }
855
856
857
858
859
860 /**************************** wrapper functions ***************************/
861 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
862 {
863         regmatch_t pmatch;
864         struct cell *t;
865         char *status, *s = NULL;
866         char backup;
867         int lowest_status, n, ret;
868         fparam_t* fp;
869         regex_t* re = NULL;
870         str tmp;
871         
872         fp = (fparam_t*)p1;
873         
874         /* first get the transaction */
875         if (t_check(msg, 0 ) == -1) return -1;
876         if ((t = get_t()) == 0) {
877                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
878                         "which has no T-state established\n");
879                 goto error;
880         }
881         backup = 0;
882         
883         switch(fp->type) {
884         case FPARAM_REGEX:
885                 re = fp->v.regex;
886                 break;
887                 
888         default:
889                 /* AVP or select, get the value and compile the regex */
890                 if (get_str_fparam(&tmp, msg, fp) < 0) goto error;
891                 s = pkg_malloc(tmp.len + 1);
892                 if (s == NULL) {
893                         ERR("Out of memory\n");
894                         goto error;
895                 }
896                 memcpy(s, tmp.s, tmp.len);
897                 s[tmp.len] = '\0';
898                 
899                 if ((re = pkg_malloc(sizeof(regex_t))) == 0) {
900                         ERR("No memory left\n");
901                         goto error;
902                 }
903                 
904                 if (regcomp(re, s, REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
905                         ERR("Bad regular expression '%s'\n", s);
906                         goto error;
907                 }
908                 break;
909         }
910         
911         switch(route_type) {
912         case REQUEST_ROUTE:
913                 /* use the status of the last sent reply */
914                 status = int2str( t->uas.status, 0);
915                 break;
916                 
917         case ONREPLY_ROUTE:
918                 /* use the status of the current reply */
919                 status = msg->first_line.u.reply.status.s;
920                 backup = status[msg->first_line.u.reply.status.len];
921                 status[msg->first_line.u.reply.status.len] = 0;
922                 break;
923
924         case FAILURE_ROUTE:
925                 /* use the status of the winning reply */
926                 ret = t_pick_branch( -1, 0, t, &lowest_status);
927                 if (ret == -1) {
928                         /* t_pick_branch() retuns error also when there are only
929                          * blind UACs. Let us give it another chance including the
930                          * blind branches. */
931                         LOG(L_DBG, "DEBUG: t_check_status: t_pick_branch returned error, "
932                                 "trying t_pick_branch_blind\n");
933                         ret = t_pick_branch_blind(t, &lowest_status);
934                 }
935                 if (ret < 0) {
936                         LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
937                                 " a final response in FAILURE_ROUTE\n");
938                         goto error;
939                 }
940                 status = int2str( lowest_status , 0);
941                 break;
942
943         default:
944                 LOG(L_ERR,"ERROR:t_check_status: unsupported route type %d\n",route_type);
945                 goto error;
946         }
947
948         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
949         /* do the checking */
950         n = regexec(re, status, 1, &pmatch, 0);
951
952         if (backup) status[msg->first_line.u.reply.status.len] = backup;
953         if (s) pkg_free(s);
954         if ((fp->type != FPARAM_REGEX) && re) {
955                 regfree(re);
956                 pkg_free(re);
957         }
958
959         if (n!=0) return -1;
960         return 1;
961
962  error:
963         if (s) pkg_free(s);
964         if ((fp->type != FPARAM_REGEX) && re) {
965                 regfree(re);
966                 pkg_free(re);
967         }
968         return -1;
969 }
970
971
972 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
973 {
974         return (t_check_msg( msg , 0  )==1) ? 1 : -1;
975 }
976
977 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
978 {
979         struct cell *ret;
980         int i=0;
981         if (msg->REQ_METHOD==METHOD_CANCEL) {
982                 ret = t_lookupOriginalT( msg );
983                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
984                 if (ret != T_NULL_CELL) {
985                         /* If the parameter is set to 1, overwrite the message flags of
986                          * the CANCEL with the flags of the INVITE */
987                         if (str && (get_int_fparam(&i, msg, (fparam_t*)str)==0) && i)
988                                 msg->flags = ret->uas.request->flags;
989
990                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
991                         So we must unref it before returning. */
992                         UNREF(ret);
993                         return 1;
994                 }
995         } else {
996                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
997         }
998         return -1;
999 }
1000
1001 inline static int str2proto(char *s, int len) {
1002         if (len == 3 && !strncasecmp(s, "udp", 3))
1003                 return PROTO_UDP;
1004         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
1005                 return PROTO_TCP;
1006         else if (len == 3 && !strncasecmp(s, "tls", 3))
1007                 return PROTO_TLS;       
1008         else if (len == 4 && !strncasecmp(s, "sctp", 4))
1009                 return PROTO_SCTP;
1010         else
1011                 return PROTO_NONE;
1012 }
1013
1014 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
1015         struct proxy_l *proxy = 0;
1016         avp_t* avp;
1017         avp_value_t val;
1018         int proto, port, err;
1019         str s;
1020         char *c;
1021         
1022         switch(((fparam_t *)proto_par)->type) {
1023         case FPARAM_AVP:
1024                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
1025                         proto = PROTO_NONE;
1026                 } else {
1027                         if (avp->flags & AVP_VAL_STR) {
1028                                 proto = str2proto(val.s.s, val.s.len);
1029                         }
1030                         else {
1031                                 proto = val.n;
1032                         }
1033                 }
1034                 break;
1035
1036         case FPARAM_INT:
1037                 proto = ((fparam_t *)proto_par)->v.i;
1038                 break;
1039         case FPARAM_STRING:
1040                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
1041                 break;
1042         default:
1043                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
1044                 return 0;
1045         }
1046
1047
1048         switch(((fparam_t *)addr_par)->type) {
1049         case FPARAM_AVP:
1050                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
1051                         s.len = 0;
1052                 } else {
1053                         if ((avp->flags & AVP_VAL_STR) == 0) {
1054                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
1055                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
1056                                 return 0;
1057                         }
1058                         s = val.s;
1059                 }
1060                 break;
1061
1062         case FPARAM_STRING:
1063                 s.s = ((fparam_t *) addr_par)->v.asciiz;
1064                 s.len = strlen(s.s);
1065                 break;
1066
1067         default:
1068                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
1069                 return 0;
1070         }
1071
1072         port = 5060;
1073         if (s.len) {
1074                 c = memchr(s.s, ':', s.len);
1075                 if (c) {
1076                         port = str2s(c+1, s.len-(c-s.s+1), &err);
1077                         if (err!=0) {
1078                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
1079                                         s.len, s.s);
1080                                  return 0;
1081                         }
1082                         s.len = c-s.s;
1083                 }
1084         }
1085         if (!s.len) {
1086                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
1087                 return 0;
1088         }
1089         proxy=mk_proxy(&s, port, proto);
1090         if (proxy==0) {
1091                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
1092                         s.len, s.s );
1093                 return 0;
1094         }
1095         return proxy;
1096 }
1097
1098 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
1099         int proto)
1100 {
1101         struct cell *t;
1102         if (t_check( msg , 0 )==-1) {
1103                 LOG(L_ERR, "ERROR: forward_nonack: "
1104                                 "can't forward when no transaction was set up\n");
1105                 return -1;
1106         }
1107         t=get_t();
1108         if ( t && t!=T_UNDEFINED ) {
1109                 if (msg->REQ_METHOD==METHOD_ACK) {
1110                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
1111                         return -1;
1112                 }
1113                 return t_forward_nonack(t, msg, proxy, proto );
1114         } else {
1115                 DBG("DEBUG: forward_nonack: no transaction found\n");
1116                 return -1;
1117         }
1118 }
1119
1120
1121 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
1122                                                                                 char* foo)
1123 {
1124         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
1125 }
1126
1127
1128 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
1129                                                                                                                                         char *bar)
1130 {
1131         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
1132 }
1133
1134
1135 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
1136                                                                                 char* foo)
1137 {
1138         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
1139 }
1140
1141
1142 #ifdef USE_TCP
1143 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
1144                                                                                 char* foo)
1145 {
1146         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
1147 }
1148 #endif
1149
1150
1151 #ifdef USE_TLS
1152 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
1153                                                                                 char* foo)
1154 {
1155         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
1156 }
1157 #endif
1158
1159
1160 #ifdef USE_SCTP
1161 inline static int w_t_forward_nonack_sctp( struct sip_msg* msg, char* proxy,
1162                                                                                 char* foo)
1163 {
1164         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_SCTP);
1165 }
1166 #endif
1167
1168
1169 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
1170         char *proto_par, 
1171         char *addr_par   )
1172 {
1173         struct proxy_l *proxy;
1174         int r = -1;
1175         proxy = t_protoaddr2proxy(proto_par, addr_par);
1176         if (proxy) {
1177                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);            
1178                 free_proxy(proxy);
1179         }
1180         return r;
1181 }
1182
1183
1184 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
1185 {
1186         struct cell *t;
1187         int code, ret = -1;
1188         str reason;
1189         char* r;
1190
1191         if (msg->REQ_METHOD==METHOD_ACK) {
1192                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
1193                 return -1;
1194         }
1195         if (t_check( msg , 0 )==-1) return -1;
1196         t=get_t();
1197         if (!t) {
1198                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
1199                         "for which no T-state has been established\n");
1200                 return -1;
1201         }
1202
1203         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
1204             code = cfg_get(tm, tm_cfg, default_code);
1205         }
1206         
1207         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
1208                 r = cfg_get(tm, tm_cfg, default_reason);
1209         } else {
1210                 r = as_asciiz(&reason);
1211                 if (r == NULL) r = cfg_get(tm, tm_cfg, default_reason);
1212         }
1213         
1214         /* if called from reply_route, make sure that unsafe version
1215          * is called; we are already in a mutex and another mutex in
1216          * the safe version would lead to a deadlock
1217          */
1218          
1219         if (is_route_type(FAILURE_ROUTE)) {
1220                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
1221                 ret = t_reply_unsafe(t, msg, code, r);
1222         } else if (is_route_type(REQUEST_ROUTE)) {
1223                 ret = t_reply( t, msg, code, r);
1224         } else {
1225                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
1226                 ret = -1;
1227         }
1228
1229         if (r && (r != cfg_get(tm, tm_cfg, default_reason))) pkg_free(r);
1230         return ret;
1231 }
1232
1233
1234 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
1235 {
1236         struct cell *t;
1237         int ret;
1238         
1239         if (t_check( msg  , 0  )==-1) return -1;
1240         t=get_t();
1241         if ( t && t!=T_UNDEFINED ) {
1242                 ret = t_release_transaction( t );
1243                 t_unref(msg);
1244                 return ret;
1245         }
1246         return 1;
1247 }
1248
1249
1250 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
1251 {
1252         struct cell *t;
1253
1254
1255         if (t_check( p_msg  , 0 )==-1)
1256                 return 1;
1257         t=get_t();
1258         if (t) {
1259                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1260                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
1261                         return -1;
1262                 }
1263                 return t_retransmit_reply( t );
1264         } else
1265                 return -1;
1266 }
1267
1268
1269 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
1270 {
1271         /* t_newtran returns 0 on error (negative value means
1272            'transaction exists' */
1273         int ret;
1274         ret = t_newtran( p_msg );
1275         if (ret==E_SCRIPT) {
1276                 LOG(L_ERR, "ERROR: t_newtran: "
1277                         "transaction already in process %p\n", get_t() );
1278         }
1279         return ret;
1280 }
1281
1282
1283 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
1284 {
1285         t_on_negative( (unsigned int )(long) go_to );
1286         return 1;
1287 }
1288
1289 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
1290 {
1291         t_on_branch( (unsigned int )(long) go_to );
1292         return 1;
1293 }
1294
1295
1296 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
1297 {
1298         t_on_reply( (unsigned int )(long) go_to );
1299         return 1;
1300 }
1301
1302
1303
1304 inline static int _w_t_relay_to(struct sip_msg  *p_msg ,
1305                                                                         struct proxy_l *proxy, int force_proto)
1306 {
1307         struct cell *t;
1308
1309         if (is_route_type(FAILURE_ROUTE)) {
1310                 t=get_t();
1311                 if (!t || t==T_UNDEFINED) {
1312                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
1313                         return -1;
1314                 }
1315                 if (t_forward_nonack(t, p_msg, proxy, force_proto)<=0 ) {
1316                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
1317                         /* let us save the error code, we might need it later
1318                         when the failure_route has finished (Miklos) */
1319                         tm_error=ser_error;
1320                         return -1;
1321                 }
1322                 return 1;
1323         }
1324         if (is_route_type(REQUEST_ROUTE))
1325                 return t_relay_to( p_msg, proxy, force_proto,
1326                         0 /* no replication */ );
1327         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported route type: %d\n", route_type);
1328         return 0;
1329 }
1330
1331
1332 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
1333                                                                         char *proxy,/* struct proxy_l * expected */
1334                                                                         char *_foo       /* nothing expected */ )
1335 {
1336         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_UDP);
1337 }
1338
1339 /* forward to uri, but force udp as transport */
1340 inline static int w_t_relay_to_udp_uri( struct sip_msg  *p_msg ,
1341                                                                                 char *_foo, char *_bar   )
1342 {
1343         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_UDP);
1344 }
1345
1346
1347 #ifdef USE_TCP
1348 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
1349                                                                         char *proxy, /* struct proxy_l* */
1350                                                                         char *_foo       /* nothing expected */ )
1351 {
1352         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_TCP);
1353 }
1354
1355 /* forward to uri, but force tcp as transport */
1356 inline static int w_t_relay_to_tcp_uri( struct sip_msg  *p_msg ,
1357                                                                                 char *_foo, char *_bar   )
1358 {
1359         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_TCP);
1360 }
1361 #endif
1362
1363
1364 #ifdef USE_TLS
1365 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
1366                                                                         char *proxy, /* struct proxy_l* expected */
1367                                                                         char *_foo       /* nothing expected */ )
1368 {
1369         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_TLS);
1370 }
1371
1372 /* forward to uri, but force tls as transport */
1373 inline static int w_t_relay_to_tls_uri( struct sip_msg  *p_msg ,
1374                                                                                 char *_foo, char *_bar   )
1375 {
1376         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_TLS);
1377 }
1378 #endif
1379
1380
1381 #ifdef USE_SCTP
1382 inline static int w_t_relay_to_sctp( struct sip_msg  *p_msg ,
1383                                                                         char *proxy, /* struct proxy_l* */
1384                                                                         char *_foo       /* nothing expected */ )
1385 {
1386         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_SCTP);
1387 }
1388
1389 /* forward to uri, but force tcp as transport */
1390 inline static int w_t_relay_to_sctp_uri( struct sip_msg  *p_msg ,
1391                                                                                 char *_foo, char *_bar   )
1392 {
1393         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_SCTP);
1394 }
1395 #endif
1396
1397
1398 inline static int w_t_relay_to_avp( struct sip_msg  *p_msg ,
1399                                                                         char *proto_par, 
1400                                                                         char *addr_par   )
1401 {
1402         struct proxy_l *proxy;
1403         int r = -1;
1404         
1405         proxy = t_protoaddr2proxy(proto_par, addr_par);
1406         if (proxy) {
1407                 r = _w_t_relay_to(p_msg, proxy, PROTO_NONE);
1408                 free_proxy(proxy);
1409         }
1410         return r;
1411 }
1412
1413
1414 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1415         char *proxy, /* struct proxy_l *proxy expected */
1416         char *_foo       /* nothing expected */ )
1417 {
1418         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1419 }
1420
1421 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1422         char *proxy, /* struct proxy_l *proxy expected */
1423         char *_foo       /* nothing expected */ )
1424 {
1425         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1426 }
1427
1428
1429 #ifdef USE_TCP
1430 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1431         char *proxy, /* struct proxy_l *proxy expected */
1432         char *_foo       /* nothing expected */ )
1433 {
1434         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1435 }
1436 #endif
1437
1438
1439 #ifdef USE_TLS
1440 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1441         char *proxy, /* struct proxy_l *proxy expected */
1442         char *_foo       /* nothing expected */ )
1443 {
1444         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1445 }
1446 #endif
1447
1448
1449 #ifdef USE_SCTP
1450 inline static int w_t_replicate_sctp( struct sip_msg  *p_msg ,
1451         char *proxy, /* struct proxy_l *proxy expected */
1452         char *_foo       /* nothing expected */ )
1453 {
1454         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_SCTP );
1455 }
1456 #endif
1457
1458
1459 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1460         char *proto_par, 
1461         char *addr_par   )
1462 {
1463         struct proxy_l *proxy;
1464         int r = -1;
1465         proxy = t_protoaddr2proxy(proto_par, addr_par);
1466         if (proxy) {
1467                 r = t_replicate(p_msg, proxy, proxy->proto);            
1468                 free_proxy(proxy);
1469         }
1470         return r;
1471 }
1472
1473 inline static int w_t_relay( struct sip_msg  *p_msg ,
1474                                                                 char *_foo, char *_bar)
1475 {
1476         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_NONE);
1477 }
1478
1479
1480 /* like t_relay but use the specified destination and port and the same proto
1481  * as the received msg */
1482 static int w_t_relay2( struct sip_msg  *p_msg , char *proxy,
1483                                                                 char *_foo)
1484 {
1485         return _w_t_relay_to(p_msg, (struct proxy_l*) proxy, p_msg->rcv.proto);
1486 }
1487
1488
1489 /* relays CANCEL at the beginning of the script */
1490 inline static int w_t_relay_cancel( struct sip_msg  *p_msg ,
1491                                                 char *_foo, char *_bar)
1492 {
1493         if (p_msg->REQ_METHOD!=METHOD_CANCEL)
1494                 return 1;
1495
1496         /* it makes no sense to use this function without reparse_invite=1 */
1497         if (!cfg_get(tm, tm_cfg, reparse_invite))
1498                 LOG(L_WARN, "WARNING: t_relay_cancel is probably used with "
1499                         "wrong configuration, check the readme for details\n");
1500
1501         return t_relay_cancel(p_msg);
1502 }
1503
1504 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1505 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1506 {
1507     int fr, fr_inv;
1508
1509     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1510     if (p2) {
1511         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1512     } else {
1513         fr = 0;
1514     }
1515
1516     return t_set_fr(msg, fr_inv, fr);
1517 }
1518
1519 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1520 {
1521         return t_set_fr_all(msg, fr_inv, (char*)0);
1522 }
1523
1524 /* reset fr_timer and fr_inv_timer to the default values */
1525 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar)
1526 {
1527         return t_reset_fr();
1528 }
1529
1530 /* set retr. intervals per transaction; 0 means: use the default value */
1531 static int w_t_set_retr(struct sip_msg* msg, char* p1, char* p2)
1532 {
1533         int t1, t2;
1534         
1535         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1536         if (p2) {
1537                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1538         } else {
1539                 t2 = 0;
1540         }
1541 #ifdef TM_DIFF_RT_TIMEOUT
1542         return t_set_retr(msg, t1, t2);
1543 #else
1544         ERR("w_t_set_retr: support for changing retransmission intervals on "
1545                         "the fly not compiled in (re-compile tm with"
1546                         " -DTM_DIFF_RT_TIMEOUT)\n");
1547         return -1;
1548 #endif
1549 }
1550
1551 /* reset retr. t1 and t2 to the default values */
1552 int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar)
1553 {
1554 #ifdef TM_DIFF_RT_TIMEOUT
1555         return t_reset_retr();
1556 #else
1557         ERR("w_t_reset_retr: support for changing retransmission intervals on "
1558                         "the fly not compiled in (re-compile tm with"
1559                         " -DTM_DIFF_RT_TIMEOUT)\n");
1560         return -1;
1561 #endif
1562 }
1563
1564 /* set maximum transaction lifetime for inv & noninv */
1565 static int w_t_set_max_lifetime(struct sip_msg* msg, char* p1, char* p2)
1566 {
1567         int t1, t2;
1568         
1569         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1570         if (p2) {
1571                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1572         } else {
1573                 t2 = 0;
1574         }
1575         return t_set_max_lifetime(msg, t1, t2);
1576 }
1577
1578 /* reset maximum invite/non-invite lifetime to the default value */
1579 int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar)
1580 {
1581         return t_reset_max_lifetime();
1582 }
1583
1584
1585
1586 /* helper macro, builds a function for setting a cell flag from the script.
1587    e.g. T_SET_FLAG_GEN_FUNC(t_set_foo, T_FOO) =>
1588    static int t_set_foo(struct sip_msg* msg, char*, char* )
1589    that will expect fparam as first param and will set or reset T_FOO
1590    in the current or next to be created transaction. */
1591 #define T_SET_FLAG_GEN_FUNC(fname, T_FLAG_NAME) \
1592 static int fname(struct sip_msg* msg, char* p1, char* p2) \
1593 { \
1594         int state; \
1595         struct cell* t; \
1596         unsigned int set_flags; \
1597         unsigned int reset_flags; \
1598          \
1599         if (get_int_fparam(&state, msg, (fparam_t*)p1) < 0) return -1; \
1600         t=get_t(); \
1601         /* in REPLY_ROUTE and FAILURE_ROUTE T will be set to current transaction; \
1602          * in REQUEST_ROUTE T will be set only if the transaction was already  \
1603          * created; if not -> use the static variables */ \
1604         if (!t || t==T_UNDEFINED ){ \
1605                 set_flags=get_msgid_val(user_cell_set_flags, msg->id, int); \
1606                 reset_flags=get_msgid_val(user_cell_reset_flags, msg->id, int); \
1607                 if (state){ \
1608                         /* set */ \
1609                         set_flags|= T_FLAG_NAME; \
1610                         reset_flags&=~T_FLAG_NAME; \
1611                 }else{ \
1612                         /* reset */ \
1613                         set_flags&=~T_FLAG_NAME; \
1614                         reset_flags|=T_FLAG_NAME; \
1615                 } \
1616                 set_msgid_val(user_cell_set_flags, msg->id, int, set_flags); \
1617                 set_msgid_val(user_cell_reset_flags, msg->id, int, reset_flags); \
1618         }else{ \
1619                 if (state) \
1620                         t->flags|=T_FLAG_NAME; \
1621                 else \
1622                         t->flags&=~T_FLAG_NAME; \
1623         } \
1624         return 1; \
1625 }
1626
1627
1628
1629 /* set automatically sending 100 replies on/off for the current or
1630  * next to be created transaction */
1631 T_SET_FLAG_GEN_FUNC(t_set_auto_inv_100, T_AUTO_INV_100)
1632
1633
1634 /* set 6xx handling for the current or next to be created transaction */
1635 T_SET_FLAG_GEN_FUNC(t_set_disable_6xx, T_DISABLE_6xx)
1636
1637
1638 /* disable dns failover for the current transaction */
1639 T_SET_FLAG_GEN_FUNC(t_set_disable_failover, T_DISABLE_FAILOVER)
1640
1641
1642
1643 /* script function, FAILURE_ROUTE only, returns true if the 
1644  * choosed "failure" branch failed because of a timeout, 
1645  * -1 otherwise */
1646 int t_branch_timeout(struct sip_msg* msg, char* foo, char* bar)
1647 {
1648         return (msg->msg_flags & FL_TIMEOUT)?1:-1;
1649 }
1650
1651
1652
1653 /* script function, FAILURE_ROUTE only, returns true if the 
1654  * choosed "failure" branch ever received a reply, -1 otherwise */
1655 int t_branch_replied(struct sip_msg* msg, char* foo, char* bar)
1656 {
1657         return (msg->msg_flags & FL_REPLIED)?1:-1;
1658 }
1659
1660
1661
1662 /* script function, returns: 1 if the transaction was canceled, -1 if not */
1663 int t_is_canceled(struct sip_msg* msg, char* foo, char* bar)
1664 {
1665         struct cell *t;
1666         int ret;
1667         
1668         
1669         if (t_check( msg , 0 )==-1) return -1;
1670         t=get_t();
1671         if ((t==0) || (t==T_UNDEFINED)){
1672                 LOG(L_ERR, "ERROR: t_is_canceled: cannot check a message "
1673                         "for which no T-state has been established\n");
1674                 ret=-1;
1675         }else{
1676                 ret=(t->flags & T_CANCELED)?1:-1;
1677         }
1678         return ret;
1679 }
1680
1681 /* script function, returns: 1 if the transaction lifetime interval has already elapsed, -1 if not */
1682 int t_is_expired(struct sip_msg* msg, char* foo, char* bar)
1683 {
1684         struct cell *t;
1685         int ret;
1686         
1687         
1688         if (t_check( msg , 0 )==-1) return -1;
1689         t=get_t();
1690         if ((t==0) || (t==T_UNDEFINED)){
1691                 LOG(L_ERR, "ERROR: t_is_expired: cannot check a message "
1692                         "for which no T-state has been established\n");
1693                 ret=-1;
1694         }else{
1695                 ret=(TICKS_GT(t->end_of_life, get_ticks_raw()))?-1:1;
1696         }
1697         return ret;
1698 }
1699
1700 /* script function, returns: 1 if any of the branches did timeout, -1 if not */
1701 int t_any_timeout(struct sip_msg* msg, char* foo, char* bar)
1702 {
1703         struct cell *t;
1704         int r;
1705         
1706         if (t_check( msg , 0 )==-1) return -1;
1707         t=get_t();
1708         if ((t==0) || (t==T_UNDEFINED)){
1709                 LOG(L_ERR, "ERROR: t_any_timeout: cannot check a message "
1710                         "for which no T-state has been established\n");
1711                 return -1;
1712         }else{
1713                 for (r=0; r<t->nr_of_outgoings; r++){
1714                         if (t->uac[r].request.flags & F_RB_TIMEOUT)
1715                                 return 1;
1716                 }
1717         }
1718         return -1;
1719 }
1720
1721
1722
1723 /* script function, returns: 1 if any of the branches received at leat one
1724  * reply, -1 if not */
1725 int t_any_replied(struct sip_msg* msg, char* foo, char* bar)
1726 {
1727         struct cell *t;
1728         int r;
1729         
1730         if (t_check( msg , 0 )==-1) return -1;
1731         t=get_t();
1732         if ((t==0) || (t==T_UNDEFINED)){
1733                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1734                         "for which no T-state has been established\n");
1735                 return -1;
1736         }else{
1737                 for (r=0; r<t->nr_of_outgoings; r++){
1738                         if (t->uac[r].request.flags & F_RB_REPLIED)
1739                                 return 1;
1740                 }
1741         }
1742         return -1;
1743 }
1744
1745
1746
1747 /* script function, returns: 1 if any of the branches received the
1748  *  reply code "status" */
1749 int t_grep_status(struct sip_msg* msg, char* status, char* bar)
1750 {
1751         struct cell *t;
1752         int r;
1753         int code;
1754         
1755     if (get_int_fparam(&code, msg, (fparam_t*)status) < 0) return -1;
1756         if (t_check( msg , 0 )==-1) return -1;
1757         t=get_t();
1758         if ((t==0) || (t==T_UNDEFINED)){
1759                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1760                         "for which no T-state has been established\n");
1761                 return -1;
1762         }else{
1763                 for (r=0; r<t->nr_of_outgoings; r++){
1764                         if ((t->uac[r].last_received==code)  && 
1765                                         (t->uac[r].request.flags & F_RB_REPLIED))
1766                                 return 1;
1767                 }
1768         }
1769         return -1;
1770 }
1771
1772 /* drop all the existing replies in failure_route to make sure
1773  * that none of them is picked up again */
1774 static int w_t_drop_replies(struct sip_msg* msg, char* foo, char* bar)
1775 {
1776         t_drop_replies();
1777         return 1;
1778 }
1779
1780 /* save the message lumps after t_newtran() but before t_relay() */
1781 static int w_t_save_lumps(struct sip_msg* msg, char* foo, char* bar)
1782 {
1783 #ifdef POSTPONE_MSG_CLONING
1784         struct cell *t;
1785
1786         t=get_t();
1787         if (!t || t==T_UNDEFINED) {
1788                 LOG(L_ERR, "ERROR: w_t_save_lumps: transaction has not been created yet\n");
1789                 return -1;
1790         }
1791
1792         if (save_msg_lumps(t->uas.request, msg)) {
1793                 LOG(L_ERR, "ERROR: w_t_save_lumps: "
1794                         "failed to save the message lumps\n");
1795                 return -1;
1796         }
1797         return 1;
1798 #else
1799         LOG(L_ERR, "ERROR: w_t_save_lumps: POSTPONE_MSG_CLONING is not defined,"
1800                         " thus, the functionality is not supported\n");
1801         return -1;
1802 #endif
1803 }
1804
1805 static rpc_export_t tm_rpc[] = {
1806         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
1807         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
1808         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
1809         {"tm.hash_stats",  tm_rpc_hash_stats, tm_rpc_hash_stats_doc, 0},
1810         {"tm.t_uac_start", rpc_t_uac_start, rpc_t_uac_start_doc, 0 },
1811         {"tm.t_uac_wait",  rpc_t_uac_wait,  rpc_t_uac_wait_doc, RET_ARRAY},
1812         {0, 0, 0, 0}
1813 };
1814
1815 /* wrapper function needed after changes in w_t_reply */
1816 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1817 {
1818         fparam_t c;
1819         fparam_t r;
1820         
1821         c.type = FPARAM_INT;
1822         c.orig = NULL; /* ? */
1823         c.v.i = code;
1824         
1825         r.type = FPARAM_STRING;
1826         r.orig = NULL; /* ? */
1827         r.v.asciiz = txt;
1828
1829         return w_t_reply(m, (char *)&c, (char*)&r);
1830 }
1831
1832
1833
1834 /** script function, check if a msg is assoc. to a transaction.
1835  * @return -1 (not), 1 (reply, e2e ack or cancel for an existing transaction),
1836  *          0 (request retransmission, ack to negative reply or ack to local
1837  *           transaction)
1838  * Note: the e2e ack matching works only for local e2e acks or for
1839  *       transactions with E2EACK* callbacks installed (but even in this
1840  *       case matching E2EACKs on proxied transaction is not entirely
1841  *       reliable: if the ACK  is delayed the proxied transaction might
1842  *       be already deleted when it reaches the proxy (wait_timeout))
1843  */
1844 static int t_check_trans(struct sip_msg* msg, char* foo, char* bar)
1845 {
1846         struct cell* t;
1847         
1848         if (msg->first_line.type==SIP_REPLY)
1849                 return w_t_check(msg, 0 ,0);
1850         else if (msg->REQ_METHOD==METHOD_CANCEL)
1851                 return w_t_lookup_cancel(msg, 0, 0);
1852         else{
1853                 switch(t_check_msg(msg, 0)){
1854                         case -2: /* possible e2e ack */
1855                                 return 1;
1856                         case 1: /* found */
1857                                 t=get_t();
1858                                 if (msg->REQ_METHOD==METHOD_ACK){
1859                                         /* ack to neg. reply  or ack to local trans.
1860                                            => process it and end the script */
1861                                         /* FIXME: there's no way to distinguish here 
1862                                            between acks to local trans. and neg. acks */
1863                                         if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
1864                                                 run_trans_callbacks(TMCB_ACK_NEG_IN, t, msg,
1865                                                                                         0, msg->REQ_METHOD);
1866                                         t_release_transaction(t);
1867                                 } else {
1868                                         /* is a retransmission */
1869                                         if (unlikely(has_tran_tmcbs(t, TMCB_REQ_RETR_IN)))
1870                                                 run_trans_callbacks(TMCB_REQ_RETR_IN, t, msg,
1871                                                                                         0, msg->REQ_METHOD);
1872                                         t_retransmit_reply(t);
1873                                 }
1874                                 /* no need for UNREF(t); set_t(0) - the end-of-script
1875                                    t_unref callback will take care of them */
1876                                 return 0; /* return from the script */
1877                 }
1878                 /* not found or error */
1879         }
1880         return -1;
1881 }