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