More log message fixes.
[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 unlikly for fresh, juicy pices 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  */
75
76
77 #include "defs.h"
78
79
80 #include <stdio.h>
81 #include <string.h>
82 #include <netdb.h>
83
84 #include "../../sr_module.h"
85 #include "../../dprint.h"
86 #include "../../error.h"
87 #include "../../ut.h"
88 #include "../../script_cb.h"
89 #include "../../fifo_server.h"
90 #include "../../usr_avp.h"
91 #include "../../mem/mem.h"
92 #include "../../unixsock_server.h"
93
94 #include "sip_msg.h"
95 #include "h_table.h"
96 #include "t_hooks.h"
97 #include "tm_load.h"
98 #include "ut.h"
99 #include "t_reply.h"
100 #include "uac.h"
101 #include "uac_fifo.h"
102 #include "uac_unixsock.h"
103 #include "t_fwd.h"
104 #include "t_lookup.h"
105 #include "t_stats.h"
106 #include "callid.h"
107 #include "t_cancel.h"
108 #include "t_fifo.h"
109
110 MODULE_VERSION
111
112 /* fixup functions */
113 static int fixup_t_send_reply(void** param, int param_no);
114 static int fixup_str2int( void** param, int param_no);
115 static int fixup_hostport2proxy(void** param, int param_no);
116 static int fixup_str2regexp(void** param, int param_no);
117
118
119 /* init functions */
120 static int mod_init(void);
121 static int child_init(int rank);
122
123
124 /* exported functions */
125 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
126 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
127 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
128 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo,
129                                 char* bar );
130 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
131 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
132 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , char *proxy, 
133                                  char *);
134 #ifdef USE_TCP
135 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , char *proxy,
136                                 char *);
137 #endif
138 #ifdef USE_TLS
139 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , char *proxy,
140                                 char *);
141 #endif
142 inline static int w_t_replicate( struct sip_msg  *p_msg , 
143                                 char *proxy, /* struct proxy_l *proxy expected */
144                                 char *_foo       /* nothing expected */ );
145 inline static int w_t_replicate_udp( struct sip_msg  *p_msg , 
146                                 char *proxy, /* struct proxy_l *proxy expected */
147                                 char *_foo       /* nothing expected */ );
148 #ifdef USE_TCP
149 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg , 
150                                 char *proxy, /* struct proxy_l *proxy expected */
151                                 char *_foo       /* nothing expected */ );
152 #endif
153 #ifdef USE_TLS
154 inline static int w_t_replicate_tls( struct sip_msg  *p_msg , 
155                                 char *proxy, /* struct proxy_l *proxy expected */
156                                 char *_foo       /* nothing expected */ );
157 #endif
158 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
159 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char* str,char*);
160 inline static int w_t_forward_nonack_udp(struct sip_msg* msg, char* str,char*);
161 #ifdef USE_TCP
162 inline static int w_t_forward_nonack_tcp(struct sip_msg* msg, char* str,char*);
163 #endif
164 #ifdef USE_TLS
165 inline static int w_t_forward_nonack_tls(struct sip_msg* msg, char* str,char*);
166 #endif
167 inline static int w_t_on_negative(struct sip_msg* msg, char *go_to, char *foo);
168 inline static int w_t_on_reply(struct sip_msg* msg, char *go_to, char *foo );
169 inline static int t_check_status(struct sip_msg* msg, char *regexp, char *foo);
170
171
172 static cmd_export_t cmds[]={
173         {"t_newtran",          w_t_newtran,             0, 0,
174                         REQUEST_ROUTE},
175         {"t_lookup_request",   w_t_check,               0, 0,
176                         REQUEST_ROUTE},
177         {T_REPLY,              w_t_reply,               2, fixup_t_send_reply,
178                         REQUEST_ROUTE | FAILURE_ROUTE },
179         {"t_retransmit_reply", w_t_retransmit_reply,    0, 0,
180                         REQUEST_ROUTE},
181         {"t_release",          w_t_release,             0, 0,
182                         REQUEST_ROUTE},
183         {T_RELAY_TO_UDP,       w_t_relay_to_udp,        2, fixup_hostport2proxy,
184                         REQUEST_ROUTE|FAILURE_ROUTE},
185 #ifdef USE_TCP
186         {T_RELAY_TO_TCP,       w_t_relay_to_tcp,        2, fixup_hostport2proxy,
187                         REQUEST_ROUTE|FAILURE_ROUTE},
188 #endif
189 #ifdef USE_TLS
190         {T_RELAY_TO_TLS,       w_t_relay_to_tls,        2, fixup_hostport2proxy,
191                         REQUEST_ROUTE|FAILURE_ROUTE},
192 #endif
193         {"t_replicate",        w_t_replicate,           2, fixup_hostport2proxy,
194                         REQUEST_ROUTE},
195         {"t_replicate_udp",    w_t_replicate_udp,       2, fixup_hostport2proxy,
196                         REQUEST_ROUTE},
197 #ifdef USE_TCP
198         {"t_replicate_tcp",    w_t_replicate_tcp,       2, fixup_hostport2proxy,
199                         REQUEST_ROUTE},
200 #endif
201 #ifdef USE_TLS
202         {"t_replicate_tls",    w_t_replicate_tls,       2, fixup_hostport2proxy,
203                         REQUEST_ROUTE},
204 #endif
205         {T_RELAY,              w_t_relay,               0, 0,
206                         REQUEST_ROUTE | FAILURE_ROUTE },
207         {T_FORWARD_NONACK,     w_t_forward_nonack,      2, fixup_hostport2proxy,
208                         REQUEST_ROUTE},
209         {T_FORWARD_NONACK_URI, w_t_forward_nonack_uri,  0, 0,
210                         REQUEST_ROUTE},
211         {T_FORWARD_NONACK_UDP, w_t_forward_nonack_udp,  2, fixup_hostport2proxy,
212                         REQUEST_ROUTE},
213 #ifdef USE_TCP
214         {T_FORWARD_NONACK_TCP, w_t_forward_nonack_tcp,  2, fixup_hostport2proxy,
215                         REQUEST_ROUTE},
216 #endif
217 #ifdef USE_TLS
218         {T_FORWARD_NONACK_TLS, w_t_forward_nonack_tls,  2, fixup_hostport2proxy,
219                         REQUEST_ROUTE},
220 #endif
221         {"t_on_failure",       w_t_on_negative,         1, fixup_str2int,
222                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
223         {"t_on_reply",         w_t_on_reply,            1, fixup_str2int,
224                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
225         {"t_check_status",     t_check_status,          1, fixup_str2regexp,
226                         REQUEST_ROUTE | FAILURE_ROUTE | ONREPLY_ROUTE },
227         {"t_write_req",       t_write_req,              2, 0,
228                         REQUEST_ROUTE | FAILURE_ROUTE },
229         {"t_write_unix",      t_write_unix,             2, 0,
230                         REQUEST_ROUTE | FAILURE_ROUTE },
231
232         /* not applicable from the script */
233         {"register_tmcb",      (cmd_function)register_tmcb,     NO_SCRIPT,   0, 0},
234         {"load_tm",            (cmd_function)load_tm,           NO_SCRIPT,   0, 0},
235         {T_REPLY_WB,           (cmd_function)t_reply_with_body, NO_SCRIPT,   0, 0},
236         {T_IS_LOCAL,           (cmd_function)t_is_local,        NO_SCRIPT,   0, 0},
237         {T_GET_TI,             (cmd_function)t_get_trans_ident, NO_SCRIPT,   0, 0},
238         {T_LOOKUP_IDENT,       (cmd_function)t_lookup_ident,    NO_SCRIPT,   0, 0},
239         {T_ADDBLIND,           (cmd_function)add_blind_uac,     NO_SCRIPT,   0, 0},
240         {"t_request_within",   (cmd_function)req_within,        NO_SCRIPT,   0, 0},
241         {"t_request_outside",  (cmd_function)req_outside,       NO_SCRIPT,   0, 0},
242         {"t_request",          (cmd_function)request,           NO_SCRIPT,   0, 0},
243         {"new_dlg_uac",        (cmd_function)new_dlg_uac,       NO_SCRIPT,   0, 0},
244         {"dlg_response_uac",   (cmd_function)dlg_response_uac,  NO_SCRIPT,   0, 0},
245         {"new_dlg_uas",        (cmd_function)new_dlg_uas,       NO_SCRIPT,   0, 0},
246         {"dlg_request_uas",    (cmd_function)dlg_request_uas,   NO_SCRIPT,   0, 0},
247         {"free_dlg",           (cmd_function)free_dlg,          NO_SCRIPT,   0, 0},
248         {"print_dlg",          (cmd_function)print_dlg,         NO_SCRIPT,   0, 0},
249         {T_GETT,               (cmd_function)get_t,             NO_SCRIPT,   0,0},
250         {0,0,0,0,0}
251 };
252
253
254 static param_export_t params[]={
255         {"ruri_matching",         INT_PARAM, &ruri_matching                         },
256         {"via1_matching",         INT_PARAM, &via1_matching                         },
257         {"fr_timer",              INT_PARAM, &(timer_id2timeout[FR_TIMER_LIST])     },
258         {"fr_inv_timer",          INT_PARAM, &(timer_id2timeout[FR_INV_TIMER_LIST]) },
259         {"wt_timer",              INT_PARAM, &(timer_id2timeout[WT_TIMER_LIST])     },
260         {"delete_timer",          INT_PARAM, &(timer_id2timeout[DELETE_LIST])       },
261         {"retr_timer1p1",         INT_PARAM, &(timer_id2timeout[RT_T1_TO_1])        },
262         {"retr_timer1p2",         INT_PARAM, &(timer_id2timeout[RT_T1_TO_2])        },
263         {"retr_timer1p3",         INT_PARAM, &(timer_id2timeout[RT_T1_TO_3])        },
264         {"retr_timer2",           INT_PARAM, &(timer_id2timeout[RT_T2])             },
265         {"noisy_ctimer",          INT_PARAM, &noisy_ctimer                          },
266         {"uac_from",              STR_PARAM, &uac_from                              },
267         {"unix_tx_timeout",       INT_PARAM, &tm_unix_tx_timeout                    },
268         {0,0,0}
269 };
270
271
272 #ifdef STATIC_TM
273 struct module_exports tm_exports = {
274 #else
275 struct module_exports exports= {
276 #endif
277         "tm",
278         /* -------- exported functions ----------- */
279         cmds,
280         /* ------------ exported variables ---------- */
281         params,
282         
283         mod_init, /* module initialization function */
284         (response_function) reply_received,
285         (destroy_function) tm_shutdown,
286         0, /* w_onbreak, */
287         child_init /* per-child init function */
288 };
289
290
291
292 /**************************** fixup functions ******************************/
293 static int fixup_str2int( void** param, int param_no)
294 {
295         unsigned long go_to;
296         int err;
297
298         if (param_no==1) {
299                 go_to=str2s(*param, strlen(*param), &err );
300                 if (err==0) {
301                         pkg_free(*param);
302                         *param=(void *)go_to;
303                         return 0;
304                 } else {
305                         LOG(L_ERR, "ERROR: fixup_str2int: bad number <%s>\n",
306                                 (char *)(*param));
307                         return E_CFG;
308                 }
309         }
310         return 0;
311 }
312
313
314 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
315 static int fixup_hostport2proxy(void** param, int param_no)
316 {
317         unsigned int port;
318         char *host;
319         int err;
320         struct proxy_l *proxy;
321         str s;
322         
323         DBG("TM module: fixup_hostport2proxy(%s, %d)\n", (char*)*param, param_no);
324         if (param_no==1){
325                 DBG("TM module: fixup_hostport2proxy: param 1.. do nothing, wait for #2\n");
326                 return 0;
327         } else if (param_no==2) {
328
329                 host=(char *) (*(param-1)); 
330                 port=str2s(*param, strlen(*param), &err);
331                 if (err!=0) {
332                         LOG(L_ERR, "TM module:fixup_hostport2proxy: bad port number <%s>\n",
333                                 (char*)(*param));
334                          return E_UNSPEC;
335                 }
336                 s.s = host;
337                 s.len = strlen(host);
338                 proxy=mk_proxy(&s, port, 0); /* FIXME: udp or tcp? */
339                 if (proxy==0) {
340                         LOG(L_ERR, "ERROR: fixup_hostport2proxy: bad host name in URI <%s>\n",
341                                 host );
342                         return E_BAD_ADDRESS;
343                 }
344                 /* success -- fix the first parameter to proxy now ! */
345
346                 /* FIXME: janakj, mk_proxy doesn't make copy of host !! */
347                 /*pkg_free( *(param-1)); you're right --andrei*/
348                 *(param-1)=proxy;
349                 return 0;
350         } else {
351                 LOG(L_ERR,"ERROR: fixup_hostport2proxy called with parameter #<>{1,2}\n");
352                 return E_BUG;
353         }
354 }
355
356
357 /* (char *code, char *reason_phrase)==>(int code, r_p as is) */
358 static int fixup_t_send_reply(void** param, int param_no)
359 {
360         unsigned long code;
361         int err;
362
363         if (param_no==1){
364                 code=str2s(*param, strlen(*param), &err);
365                 if (err==0){
366                         pkg_free(*param);
367                         *param=(void*)code;
368                         return 0;
369                 }else{
370                         LOG(L_ERR, "TM module:fixup_t_send_reply: bad  number <%s>\n",
371                                         (char*)(*param));
372                         return E_UNSPEC;
373                 }
374         }
375         /* second param => no conversion*/
376         return 0;
377 }
378
379
380 static int fixup_str2regexp(void** param, int param_no)
381 {
382         regex_t* re;
383
384         if (param_no==1) {
385                 if ((re=pkg_malloc(sizeof(regex_t)))==0)
386                         return E_OUT_OF_MEM;
387                 if (regcomp(re, *param, REG_EXTENDED|REG_ICASE|REG_NEWLINE) ) {
388                         pkg_free(re);
389                         LOG(L_ERR,"ERROR: %s : bad re %s\n", exports.name, (char*)*param);
390                         return E_BAD_RE;
391                 }
392                 /* free string */
393                 pkg_free(*param);
394                 /* replace it with the compiled re */
395                 *param=re;
396         } else {
397                 LOG(L_ERR,"ERROR: fixup_str2regexp called with parameter != 1\n");
398                 return E_BUG;
399         }
400         return 0;
401 }
402
403
404
405
406 /***************************** init functions *****************************/
407 static int w_t_unref( struct sip_msg *foo, void *bar)
408 {
409         return t_unref(foo);
410 }
411
412
413 static int script_init( struct sip_msg *foo, void *bar)
414 {   
415         /* we primarily reset all private memory here to make sure
416          * private values left over from previous message will
417          * not be used again */
418
419         if (foo->first_line.type==SIP_REQUEST){
420                 /* make sure the new message will not inherit previous
421                         message's t_on_negative value
422                 */
423                 t_on_negative( 0 );
424                 t_on_reply(0);
425                 /* reset the kr status */
426                 set_kr(0);
427                 /* set request mode so that multiple-mode actions know
428                  * how to behave */
429                 rmode=MODE_REQUEST;
430         }
431         return 1;
432 }
433
434
435 static int mod_init(void)
436 {
437         DBG( "TM - (size of cell=%d) initializing...\n",sizeof(struct cell));
438         /* checking if we have sufficient bitmap capacity for given
439            maximum number of  branches */
440         if (MAX_BRANCHES+1>31) {
441                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
442                         MAX_BRANCHES );
443                 return -1;
444         }
445
446         if (init_callid() < 0) {
447                 LOG(L_CRIT, "Error while initializin Call-ID generator\n");
448                 return -1;
449         }
450
451         if (register_fifo_cmd(fifo_uac, "t_uac_dlg", 0) < 0) {
452                 LOG(L_CRIT, "cannot register fifo t_uac\n");
453                 return -1;
454         }
455
456         if (register_fifo_cmd(fifo_uac_cancel, "t_uac_cancel", 0) < 0) {
457                 LOG(L_CRIT, "cannot register fifo t_uac_cancel\n");
458                 return -1;
459         }
460
461         if (register_fifo_cmd(fifo_hash, "t_hash", 0)<0) {
462                 LOG(L_CRIT, "cannot register hash\n");
463                 return -1;
464         }
465
466         if (register_fifo_cmd(fifo_t_reply, "t_reply", 0)<0) {
467                 LOG(L_CRIT, "cannot register t_reply\n");
468                 return -1;
469         }
470
471         if (unixsock_register_cmd("t_uac_dlg", unixsock_uac) < 0) {
472                 LOG(L_CRIT, "cannot register t_uac with the unix server\n");
473                 return -1;
474         }
475
476         if (unixsock_register_cmd("t_uac_cancel", unixsock_uac_cancel) < 0) {
477                 LOG(L_CRIT, "cannot register t_uac_cancel with the unix server\n");
478                 return -1;
479         }
480
481         if (unixsock_register_cmd("t_hash", unixsock_hash) < 0) {
482                 LOG(L_CRIT, "cannot register t_hash with the unix server\n");
483                 return -1;
484         }
485
486         if (unixsock_register_cmd("t_reply", unixsock_t_reply) < 0) {
487                 LOG(L_CRIT, "cannot register t_reply with the unix server\n");
488                 return -1;
489         }
490
491         /* building the hash table*/
492         if (!init_hash_table()) {
493                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
494                 return -1;
495         }
496
497         /* init static hidden values */
498         init_t();
499
500         if (!tm_init_timers()) {
501                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
502                 return -1;
503         }
504         /* register the timer function */
505         register_timer( timer_routine , 0 /* empty attr */, 1 );
506
507         /* init_tm_stats calls process_count, which should
508          * NOT be called from mod_init, because one does not
509          * now, if a timer is used and thus how many processes
510          * will be started; however we started already our
511          * timers, so we know and process_count should not
512          * change any more
513          */     
514         if (init_tm_stats()<0) {
515                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
516                 return -1;
517         }
518
519         if (uac_init()==-1) {
520                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
521                 return -1;
522         }
523
524         if (init_tmcb_lists()!=1) {
525                 LOG(L_CRIT, "ERROR:tm:mod_init: failed to init tmcb lists\n");
526                 return -1;
527         }
528
529         tm_init_tags();
530         init_twrite_lines();
531         if (init_twrite_sock() < 0) {
532                 LOG(L_ERR, "ERROR:tm:mod_init: Unable to create socket\n");
533                 return -1;
534         }
535
536         /* register post-script clean-up function */
537         register_script_cb( w_t_unref, POST_SCRIPT_CB, 
538                         0 /* empty param */ );
539         register_script_cb( script_init, PRE_SCRIPT_CB , 
540                         0 /* empty param */ );
541
542         return 0;
543 }
544
545 static int child_init(int rank) {
546         if (child_init_callid(rank) < 0) {
547                 LOG(L_ERR, "ERROR: child_init: Error while initializing Call-ID generator\n");
548                 return -2;
549         }
550
551         return 0;
552 }
553
554
555
556
557
558 /**************************** wrapper functions ***************************/
559 static int t_check_status(struct sip_msg* msg, char *regexp, char *foo)
560 {
561         regmatch_t pmatch;
562         struct cell *t;
563         char *status;
564         char backup;
565         int lowest_status;
566         int n;
567
568         /* first get the transaction */
569         if (t_check( msg , 0 )==-1) return -1;
570         if ( (t=get_t())==0) {
571                 LOG(L_ERR, "ERROR: t_check_status: cannot check status for a reply "
572                         "which has no T-state established\n");
573                 return -1;
574         }
575         backup = 0;
576
577         switch (rmode) {
578                 case MODE_REQUEST:
579                         /* use the status of the last sent reply */
580                         status = int2str( t->uas.status, 0);
581                         break;
582                 case MODE_ONREPLY:
583                         /* use the status of the current reply */
584                         status = msg->first_line.u.reply.status.s;
585                         backup = status[msg->first_line.u.reply.status.len];
586                         status[msg->first_line.u.reply.status.len] = 0;
587                         break;
588                 case MODE_ONFAILURE:
589                         /* use the status of the winning reply */
590                         if (t_pick_branch( -1, 0, t, &lowest_status)<0 ) {
591                                 LOG(L_CRIT,"BUG:t_check_status: t_pick_branch failed to get "
592                                         " a final response in MODE_ONFAILURE\n");
593                                 return -1;
594                         }
595                         status = int2str( lowest_status , 0);
596                         break;
597                 default:
598                         LOG(L_ERR,"ERROR:t_check_status: unsupported mode %d\n",rmode);
599                         return -1;
600         }
601
602         DBG("DEBUG:t_check_status: checked status is <%s>\n",status);
603         /* do the checking */
604         n = regexec((regex_t*)regexp, status, 1, &pmatch, 0);
605
606         if (backup) status[msg->first_line.u.reply.status.len] = backup;
607         if (n!=0) return -1;
608         return 1;
609 }
610
611
612 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
613 {
614         return t_check( msg , 0  ) ? 1 : -1;
615 }
616
617
618 inline static int _w_t_forward_nonack(struct sip_msg* msg, char* proxy,
619                                                                                                                                         int proto)
620 {
621         struct cell *t;
622         if (t_check( msg , 0 )==-1) {
623                 LOG(L_ERR, "ERROR: forward_nonack: "
624                                 "can't forward when no transaction was set up\n");
625                 return -1;
626         }
627         t=get_t();
628         if ( t && t!=T_UNDEFINED ) {
629                 if (msg->REQ_METHOD==METHOD_ACK) {
630                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
631                         return -1;
632                 }
633                 return t_forward_nonack(t, msg, ( struct proxy_l *) proxy, proto );
634         } else {
635                 DBG("DEBUG: forward_nonack: no transaction found\n");
636                 return -1;
637         }
638 }
639
640
641 inline static int w_t_forward_nonack( struct sip_msg* msg, char* proxy,
642                                                                                 char* foo)
643 {
644         return _w_t_forward_nonack(msg, proxy, PROTO_NONE);
645 }
646
647
648 inline static int w_t_forward_nonack_uri(struct sip_msg* msg, char *foo,
649                                                                                                                                         char *bar)
650 {
651         return _w_t_forward_nonack(msg, 0, PROTO_NONE);
652 }
653
654
655 inline static int w_t_forward_nonack_udp( struct sip_msg* msg, char* proxy,
656                                                                                 char* foo)
657 {
658         return _w_t_forward_nonack(msg, proxy, PROTO_UDP);
659 }
660
661
662 #ifdef USE_TCP
663 inline static int w_t_forward_nonack_tcp( struct sip_msg* msg, char* proxy,
664                                                                                 char* foo)
665 {
666         return _w_t_forward_nonack(msg, proxy, PROTO_TCP);
667 }
668 #endif
669
670
671 #ifdef USE_TLS
672 inline static int w_t_forward_nonack_tls( struct sip_msg* msg, char* proxy,
673                                                                                 char* foo)
674 {
675         return _w_t_forward_nonack(msg, proxy, PROTO_TLS);
676 }
677 #endif
678
679
680 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2)
681 {
682         struct cell *t;
683
684         if (msg->REQ_METHOD==METHOD_ACK) {
685                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
686                 return -1;
687         }
688         if (t_check( msg , 0 )==-1) return -1;
689         t=get_t();
690         if (!t) {
691                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
692                         "for which no T-state has been established\n");
693                 return -1;
694         }
695         /* if called from reply_route, make sure that unsafe version
696          * is called; we are already in a mutex and another mutex in
697          * the safe version would lead to a deadlock
698          */
699         if (rmode==MODE_ONFAILURE) { 
700                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
701                 return t_reply_unsafe(t, msg, (unsigned int)(long) str, str2);
702         } else if (rmode==MODE_REQUEST) {
703                 return t_reply( t, msg, (unsigned int)(long) str, str2);
704         } else {
705                 LOG(L_CRIT, "BUG: w_t_reply entered in unsupported mode\n");
706                 return -1;
707         }
708 }
709
710
711 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
712 {
713         struct cell *t;
714         if (t_check( msg  , 0  )==-1) return -1;
715         t=get_t();
716         if ( t && t!=T_UNDEFINED ) 
717                 return t_release_transaction( t );
718         return 1;
719 }
720
721
722 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
723 {
724         struct cell *t;
725
726
727         if (t_check( p_msg  , 0 )==-1) 
728                 return 1;
729         t=get_t();
730         if (t) {
731                 if (p_msg->REQ_METHOD==METHOD_ACK) {
732                         LOG(L_WARN, "WARNING: : ACKs ansmit_replies not replied\n");
733                         return -1;
734                 }
735                 return t_retransmit_reply( t );
736         } else 
737                 return -1;
738 }
739
740
741 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar ) 
742 {
743         /* t_newtran returns 0 on error (negative value means
744            'transaction exists' */
745         return t_newtran( p_msg );
746 }
747
748
749 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo)
750 {
751         t_on_negative( (unsigned int )(long) go_to );
752         return 1;
753 }
754
755
756 inline static int w_t_on_reply( struct sip_msg* msg, char *go_to, char *foo )
757 {
758         t_on_reply( (unsigned int )(long) go_to );
759         return 1;
760 }
761
762
763
764 inline static int _w_t_relay_to( struct sip_msg  *p_msg , 
765         struct proxy_l *proxy )
766 {
767         struct cell *t;
768
769         if (rmode==MODE_ONFAILURE) { 
770                 t=get_t();
771                 if (!t || t==T_UNDEFINED) {
772                         LOG(L_CRIT, "BUG: w_t_relay_to: undefined T\n");
773                         return -1;
774                 }
775                 if (t_forward_nonack(t, p_msg, proxy, PROTO_NONE)<=0 ) {
776                         LOG(L_ERR, "ERROR: w_t_relay_to: t_relay_to failed\n");
777                         return -1;
778                 }
779                 return 1;
780         }
781         if (rmode==MODE_REQUEST) 
782                 return t_relay_to( p_msg, proxy, PROTO_NONE,
783                         0 /* no replication */ );
784         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
785         return 0;
786 }
787
788
789 inline static int w_t_relay_to_udp( struct sip_msg  *p_msg , 
790         char *proxy, /* struct proxy_l *proxy expected */
791         char *_foo       /* nothing expected */ )
792 {
793         ((struct proxy_l *)proxy)->proto=PROTO_UDP;
794         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
795 }
796
797
798 #ifdef USE_TCP
799 inline static int w_t_relay_to_tcp( struct sip_msg  *p_msg , 
800         char *proxy, /* struct proxy_l *proxy expected */
801         char *_foo       /* nothing expected */ )
802 {
803         ((struct proxy_l *)proxy)->proto=PROTO_TCP;
804         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
805 }
806 #endif
807
808
809 #ifdef USE_TLS
810 inline static int w_t_relay_to_tls( struct sip_msg  *p_msg , 
811         char *proxy, /* struct proxy_l *proxy expected */
812         char *_foo       /* nothing expected */ )
813 {
814         ((struct proxy_l *)proxy)->proto=PROTO_TLS;
815         return _w_t_relay_to( p_msg, ( struct proxy_l *) proxy);
816 }
817 #endif
818
819
820 inline static int w_t_replicate( struct sip_msg  *p_msg , 
821         char *proxy, /* struct proxy_l *proxy expected */
822         char *_foo       /* nothing expected */ )
823 {
824         return t_replicate(p_msg, ( struct proxy_l *) proxy, p_msg->rcv.proto );
825 }
826
827
828 inline static int w_t_replicate_udp( struct sip_msg  *p_msg , 
829         char *proxy, /* struct proxy_l *proxy expected */
830         char *_foo       /* nothing expected */ )
831 {
832         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_UDP );
833 }
834
835
836 #ifdef USE_TCP
837 inline static int w_t_replicate_tcp( struct sip_msg  *p_msg , 
838         char *proxy, /* struct proxy_l *proxy expected */
839         char *_foo       /* nothing expected */ )
840 {
841         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TCP );
842 }
843 #endif
844
845
846 #ifdef USE_TLS
847 inline static int w_t_replicate_tls( struct sip_msg  *p_msg , 
848         char *proxy, /* struct proxy_l *proxy expected */
849         char *_foo       /* nothing expected */ )
850 {
851         return t_replicate(p_msg, ( struct proxy_l *) proxy, PROTO_TLS );
852 }
853 #endif
854
855
856 inline static int w_t_relay( struct sip_msg  *p_msg , 
857                                                 char *_foo, char *_bar)
858 {
859         struct cell *t;
860
861         if (rmode==MODE_ONFAILURE) { 
862                 t=get_t();
863                 if (!t || t==T_UNDEFINED) {
864                         LOG(L_CRIT, "BUG: w_t_relay: undefined T\n");
865                         return -1;
866                 } 
867                 if (t_forward_nonack(t, p_msg, ( struct proxy_l *) 0, PROTO_NONE)<=0) {
868                         LOG(L_ERR, "ERROR: w_t_relay (failure mode): forwarding failed\n");
869                         return -1;
870                 }
871                 return 1;
872         }
873         if (rmode==MODE_REQUEST) 
874                 return t_relay_to( p_msg, 
875                 (struct proxy_l *) 0 /* no proxy */, PROTO_NONE,
876                 0 /* no replication */ );
877         LOG(L_CRIT, "ERROR: w_t_relay_to: unsupported mode: %d\n", rmode);
878         return 0;
879 }