aac05e13800c796a77790f01c669a0807c43bbce
[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  */
81
82
83 #include "defs.h"
84
85
86 #include <stdio.h>
87 #include <string.h>
88 #include <netdb.h>
89
90 #include "../../sr_module.h"
91 #include "../../dprint.h"
92 #include "../../error.h"
93 #include "../../ut.h"
94 #include "../../script_cb.h"
95 #include "../../usr_avp.h"
96 #include "../../mem/mem.h"
97 #include "../../route_struct.h"
98 #include "../../route.h"
99
100 #include "sip_msg.h"
101 #include "h_table.h"
102 #include "t_hooks.h"
103 #include "tm_load.h"
104 #include "ut.h"
105 #include "t_reply.h"
106 #include "uac.h"
107 #include "t_fwd.h"
108 #include "t_lookup.h"
109 #include "t_stats.h"
110 #include "callid.h"
111 #include "t_cancel.h"
112 #include "t_fifo.h"
113 #include "timer.h"
114
115 MODULE_VERSION
116
117 /* fixup functions */
118 static int fixup_hostport2proxy(void** param, int param_no);
119 static int fixup_proto_hostport2proxy(void** param, int param_no);
120 static int fixup_on_failure(void** param, int param_no);
121 static int fixup_on_reply(void** param, int param_no);
122 static int fixup_on_branch(void** param, int param_no);
123 static int fixup_t_reply(void** param, int param_no);
124
125
126 /* init functions */
127 static int mod_init(void);
128 static int child_init(int rank);
129
130
131 /* exported functions */
132 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
133 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2);
134 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
135 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
136 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
137                                 char* bar );
138 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
139 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
140 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy,
141                                  char *);
142 #ifdef USE_TCP
143 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
144                                 char *);
145 #endif
146 #ifdef USE_TLS
147 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
148                                 char *);
149 #endif
150 inline static int w_t_relay_to(struct sip_msg* msg, char* str,char*);
151 inline static int w_t_replicate( struct sip_msg  *p_msg ,
152                                 char *proxy, /* struct proxy_l *proxy expected */
153                                 char *_foo       /* nothing expected */ );
154 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
155                                 char *proxy, /* struct proxy_l *proxy expected */
156                                 char *_foo       /* nothing expected */ );
157 #ifdef USE_TCP
158 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
159                                 char *proxy, /* struct proxy_l *proxy expected */
160                                 char *_foo       /* nothing expected */ );
161 #endif
162 #ifdef USE_TLS
163 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
164                                 char *proxy, /* struct proxy_l *proxy expected */
165                                 char *_foo       /* nothing expected */ );
166 #endif
167 inline static int w_t_replicate_to(struct sip_msg* msg, char* str,char*);
168 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
169 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
170 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
171 #ifdef USE_TCP
172 inline static int w_t_forward_nonack_tcp(struct sip_msg* msg, char* str,char*);
173 #endif
174 #ifdef USE_TLS
175 inline static int w_t_forward_nonack_tls(struct sip_msg* msg, char* str,char*);
176 #endif
177 inline static int w_t_forward_nonack_to(struct sip_msg* msg, char* str,char*);
178 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
179 inline static int w_t_on_branch(struct sip_msg* msg, char *go_to, char *foo);
180 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
181 inline static int t_check_status(struct sip_msg* msg, char *regexp, char *foo);
182 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo);
183 static int t_set_fr_all(struct sip_msg* msg, char* fr_inv, char* fr);
184
185
186 static char *fr_timer_param = FR_TIMER_AVP;
187 static char *fr_inv_timer_param = FR_INV_TIMER_AVP;
188
189 static rpc_export_t tm_rpc[];
190
191 static int default_code = 500;
192 static str default_reason = STR_STATIC_INIT("Server Internal Error");
193
194
195 static cmd_export_t cmds[]={
196         {"t_newtran",          w_t_newtran,             0, 0,
197                         REQUEST_ROUTE},
198         {"t_lookup_request",   w_t_check,               0, 0,
199                         REQUEST_ROUTE},
200         {"t_lookup_cancel",    w_t_lookup_cancel,     0, 0,
201                         REQUEST_ROUTE},
202         {T_REPLY,              w_t_reply,               2, fixup_t_reply,
203                         REQUEST_ROUTE | FAILURE_ROUTE },
204         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
205                         REQUEST_ROUTE},
206         {"t_release",          w_t_release,             0, 0,
207                         REQUEST_ROUTE},
208         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
209                         REQUEST_ROUTE|FAILURE_ROUTE},
210 #ifdef USE_TCP
211         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
212                         REQUEST_ROUTE|FAILURE_ROUTE},
213 #endif
214 #ifdef USE_TLS
215         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
216                         REQUEST_ROUTE|FAILURE_ROUTE},
217 #endif
218         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
219                         REQUEST_ROUTE},
220         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
221                         REQUEST_ROUTE},
222 #ifdef USE_TCP
223         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
224                         REQUEST_ROUTE},
225 #endif
226 #ifdef USE_TLS
227         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
228                         REQUEST_ROUTE},
229 #endif
230         {"t_replicate_to", w_t_replicate_to,            2, fixup_proto_hostport2proxy,
231                         REQUEST_ROUTE},
232         {T_RELAY,              w_t_relay,               0, 0,
233                         REQUEST_ROUTE | FAILURE_ROUTE },
234         {"t_relay_to", w_t_relay_to,                    2, fixup_proto_hostport2proxy,
235                         REQUEST_ROUTE},
236         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
237                         REQUEST_ROUTE},
238         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
239                         REQUEST_ROUTE},
240         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
241                         REQUEST_ROUTE},
242 #ifdef USE_TCP
243         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
244                         REQUEST_ROUTE},
245 #endif
246 #ifdef USE_TLS
247         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
248                         REQUEST_ROUTE},
249 #endif
250         {"t_forward_nonack_to", w_t_forward_nonack_to,  2, fixup_proto_hostport2proxy,
251                         REQUEST_ROUTE},
252         {"t_on_failure",       w_t_on_negative,         1, fixup_on_failure,
253                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
254         {"t_on_reply",         w_t_on_reply,            1, fixup_on_reply,
255                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
256         {"t_on_branch",       w_t_on_branch,         1, fixup_on_branch,
257                         REQUEST_ROUTE | FAILURE_ROUTE },
258         {"t_check_status",     t_check_status,          1, fixup_regex_1,
259                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
260         {"t_write_req",       t_write_req,              2, fixup_t_write,
261                         REQUEST_ROUTE | FAILURE_ROUTE },
262         {"t_write_unix",      t_write_unix,             2, fixup_t_write,
263                         REQUEST_ROUTE | FAILURE_ROUTE },
264         {"t_set_fr",          t_set_fr_inv,             1, fixup_var_int_1,
265                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
266         {"t_set_fr",          t_set_fr_all,             2, fixup_var_int_12,
267                         REQUEST_ROUTE|ONREPLY_ROUTE|FAILURE_ROUTE|BRANCH_ROUTE },
268
269         /* not applicable from the script */
270         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
271         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
272         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
273         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
274         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
275         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
276         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
277         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
278         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
279         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
280         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
281         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
282         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
283         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
284         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
285         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
286         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0, 0},
287         {"calculate_hooks",    (cmd_function)w_calculate_hooks, NO_SCRIPT,   0, 0},
288         {"t_uac",              (cmd_function)t_uac,             NO_SCRIPT,   0, 0},
289         {0,0,0,0,0}
290 };
291
292
293 static param_export_t params[]={
294         {"ruri_matching",       PARAM_INT, &ruri_matching                        },
295         {"via1_matching",       PARAM_INT, &via1_matching                        },
296         {"fr_timer",            PARAM_INT, &fr_timeout                           },
297         {"fr_inv_timer",        PARAM_INT, &fr_inv_timeout                       },
298         {"wt_timer",            PARAM_INT, &wait_timeout                         },
299         {"delete_timer",        PARAM_INT, &delete_timeout                       },
300         {"retr_timer1",         PARAM_INT, &rt_t1_timeout                        },
301         {"retr_timer2"  ,       PARAM_INT, &rt_t2_timeout                        },
302         {"noisy_ctimer",        PARAM_INT, &noisy_ctimer                         },
303         {"uac_from",            PARAM_STRING, &uac_from                          },
304         {"unix_tx_timeout",     PARAM_INT, &tm_unix_tx_timeout                   },
305         {"restart_fr_on_each_reply", PARAM_INT, &restart_fr_on_each_reply        },
306         {"fr_timer_avp",        PARAM_STRING, &fr_timer_param                    },
307         {"fr_inv_timer_avp",    PARAM_STRING, &fr_inv_timer_param                },
308         {"tw_append",           PARAM_STRING|PARAM_USE_FUNC, (void*)parse_tw_append },
309         {"pass_provisional_replies", PARAM_INT, &pass_provisional_replies        },
310         {"default_code",        PARAM_INT, &default_code                         },
311         {"default_reason",      PARAM_STR, &default_reason                       },
312         {0,0,0}
313 };
314
315
316 #ifdef STATIC_TM
317 struct module_exports tm_exports = {
318 #else
319 struct module_exports exports= {
320 #endif
321         "tm",
322         /* -------- exported functions ----------- */
323         cmds,
324         tm_rpc,    /* RPC methods */
325         /* ------------ exported variables ---------- */
326         params,
327
328         mod_init, /* module initialization function */
329         (response_function) reply_received,
330         (destroy_function) tm_shutdown,
331         0, /* w_onbreak, */
332         child_init /* per-child init function */
333 };
334
335
336
337 /* helper for fixup_on_* */
338 static int fixup_routes(char* r_type, struct route_list* rt, void** param)
339 {
340         int i;
341         
342         i=route_get(rt, (char*)*param);
343         if (i==-1){
344                 LOG(L_ERR, "ERROR: tm: fixup_routes: route_get failed\n");
345                 return E_UNSPEC;
346         }
347         if (rt->rlist[i]==0){
348                 LOG(L_WARN, "WARNING: %s(\"%s\"): empty/non existing route\n",
349                                 r_type, (char*)*param);
350         }
351         *param=(void*)(long)i;
352         return 0;
353 }
354
355 static int fixup_t_reply(void** param, int param_no)
356 {
357         int ret;
358
359         if (param_no == 1) {
360                 ret = fix_param(FPARAM_AVP, param);
361                 if (ret <= 0) return ret;
362                 return fix_param(FPARAM_INT, param);
363         } else if (param_no == 2) {
364                 return fixup_var_str_12(param, 2);
365         }
366     return 0;
367 }
368
369 static int fixup_on_failure(void** param, int param_no)
370 {
371         if (param_no==1){
372                 return fixup_routes("t_on_failure", &failure_rt, param);
373         }
374         return 0;
375 }
376
377
378
379 static int fixup_on_reply(void** param, int param_no)
380 {
381         if (param_no==1){
382                 return fixup_routes("t_on_reply", &onreply_rt, param);
383         }
384         return 0;
385 }
386
387
388
389 static int fixup_on_branch(void** param, int param_no)
390 {
391         if (param_no==1){
392                 return fixup_routes("t_on_branch", &branch_rt, param);
393         }
394         return 0;
395 }
396
397
398
399 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
400 static int fixup_hostport2proxy(void** param, int param_no)
401 {
402         unsigned int port;
403         char *host;
404         int err;
405         struct proxy_l *proxy;
406         action_u_t *a;
407         str s;
408
409         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
410         if (param_no==1){
411                 return 0;
412         } else if (param_no==2) {
413                 a = fixup_get_param(param, param_no, 1);
414                 host= a->u.string;
415                 port=str2s(*param, strlen(*param), &err);
416                 if (err!=0) {
417                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
418                                 (char*)(*param));
419                          return E_UNSPEC;
420                 }
421                 s.s = host;
422                 s.len = strlen(host);
423                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
424                 if (proxy==0) {
425                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
426                                 host );
427                         return E_BAD_ADDRESS;
428                 }
429                 /* success -- fix the first parameter to proxy now ! */
430
431                 a->u.data=proxy;
432                 return 0;
433         } else {
434                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
435                 return E_BUG;
436         }
437 }
438
439 /* (char *$proto, char *$host:port) ==> (fparam, fparam)  */
440 static int fixup_proto_hostport2proxy(void** param, int param_no) {
441         int ret;
442
443         ret = fix_param(FPARAM_AVP, param);
444         if (ret <= 0) return ret;
445 /*      if (param_no = 1) {             FIXME: param_str currently does not offer INT/STR overloading
446                 ret = fix_param(FPARAM_INT, param);
447                 if (ret <= 0) return ret;
448         } */
449         return fix_param(FPARAM_STRING, param);
450 }
451
452
453 /***************************** init functions *****************************/
454 static int w_t_unref( struct sip_msg *foo, void *bar)
455 {
456         return t_unref(foo);
457 }
458
459
460 static int script_init( struct sip_msg *foo, void *bar)
461 {
462         /* we primarily reset all private memory here to make sure
463          * private values left over from previous message will
464          * not be used again */
465
466         /* make sure the new message will not inherit previous
467                 message's t_on_negative value
468         */
469         t_on_negative( 0 );
470         t_on_reply(0);
471         t_on_branch(0);
472         /* reset the kr status */
473         set_kr(0);
474         /* set request mode so that multiple-mode actions know
475          * how to behave */
476         rmode=MODE_REQUEST;
477         return 1;
478 }
479
480
481 static int mod_init(void)
482 {
483         DBG( "TM - (sizeof cell=%ld, sip_msg=%ld) initializing...\n",
484                         (long)sizeof(struct cell), (long)sizeof(struct sip_msg));
485         /* checking if we have sufficient bitmap capacity for given
486            maximum number of  branches */
487         if (MAX_BRANCHES+1>31) {
488                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
489                         MAX_BRANCHES );
490                 return -1;
491         }
492
493         if (init_callid() < 0) {
494                 LOG(L_CRIT, "Error while initializing Call-ID generator\n");
495                 return -1;
496         }
497
498         /* building the hash table*/
499         if (!init_hash_table()) {
500                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
501                 return -1;
502         }
503
504         /* init static hidden values */
505         init_t();
506
507         if (tm_init_timers()==-1) {
508                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
509                 return -1;
510         }
511
512              /* First tm_stat initialization function only allocates the top level stat
513               * structure in shared memory, the initialization will complete in child
514               * init with init_tm_stats_child when the final value of process_count is
515               * known
516               */
517         if (init_tm_stats() < 0) {
518                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
519                 return -1;
520         }
521
522         if (uac_init()==-1) {
523                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
524                 return -1;
525         }
526
527         if (init_tmcb_lists()!=1) {
528                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
529                 return -1;
530         }
531
532         tm_init_tags();
533         init_twrite_lines();
534         if (init_twrite_sock() < 0) {
535                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
536                 return -1;
537         }
538
539         /* register post-script clean-up function */
540         if (register_script_cb( w_t_unref, POST_SCRIPT_CB|REQ_TYPE_CB, 0)<0 ) {
541                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register POST request "
542                         "callback\n");
543                 return -1;
544         }
545         if (register_script_cb( script_init, PRE_SCRIPT_CB|REQ_TYPE_CB , 0)<0 ) {
546                 LOG(L_ERR,"ERROR:tm:mod_init: failed to register PRE request "
547                         "callback\n");
548                 return -1;
549         }
550
551         if (init_avp_params( fr_timer_param, fr_inv_timer_param)<0 ){
552                 LOG(L_ERR,"ERROR:tm:mod_init: failed to process timer AVPs\n");
553                 return -1;
554         }
555
556         tm_init = 1;
557         return 0;
558 }
559
560 static int child_init(int rank) {
561         if (child_init_callid(rank) < 0) {
562                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID generator\n");
563                 return -2;
564         }
565
566         if (rank == 1) {
567                 if (init_tm_stats_child() < 0) {
568                         ERR("Error while initializing tm statistics structures\n");
569                         return -1;
570                 }
571         }
572
573         return 0;
574 }
575
576
577
578
579
580 /**************************** wrapper functions ***************************/
581 static int t_check_status(struct sip_msg* msg, char *p1, char *foo)
582 {
583         regmatch_t pmatch;
584         struct cell *t;
585         char *status;
586         char backup;
587         int lowest_status;
588         int n;
589
590         /* first get the transaction */
591         if (t_check( msg , 0 )==-1) return -1;
592         if ( (t=get_t())==0) {
593                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
594                         "which has no T-state established\n");
595                 return -1;
596         }
597         backup = 0;
598
599         switch (rmode) {
600                 case MODE_REQUEST:
601                         /* use the status of the last sent reply */
602                         status = int2str( t->uas.status, 0);
603                         break;
604                 case MODE_ONREPLY:
605                         /* use the status of the current reply */
606                         status = msg->first_line.u.reply.status.s;
607                         backup = status[msg->first_line.u.reply.status.len];
608                         status[msg->first_line.u.reply.status.len] = 0;
609                         break;
610                 case MODE_ONFAILURE:
611                         /* use the status of the winning reply */
612                         if (t_pick_branch( -1, 0, t, &lowest_status)<0 ) {
613                                 LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
614                                         " a final response in MODE_ONFAILURE\n");
615                                 return -1;
616                         }
617                         status = int2str( lowest_status , 0);
618                         break;
619                 default:
620                         LOG(L_ERR,"ERROR:t_check_status: unsupported mode %d\n",rmode);
621                         return -1;
622         }
623
624         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
625         /* do the checking */
626         n = regexec(((fparam_t*)p1)->v.regex, status, 1, &pmatch, 0);
627
628         if (backup) status[msg->first_line.u.reply.status.len] = backup;
629         if (n!=0) return -1;
630         return 1;
631 }
632
633
634 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
635 {
636         return t_check( msg , 0  ) ? 1 : -1;
637 }
638
639 inline static int w_t_lookup_cancel(struct sip_msg* msg, char* str, char* str2)
640 {
641         struct cell *ret;
642         if (msg->REQ_METHOD==METHOD_CANCEL) {
643                 if (t_check( msg , 0 )==-1) {
644                         LOG(L_WARN, "WARNING: t_lookup_cancel() failed to find transaction\n");
645                         return -1;
646                 }
647                 ret = t_lookupOriginalT( msg );
648                 DBG("lookup_original: t_lookupOriginalT returned: %p\n", ret);
649                 if (ret != T_NULL_CELL) {
650                         /* The cell is reffed by t_lookupOriginalT, but T is not set.
651                         So we must unref it before returning. */
652                         UNREF(ret);
653                         return 1;
654                 }
655         } else {
656                 LOG(L_WARN, "WARNING: script error t_lookup_cancel() called for non-CANCEL request\n");
657         }
658         return -1;
659 }
660
661 inline static int str2proto(char *s, int len) {
662         if (len == 3 && !strncasecmp(s, "udp", 3))
663                 return PROTO_UDP;
664         else if (len == 3 && !strncasecmp(s, "tcp", 3))  /* tcp&tls checks will be passed in getproto() */
665                 return PROTO_TCP;
666         else if (len == 3 && !strncasecmp(s, "tls", 3))
667                 return PROTO_TLS;       
668         else
669                 return PROTO_NONE;
670 }
671
672 inline static struct proxy_l* t_protoaddr2proxy(char *proto_par, char *addr_par) {
673         struct proxy_l *proxy = 0;
674         avp_t* avp;
675         avp_value_t val;
676         int proto, port, err;
677         str s;
678         char *c;
679         
680         switch(((fparam_t *)proto_par)->type) {
681         case FPARAM_AVP:
682                 if (!(avp = search_first_avp(((fparam_t *)proto_par)->v.avp.flags, ((fparam_t *)proto_par)->v.avp.name, &val, 0))) {
683                         proto = PROTO_NONE;
684                 } else {
685                         if (avp->flags & AVP_VAL_STR) {
686                                 proto = str2proto(val.s.s, val.s.len);
687                         }
688                         else {
689                                 proto = val.n;
690                         }
691                 }
692                 break;
693
694         case FPARAM_INT:
695                 proto = ((fparam_t *)proto_par)->v.i;
696                 break;
697         case FPARAM_STRING:
698                 proto = str2proto( ((fparam_t *)proto_par)->v.asciiz, strlen(((fparam_t *)proto_par)->v.asciiz));
699                 break;
700         default:
701                 ERR("BUG: Invalid proto parameter value in t_protoaddr2proxy\n");
702                 return 0;
703         }
704
705
706         switch(((fparam_t *)addr_par)->type) {
707         case FPARAM_AVP:
708                 if (!(avp = search_first_avp(((fparam_t *)addr_par)->v.avp.flags, ((fparam_t *)addr_par)->v.avp.name, &val, 0))) {
709                         s.len = 0;
710                 } else {
711                         if ((avp->flags & AVP_VAL_STR) == 0) {
712                                 LOG(L_ERR, "tm:t_protoaddr2proxy: avp <%.*s> value is not string\n",
713                                         ((fparam_t *)addr_par)->v.avp.name.s.len, ((fparam_t *)addr_par)->v.avp.name.s.s);
714                                 return 0;
715                         }
716                         s = val.s;
717                 }
718                 break;
719
720         case FPARAM_STRING:
721                 s.s = ((fparam_t *) addr_par)->v.asciiz;
722                 s.len = strlen(s.s);
723                 break;
724
725         default:
726                 ERR("BUG: Invalid addr parameter value in t_protoaddr2proxy\n");
727                 return 0;
728         }
729
730         port = 5060;
731         if (s.len) {
732                 c = memchr(s.s, ':', s.len);
733                 if (c) {
734                         port = str2s(c+1, s.len-(c-s.s+1), &err);
735                         if (err!=0) {
736                                 LOG(L_ERR, "tm:t_protoaddr2proxy: bad port number <%.*s>\n",
737                                         s.len, s.s);
738                                  return 0;
739                         }
740                         s.len = c-s.s;
741                 }
742         }
743         if (!s.len) {
744                 LOG(L_ERR, "tm: protoaddr2proxy: host name is empty\n");
745                 return 0;
746         }
747         proxy=mk_proxy(&s, port, proto);
748         if (proxy==0) {
749                 LOG(L_ERR, "tm: protoaddr2proxy: bad host name in URI <%.*s>\n",
750                         s.len, s.s );
751                 return 0;
752         }
753         return proxy;
754 }
755
756 inline static int _w_t_forward_nonack(struct sip_msg* msg, struct proxy_l* proxy,
757         int proto)
758 {
759         struct cell *t;
760         if (t_check( msg , 0 )==-1) {
761                 LOG(L_ERR, "ERROR: forward_nonack: "
762                                 "can't forward when no transaction was set up\n");
763                 return -1;
764         }
765         t=get_t();
766         if ( t && t!=T_UNDEFINED ) {
767                 if (msg->REQ_METHOD==METHOD_ACK) {
768                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
769                         return -1;
770                 }
771                 return t_forward_nonack(t, msg, proxy, proto );
772         } else {
773                 DBG("DEBUG: forward_nonack: no transaction found\n");
774                 return -1;
775         }
776 }
777
778
779 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
780                                                                                 char* foo)
781 {
782         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_NONE);
783 }
784
785
786 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
787                                                                                                                                         char *bar)
788 {
789         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
790 }
791
792
793 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
794                                                                                 char* foo)
795 {
796         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_UDP);
797 }
798
799
800 #ifdef USE_TCP
801 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
802                                                                                 char* foo)
803 {
804         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TCP);
805 }
806 #endif
807
808
809 #ifdef USE_TLS
810 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
811                                                                                 char* foo)
812 {
813         return _w_t_forward_nonack(msg, ( struct proxy_l *) proxy, PROTO_TLS);
814 }
815 #endif
816
817 inline static int w_t_forward_nonack_to( struct sip_msg  *p_msg ,
818         char *proto_par, 
819         char *addr_par   )
820 {
821         struct proxy_l *proxy;
822         int r = -1;
823         proxy = t_protoaddr2proxy(proto_par, addr_par);
824         if (proxy) {
825                 r = _w_t_forward_nonack(p_msg, proxy, proxy->proto);            
826                 free_proxy(proxy);
827         }
828         return r;
829 }
830
831
832 inline static int w_t_reply(struct sip_msg* msg, char* p1, char* p2)
833 {
834         struct cell *t;
835         int code, ret = -1;
836         str reason;
837         char* r;
838
839         if (msg->REQ_METHOD==METHOD_ACK) {
840                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
841                 return -1;
842         }
843         if (t_check( msg , 0 )==-1) return -1;
844         t=get_t();
845         if (!t) {
846                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
847                         "for which no T-state has been established\n");
848                 return -1;
849         }
850
851         if (get_int_fparam(&code, msg, (fparam_t*)p1) < 0) {
852             code = default_code;
853         }
854         
855         if (get_str_fparam(&reason, msg, (fparam_t*)p2) < 0) {
856             reason = default_reason;
857         }
858         
859         r = as_asciiz(&reason);
860         if (r == NULL) r = default_reason.s;
861         
862         /* if called from reply_route, make sure that unsafe version
863          * is called; we are already in a mutex and another mutex in
864          * the safe version would lead to a deadlock
865          */
866          
867         if (rmode==MODE_ONFAILURE) {
868                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
869                 ret = t_reply_unsafe(t, msg, code, r);
870         } else if (rmode==MODE_REQUEST) {
871                 ret = t_reply( t, msg, code, r);
872         } else {
873                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
874                 ret = -1;
875         }
876
877         if (r) pkg_free(r);
878         return ret;
879 }
880
881
882 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
883 {
884         struct cell *t;
885         if (t_check( msg  , 0  )==-1) return -1;
886         t=get_t();
887         if ( t && t!=T_UNDEFINED )
888                 return t_release_transaction( t );
889         return 1;
890 }
891
892
893 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
894 {
895         struct cell *t;
896
897
898         if (t_check( p_msg  , 0 )==-1)
899                 return 1;
900         t=get_t();
901         if (t) {
902                 if (p_msg->REQ_METHOD==METHOD_ACK) {
903                         LOG(L_WARN, "WARNING: : ACKs transmit_replies not replied\n");
904                         return -1;
905                 }
906                 return t_retransmit_reply( t );
907         } else
908                 return -1;
909 }
910
911
912 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar )
913 {
914         /* t_newtran returns 0 on error (negative value means
915            'transaction exists' */
916         int ret;
917         ret = t_newtran( p_msg );
918         if (ret==E_SCRIPT) {
919                 LOG(L_ERR, "ERROR: t_newtran: "
920                         "transaction already in process %p\n", get_t() );
921         }
922         return ret;
923 }
924
925
926 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
927 {
928         t_on_negative( (unsigned int )(long) go_to );
929         return 1;
930 }
931
932 inline static int w_t_on_branch( struct sip_msg* msg, char *go_to, char *foo)
933 {
934         t_on_branch( (unsigned int )(long) go_to );
935         return 1;
936 }
937
938
939 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
940 {
941         t_on_reply( (unsigned int )(long) go_to );
942         return 1;
943 }
944
945
946
947 inline static int _w_t_relay_to( struct sip_msg  *p_msg ,
948         struct proxy_l *proxy )
949 {
950         struct cell *t;
951
952         if (rmode==MODE_ONFAILURE) {
953                 t=get_t();
954                 if (!t || t==T_UNDEFINED) {
955                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
956                         return -1;
957                 }
958                 if (t_forward_nonack(t, p_msg, proxy, PROTO_NONE)<=0 ) {
959                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
960                         return -1;
961                 }
962                 return 1;
963         }
964         if (rmode==MODE_REQUEST)
965                 return t_relay_to( p_msg, proxy, PROTO_NONE,
966                         0 /* no replication */ );
967         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
968         return 0;
969 }
970
971
972 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg ,
973         char *proxy, /* struct proxy_l *proxy expected */
974         char *_foo       /* nothing expected */ )
975 {
976         ((struct proxy_l *)proxy)->proto=PROTO_UDP;
977         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
978 }
979
980
981 #ifdef USE_TCP
982 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg ,
983         char *proxy, /* struct proxy_l *proxy expected */
984         char *_foo       /* nothing expected */ )
985 {
986         ((struct proxy_l *)proxy)->proto=PROTO_TCP;
987         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
988 }
989 #endif
990
991
992 #ifdef USE_TLS
993 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg ,
994         char *proxy, /* struct proxy_l *proxy expected */
995         char *_foo       /* nothing expected */ )
996 {
997         ((struct proxy_l *)proxy)->proto=PROTO_TLS;
998         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
999 }
1000 #endif
1001
1002 inline static int w_t_relay_to( struct sip_msg  *p_msg ,
1003         char *proto_par, 
1004         char *addr_par   )
1005 {
1006         struct proxy_l *proxy;
1007         int r = -1;
1008         proxy = t_protoaddr2proxy(proto_par, addr_par);
1009         if (proxy) {
1010                 r = _w_t_relay_to(p_msg, proxy);                
1011                 free_proxy(proxy);
1012         }
1013         return r;
1014 }
1015
1016
1017 inline static int w_t_replicate( struct sip_msg  *p_msg ,
1018         char *proxy, /* struct proxy_l *proxy expected */
1019         char *_foo       /* nothing expected */ )
1020 {
1021         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
1022 }
1023
1024 inline static int w_t_replicate_udp( struct sip_msg  *p_msg ,
1025         char *proxy, /* struct proxy_l *proxy expected */
1026         char *_foo       /* nothing expected */ )
1027 {
1028         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
1029 }
1030
1031
1032 #ifdef USE_TCP
1033 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg ,
1034         char *proxy, /* struct proxy_l *proxy expected */
1035         char *_foo       /* nothing expected */ )
1036 {
1037         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
1038 }
1039 #endif
1040
1041
1042 #ifdef USE_TLS
1043 inline static int w_t_replicate_tls( struct sip_msg  *p_msg ,
1044         char *proxy, /* struct proxy_l *proxy expected */
1045         char *_foo       /* nothing expected */ )
1046 {
1047         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
1048 }
1049 #endif
1050
1051 inline static int w_t_replicate_to( struct sip_msg  *p_msg ,
1052         char *proto_par, 
1053         char *addr_par   )
1054 {
1055         struct proxy_l *proxy;
1056         int r = -1;
1057         proxy = t_protoaddr2proxy(proto_par, addr_par);
1058         if (proxy) {
1059                 r = t_replicate(p_msg, proxy, proxy->proto);            
1060                 free_proxy(proxy);
1061         }
1062         return r;
1063 }
1064
1065 inline static int w_t_relay( struct sip_msg  *p_msg ,
1066                                                 char *_foo, char *_bar)
1067 {
1068         struct cell *t;
1069
1070         if (rmode==MODE_ONFAILURE) {
1071                 t=get_t();
1072                 if (!t || t==T_UNDEFINED) {
1073                         LOG(L_CRIT, "BUG: w_t_relay: undefined T\n");
1074                         return -1;
1075                 }
1076                 if (t_forward_nonack(t, p_msg, ( struct proxy_l *) 0, PROTO_NONE)<=0) {
1077                         LOG(L_ERR, "ERROR: w_t_relay (failure mode): forwarding failed\n");
1078                         return -1;
1079                 }
1080                 return 1;
1081         }
1082         if (rmode==MODE_REQUEST)
1083                 return t_relay_to( p_msg,
1084                 (struct proxy_l *) 0 /* no proxy */, PROTO_NONE,
1085                 0 /* no replication */ );
1086         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
1087         return 0;
1088 }
1089
1090 /* set fr_inv_timeout & or fr_timeout; 0 means: use the default value */
1091 static int t_set_fr_all(struct sip_msg* msg, char* p1, char* p2)
1092 {
1093     int fr, fr_inv;
1094
1095     if (get_int_fparam(&fr_inv, msg, (fparam_t*)p1) < 0) return -1;
1096     if (p2) {
1097         if (get_int_fparam(&fr, msg, (fparam_t*)p2) < 0) return -1;
1098     } else {
1099         fr = 0;
1100     }
1101
1102     return t_set_fr(msg, fr_inv, fr);
1103 }
1104
1105 static int t_set_fr_inv(struct sip_msg* msg, char* fr_inv, char* foo)
1106 {
1107         return t_set_fr_all(msg, fr_inv, (char*)0);
1108 }
1109
1110
1111 static rpc_export_t tm_rpc[] = {
1112         {"tm.cancel", rpc_cancel,   rpc_cancel_doc,   0},
1113         {"tm.reply",  rpc_reply,    rpc_reply_doc,    0},
1114         {"tm.stats",  tm_rpc_stats, tm_rpc_stats_doc, 0},
1115         {0, 0, 0, 0}
1116 };
1117
1118 /* wrapper function needed after changes in w_t_reply */
1119 int w_t_reply_wrp(struct sip_msg *m, unsigned int code, char *txt)
1120 {
1121         fparam_t c;
1122         fparam_t r;
1123         
1124         c.type = FPARAM_INT;
1125         c.orig = NULL; /* ? */
1126         c.v.i = code;
1127         
1128         r.type = FPARAM_STRING;
1129         r.orig = NULL; /* ? */
1130         r.v.asciiz = txt;
1131
1132         return w_t_reply(m, (char *)&c, (char*)&r);
1133 }
1134