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