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