d9b8bbfde45242c8dbdd49450f834805061453fa
[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_ms      },
486         {"retr_timer2"  ,       PARAM_INT, &default_tm_cfg.rt_t2_timeout_ms      },
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         {"faked_reply_prio",    PARAM_INT, &faked_reply_prio                     },
521 #ifdef CANCEL_REASON_SUPPORT
522         {"local_cancel_reason", PARAM_INT, &default_tm_cfg.local_cancel_reason   },
523         {"e2e_cancel_reason",   PARAM_INT, &default_tm_cfg.e2e_cancel_reason     },
524 #endif /* CANCEL_REASON_SUPPORT */
525         {0,0,0}
526 };
527
528 #ifdef STATIC_TM
529 struct module_exports tm_exports = {
530 #else
531 struct module_exports exports= {
532 #endif
533         "tm",
534         /* -------- exported functions ----------- */
535         cmds,
536         tm_rpc,    /* RPC methods */
537         /* ------------ exported variables ---------- */
538         params,
539
540         mod_init, /* module initialization function */
541         (response_function) reply_received,
542         (destroy_function) tm_shutdown,
543         0, /* w_onbreak, */
544         child_init /* per-child init function */
545 };
546
547
548
549 /* helper for fixup_on_* */
550 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
551 {
552         int i;
553         
554         i=route_get(rt, (char*)*param);
555         if (i==-1){
556                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
557                 return E_UNSPEC;
558         }
559         if (r_type && rt->rlist[i]==0){
560                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
561                                 r_type, (char*)*param);
562         }
563         *param=(void*)(long)i;
564         return 0;
565 }
566
567 static int fixup_t_reply(void** param, int param_no)
568 {
569         if (param_no == 1) {
570                 if (fixup_var_int_12(param, 1) != 0) return -1;
571         } else if (param_no == 2) {
572                 return fixup_var_str_12(param, 2);
573         }
574     return 0;
575 }
576
577 static int fixup_on_failure(void** param, int param_no)
578 {
579         if (param_no==1){
580                 if(strlen((char*)*param)<=1
581                                 && (*(char*)(*param)==0 || *(char*)(*param)=='0')) {
582                         *param = (void*)0;
583                         return 0;
584                 }
585                 return fixup_routes("t_on_failure", &failure_rt, param);
586         }
587         return 0;
588 }
589
590
591
592 static int fixup_on_reply(void** param, int param_no)
593 {
594         if (param_no==1){
595                 if(strlen((char*)*param)<=1
596                                 && (*(char*)(*param)==0 || *(char*)(*param)=='0')) {
597                         *param = (void*)0;
598                         return 0;
599                 }
600                 return fixup_routes("t_on_reply", &onreply_rt, param);
601         }
602         return 0;
603 }
604
605
606
607 static int fixup_on_branch(void** param, int param_no)
608 {
609         if (param_no==1){
610                 if(strlen((char*)*param)<=1
611                                 && (*(char*)(*param)==0 || *(char*)(*param)=='0')) {
612                         *param = (void*)0;
613                         return 0;
614                 }
615                 return fixup_routes("t_on_branch", &branch_rt, param);
616         }
617         return 0;
618 }
619
620 static int fixup_on_sl_reply(modparam_t type, void* val)
621 {
622         if ((type & PARAM_STRING) == 0) {
623                 LOG(L_ERR, "ERROR: tm: fixup_on_sl_reply: not a string parameter\n");
624                 return -1;
625         }
626
627         if (fixup_routes(0, &onreply_rt, &val))
628                 return -1;
629
630         goto_on_sl_reply = (int)(long)val;
631         return 0;
632 }
633
634
635
636 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
637 static int fixup_hostport2proxy(void** param, int param_no)
638 {
639         unsigned int port;
640         char *host;
641         int err;
642         struct proxy_l *proxy;
643         action_u_t *a;
644         str s;
645
646         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
647         if (param_no==1){
648                 return 0;
649         } else if (param_no==2) {
650                 a = fixup_get_param(param, param_no, 1);
651                 host= a->u.string;
652                 port=str2s(*param, strlen(*param), &err);
653                 if (err!=0) {
654                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
655                                 (char*)(*param));
656                          return E_UNSPEC;
657                 }
658                 s.s = host;
659                 s.len = strlen(host);
660                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
661                 if (proxy==0) {
662                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
663                                 host );
664                         return E_BAD_ADDRESS;
665                 }
666                 /* success -- fix the first parameter to proxy now ! */
667
668                 a->u.data=proxy;
669                 return 0;
670         } else {
671                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
672                 return E_BUG;
673         }
674 }
675
676 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
677 static int fixup_proto_hostport2proxy(void** param, int param_no) {
678         int ret;
679
680         ret = fix_param(FPARAM_AVP, param);
681         if (ret <= 0) return ret;
682 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
683                 ret = fix_param(FPARAM_INT, param);
684                 if (ret <= 0) return ret;
685         } */
686         if (fix_param(FPARAM_STRING, param) != 0) return -1;
687         return 0;
688 }
689
690
691 static int fixup_t_check_status(void** param, int param_no)
692 {
693         int ret;
694
695         ret = fix_param(FPARAM_AVP, param);
696         if (ret <= 0) return ret;
697
698         ret = fix_param(FPARAM_SELECT, param);
699         if (ret <= 0) return ret;
700
701         if (fix_param(FPARAM_REGEX, param) != 0) return -1;
702         return 0;
703 }
704
705
706 /***************************** init functions *****************************/
707 static int w_t_unref( struct sip_msg *foo, unsigned int flags, void *bar)
708 {
709         return t_unref(foo);
710 }
711
712
713 static int script_init( struct sip_msg *foo, unsigned int flags, void *bar)
714 {
715         /* we primarily reset all private memory here to make sure
716          * private values left over from previous message will
717          * not be used again */
718
719         /* make sure the new message will not inherit previous
720                 message's t_on_negative value
721         */
722         t_on_negative( 0 );
723         t_on_reply(0);
724         t_on_branch(0);
725         /* reset the kr status */
726         reset_kr();
727         /* set request mode so that multiple-mode actions know
728          * how to behave */
729         set_route_type(REQUEST_ROUTE);
730         lumps_are_cloned = 0;
731         return 1;
732 }
733
734
735 static int mod_init(void)
736 {
737         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
738                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
739
740         /* checking if we have sufficient bitmap capacity for given
741            maximum number of  branches */
742         if (MAX_BRANCHES+1>31) {
743                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
744                         MAX_BRANCHES );
745                 return -1;
746         }
747
748         if (init_callid() < 0) {
749                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
750                 return -1;
751         }
752
753         /* building the hash table*/
754         if (!init_hash_table()) {
755                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
756                 return -1;
757         }
758
759         /* init static hidden values */
760         init_t();
761
762         if (tm_init_selects()==-1) {
763                 LOG(L_ERR, "ERROR: mod_init: select init failed\n");
764                 return -1;
765         }
766
767         /* the default timer values must be fixed-up before
768          * declaring the configuration (Miklos) */
769         if (tm_init_timers()==-1) {
770                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
771                 return -1;
772         }
773         
774         /* the cancel branch flags must be fixed before declaring the 
775          * configuration */
776         if (cancel_b_flags_get(&default_tm_cfg.cancel_b_flags, 
777                                                         default_tm_cfg.cancel_b_flags)<0){
778                 LOG(L_ERR, "ERROR: mod_init: bad cancel branch method\n");
779                 return -1;
780         }
781
782 #ifdef USE_DNS_FAILOVER
783         if (default_tm_cfg.reparse_on_dns_failover && mhomed) {
784                 LOG(L_WARN, "WARNING: mod_init: "
785                         "reparse_on_dns_failover is enabled on a "
786                         "multihomed host -- check the readme of tm module!\n");
787         }
788 #endif
789
790         /* declare the configuration */
791         if (cfg_declare("tm", tm_cfg_def, &default_tm_cfg, cfg_sizeof(tm),
792                          &tm_cfg)) {
793                 LOG(L_ERR, "ERROR: mod_init: failed to declare the configuration\n");
794                 return -1;
795         }
796
797              /* First tm_stat initialization function only allocates the top level stat
798               * structure in shared memory, the initialization will complete in child
799               * init with init_tm_stats_child when the final value of estimated_process_count is
800               * known
801               */
802         if (init_tm_stats() < 0) {
803                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
804                 return -1;
805         }
806
807         if (uac_init()==-1) {
808                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
809                 return -1;
810         }
811
812         if (init_tmcb_lists()!=1) {
813                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
814                 return -1;
815         }
816         
817         tm_init_tags();
818         init_twrite_lines();
819         if (init_twrite_sock() < 0) {
820                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
821                 return -1;
822         }
823
824         /* register post-script clean-up function */
825         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQUEST_CB, 0)<0 ) {
826                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
827                         "callback\n");
828                 return -1;
829         }
830         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQUEST_CB , 0)<0 ) {
831                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
832                         "callback\n");
833                 return -1;
834         }
835
836         if (init_avp_params( fr_timer_param, fr_inv_timer_param,
837                                                  contacts_avp_param)<0 ){
838                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process AVP params\n");
839                 return -1;
840         }
841 #ifdef WITH_EVENT_LOCAL_REQUEST
842         goto_on_local_req=route_lookup(&event_rt, "tm:local-request");
843         if (goto_on_local_req>=0 && event_rt.rlist[goto_on_local_req]==0)
844                 goto_on_local_req=-1; /* disable */
845 #endif /* WITH_EVENT_LOCAL_REQUEST */
846         if (goto_on_sl_reply && onreply_rt.rlist[goto_on_sl_reply]==0)
847                 WARN("empty/non existing on_sl_reply route\n");
848         tm_init = 1;
849         return 0;
850 }
851
852 static int child_init(int rank)
853 {
854         if (rank == PROC_INIT) {
855                 /* we must init stats when rank==PROC_INIT: after mod_init we know
856                  * the exact number of processes and we must init the shared structure
857                  * before any other process is starting (or else some new process
858                  * might try to use the stats before the stats array is allocated) */
859                 if (init_tm_stats_child() < 0) {
860                         ERR("Error while initializing tm statistics structures\n");
861                         return -1;
862                 }
863         }else if (child_init_callid(rank) < 0) { 
864                 /* don't init callid for PROC_INIT*/
865                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID"
866                                 " generator\n");
867                 return -2;
868         }
869         return 0;
870 }
871
872
873
874
875
876 /**************************** wrapper functions ***************************/
877 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
878 {
879         regmatch_t pmatch;
880         struct cell *t;
881         char *status, *s = NULL;
882         char backup;
883         int lowest_status, n, ret;
884         fparam_t* fp;
885         regex_t* re = NULL;
886         str tmp;
887         
888         fp = (fparam_t*)p1;
889         t = 0;
890         /* first get the transaction */
891         if (t_check(msg, 0 ) == -1) return -1;
892         if ((t = get_t()) == 0) {
893                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
894                         "which has no T-state established\n");
895                 goto error;
896         }
897         backup = 0;
898         
899         switch(fp->type) {
900         case FPARAM_REGEX:
901                 re = fp->v.regex;
902                 break;
903                 
904         default:
905                 /* AVP or select, get the value and compile the regex */
906                 if (get_str_fparam(&tmp, msg, fp) < 0) goto error;
907                 s = pkg_malloc(tmp.len + 1);
908                 if (s == NULL) {
909                         ERR("Out of memory\n");
910                         goto error;
911                 }
912                 memcpy(s, tmp.s, tmp.len);
913                 s[tmp.len] = '\0';
914                 
915                 if ((re = pkg_malloc(sizeof(regex_t))) == 0) {
916                         ERR("No memory left\n");
917                         goto error;
918                 }
919                 
920                 if (regcomp(re, s, REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
921                         ERR("Bad regular expression '%s'\n", s);
922                         goto error;
923                 }
924                 break;
925         }
926         
927         switch(get_route_type()) {
928         case REQUEST_ROUTE:
929                 /* use the status of the last sent reply */
930                 status = int2str( t->uas.status, 0);
931                 break;
932                 
933         case TM_ONREPLY_ROUTE:
934         case CORE_ONREPLY_ROUTE:
935                 /* use the status of the current reply */
936                 status = msg->first_line.u.reply.status.s;
937                 backup = status[msg->first_line.u.reply.status.len];
938                 status[msg->first_line.u.reply.status.len] = 0;
939                 break;
940
941         case FAILURE_ROUTE:
942                 /* use the status of the winning reply */
943                 ret = t_pick_branch( -1, 0, t, &lowest_status);
944                 if (ret == -1) {
945                         /* t_pick_branch() retuns error also when there are only
946                          * blind UACs. Let us give it another chance including the
947                          * blind branches. */
948                         LOG(L_DBG, "DEBUG: t_check_status: t_pick_branch returned error, "
949                                 "trying t_pick_branch_blind\n");
950                         ret = t_pick_branch_blind(t, &lowest_status);
951                 }
952                 if (ret < 0) {
953                         LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
954                                 " a final response in FAILURE_ROUTE\n");
955                         goto error;
956                 }
957                 status = int2str( lowest_status , 0);
958                 break;
959
960         default:
961                 LOG(L_ERR,"ERROR:t_check_status: unsupported route type %d\n",
962                                 get_route_type());
963                 goto error;
964         }
965
966         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
967         /* do the checking */
968         n = regexec(re, status, 1, &pmatch, 0);
969
970         if (backup) status[msg->first_line.u.reply.status.len] = backup;
971         if (s) pkg_free(s);
972         if ((fp->type != FPARAM_REGEX) && re) {
973                 regfree(re);
974                 pkg_free(re);
975         }
976         
977         if (unlikely(t && is_route_type(CORE_ONREPLY_ROUTE))){
978                 /* t_check() above has the side effect of setting T and
979                    REFerencing T => we must unref and unset it.  */
980                 UNREF( t );
981                 set_t(T_UNDEFINED, T_BR_UNDEFINED);
982         }
983         if (n!=0) return -1;
984         return 1;
985
986  error:
987         if (unlikely(t && is_route_type(CORE_ONREPLY_ROUTE))){
988                 /* t_check() above has the side effect of setting T and
989                    REFerencing T => we must unref and unset it.  */
990                 UNREF( t );
991                 set_t(T_UNDEFINED, T_BR_UNDEFINED);
992         }
993         if (s) pkg_free(s);
994         if ((fp->type != FPARAM_REGEX) && re) {
995                 regfree(re);
996                 pkg_free(re);
997         }
998         return -1;
999 }
1000
1001
1002 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
1003 {
1004         return (t_check_msg( msg , 0  )==1) ? 1 : -1;
1005 }
1006
1007 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
1008 {
1009         struct cell *ret;
1010         int i=0;
1011         if (msg->REQ_METHOD==METHOD_CANCEL) {
1012                 ret = t_lookupOriginalT( msg );
1013                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
1014                 if (ret != T_NULL_CELL) {
1015                         /* If the parameter is set to 1, overwrite the message flags of
1016                          * the CANCEL with the flags of the INVITE */
1017                         if (str && (get_int_fparam(&i, msg, (fparam_t*)str)==0) && i)
1018                                 msg->flags = ret->uas.request->flags;
1019
1020                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
1021                         So we must unref it before returning. */
1022                         UNREF(ret);
1023                         return 1;
1024                 }
1025         } else {
1026                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
1027         }
1028         return -1;
1029 }
1030
1031 inline static int str2proto(char *s, int len) {
1032         if (len == 3 && !strncasecmp(s, "udp", 3))
1033                 return PROTO_UDP;
1034         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
1035                 return PROTO_TCP;
1036         else if (len == 3 && !strncasecmp(s, "tls", 3))
1037                 return PROTO_TLS;       
1038         else if (len == 4 && !strncasecmp(s, "sctp", 4))
1039                 return PROTO_SCTP;
1040         else
1041                 return PROTO_NONE;
1042 }
1043
1044 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
1045         struct proxy_l *proxy = 0;
1046         avp_t* avp;
1047         avp_value_t val;
1048         int proto, port, err;
1049         str s;
1050         char *c;
1051         
1052         switch(((fparam_t *)proto_par)->type) {
1053         case FPARAM_AVP:
1054                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
1055                         proto = PROTO_NONE;
1056                 } else {
1057                         if (avp->flags & AVP_VAL_STR) {
1058                                 proto = str2proto(val.s.s, val.s.len);
1059                         }
1060                         else {
1061                                 proto = val.n;
1062                         }
1063                 }
1064                 break;
1065
1066         case FPARAM_INT:
1067                 proto = ((fparam_t *)proto_par)->v.i;
1068                 break;
1069         case FPARAM_STRING:
1070                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
1071                 break;
1072         default:
1073                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
1074                 return 0;
1075         }
1076
1077
1078         switch(((fparam_t *)addr_par)->type) {
1079         case FPARAM_AVP:
1080                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
1081                         s.len = 0;
1082                 } else {
1083                         if ((avp->flags & AVP_VAL_STR) == 0) {
1084                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
1085                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
1086                                 return 0;
1087                         }
1088                         s = val.s;
1089                 }
1090                 break;
1091
1092         case FPARAM_STRING:
1093                 s.s = ((fparam_t *) addr_par)->v.asciiz;
1094                 s.len = strlen(s.s);
1095                 break;
1096
1097         default:
1098                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
1099                 return 0;
1100         }
1101
1102         port = 5060;
1103         if (s.len) {
1104                 c = memchr(s.s, ':', s.len);
1105                 if (c) {
1106                         port = str2s(c+1, s.len-(c-s.s+1), &err);
1107                         if (err!=0) {
1108                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
1109                                         s.len, s.s);
1110                                  return 0;
1111                         }
1112                         s.len = c-s.s;
1113                 }
1114         }
1115         if (!s.len) {
1116                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
1117                 return 0;
1118         }
1119         proxy=mk_proxy(&s, port, proto);
1120         if (proxy==0) {
1121                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
1122                         s.len, s.s );
1123                 return 0;
1124         }
1125         return proxy;
1126 }
1127
1128 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
1129         int proto)
1130 {
1131         struct cell *t;
1132         if (t_check( msg , 0 )==-1) {
1133                 LOG(L_ERR, "ERROR: forward_nonack: "
1134                                 "can't forward when no transaction was set up\n");
1135                 return -1;
1136         }
1137         t=get_t();
1138         if ( t && t!=T_UNDEFINED ) {
1139                 if (msg->REQ_METHOD==METHOD_ACK) {
1140                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
1141                         return -1;
1142                 }
1143                 return t_forward_nonack(t, msg, proxy, proto );
1144         } else {
1145                 DBG("DEBUG: forward_nonack: no transaction found\n");
1146                 return -1;
1147         }
1148 }
1149
1150
1151 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
1152                                                                                 char* foo)
1153 {
1154         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
1155 }
1156
1157
1158 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
1159                                                                                                                                         char *bar)
1160 {
1161         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
1162 }
1163
1164
1165 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
1166                                                                                 char* foo)
1167 {
1168         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
1169 }
1170
1171
1172 #ifdef USE_TCP
1173 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
1174                                                                                 char* foo)
1175 {
1176         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
1177 }
1178 #endif
1179
1180
1181 #ifdef USE_TLS
1182 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
1183                                                                                 char* foo)
1184 {
1185         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
1186 }
1187 #endif
1188
1189
1190 #ifdef USE_SCTP
1191 inline static int w_t_forward_nonack_sctp( struct sip_msg* msg, char* proxy,
1192                                                                                 char* foo)
1193 {
1194         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_SCTP);
1195 }
1196 #endif
1197
1198
1199 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
1200         char *proto_par, 
1201         char *addr_par   )
1202 {
1203         struct proxy_l *proxy;
1204         int r = -1;
1205         proxy = t_protoaddr2proxy(proto_par, addr_par);
1206         if (proxy) {
1207                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);            
1208                 free_proxy(proxy);
1209                 pkg_free(proxy);
1210         }
1211         return r;
1212 }
1213
1214
1215 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
1216 {
1217         struct cell *t;
1218         int code, ret = -1;
1219         str reason;
1220         char* r;
1221
1222         if (msg->REQ_METHOD==METHOD_ACK) {
1223                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
1224                 return -1;
1225         }
1226         if (t_check( msg , 0 )==-1) return -1;
1227         t=get_t();
1228         if (!t) {
1229                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
1230                         "for which no T-state has been established\n");
1231                 return -1;
1232         }
1233
1234         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
1235             code = cfg_get(tm, tm_cfg, default_code);
1236         }
1237         
1238         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
1239                 r = cfg_get(tm, tm_cfg, default_reason);
1240         } else {
1241                 r = as_asciiz(&reason);
1242                 if (r == NULL) r = cfg_get(tm, tm_cfg, default_reason);
1243         }
1244         
1245         /* if called from reply_route, make sure that unsafe version
1246          * is called; we are already in a mutex and another mutex in
1247          * the safe version would lead to a deadlock
1248          */
1249          
1250         if (is_route_type(FAILURE_ROUTE)) {
1251                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
1252                 ret = t_reply_unsafe(t, msg, code, r);
1253         } else if (is_route_type(REQUEST_ROUTE)) {
1254                 ret = t_reply( t, msg, code, r);
1255         } else if (is_route_type(ONREPLY_ROUTE)) {
1256                 if (likely(t->uas.request)){
1257                         if (is_route_type(CORE_ONREPLY_ROUTE))
1258                                 ret=t_reply(t, t->uas.request, code, r);
1259                         else
1260                                 ret=t_reply_unsafe(t, t->uas.request, code, r);
1261                 }else
1262                         ret=-1;
1263                 /* t_check() above has the side effect of setting T and
1264                    REFerencing T => we must unref and unset it.
1265                    Note: this is needed only in the CORE_ONREPLY_ROUTE and not also in
1266                    the TM_ONREPLY_ROUTE.
1267                  */
1268                 if (is_route_type(CORE_ONREPLY_ROUTE)) {
1269                         UNREF( t );
1270                         set_t(T_UNDEFINED, T_BR_UNDEFINED);
1271                 }
1272         } else {
1273                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
1274                 ret = -1;
1275         }
1276
1277         if (r && (r != cfg_get(tm, tm_cfg, default_reason))) pkg_free(r);
1278         return ret;
1279 }
1280
1281
1282 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
1283 {
1284         struct cell *t;
1285         int ret;
1286         
1287         if (t_check( msg  , 0  )==-1) return -1;
1288         t=get_t();
1289         if ( t && t!=T_UNDEFINED ) {
1290                 ret = t_release_transaction( t );
1291                 t_unref(msg);
1292                 return ret;
1293         }
1294         return 1;
1295 }
1296
1297
1298 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
1299 {
1300         struct cell *t;
1301
1302
1303         if (t_check( p_msg  , 0 )==-1)
1304                 return 1;
1305         t=get_t();
1306         if (t) {
1307                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1308                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
1309                         return -1;
1310                 }
1311                 return t_retransmit_reply( t );
1312         } else
1313                 return -1;
1314 }
1315
1316
1317 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
1318 {
1319         /* t_newtran returns 0 on error (negative value means
1320            'transaction exists' */
1321         int ret;
1322         ret = t_newtran( p_msg );
1323         if (ret==E_SCRIPT) {
1324                 LOG(L_ERR, "ERROR: t_newtran: "
1325                         "transaction already in process %p\n", get_t() );
1326         }
1327         return ret;
1328 }
1329
1330
1331 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
1332 {
1333         t_on_negative( (unsigned int )(long) go_to );
1334         return 1;
1335 }
1336
1337 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
1338 {
1339         t_on_branch( (unsigned int )(long) go_to );
1340         return 1;
1341 }
1342
1343
1344 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
1345 {
1346         t_on_reply( (unsigned int )(long) go_to );
1347         return 1;
1348 }
1349
1350
1351
1352 inline static int _w_t_relay_to(struct sip_msg  *p_msg ,
1353                                                                         struct proxy_l *proxy, int force_proto)
1354 {
1355         struct cell *t;
1356         int res;
1357
1358         if (is_route_type(FAILURE_ROUTE)) {
1359                 t=get_t();
1360                 if (!t || t==T_UNDEFINED) {
1361                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
1362                         return -1;
1363                 }
1364                 res = t_forward_nonack(t, p_msg, proxy, force_proto);
1365                 if (res <= 0) {
1366                         if (res != E_CFG) {
1367                             LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
1368                             /* let us save the error code, we might need it later
1369                                when the failure_route has finished (Miklos) */
1370                         }
1371                         tm_error=ser_error;
1372                         return -1;
1373                 }
1374                 return 1;
1375         }
1376         if (is_route_type(REQUEST_ROUTE))
1377                 return t_relay_to( p_msg, proxy, force_proto,
1378                                                         0 /* no replication */ );
1379         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported route type: %d\n",
1380                         get_route_type());
1381         return 0;
1382 }
1383
1384
1385 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
1386                                                                         char *proxy,/* struct proxy_l * expected */
1387                                                                         char *_foo       /* nothing expected */ )
1388 {
1389         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_UDP);
1390 }
1391
1392 /* forward to uri, but force udp as transport */
1393 inline static int w_t_relay_to_udp_uri( struct sip_msg  *p_msg ,
1394                                                                                 char *_foo, char *_bar   )
1395 {
1396         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_UDP);
1397 }
1398
1399
1400 #ifdef USE_TCP
1401 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
1402                                                                         char *proxy, /* struct proxy_l* */
1403                                                                         char *_foo       /* nothing expected */ )
1404 {
1405         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_TCP);
1406 }
1407
1408 /* forward to uri, but force tcp as transport */
1409 inline static int w_t_relay_to_tcp_uri( struct sip_msg  *p_msg ,
1410                                                                                 char *_foo, char *_bar   )
1411 {
1412         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_TCP);
1413 }
1414 #endif
1415
1416
1417 #ifdef USE_TLS
1418 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
1419                                                                         char *proxy, /* struct proxy_l* expected */
1420                                                                         char *_foo       /* nothing expected */ )
1421 {
1422         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_TLS);
1423 }
1424
1425 /* forward to uri, but force tls as transport */
1426 inline static int w_t_relay_to_tls_uri( struct sip_msg  *p_msg ,
1427                                                                                 char *_foo, char *_bar   )
1428 {
1429         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_TLS);
1430 }
1431 #endif
1432
1433
1434 #ifdef USE_SCTP
1435 inline static int w_t_relay_to_sctp( struct sip_msg  *p_msg ,
1436                                                                         char *proxy, /* struct proxy_l* */
1437                                                                         char *_foo       /* nothing expected */ )
1438 {
1439         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy, PROTO_SCTP);
1440 }
1441
1442 /* forward to uri, but force tcp as transport */
1443 inline static int w_t_relay_to_sctp_uri( struct sip_msg  *p_msg ,
1444                                                                                 char *_foo, char *_bar   )
1445 {
1446         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_SCTP);
1447 }
1448 #endif
1449
1450
1451 inline static int w_t_relay_to_avp( struct sip_msg  *p_msg ,
1452                                                                         char *proto_par, 
1453                                                                         char *addr_par   )
1454 {
1455         struct proxy_l *proxy;
1456         int r = -1;
1457         
1458         proxy = t_protoaddr2proxy(proto_par, addr_par);
1459         if (proxy) {
1460                 r = _w_t_relay_to(p_msg, proxy, PROTO_NONE);
1461                 free_proxy(proxy);
1462                 pkg_free(proxy);
1463         }
1464         return r;
1465 }
1466
1467 inline static int w_t_replicate_uri(struct sip_msg  *msg ,
1468                                 char *uri,       /* sip uri as string or variable */
1469                                 char *_foo       /* nothing expected */ )
1470 {
1471         struct proxy_l *proxy;
1472         struct sip_uri turi;
1473         str suri;
1474         int r = -1;
1475
1476         memset(&turi, 0, sizeof(struct sip_uri));
1477         if(fixup_get_svalue(msg, (gparam_p)uri, &suri)!=0)
1478         {
1479                 LM_ERR("invalid replicate uri parameter");
1480                 return -1;
1481         }
1482         if(parse_uri(suri.s, suri.len, &turi)!=0)
1483         {
1484                 LM_ERR("bad replicate SIP address!\n");
1485                 return -1;
1486         }
1487
1488         proxy=mk_proxy(&turi.host, turi.port_no, turi.proto);
1489         if (proxy==0) {
1490                 LM_ERR("cannot create proxy from URI <%.*s>\n",
1491                         suri.len, suri.s );
1492                 return -1;
1493         }
1494
1495         r = t_replicate(msg, proxy, proxy->proto);
1496         free_proxy(proxy);
1497         pkg_free(proxy);
1498         return r;
1499
1500 }
1501
1502 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1503         char *proxy, /* struct proxy_l *proxy expected */
1504         char *_foo       /* nothing expected */ )
1505 {
1506         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1507 }
1508
1509 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1510         char *proxy, /* struct proxy_l *proxy expected */
1511         char *_foo       /* nothing expected */ )
1512 {
1513         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1514 }
1515
1516
1517 #ifdef USE_TCP
1518 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1519         char *proxy, /* struct proxy_l *proxy expected */
1520         char *_foo       /* nothing expected */ )
1521 {
1522         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1523 }
1524 #endif
1525
1526
1527 #ifdef USE_TLS
1528 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1529         char *proxy, /* struct proxy_l *proxy expected */
1530         char *_foo       /* nothing expected */ )
1531 {
1532         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1533 }
1534 #endif
1535
1536
1537 #ifdef USE_SCTP
1538 inline static int w_t_replicate_sctp( struct sip_msg  *p_msg ,
1539         char *proxy, /* struct proxy_l *proxy expected */
1540         char *_foo       /* nothing expected */ )
1541 {
1542         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_SCTP );
1543 }
1544 #endif
1545
1546
1547 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1548         char *proto_par, 
1549         char *addr_par   )
1550 {
1551         struct proxy_l *proxy;
1552         int r = -1;
1553         proxy = t_protoaddr2proxy(proto_par, addr_par);
1554         if (proxy) {
1555                 r = t_replicate(p_msg, proxy, proxy->proto);
1556                 free_proxy(proxy);
1557                 pkg_free(proxy);
1558         }
1559         return r;
1560 }
1561
1562 inline static int w_t_relay( struct sip_msg  *p_msg ,
1563                                                                 char *_foo, char *_bar)
1564 {
1565         return _w_t_relay_to(p_msg, (struct proxy_l *)0, PROTO_NONE);
1566 }
1567
1568
1569 /* like t_relay but use the specified destination and port and the same proto
1570  * as the received msg */
1571 static int w_t_relay2( struct sip_msg  *p_msg , char *proxy,
1572                                                                 char *_foo)
1573 {
1574         return _w_t_relay_to(p_msg, (struct proxy_l*) proxy, p_msg->rcv.proto);
1575 }
1576
1577
1578 /* relays CANCEL at the beginning of the script */
1579 inline static int w_t_relay_cancel( struct sip_msg  *p_msg ,
1580                                                 char *_foo, char *_bar)
1581 {
1582         if (p_msg->REQ_METHOD!=METHOD_CANCEL)
1583                 return 1;
1584
1585         /* it makes no sense to use this function without reparse_invite=1 */
1586         if (!cfg_get(tm, tm_cfg, reparse_invite))
1587                 LOG(L_WARN, "WARNING: t_relay_cancel is probably used with "
1588                         "wrong configuration, check the readme for details\n");
1589
1590         return t_relay_cancel(p_msg);
1591 }
1592
1593 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1594 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1595 {
1596     int fr, fr_inv;
1597
1598     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1599     if (p2) {
1600         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1601     } else {
1602         fr = 0;
1603     }
1604
1605     return t_set_fr(msg, fr_inv, fr);
1606 }
1607
1608 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1609 {
1610         return t_set_fr_all(msg, fr_inv, (char*)0);
1611 }
1612
1613 /* reset fr_timer and fr_inv_timer to the default values */
1614 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar)
1615 {
1616         return t_reset_fr();
1617 }
1618
1619 /* set retr. intervals per transaction; 0 means: use the default value */
1620 static int w_t_set_retr(struct sip_msg* msg, char* p1, char* p2)
1621 {
1622         int t1, t2;
1623         
1624         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1625         if (p2) {
1626                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1627         } else {
1628                 t2 = 0;
1629         }
1630 #ifdef TM_DIFF_RT_TIMEOUT
1631         return t_set_retr(msg, t1, t2);
1632 #else
1633         ERR("w_t_set_retr: support for changing retransmission intervals on "
1634                         "the fly not compiled in (re-compile tm with"
1635                         " -DTM_DIFF_RT_TIMEOUT)\n");
1636         return -1;
1637 #endif
1638 }
1639
1640 /* reset retr. t1 and t2 to the default values */
1641 int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar)
1642 {
1643 #ifdef TM_DIFF_RT_TIMEOUT
1644         return t_reset_retr();
1645 #else
1646         ERR("w_t_reset_retr: support for changing retransmission intervals on "
1647                         "the fly not compiled in (re-compile tm with"
1648                         " -DTM_DIFF_RT_TIMEOUT)\n");
1649         return -1;
1650 #endif
1651 }
1652
1653 /* set maximum transaction lifetime for inv & noninv */
1654 static int w_t_set_max_lifetime(struct sip_msg* msg, char* p1, char* p2)
1655 {
1656         int t1, t2;
1657         
1658         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1659         if (p2) {
1660                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1661         } else {
1662                 t2 = 0;
1663         }
1664         return t_set_max_lifetime(msg, t1, t2);
1665 }
1666
1667 /* reset maximum invite/non-invite lifetime to the default value */
1668 int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar)
1669 {
1670         return t_reset_max_lifetime();
1671 }
1672
1673
1674
1675 /* helper macro, builds a function for setting a cell flag from the script.
1676    e.g. T_SET_FLAG_GEN_FUNC(t_set_foo, T_FOO) =>
1677    static int t_set_foo(struct sip_msg* msg, char*, char* )
1678    that will expect fparam as first param and will set or reset T_FOO
1679    in the current or next to be created transaction. */
1680 #define T_SET_FLAG_GEN_FUNC(fname, T_FLAG_NAME) \
1681 static int fname(struct sip_msg* msg, char* p1, char* p2) \
1682 { \
1683         int state; \
1684         struct cell* t; \
1685         unsigned int set_flags; \
1686         unsigned int reset_flags; \
1687          \
1688         if (get_int_fparam(&state, msg, (fparam_t*)p1) < 0) return -1; \
1689         t=get_t(); \
1690         /* in REPLY_ROUTE and FAILURE_ROUTE T will be set to current transaction; \
1691          * in REQUEST_ROUTE T will be set only if the transaction was already  \
1692          * created; if not -> use the static variables */ \
1693         if (!t || t==T_UNDEFINED ){ \
1694                 set_flags=get_msgid_val(user_cell_set_flags, msg->id, int); \
1695                 reset_flags=get_msgid_val(user_cell_reset_flags, msg->id, int); \
1696                 if (state){ \
1697                         /* set */ \
1698                         set_flags|= T_FLAG_NAME; \
1699                         reset_flags&=~T_FLAG_NAME; \
1700                 }else{ \
1701                         /* reset */ \
1702                         set_flags&=~T_FLAG_NAME; \
1703                         reset_flags|=T_FLAG_NAME; \
1704                 } \
1705                 set_msgid_val(user_cell_set_flags, msg->id, int, set_flags); \
1706                 set_msgid_val(user_cell_reset_flags, msg->id, int, reset_flags); \
1707         }else{ \
1708                 if (state) \
1709                         t->flags|=T_FLAG_NAME; \
1710                 else \
1711                         t->flags&=~T_FLAG_NAME; \
1712         } \
1713         return 1; \
1714 }
1715
1716
1717
1718 /* set automatically sending 100 replies on/off for the current or
1719  * next to be created transaction */
1720 T_SET_FLAG_GEN_FUNC(t_set_auto_inv_100, T_AUTO_INV_100)
1721
1722
1723 /* set 6xx handling for the current or next to be created transaction */
1724 T_SET_FLAG_GEN_FUNC(t_set_disable_6xx, T_DISABLE_6xx)
1725
1726
1727 /* disable dns failover for the current transaction */
1728 T_SET_FLAG_GEN_FUNC(t_set_disable_failover, T_DISABLE_FAILOVER)
1729
1730
1731 #ifdef CANCEL_REASON_SUPPORT
1732 /* disable/enable e2e cancel reason copy for the current transaction */
1733 T_SET_FLAG_GEN_FUNC(t_set_no_e2e_cancel_reason, T_NO_E2E_CANCEL_REASON)
1734 #endif /* CANCEL_REASON_SUPPORT */
1735
1736
1737 /* script function, FAILURE_ROUTE only, returns true if the 
1738  * choosed "failure" branch failed because of a timeout, 
1739  * -1 otherwise */
1740 int t_branch_timeout(struct sip_msg* msg, char* foo, char* bar)
1741 {
1742         return (msg->msg_flags & FL_TIMEOUT)?1:-1;
1743 }
1744
1745
1746
1747 /* script function, FAILURE_ROUTE only, returns true if the 
1748  * choosed "failure" branch ever received a reply, -1 otherwise */
1749 int t_branch_replied(struct sip_msg* msg, char* foo, char* bar)
1750 {
1751         return (msg->msg_flags & FL_REPLIED)?1:-1;
1752 }
1753
1754
1755
1756 /* script function, returns: 1 if the transaction was canceled, -1 if not */
1757 int t_is_canceled(struct sip_msg* msg)
1758 {
1759         struct cell *t;
1760         int ret;
1761         
1762         
1763         if (t_check( msg , 0 )==-1) return -1;
1764         t=get_t();
1765         if ((t==0) || (t==T_UNDEFINED)){
1766                 LOG(L_ERR, "ERROR: t_is_canceled: cannot check a message "
1767                         "for which no T-state has been established\n");
1768                 ret=-1;
1769         }else{
1770                 ret=(t->flags & T_CANCELED)?1:-1;
1771         }
1772         return ret;
1773 }
1774
1775 static int w_t_is_canceled(struct sip_msg* msg, char* foo, char* bar)
1776 {
1777         return t_is_canceled(msg);
1778 }
1779
1780 /* script function, returns: 1 if the transaction lifetime interval has already elapsed, -1 if not */
1781 int t_is_expired(struct sip_msg* msg, char* foo, char* bar)
1782 {
1783         struct cell *t;
1784         int ret;
1785         
1786         
1787         if (t_check( msg , 0 )==-1) return -1;
1788         t=get_t();
1789         if ((t==0) || (t==T_UNDEFINED)){
1790                 LOG(L_ERR, "ERROR: t_is_expired: cannot check a message "
1791                         "for which no T-state has been established\n");
1792                 ret=-1;
1793         }else{
1794                 ret=(TICKS_GT(t->end_of_life, get_ticks_raw()))?-1:1;
1795         }
1796         return ret;
1797 }
1798
1799 /* script function, returns: 1 if any of the branches did timeout, -1 if not */
1800 int t_any_timeout(struct sip_msg* msg, char* foo, char* bar)
1801 {
1802         struct cell *t;
1803         int r;
1804         
1805         if (t_check( msg , 0 )==-1) return -1;
1806         t=get_t();
1807         if ((t==0) || (t==T_UNDEFINED)){
1808                 LOG(L_ERR, "ERROR: t_any_timeout: cannot check a message "
1809                         "for which no T-state has been established\n");
1810                 return -1;
1811         }else{
1812                 for (r=0; r<t->nr_of_outgoings; r++){
1813                         if (t->uac[r].request.flags & F_RB_TIMEOUT)
1814                                 return 1;
1815                 }
1816         }
1817         return -1;
1818 }
1819
1820
1821
1822 /* script function, returns: 1 if any of the branches received at leat one
1823  * reply, -1 if not */
1824 int t_any_replied(struct sip_msg* msg, char* foo, char* bar)
1825 {
1826         struct cell *t;
1827         int r;
1828         
1829         if (t_check( msg , 0 )==-1) return -1;
1830         t=get_t();
1831         if ((t==0) || (t==T_UNDEFINED)){
1832                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1833                         "for which no T-state has been established\n");
1834                 return -1;
1835         }else{
1836                 for (r=0; r<t->nr_of_outgoings; r++){
1837                         if (t->uac[r].request.flags & F_RB_REPLIED)
1838                                 return 1;
1839                 }
1840         }
1841         return -1;
1842 }
1843
1844
1845
1846 /* script function, returns: 1 if any of the branches received the
1847  *  reply code "status" */
1848 int t_grep_status(struct sip_msg* msg, char* status, char* bar)
1849 {
1850         struct cell *t;
1851         int r;
1852         int code;
1853         
1854     if (get_int_fparam(&code, msg, (fparam_t*)status) < 0) return -1;
1855         if (t_check( msg , 0 )==-1) return -1;
1856         t=get_t();
1857         if ((t==0) || (t==T_UNDEFINED)){
1858                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1859                         "for which no T-state has been established\n");
1860                 return -1;
1861         }else{
1862                 for (r=0; r<t->nr_of_outgoings; r++){
1863                         if ((t->uac[r].last_received==code)  && 
1864                                         (t->uac[r].request.flags & F_RB_REPLIED))
1865                                 return 1;
1866                 }
1867         }
1868         return -1;
1869 }
1870
1871 /* drop all the existing replies in failure_route to make sure
1872  * that none of them is picked up again */
1873 static int w_t_drop_replies(struct sip_msg* msg, char* foo, char* bar)
1874 {
1875         if(foo==NULL)
1876                 t_drop_replies(1);
1877         else if(*foo=='n')
1878                 t_drop_replies(0);
1879         else if(*foo=='l')
1880                 t_drop_replies(2);
1881         else
1882                 t_drop_replies(1);
1883         return 1;
1884 }
1885
1886 /* save the message lumps after t_newtran() but before t_relay() */
1887 static int w_t_save_lumps(struct sip_msg* msg, char* foo, char* bar)
1888 {
1889         struct cell *t;
1890
1891         if (is_route_type(REQUEST_ROUTE)) {
1892                 t=get_t();
1893                 if (!t || t==T_UNDEFINED) {
1894                         LOG(L_ERR, "ERROR: w_t_save_lumps: transaction has not been created yet\n");
1895                         return -1;
1896                 }
1897
1898                 if (save_msg_lumps(t->uas.request, msg)) {
1899                         LOG(L_ERR, "ERROR: w_t_save_lumps: "
1900                                 "failed to save the message lumps\n");
1901                         return -1;
1902                 }
1903         } /* else nothing to do, the lumps have already been saved */
1904         return 1;
1905 }
1906
1907
1908
1909 /* wrapper function needed after changes in w_t_reply */
1910 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1911 {
1912         fparam_t c;
1913         fparam_t r;
1914         
1915         c.type = FPARAM_INT;
1916         c.orig = NULL; /* ? */
1917         c.v.i = code;
1918         
1919         r.type = FPARAM_STRING;
1920         r.orig = NULL; /* ? */
1921         r.v.asciiz = txt;
1922
1923         return w_t_reply(m, (char *)&c, (char*)&r);
1924 }
1925
1926
1927
1928 /** script function, check if a msg is assoc. to a transaction.
1929  * @return -1 (not), 1 (reply, e2e ack or cancel for an existing transaction),
1930  *          0 (request retransmission, ack to negative reply or ack to local
1931  *           transaction)
1932  * Note: the e2e ack matching works only for local e2e acks or for
1933  *       transactions with E2EACK* callbacks installed (but even in this
1934  *       case matching E2EACKs on proxied transaction is not entirely
1935  *       reliable: if the ACK  is delayed the proxied transaction might
1936  *       be already deleted when it reaches the proxy (wait_timeout))
1937  */
1938 int t_check_trans(struct sip_msg* msg)
1939 {
1940         struct cell* t;
1941         int branch;
1942         int ret;
1943         
1944         if (msg->first_line.type==SIP_REPLY) {
1945                 branch = 0;
1946                 ret = (t_check_msg( msg , &branch)==1) ? 1 : -1;
1947                 tm_ctx_set_branch_index(branch);
1948                 return ret;
1949         } else if (msg->REQ_METHOD==METHOD_CANCEL) {
1950                 return w_t_lookup_cancel(msg, 0, 0);
1951         } else {
1952                 switch(t_check_msg(msg, 0)){
1953                         case -2: /* possible e2e ack */
1954                                 return 1;
1955                         case 1: /* found */
1956                                 t=get_t();
1957                                 if (msg->REQ_METHOD==METHOD_ACK){
1958                                         /* ack to neg. reply  or ack to local trans.
1959                                            => process it and end the script */
1960                                         /* FIXME: there's no way to distinguish here 
1961                                            between acks to local trans. and neg. acks */
1962                                         if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
1963                                                 run_trans_callbacks(TMCB_ACK_NEG_IN, t, msg,
1964                                                                                         0, msg->REQ_METHOD);
1965                                         t_release_transaction(t);
1966                                 } else {
1967                                         /* is a retransmission */
1968                                         if (unlikely(has_tran_tmcbs(t, TMCB_REQ_RETR_IN)))
1969                                                 run_trans_callbacks(TMCB_REQ_RETR_IN, t, msg,
1970                                                                                         0, msg->REQ_METHOD);
1971                                         t_retransmit_reply(t);
1972                                 }
1973                                 /* no need for UNREF(t); set_t(0) - the end-of-script
1974                                    t_unref callback will take care of them */
1975                                 return 0; /* return from the script */
1976                 }
1977                 /* not found or error */
1978         }
1979         return -1;
1980 }
1981
1982 static int w_t_check_trans(struct sip_msg* msg, char* foo, char* bar)
1983 {
1984         return t_check_trans(msg);
1985 }
1986
1987 static int hexatoi(str *s, unsigned int* result)
1988 {
1989         int i, xv, fact;
1990
1991         /* more than 32bit hexa? */
1992         if (s->len>8)
1993                 return -1;
1994
1995         *result = 0;
1996         fact = 1;
1997
1998         for(i=s->len-1; i>=0 ;i--)
1999         {
2000                 xv = hex2int(s->s[i]);
2001                 if(xv<0)
2002                         return -1;
2003
2004                 *result += (xv * fact);
2005                 fact *= 16;
2006         }
2007         return 0;
2008 }
2009
2010 static int fixup_t_relay_to(void** param, int param_no)
2011 {
2012
2013         int port;
2014         int proto;
2015         unsigned int flags;
2016         struct proxy_l *proxy;
2017         action_u_t *a;
2018         str s;
2019         str host;
2020
2021         s.s = (char*)*param;
2022         s.len = strlen(s.s);
2023         LM_DBG("fixing (%s, %d)\n", s.s, param_no);
2024         if (param_no==1){
2025                 a = fixup_get_param(param, param_no, 2);
2026                 if(a==NULL)
2027                 {
2028                         LM_CRIT("server error for parameter <%s>\n",s.s);
2029                         return E_UNSPEC;
2030                 }
2031                 if(a->u.string!=NULL) {
2032                         /* second parameter set, first should be proxy addr */
2033                         if (parse_phostport(s.s, &host.s, &host.len, &port, &proto)!=0){
2034                                 LM_CRIT("invalid proxy addr parameter <%s>\n",s.s);
2035                                 return E_UNSPEC;
2036                         }
2037
2038                         proxy = mk_proxy(&host, port, proto);
2039                         if (proxy==0) {
2040                                 LM_ERR("failed to build proxy structure for <%.*s>\n", host.len, host.s );
2041                                 return E_UNSPEC;
2042                         }
2043                         *(param)=proxy;
2044                         return 0;
2045                 } else {
2046                         /* no second parameter, then is proxy addr or flags */
2047                         flags = 0;
2048                         if (s.len>2 && s.s[0]=='0' && s.s[1]=='x') {
2049                                 s.s += 2;
2050                                 s.len -= 2;
2051                                 if(hexatoi(&s, &flags)<0)
2052                                 {
2053                                         LM_CRIT("invalid hexa flags <%s>\n", s.s);
2054                                         return E_UNSPEC;
2055                                 }
2056                                 a->u.data = (void*)(unsigned long int)flags;
2057                                 *(param)= 0;
2058                                 return 0;
2059                         } else {
2060                                 if(str2int(&s, &flags)==0)
2061                                 {
2062                                         a->u.data = (void*)(unsigned long int)flags;
2063                                         *(param)= 0;
2064                                         return 0;
2065                                 } else {
2066                                         /* try proxy */
2067                                         if (parse_phostport(s.s, &host.s, &host.len, &port, &proto)!=0){
2068                                                 LM_CRIT("invalid proxy addr parameter <%s>\n",s.s);
2069                                                 return E_UNSPEC;
2070                                         }
2071
2072                                         proxy = mk_proxy(&host, port, proto);
2073                                         if (proxy==0) {
2074                                                 LM_ERR("failed to build proxy structure for <%.*s>\n", host.len, host.s );
2075                                                 return E_UNSPEC;
2076                                         }
2077                                         *(param)=proxy;
2078                                         return 0;
2079                                 }
2080                         }
2081                 }
2082         } else if (param_no==2) {
2083                 /* flags */
2084                 flags = 0;
2085                 if (s.len>2 && s.s[0]=='0' && s.s[1]=='x') {
2086                         s.s += 2;
2087                         s.len -= 2;
2088                         if(hexatoi(&s, &flags)<0)
2089                         {
2090                                 LM_CRIT("invalid hexa flags <%s>\n", s.s);
2091                                 return E_UNSPEC;
2092                         }
2093                         *(param) = (void*)(unsigned long int)flags;
2094                         return 0;
2095                 } else {
2096                         if(str2int(&s, &flags)==0)
2097                         {
2098                                 *(param) = (void*)(unsigned long int)flags;
2099                                 return 0;
2100                         } else {
2101                                 LM_CRIT("invalid flags <%s>\n", s.s);
2102                                 return E_UNSPEC;
2103                         }
2104                 }
2105         } else {
2106                 LM_ERR("invalid parameter number %d\n", param_no);
2107                 return E_BUG;
2108         }
2109 }
2110
2111
2112 inline static int w_t_relay_to(struct sip_msg *msg, char *proxy, char *flags)
2113 {
2114         unsigned int fl;
2115         struct proxy_l *px;
2116         fparam_t param;
2117
2118         fl = (unsigned int)(long)(void*)flags;
2119         px = (struct proxy_l*)proxy;
2120
2121         if(flags!=0)
2122         {
2123                 memset(&param, 0, sizeof(fparam_t));
2124                 param.type = FPARAM_INT;
2125                 /* no auto 100 trying */
2126                 if(fl&1) {
2127                         param.v.i = 0;
2128                         t_set_auto_inv_100(msg, (char*)(&param), 0);
2129                 }
2130                 /* no auto negative reply - not implemented */
2131                 /*
2132                 if(fl&2) {
2133                         param.v.i = 1;
2134                         t_set_disable_internal_reply(msg, (char*)param, 0);
2135                 }
2136                 */
2137                 /* no dns failover */
2138                 if(fl&4) {
2139                         param.v.i = 1;
2140                         t_set_disable_failover(msg, (char*)(&param), 0);
2141                 }
2142         }
2143         return _w_t_relay_to(msg, px, PROTO_NONE);
2144 }
2145
2146
2147
2148 /* rpc docs */
2149
2150 static const char* rpc_cancel_doc[2] = {
2151         "Cancel a pending transaction",
2152         0
2153 };
2154
2155 static const char* rpc_reply_doc[2] = {
2156         "Reply transaction",
2157         0
2158 };
2159
2160 static const char* tm_rpc_stats_doc[2] = {
2161         "Print transaction statistics.",
2162         0
2163 };
2164
2165 static const char* tm_rpc_hash_stats_doc[2] = {
2166         "Prints hash table statistics (can be used only if tm is compiled"
2167                 " with -DTM_HASH_STATS).",
2168         0
2169 };
2170
2171 static const char* rpc_t_uac_start_doc[2] = {
2172         "starts a tm uac using  a list of string parameters: method, ruri, dst_uri"
2173                 ", send_sock, headers (CRLF separated) and body (optional)",
2174         0
2175 };
2176
2177 static const char* rpc_t_uac_wait_doc[2] = {
2178         "starts a tm uac and waits for the final reply, using a list of string "
2179                 "parameters: method, ruri, dst_uri send_sock, headers (CRLF separated)"
2180                 " and body (optional)",
2181         0
2182 };
2183
2184
2185 /* rpc exports */
2186 static rpc_export_t tm_rpc[] = {
2187         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
2188         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
2189         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
2190         {"tm.hash_stats",  tm_rpc_hash_stats, tm_rpc_hash_stats_doc, 0},
2191         {"tm.t_uac_start", rpc_t_uac_start, rpc_t_uac_start_doc, 0 },
2192         {"tm.t_uac_wait",  rpc_t_uac_wait,  rpc_t_uac_wait_doc, RET_ARRAY},
2193         {0, 0, 0, 0}
2194 };
2195