234eb35f4fbd64550fe77abf488fe03b53f6b40b
[sip-router] / modules / tm / tm.c
1 /*
2  * $Id$
3  *
4  * TM module
5  *
6  *
7  * ***************************************************
8  * * Jiri's Source Memorial                          *
9  * *                                                 *
10  * * Welcome, pilgrim ! This is the greatest place   *
11  * * where dramatic changes happend. There are not   *
12  * * many places with a history like this, as there  *
13  * * are not so many people like Jiri, one of the    *
14  * * ser's fathers, who brought everywhere the wind  *
15  * * of change, the flood of clean-up. We all felt   *
16  * * his fatherly eye watching over us day and night.*
17  * *                                                 *
18  * * Please, preserve this codework heritage, as     *
19  * * it's unlikely for fresh, juicy pieces of code to  *
20  * * arise to give him the again the chance to       *
21  * * demonstrate his clean-up and improvement skills.*
22  * *                                                 *
23  * * Hereby, we solicit you to adopt this historical *
24  * * piece of code. For $100, your name will be      *
25  * * be printed in this banner and we will use       *
26  * * collected funds to create and display an ASCII  *
27  * * statue of Jiri  .                               *
28  * ***************************************************
29  *
30  *
31  * Copyright (C) 2001-2003 FhG Fokus
32  *
33  * This file is part of ser, a free SIP server.
34  *
35  * ser is free software; you can redistribute it and/or modify
36  * it under the terms of the GNU General Public License as published by
37  * the Free Software Foundation; either version 2 of the License, or
38  * (at your option) any later version
39  *
40  * For a license to use the ser software under conditions
41  * other than those described here, or to purchase support for this
42  * software, please contact iptel.org by e-mail at the following addresses:
43  *    info@iptel.org
44  *
45  * ser is distributed in the hope that it will be useful,
46  * but WITHOUT ANY WARRANTY; without even the implied warranty of
47  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
48  * GNU General Public License for more details.
49  *
50  * You should have received a copy of the GNU General Public License
51  * along with this program; if not, write to the Free Software
52  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
53  */
54 /*
55  * History:
56  * --------
57  *  2003-02-18  added t_forward_nonack_{udp, tcp}, t_relay_to_{udp,tcp},
58  *               t_replicate_{udp, tcp} (andrei)
59  *  2003-02-19  added t_rely_{udp, tcp} (andrei)
60  *  2003-03-06  voicemail changes accepted (jiri)
61  *  2003-03-10  module export interface updated to the new format (andrei)
62  *  2003-03-16  flags export parameter added (janakj)
63  *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
64  *  2003-03-30  set_kr for requests only (jiri)
65  *  2003-04-05  s/reply_route/failure_route, onreply_route introduced (jiri)
66  *  2003-04-14  use protocol from uri (jiri)
67  *  2003-07-07  added t_relay_to_tls, t_replicate_tls, t_forward_nonack_tls
68  *              added #ifdef USE_TCP, USE_TLS
69  *              removed t_relay_{udp,tcp,tls} (andrei)
70  *  2003-09-26  added t_forward_nonack_uri() - same as t_forward_nonack() but
71  *              takes no parameters -> forwards to uri (bogdan)
72  *  2004-02-11  FIFO/CANCEL + alignments (hash=f(callid,cseq)) (uli+jiri)
73  *  2004-02-18  t_reply exported via FIFO - imported from VM (bogdan)
74  *  2004-10-01  added a new param.: restart_fr_on_each_reply (andrei)
75  *  2005-11-14  new timer support, changed timer related module params (andrei)
76  *  2005-12-09  fixup_hostport2proxy uses route_struct to access param #1
77  *              when fixing param #2
78  *  2005-12-09  added t_set_fr() (andrei)
79  *  2006-02-07  named routes support (andrei)
80  *  2006-09-28  added t_branch_replied, t_branch_timeout, t_any_replied, 
81  *               t_any_timeout, t_is_canceled (andrei)
82  *  2006-10-16  added a new param.: aggregate challenges (andrei)
83  *  2007-05-28  two new params: reparse_invite, ac_extra_hdrs
84  *              added w_t_relay_cancel() (Miklos)
85  *  2007-06-05  added t_set_auto_inv_100() and auto_inv_100 (param);
86  *               t_set_max_lifetime(), max_{non}inv_lifetime  (andrei)
87  *  2008-02-05  module config parameters use the configuration framework (Miklos)
88  *  2008-02-29  added t_grep_status(code) (andrei)
89  */
90
91
92 #include "defs.h"
93
94
95 #include <stdio.h>
96 #include <string.h>
97 #include <netdb.h>
98
99 #include "../../sr_module.h"
100 #include "../../dprint.h"
101 #include "../../error.h"
102 #include "../../ut.h"
103 #include "../../script_cb.h"
104 #include "../../usr_avp.h"
105 #include "../../mem/mem.h"
106 #include "../../route_struct.h"
107 #include "../../route.h"
108 #include "../../cfg/cfg.h"
109
110 #include "config.h"
111 #include "sip_msg.h"
112 #include "h_table.h"
113 #include "t_hooks.h"
114 #include "tm_load.h"
115 #include "ut.h"
116 #include "t_reply.h"
117 #include "uac.h"
118 #include "t_fwd.h"
119 #include "t_lookup.h"
120 #include "t_stats.h"
121 #include "callid.h"
122 #include "t_cancel.h"
123 #include "t_fifo.h"
124 #include "timer.h"
125 #include "t_msgbuilder.h"
126 #include "select.h"
127
128 MODULE_VERSION
129
130 /* fixup functions */
131 static int fixup_hostport2proxy(void** param, int param_no);
132 static int fixup_proto_hostport2proxy(void** param, int param_no);
133 static int fixup_on_failure(void** param, int param_no);
134 static int fixup_on_reply(void** param, int param_no);
135 static int fixup_on_branch(void** param, int param_no);
136 static int fixup_t_reply(void** param, int param_no);
137
138
139 /* init functions */
140 static int mod_init(void);
141 static int child_init(int rank);
142
143
144 /* exported functions */
145 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
146 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2);
147 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
148 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
149 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
150                                 char* bar );
151 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
152 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
153 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy,
154                                  char *);
155 #ifdef USE_TCP
156 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
157                                 char *);
158 #endif
159 #ifdef USE_TLS
160 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
161                                 char *);
162 #endif
163 inline static int w_t_relay_to(struct sip_msg* msg, char* str,char*);
164 inline static int w_t_replicate( struct sip_msg  *p_msg ,
165                                 char *proxy, /* struct proxy_l *proxy expected */
166                                 char *_foo       /* nothing expected */ );
167 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
168                                 char *proxy, /* struct proxy_l *proxy expected */
169                                 char *_foo       /* nothing expected */ );
170 #ifdef USE_TCP
171 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
172                                 char *proxy, /* struct proxy_l *proxy expected */
173                                 char *_foo       /* nothing expected */ );
174 #endif
175 #ifdef USE_TLS
176 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
177                                 char *proxy, /* struct proxy_l *proxy expected */
178                                 char *_foo       /* nothing expected */ );
179 #endif
180 inline static int w_t_replicate_to(struct sip_msg* msg, char* str,char*);
181 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
182 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
183 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
184 #ifdef USE_TCP
185 inline static int w_t_forward_nonack_tcp(struct sip_msg* msg, char* str,char*);
186 #endif
187 #ifdef USE_TLS
188 inline static int w_t_forward_nonack_tls(struct sip_msg* msg, char* str,char*);
189 #endif
190 inline static int w_t_forward_nonack_to(struct sip_msg* msg, char* str,char*);
191 inline static int w_t_relay_cancel(struct sip_msg *p_msg, char *_foo, char *_bar);
192 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
193 inline static int w_t_on_branch(struct sip_msg* msg, char *go_to, char *foo);
194 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
195 inline static int t_check_status(struct sip_msg* msg, char *match, char *foo);
196 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo);
197 static int t_set_fr_all(struct sip_msg* msg, char* fr_inv, char* fr);
198 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar);
199 static int w_t_set_retr(struct sip_msg* msg, char* retr_t1, char* retr_t2);
200 static int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar);
201 static int w_t_set_max_lifetime(struct sip_msg* msg, char* inv, char* noninv);
202 static int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar);
203 static int t_set_auto_inv_100(struct sip_msg* msg, char* on_off, char* foo);
204 static int t_branch_timeout(struct sip_msg* msg, char*, char*);
205 static int t_branch_replied(struct sip_msg* msg, char*, char*);
206 static int t_any_timeout(struct sip_msg* msg, char*, char*);
207 static int t_any_replied(struct sip_msg* msg, char*, char*);
208 static int t_is_canceled(struct sip_msg* msg, char*, char*);
209 static int t_grep_status(struct sip_msg* msg, char*, char*);
210
211
212 /* by default the fr timers avps are not set, so that the avps won't be
213  * searched for nothing each time a new transaction is created */
214 static char *fr_timer_param = 0 /*FR_TIMER_AVP*/;
215 static char *fr_inv_timer_param = 0 /*FR_INV_TIMER_AVP*/;
216
217 static rpc_export_t tm_rpc[];
218
219 static int fixup_t_check_status(void** param, int param_no);
220
221 static cmd_export_t cmds[]={
222         {"t_newtran",          w_t_newtran,             0, 0,
223                         REQUEST_ROUTE},
224         {"t_lookup_request",   w_t_check,               0, 0,
225                         REQUEST_ROUTE},
226         {"t_lookup_cancel",    w_t_lookup_cancel,     0, 0,
227                         REQUEST_ROUTE},
228         {T_REPLY,              w_t_reply,               2, fixup_t_reply,
229                         REQUEST_ROUTE | FAILURE_ROUTE },
230         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
231                         REQUEST_ROUTE},
232         {"t_release",          w_t_release,             0, 0,
233                         REQUEST_ROUTE},
234         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
235                         REQUEST_ROUTE|FAILURE_ROUTE},
236 #ifdef USE_TCP
237         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
238                         REQUEST_ROUTE|FAILURE_ROUTE},
239 #endif
240 #ifdef USE_TLS
241         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
242                         REQUEST_ROUTE|FAILURE_ROUTE},
243 #endif
244         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
245                         REQUEST_ROUTE},
246         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
247                         REQUEST_ROUTE},
248 #ifdef USE_TCP
249         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
250                         REQUEST_ROUTE},
251 #endif
252 #ifdef USE_TLS
253         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
254                         REQUEST_ROUTE},
255 #endif
256         {"t_replicate_to", w_t_replicate_to,            2, fixup_proto_hostport2proxy,
257                         REQUEST_ROUTE},
258         {T_RELAY,              w_t_relay,               0, 0,
259                         REQUEST_ROUTE | FAILURE_ROUTE },
260         {"t_relay_to", w_t_relay_to,                    2, fixup_proto_hostport2proxy,
261                         REQUEST_ROUTE},
262         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
263                         REQUEST_ROUTE},
264         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
265                         REQUEST_ROUTE},
266         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
267                         REQUEST_ROUTE},
268 #ifdef USE_TCP
269         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
270                         REQUEST_ROUTE},
271 #endif
272 #ifdef USE_TLS
273         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
274                         REQUEST_ROUTE},
275 #endif
276         {"t_forward_nonack_to", w_t_forward_nonack_to,  2, fixup_proto_hostport2proxy,
277                         REQUEST_ROUTE},
278         {"t_relay_cancel",     w_t_relay_cancel,        0, 0,
279                         REQUEST_ROUTE},
280         {"t_on_failure",       w_t_on_negative,         1, fixup_on_failure,
281                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
282         {"t_on_reply",         w_t_on_reply,            1, fixup_on_reply,
283                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
284         {"t_on_branch",       w_t_on_branch,         1, fixup_on_branch,
285                         REQUEST_ROUTE | FAILURE_ROUTE },
286         {"t_check_status",     t_check_status,          1, fixup_t_check_status,
287                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
288         {"t_write_req",       t_write_req,              2, fixup_t_write,
289                         REQUEST_ROUTE | FAILURE_ROUTE },
290         {"t_write_unix",      t_write_unix,             2, fixup_t_write,
291                         REQUEST_ROUTE | FAILURE_ROUTE },
292         {"t_set_fr",          t_set_fr_inv,             1, fixup_var_int_1,
293                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
294         {"t_set_fr",          t_set_fr_all,             2, fixup_var_int_12,
295                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
296         {"t_reset_fr",        w_t_reset_fr,             0, 0,
297                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
298         {"t_set_retr",        w_t_set_retr,               2, fixup_var_int_12,
299                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
300         {"t_reset_retr",      w_t_reset_retr,           0, 0,
301                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
302         {"t_set_max_lifetime", w_t_set_max_lifetime,      2, fixup_var_int_12,
303                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
304         {"t_reset_max_lifetime", w_t_reset_max_lifetime, 0, 0,
305                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
306         {"t_set_auto_inv_100", t_set_auto_inv_100,       1, fixup_var_int_1,
307                                                                                                           REQUEST_ROUTE},
308         {"t_branch_timeout",  t_branch_timeout,         0, 0,  FAILURE_ROUTE},
309         {"t_branch_replied",  t_branch_replied,         0, 0,  FAILURE_ROUTE},
310         {"t_any_timeout",     t_any_timeout,            0, 0, 
311                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
312         {"t_any_replied",     t_any_replied,            0, 0, 
313                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
314         {"t_is_canceled",     t_is_canceled,            0, 0,
315                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
316         {"t_grep_status",     t_grep_status,            1, fixup_var_int_1, 
317                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
318
319         /* not applicable from the script */
320         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
321         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
322         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
323         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
324         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
325         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
326         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
327         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
328         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
329         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
330         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
331         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
332         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
333         {"update_dlg_uas",     (cmd_function)update_dlg_uas,    NO_SCRIPT,   0, 0},
334         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
335         {"set_dlg_target",     (cmd_function)set_dlg_target,    NO_SCRIPT,   0, 0},
336         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
337         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
338         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0, 0},
339         {"calculate_hooks",    (cmd_function)w_calculate_hooks, NO_SCRIPT,   0, 0},
340         {"t_uac",              (cmd_function)t_uac,             NO_SCRIPT,   0, 0},
341         {"t_uac_with_ids",     (cmd_function)t_uac_with_ids,    NO_SCRIPT,   0, 0},
342         {"t_unref",            (cmd_function)t_unref,           NO_SCRIPT,   0, 0},
343         {"run_failure_handlers", (cmd_function)run_failure_handlers, NO_SCRIPT,   0, 0},
344         {"cancel_uacs",        (cmd_function)cancel_uacs,       NO_SCRIPT,   0, 0},
345         {0,0,0,0,0}
346 };
347
348
349 static param_export_t params[]={
350         {"ruri_matching",       PARAM_INT, &default_tm_cfg.ruri_matching         },
351         {"via1_matching",       PARAM_INT, &default_tm_cfg.via1_matching         },
352         {"fr_timer",            PARAM_INT, &default_tm_cfg.fr_timeout            },
353         {"fr_inv_timer",        PARAM_INT, &default_tm_cfg.fr_inv_timeout        },
354         {"wt_timer",            PARAM_INT, &default_tm_cfg.wait_timeout          },
355         {"delete_timer",        PARAM_INT, &default_tm_cfg.delete_timeout        },
356         {"retr_timer1",         PARAM_INT, &default_tm_cfg.rt_t1_timeout         },
357         {"retr_timer2"  ,       PARAM_INT, &default_tm_cfg.rt_t2_timeout         },
358         {"max_inv_lifetime",    PARAM_INT, &default_tm_cfg.tm_max_inv_lifetime   },
359         {"max_noninv_lifetime", PARAM_INT, &default_tm_cfg.tm_max_noninv_lifetime},
360         {"noisy_ctimer",        PARAM_INT, &default_tm_cfg.noisy_ctimer          },
361         {"auto_inv_100",        PARAM_INT, &default_tm_cfg.tm_auto_inv_100       },
362         {"unix_tx_timeout",     PARAM_INT, &default_tm_cfg.tm_unix_tx_timeout    },
363         {"restart_fr_on_each_reply", PARAM_INT,
364                                                                         &default_tm_cfg.restart_fr_on_each_reply},
365         {"fr_timer_avp",        PARAM_STRING, &fr_timer_param                    },
366         {"fr_inv_timer_avp",    PARAM_STRING, &fr_inv_timer_param                },
367         {"tw_append",           PARAM_STRING|PARAM_USE_FUNC, 
368                                                                                                         (void*)parse_tw_append   },
369         {"pass_provisional_replies", PARAM_INT, 
370                                                                         &default_tm_cfg.pass_provisional_replies },
371         {"aggregate_challenges", PARAM_INT, &default_tm_cfg.tm_aggregate_auth    },
372         {"unmatched_cancel",    PARAM_INT, &default_tm_cfg.unmatched_cancel      },
373         {"default_code",        PARAM_INT, &default_tm_cfg.default_code          },
374         {"default_reason",      PARAM_STRING, &default_tm_cfg.default_reason     },
375         {"reparse_invite",      PARAM_INT, &default_tm_cfg.reparse_invite        },
376         {"ac_extra_hdrs",       PARAM_STR, &default_tm_cfg.ac_extra_hdrs         },
377         {"blst_503",            PARAM_INT, &default_tm_cfg.tm_blst_503           },
378         {"blst_503_def_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_default   },
379         {"blst_503_min_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_min       },
380         {"blst_503_max_timeout",PARAM_INT, &default_tm_cfg.tm_blst_503_max       },
381         {"blst_methods_add",    PARAM_INT, &default_tm_cfg.tm_blst_methods_add   },
382         {"blst_methods_lookup", PARAM_INT, &default_tm_cfg.tm_blst_methods_lookup},
383         {"cancel_b_method",     PARAM_INT, &default_tm_cfg.cancel_b_flags},
384         {0,0,0}
385 };
386
387 #ifdef STATIC_TM
388 struct module_exports tm_exports = {
389 #else
390 struct module_exports exports= {
391 #endif
392         "tm",
393         /* -------- exported functions ----------- */
394         cmds,
395         tm_rpc,    /* RPC methods */
396         /* ------------ exported variables ---------- */
397         params,
398
399         mod_init, /* module initialization function */
400         (response_function) reply_received,
401         (destroy_function) tm_shutdown,
402         0, /* w_onbreak, */
403         child_init /* per-child init function */
404 };
405
406
407
408 /* helper for fixup_on_* */
409 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
410 {
411         int i;
412         
413         i=route_get(rt, (char*)*param);
414         if (i==-1){
415                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
416                 return E_UNSPEC;
417         }
418         if (rt->rlist[i]==0){
419                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
420                                 r_type, (char*)*param);
421         }
422         *param=(void*)(long)i;
423         return 0;
424 }
425
426 static int fixup_t_reply(void** param, int param_no)
427 {
428         int ret;
429
430         if (param_no == 1) {
431                 ret = fix_param(FPARAM_AVP, param);
432                 if (ret <= 0) return ret;
433             if (fix_param(FPARAM_INT, param) != 0) return -1;
434         } else if (param_no == 2) {
435                 return fixup_var_str_12(param, 2);
436         }
437     return 0;
438 }
439
440 static int fixup_on_failure(void** param, int param_no)
441 {
442         if (param_no==1){
443                 return fixup_routes("t_on_failure", &failure_rt, param);
444         }
445         return 0;
446 }
447
448
449
450 static int fixup_on_reply(void** param, int param_no)
451 {
452         if (param_no==1){
453                 return fixup_routes("t_on_reply", &onreply_rt, param);
454         }
455         return 0;
456 }
457
458
459
460 static int fixup_on_branch(void** param, int param_no)
461 {
462         if (param_no==1){
463                 return fixup_routes("t_on_branch", &branch_rt, param);
464         }
465         return 0;
466 }
467
468
469
470 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
471 static int fixup_hostport2proxy(void** param, int param_no)
472 {
473         unsigned int port;
474         char *host;
475         int err;
476         struct proxy_l *proxy;
477         action_u_t *a;
478         str s;
479
480         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
481         if (param_no==1){
482                 return 0;
483         } else if (param_no==2) {
484                 a = fixup_get_param(param, param_no, 1);
485                 host= a->u.string;
486                 port=str2s(*param, strlen(*param), &err);
487                 if (err!=0) {
488                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
489                                 (char*)(*param));
490                          return E_UNSPEC;
491                 }
492                 s.s = host;
493                 s.len = strlen(host);
494                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
495                 if (proxy==0) {
496                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
497                                 host );
498                         return E_BAD_ADDRESS;
499                 }
500                 /* success -- fix the first parameter to proxy now ! */
501
502                 a->u.data=proxy;
503                 return 0;
504         } else {
505                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
506                 return E_BUG;
507         }
508 }
509
510 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
511 static int fixup_proto_hostport2proxy(void** param, int param_no) {
512         int ret;
513
514         ret = fix_param(FPARAM_AVP, param);
515         if (ret <= 0) return ret;
516 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
517                 ret = fix_param(FPARAM_INT, param);
518                 if (ret <= 0) return ret;
519         } */
520         if (fix_param(FPARAM_STRING, param) != 0) return -1;
521         return 0;
522 }
523
524
525 static int fixup_t_check_status(void** param, int param_no)
526 {
527         int ret;
528
529         ret = fix_param(FPARAM_AVP, param);
530         if (ret <= 0) return ret;
531
532         ret = fix_param(FPARAM_SELECT, param);
533         if (ret <= 0) return ret;
534
535         if (fix_param(FPARAM_REGEX, param) != 0) return -1;
536         return 0;
537 }
538
539
540 /***************************** init functions *****************************/
541 static int w_t_unref( struct sip_msg *foo, void *bar)
542 {
543         return t_unref(foo);
544 }
545
546
547 static int script_init( struct sip_msg *foo, void *bar)
548 {
549         /* we primarily reset all private memory here to make sure
550          * private values left over from previous message will
551          * not be used again */
552
553         /* make sure the new message will not inherit previous
554                 message's t_on_negative value
555         */
556         t_on_negative( 0 );
557         t_on_reply(0);
558         t_on_branch(0);
559         /* reset the kr status */
560         reset_kr(0);
561         /* set request mode so that multiple-mode actions know
562          * how to behave */
563         rmode=MODE_REQUEST;
564         return 1;
565 }
566
567
568 static int mod_init(void)
569 {
570         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
571                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
572
573         /* checking if we have sufficient bitmap capacity for given
574            maximum number of  branches */
575         if (MAX_BRANCHES+1>31) {
576                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
577                         MAX_BRANCHES );
578                 return -1;
579         }
580
581         if (init_callid() < 0) {
582                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
583                 return -1;
584         }
585
586         /* building the hash table*/
587         if (!init_hash_table()) {
588                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
589                 return -1;
590         }
591
592         /* init static hidden values */
593         init_t();
594
595         if (tm_init_selects()==-1) {
596                 LOG(L_ERR, "ERROR: mod_init: select init failed\n");
597                 return -1;
598         }
599
600         /* the default timer values must be fixed-up before
601          * declaring the configuration (Miklos) */
602         if (tm_init_timers()==-1) {
603                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
604                 return -1;
605         }
606         
607         /* the cancel branch flags must be fixed before declaring the 
608          * configuration */
609         if (cancel_b_flags_get(&default_tm_cfg.cancel_b_flags, 
610                                                         default_tm_cfg.cancel_b_flags)<0){
611                 LOG(L_ERR, "ERROR: mod_init: bad cancel branch method\n");
612                 return -1;
613         }
614
615         /* declare the configuration */
616         if (cfg_declare("tm", tm_cfg_def, &default_tm_cfg, cfg_size(tm),
617                          &tm_cfg)) {
618                 LOG(L_ERR, "ERROR: mod_init: failed to declare the configuration\n");
619                 return -1;
620         }
621
622              /* First tm_stat initialization function only allocates the top level stat
623               * structure in shared memory, the initialization will complete in child
624               * init with init_tm_stats_child when the final value of estimated_process_count is
625               * known
626               */
627         if (init_tm_stats() < 0) {
628                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
629                 return -1;
630         }
631
632         if (uac_init()==-1) {
633                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
634                 return -1;
635         }
636
637         if (init_tmcb_lists()!=1) {
638                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
639                 return -1;
640         }
641         
642         tm_init_tags();
643         init_twrite_lines();
644         if (init_twrite_sock() < 0) {
645                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
646                 return -1;
647         }
648
649         /* register post-script clean-up function */
650         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0 ) {
651                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
652                         "callback\n");
653                 return -1;
654         }
655         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQ_TYPE_CB , 0)<0 ) {
656                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
657                         "callback\n");
658                 return -1;
659         }
660
661         if (init_avp_params( fr_timer_param, fr_inv_timer_param)<0 ){
662                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process timer AVPs\n");
663                 return -1;
664         }
665         tm_init = 1;
666         return 0;
667 }
668
669 static int child_init(int rank)
670 {
671         if (rank == PROC_INIT) {
672                 /* we must init stats when rank==PROC_INIT: after mod_init we know
673                  * the exact number of processes and we must init the shared structure
674                  * before any other process is starting (or else some new process
675                  * might try to use the stats before the stats array is allocated) */
676                 if (init_tm_stats_child() < 0) {
677                         ERR("Error while initializing tm statistics structures\n");
678                         return -1;
679                 }
680         }else if (child_init_callid(rank) < 0) { 
681                 /* don't init callid for PROC_INIT*/
682                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID"
683                                 " generator\n");
684                 return -2;
685         }
686         return 0;
687 }
688
689
690
691
692
693 /**************************** wrapper functions ***************************/
694 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
695 {
696         regmatch_t pmatch;
697         struct cell *t;
698         char *status, *s = NULL;
699         char backup;
700         int lowest_status, n;
701         fparam_t* fp;
702         regex_t* re = NULL;
703         str tmp;
704         
705         fp = (fparam_t*)p1;
706         
707         /* first get the transaction */
708         if (t_check(msg, 0 ) == -1) return -1;
709         if ((t = get_t()) == 0) {
710                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
711                         "which has no T-state established\n");
712                 goto error;
713         }
714         backup = 0;
715         
716         switch(fp->type) {
717         case FPARAM_REGEX:
718                 re = fp->v.regex;
719                 break;
720                 
721         default:
722                 /* AVP or select, get the value and compile the regex */
723                 if (get_str_fparam(&tmp, msg, fp) < 0) goto error;
724                 s = pkg_malloc(tmp.len + 1);
725                 if (s == NULL) {
726                         ERR("Out of memory\n");
727                         goto error;
728                 }
729                 memcpy(s, tmp.s, tmp.len);
730                 s[tmp.len] = '\0';
731                 
732                 if ((re = pkg_malloc(sizeof(regex_t))) == 0) {
733                         ERR("No memory left\n");
734                         goto error;
735                 }
736                 
737                 if (regcomp(re, s, REG_EXTENDED|REG_ICASE|REG_NEWLINE)) {
738                         ERR("Bad regular expression '%s'\n", s);
739                         goto error;
740                 }
741                 break;
742         }
743         
744         switch(rmode) {
745         case MODE_REQUEST:
746                 /* use the status of the last sent reply */
747                 status = int2str( t->uas.status, 0);
748                 break;
749                 
750         case MODE_ONREPLY:
751                 /* use the status of the current reply */
752                 status = msg->first_line.u.reply.status.s;
753                 backup = status[msg->first_line.u.reply.status.len];
754                 status[msg->first_line.u.reply.status.len] = 0;
755                 break;
756
757         case MODE_ONFAILURE:
758                 /* use the status of the winning reply */
759                 if (t_pick_branch( -1, 0, t, &lowest_status)<0 ) {
760                         LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
761                                 " a final response in MODE_ONFAILURE\n");
762                         goto error;
763                 }
764                 status = int2str( lowest_status , 0);
765                 break;
766
767         default:
768                 LOG(L_ERR,"ERROR:t_check_status: unsupported mode %d\n",rmode);
769                 goto error;
770         }
771
772         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
773         /* do the checking */
774         n = regexec(re, status, 1, &pmatch, 0);
775
776         if (backup) status[msg->first_line.u.reply.status.len] = backup;
777         if (s) pkg_free(s);
778         if ((fp->type != FPARAM_REGEX) && re) {
779                 regfree(re);
780                 pkg_free(re);
781         }
782
783         if (n!=0) return -1;
784         return 1;
785
786  error:
787         if (s) pkg_free(s);
788         if ((fp->type != FPARAM_REGEX) && re) {
789                 regfree(re);
790                 pkg_free(re);
791         }
792         return -1;
793 }
794
795
796 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
797 {
798         return t_check( msg , 0  ) ? 1 : -1;
799 }
800
801 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
802 {
803         struct cell *ret;
804         if (msg->REQ_METHOD==METHOD_CANCEL) {
805                 ret = t_lookupOriginalT( msg );
806                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
807                 if (ret != T_NULL_CELL) {
808                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
809                         So we must unref it before returning. */
810                         UNREF(ret);
811                         set_t(T_UNDEFINED);
812                         return 1;
813                 }
814                 set_t(T_UNDEFINED);
815         } else {
816                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
817         }
818         return -1;
819 }
820
821 inline static int str2proto(char *s, int len) {
822         if (len == 3 && !strncasecmp(s, "udp", 3))
823                 return PROTO_UDP;
824         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
825                 return PROTO_TCP;
826         else if (len == 3 && !strncasecmp(s, "tls", 3))
827                 return PROTO_TLS;       
828         else
829                 return PROTO_NONE;
830 }
831
832 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
833         struct proxy_l *proxy = 0;
834         avp_t* avp;
835         avp_value_t val;
836         int proto, port, err;
837         str s;
838         char *c;
839         
840         switch(((fparam_t *)proto_par)->type) {
841         case FPARAM_AVP:
842                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
843                         proto = PROTO_NONE;
844                 } else {
845                         if (avp->flags & AVP_VAL_STR) {
846                                 proto = str2proto(val.s.s, val.s.len);
847                         }
848                         else {
849                                 proto = val.n;
850                         }
851                 }
852                 break;
853
854         case FPARAM_INT:
855                 proto = ((fparam_t *)proto_par)->v.i;
856                 break;
857         case FPARAM_STRING:
858                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
859                 break;
860         default:
861                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
862                 return 0;
863         }
864
865
866         switch(((fparam_t *)addr_par)->type) {
867         case FPARAM_AVP:
868                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
869                         s.len = 0;
870                 } else {
871                         if ((avp->flags & AVP_VAL_STR) == 0) {
872                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
873                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
874                                 return 0;
875                         }
876                         s = val.s;
877                 }
878                 break;
879
880         case FPARAM_STRING:
881                 s.s = ((fparam_t *) addr_par)->v.asciiz;
882                 s.len = strlen(s.s);
883                 break;
884
885         default:
886                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
887                 return 0;
888         }
889
890         port = 5060;
891         if (s.len) {
892                 c = memchr(s.s, ':', s.len);
893                 if (c) {
894                         port = str2s(c+1, s.len-(c-s.s+1), &err);
895                         if (err!=0) {
896                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
897                                         s.len, s.s);
898                                  return 0;
899                         }
900                         s.len = c-s.s;
901                 }
902         }
903         if (!s.len) {
904                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
905                 return 0;
906         }
907         proxy=mk_proxy(&s, port, proto);
908         if (proxy==0) {
909                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
910                         s.len, s.s );
911                 return 0;
912         }
913         return proxy;
914 }
915
916 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
917         int proto)
918 {
919         struct cell *t;
920         if (t_check( msg , 0 )==-1) {
921                 LOG(L_ERR, "ERROR: forward_nonack: "
922                                 "can't forward when no transaction was set up\n");
923                 return -1;
924         }
925         t=get_t();
926         if ( t && t!=T_UNDEFINED ) {
927                 if (msg->REQ_METHOD==METHOD_ACK) {
928                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
929                         return -1;
930                 }
931                 return t_forward_nonack(t, msg, proxy, proto );
932         } else {
933                 DBG("DEBUG: forward_nonack: no transaction found\n");
934                 return -1;
935         }
936 }
937
938
939 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
940                                                                                 char* foo)
941 {
942         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
943 }
944
945
946 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
947                                                                                                                                         char *bar)
948 {
949         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
950 }
951
952
953 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
954                                                                                 char* foo)
955 {
956         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
957 }
958
959
960 #ifdef USE_TCP
961 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
962                                                                                 char* foo)
963 {
964         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
965 }
966 #endif
967
968
969 #ifdef USE_TLS
970 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
971                                                                                 char* foo)
972 {
973         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
974 }
975 #endif
976
977 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
978         char *proto_par, 
979         char *addr_par   )
980 {
981         struct proxy_l *proxy;
982         int r = -1;
983         proxy = t_protoaddr2proxy(proto_par, addr_par);
984         if (proxy) {
985                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);            
986                 free_proxy(proxy);
987         }
988         return r;
989 }
990
991
992 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
993 {
994         struct cell *t;
995         int code, ret = -1;
996         str reason;
997         char* r;
998
999         if (msg->REQ_METHOD==METHOD_ACK) {
1000                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
1001                 return -1;
1002         }
1003         if (t_check( msg , 0 )==-1) return -1;
1004         t=get_t();
1005         if (!t) {
1006                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
1007                         "for which no T-state has been established\n");
1008                 return -1;
1009         }
1010
1011         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
1012             code = cfg_get(tm, tm_cfg, default_code);
1013         }
1014         
1015         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
1016                 r = cfg_get(tm, tm_cfg, default_reason);
1017         } else {
1018                 r = as_asciiz(&reason);
1019                 if (r == NULL) r = cfg_get(tm, tm_cfg, default_reason);
1020         }
1021         
1022         /* if called from reply_route, make sure that unsafe version
1023          * is called; we are already in a mutex and another mutex in
1024          * the safe version would lead to a deadlock
1025          */
1026          
1027         if (rmode==MODE_ONFAILURE) {
1028                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
1029                 ret = t_reply_unsafe(t, msg, code, r);
1030         } else if (rmode==MODE_REQUEST) {
1031                 ret = t_reply( t, msg, code, r);
1032         } else {
1033                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
1034                 ret = -1;
1035         }
1036
1037         if (r && (r != cfg_get(tm, tm_cfg, default_reason))) pkg_free(r);
1038         return ret;
1039 }
1040
1041
1042 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
1043 {
1044         struct cell *t;
1045         int ret;
1046         
1047         if (t_check( msg  , 0  )==-1) return -1;
1048         t=get_t();
1049         if ( t && t!=T_UNDEFINED ) {
1050                 ret = t_release_transaction( t );
1051                 t_unref(msg);
1052                 return ret;
1053         }
1054         return 1;
1055 }
1056
1057
1058 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
1059 {
1060         struct cell *t;
1061
1062
1063         if (t_check( p_msg  , 0 )==-1)
1064                 return 1;
1065         t=get_t();
1066         if (t) {
1067                 if (p_msg->REQ_METHOD==METHOD_ACK) {
1068                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
1069                         return -1;
1070                 }
1071                 return t_retransmit_reply( t );
1072         } else
1073                 return -1;
1074 }
1075
1076
1077 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
1078 {
1079         /* t_newtran returns 0 on error (negative value means
1080            'transaction exists' */
1081         int ret;
1082         ret = t_newtran( p_msg );
1083         if (ret==E_SCRIPT) {
1084                 LOG(L_ERR, "ERROR: t_newtran: "
1085                         "transaction already in process %p\n", get_t() );
1086         }
1087         return ret;
1088 }
1089
1090
1091 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
1092 {
1093         t_on_negative( (unsigned int )(long) go_to );
1094         return 1;
1095 }
1096
1097 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
1098 {
1099         t_on_branch( (unsigned int )(long) go_to );
1100         return 1;
1101 }
1102
1103
1104 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
1105 {
1106         t_on_reply( (unsigned int )(long) go_to );
1107         return 1;
1108 }
1109
1110
1111
1112 inline static int _w_t_relay_to( struct sip_msg  *p_msg ,
1113         struct proxy_l *proxy )
1114 {
1115         struct cell *t;
1116
1117         if (rmode==MODE_ONFAILURE) {
1118                 t=get_t();
1119                 if (!t || t==T_UNDEFINED) {
1120                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
1121                         return -1;
1122                 }
1123                 if (t_forward_nonack(t, p_msg, proxy, PROTO_NONE)<=0 ) {
1124                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
1125                         return -1;
1126                 }
1127                 return 1;
1128         }
1129         if (rmode==MODE_REQUEST)
1130                 return t_relay_to( p_msg, proxy, PROTO_NONE,
1131                         0 /* no replication */ );
1132         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1133         return 0;
1134 }
1135
1136
1137 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
1138         char *proxy, /* struct proxy_l *proxy expected */
1139         char *_foo       /* nothing expected */ )
1140 {
1141         ((struct proxy_l *)proxy)->proto=PROTO_UDP;
1142         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1143 }
1144
1145
1146 #ifdef USE_TCP
1147 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
1148         char *proxy, /* struct proxy_l *proxy expected */
1149         char *_foo       /* nothing expected */ )
1150 {
1151         ((struct proxy_l *)proxy)->proto=PROTO_TCP;
1152         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1153 }
1154 #endif
1155
1156
1157 #ifdef USE_TLS
1158 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
1159         char *proxy, /* struct proxy_l *proxy expected */
1160         char *_foo       /* nothing expected */ )
1161 {
1162         ((struct proxy_l *)proxy)->proto=PROTO_TLS;
1163         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
1164 }
1165 #endif
1166
1167 inline static int w_t_relay_to( struct sip_msg  *p_msg ,
1168         char *proto_par, 
1169         char *addr_par   )
1170 {
1171         struct proxy_l *proxy;
1172         int r = -1;
1173         proxy = t_protoaddr2proxy(proto_par, addr_par);
1174         if (proxy) {
1175                 r = _w_t_relay_to(p_msg, proxy);                
1176                 free_proxy(proxy);
1177         }
1178         return r;
1179 }
1180
1181
1182 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1183         char *proxy, /* struct proxy_l *proxy expected */
1184         char *_foo       /* nothing expected */ )
1185 {
1186         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1187 }
1188
1189 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1190         char *proxy, /* struct proxy_l *proxy expected */
1191         char *_foo       /* nothing expected */ )
1192 {
1193         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1194 }
1195
1196
1197 #ifdef USE_TCP
1198 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1199         char *proxy, /* struct proxy_l *proxy expected */
1200         char *_foo       /* nothing expected */ )
1201 {
1202         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1203 }
1204 #endif
1205
1206
1207 #ifdef USE_TLS
1208 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1209         char *proxy, /* struct proxy_l *proxy expected */
1210         char *_foo       /* nothing expected */ )
1211 {
1212         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1213 }
1214 #endif
1215
1216 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1217         char *proto_par, 
1218         char *addr_par   )
1219 {
1220         struct proxy_l *proxy;
1221         int r = -1;
1222         proxy = t_protoaddr2proxy(proto_par, addr_par);
1223         if (proxy) {
1224                 r = t_replicate(p_msg, proxy, proxy->proto);            
1225                 free_proxy(proxy);
1226         }
1227         return r;
1228 }
1229
1230 inline static int w_t_relay( struct sip_msg  *p_msg ,
1231                                                 char *_foo, char *_bar)
1232 {
1233         struct cell *t;
1234
1235         if (rmode==MODE_ONFAILURE) {
1236                 t=get_t();
1237                 if (!t || t==T_UNDEFINED) {
1238                         LOG(L_CRIT, "BUG: w_t_relay: undefined T\n");
1239                         return -1;
1240                 }
1241                 if (t_forward_nonack(t, p_msg, ( struct proxy_l *) 0, PROTO_NONE)<=0) {
1242                         LOG(L_ERR, "ERROR: w_t_relay (failure mode): forwarding failed\n");
1243                         return -1;
1244                 }
1245                 return 1;
1246         }
1247         if (rmode==MODE_REQUEST)
1248                 return t_relay_to( p_msg,
1249                 (struct proxy_l *) 0 /* no proxy */, PROTO_NONE,
1250                 0 /* no replication */ );
1251         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1252         return 0;
1253 }
1254
1255 /* relays CANCEL at the beginning of the script */
1256 inline static int w_t_relay_cancel( struct sip_msg  *p_msg ,
1257                                                 char *_foo, char *_bar)
1258 {
1259         if (p_msg->REQ_METHOD!=METHOD_CANCEL)
1260                 return 1;
1261
1262         /* it makes no sense to use this function without reparse_invite=1 */
1263         if (!cfg_get(tm, tm_cfg, reparse_invite))
1264                 LOG(L_WARN, "WARNING: t_relay_cancel is probably used with "
1265                         "wrong configuration, check the readme for details\n");
1266
1267         return t_relay_cancel(p_msg);
1268 }
1269
1270 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1271 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1272 {
1273     int fr, fr_inv;
1274
1275     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1276     if (p2) {
1277         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1278     } else {
1279         fr = 0;
1280     }
1281
1282     return t_set_fr(msg, fr_inv, fr);
1283 }
1284
1285 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1286 {
1287         return t_set_fr_all(msg, fr_inv, (char*)0);
1288 }
1289
1290 /* reset fr_timer and fr_inv_timer to the default values */
1291 static int w_t_reset_fr(struct sip_msg* msg, char* foo, char* bar)
1292 {
1293         return t_reset_fr();
1294 }
1295
1296 /* set retr. intervals per transaction; 0 means: use the default value */
1297 static int w_t_set_retr(struct sip_msg* msg, char* p1, char* p2)
1298 {
1299         int t1, t2;
1300         
1301         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1302         if (p2) {
1303                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1304         } else {
1305                 t2 = 0;
1306         }
1307 #ifdef TM_DIFF_RT_TIMEOUT
1308         return t_set_retr(msg, t1, t2);
1309 #else
1310         ERR("w_t_set_retr: support for changing retransmission intervals on "
1311                         "the fly not compiled in (re-compile tm with"
1312                         " -DTM_DIFF_RT_TIMEOUT)\n");
1313         return -1;
1314 #endif
1315 }
1316
1317 /* reset retr. t1 and t2 to the default values */
1318 int w_t_reset_retr(struct sip_msg* msg, char* foo, char* bar)
1319 {
1320 #ifdef TM_DIFF_RT_TIMEOUT
1321         return t_reset_retr();
1322 #else
1323         ERR("w_t_reset_retr: support for changing retransmission intervals on "
1324                         "the fly not compiled in (re-compile tm with"
1325                         " -DTM_DIFF_RT_TIMEOUT)\n");
1326         return -1;
1327 #endif
1328 }
1329
1330 /* set maximum transaction lifetime for inv & noninv */
1331 static int w_t_set_max_lifetime(struct sip_msg* msg, char* p1, char* p2)
1332 {
1333         int t1, t2;
1334         
1335         if (get_int_fparam(&t1, msg, (fparam_t*)p1) < 0) return -1;
1336         if (p2) {
1337                 if (get_int_fparam(&t2, msg, (fparam_t*)p2) < 0) return -1;
1338         } else {
1339                 t2 = 0;
1340         }
1341         return t_set_max_lifetime(msg, t1, t2);
1342 }
1343
1344 /* reset maximum invite/non-invite lifetime to the default value */
1345 int w_t_reset_max_lifetime(struct sip_msg* msg, char* foo, char* bar)
1346 {
1347         return t_reset_max_lifetime();
1348 }
1349
1350 /* set automatically sending 100 replies on/off for the current or
1351  * next to be created transaction */
1352 static int t_set_auto_inv_100(struct sip_msg* msg, char* p1, char* p2)
1353 {
1354         int state;
1355         struct cell* t;
1356         
1357         if (get_int_fparam(&state, msg, (fparam_t*)p1) < 0) return -1;
1358         t=get_t();
1359         /* in MODE_REPLY and MODE_ONFAILURE T will be set to current transaction;
1360          * in MODE_REQUEST T will be set only if the transaction was already
1361          * created; if not -> use the static variables */
1362         if (!t || t==T_UNDEFINED ){
1363                 if (state)
1364                         set_msgid_val(user_auto_inv_100, msg->id, int, 1); /* set */
1365                 else
1366                         set_msgid_val(user_auto_inv_100, msg->id, int, -1); /* reset */
1367         }else{
1368                 if (state)
1369                         t->flags|=T_AUTO_INV_100;
1370                 else
1371                         t->flags&=~T_AUTO_INV_100;
1372         }
1373         return 1;
1374 }
1375
1376
1377
1378 /* script function, FAILURE_ROUTE only, returns true if the 
1379  * choosed "failure" branch failed because of a timeout, 
1380  * -1 otherwise */
1381 int t_branch_timeout(struct sip_msg* msg, char* foo, char* bar)
1382 {
1383         return (msg->msg_flags & FL_TIMEOUT)?1:-1;
1384 }
1385
1386
1387
1388 /* script function, FAILURE_ROUTE only, returns true if the 
1389  * choosed "failure" branch ever received a reply, -1 otherwise */
1390 int t_branch_replied(struct sip_msg* msg, char* foo, char* bar)
1391 {
1392         return (msg->msg_flags & FL_REPLIED)?1:-1;
1393 }
1394
1395
1396
1397 /* script function, returns: 1 if the transaction was canceled, -1 if not */
1398 int t_is_canceled(struct sip_msg* msg, char* foo, char* bar)
1399 {
1400         struct cell *t;
1401         int ret;
1402         
1403         
1404         if (t_check( msg , 0 )==-1) return -1;
1405         t=get_t();
1406         if ((t==0) || (t==T_UNDEFINED)){
1407                 LOG(L_ERR, "ERROR: t_is_canceled: cannot check a message "
1408                         "for which no T-state has been established\n");
1409                 ret=-1;
1410         }else{
1411                 ret=(t->flags & T_CANCELED)?1:-1;
1412         }
1413         return ret;
1414 }
1415
1416
1417
1418 /* script function, returns: 1 if any of the branches did timeout, -1 if not */
1419 int t_any_timeout(struct sip_msg* msg, char* foo, char* bar)
1420 {
1421         struct cell *t;
1422         int r;
1423         
1424         if (t_check( msg , 0 )==-1) return -1;
1425         t=get_t();
1426         if ((t==0) || (t==T_UNDEFINED)){
1427                 LOG(L_ERR, "ERROR: t_any_timeout: cannot check a message "
1428                         "for which no T-state has been established\n");
1429                 return -1;
1430         }else{
1431                 for (r=0; r<t->nr_of_outgoings; r++){
1432                         if (t->uac[r].request.flags & F_RB_TIMEOUT)
1433                                 return 1;
1434                 }
1435         }
1436         return -1;
1437 }
1438
1439
1440
1441 /* script function, returns: 1 if any of the branches received at leat one
1442  * reply, -1 if not */
1443 int t_any_replied(struct sip_msg* msg, char* foo, char* bar)
1444 {
1445         struct cell *t;
1446         int r;
1447         
1448         if (t_check( msg , 0 )==-1) return -1;
1449         t=get_t();
1450         if ((t==0) || (t==T_UNDEFINED)){
1451                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1452                         "for which no T-state has been established\n");
1453                 return -1;
1454         }else{
1455                 for (r=0; r<t->nr_of_outgoings; r++){
1456                         if (t->uac[r].request.flags & F_RB_REPLIED)
1457                                 return 1;
1458                 }
1459         }
1460         return -1;
1461 }
1462
1463
1464
1465 /* script function, returns: 1 if any of the branches received the
1466  *  reply code "status" */
1467 int t_grep_status(struct sip_msg* msg, char* status, char* bar)
1468 {
1469         struct cell *t;
1470         int r;
1471         int code;
1472         
1473     if (get_int_fparam(&code, msg, (fparam_t*)status) < 0) return -1;
1474         if (t_check( msg , 0 )==-1) return -1;
1475         t=get_t();
1476         if ((t==0) || (t==T_UNDEFINED)){
1477                 LOG(L_ERR, "ERROR: t_any_replied: cannot check a message "
1478                         "for which no T-state has been established\n");
1479                 return -1;
1480         }else{
1481                 for (r=0; r<t->nr_of_outgoings; r++){
1482                         if ((t->uac[r].last_received==code)  && 
1483                                         (t->uac[r].request.flags & F_RB_REPLIED))
1484                                 return 1;
1485                 }
1486         }
1487         return -1;
1488 }
1489
1490
1491
1492 static rpc_export_t tm_rpc[] = {
1493         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
1494         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
1495         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
1496         {"tm.hash_stats",  tm_rpc_hash_stats, tm_rpc_hash_stats_doc, 0},
1497         {0, 0, 0, 0}
1498 };
1499
1500 /* wrapper function needed after changes in w_t_reply */
1501 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1502 {
1503         fparam_t c;
1504         fparam_t r;
1505         
1506         c.type = FPARAM_INT;
1507         c.orig = NULL; /* ? */
1508         c.v.i = code;
1509         
1510         r.type = FPARAM_STRING;
1511         r.orig = NULL; /* ? */
1512         r.v.asciiz = txt;
1513
1514         return w_t_reply(m, (char *)&c, (char*)&r);
1515 }
1516