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