174279ef8e56c09ee660d71fd7ddb782ea4018f2
[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
56 #include "defs.h"
57
58
59 #include <stdio.h>
60 #include <string.h>
61 #include <netdb.h>
62
63 #include "../../sr_module.h"
64 #include "../../dprint.h"
65 #include "../../error.h"
66 #include "../../ut.h"
67 #include "../../script_cb.h"
68 #include "../../fifo_server.h"
69
70 #include "sip_msg.h"
71 #include "h_table.h"
72 #include "t_funcs.h"
73 #include "t_hooks.h"
74 #include "tm_load.h"
75 #include "ut.h"
76 #include "t_reply.h"
77 #include "uac.h"
78 #include "t_fwd.h"
79 #include "t_lookup.h"
80 #include "t_stats.h"
81
82
83
84 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2);
85 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2);
86 #ifdef _OBSOLETED
87 inline static int w_t_reply_unsafe(struct sip_msg* msg, char* str, char* str2);
88 #endif
89 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2);
90 inline static int fixup_t_send_reply(void** param, int param_no);
91 inline static int fixup_str2int( void** param, int param_no);
92 inline static int w_t_retransmit_reply(struct sip_msg* p_msg, char* foo, char* bar );
93 inline static int w_t_newtran(struct sip_msg* p_msg, char* foo, char* bar );
94 inline static int w_t_newdlg( struct sip_msg* p_msg, char* foo, char* bar );
95 inline static int w_t_relay( struct sip_msg  *p_msg , char *_foo, char *_bar);
96 inline static int w_t_relay_to( struct sip_msg  *p_msg , char *proxy, char *);
97 inline static int w_t_replicate( struct sip_msg  *p_msg , 
98         char *proxy, /* struct proxy_l *proxy expected */
99         char *_foo       /* nothing expected */ );
100 inline static int w_t_forward_nonack(struct sip_msg* msg, char* str, char* );
101 inline static int fixup_hostport2proxy(void** param, int param_no);
102 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo );
103
104
105 static int mod_init(void);
106
107 static int child_init(int rank);
108
109
110 #ifdef STATIC_TM
111 struct module_exports tm_exports = {
112 #else
113 struct module_exports exports= {
114 #endif
115         "tm",
116         /* -------- exported functions ----------- */
117         (char*[]){                      
118                                 "t_newtran",
119                                 "t_lookup_request",
120                                 T_REPLY,
121 #ifdef _OBSO
122                                 T_REPLY_UNSAFE,
123 #endif
124                                 "t_retransmit_reply",
125                                 "t_release",
126                                 T_RELAY_TO,
127                                 "t_replicate",
128                                 T_RELAY,
129                                 T_FORWARD_NONACK,
130                                 "t_on_negative",
131
132                                 /* not applicable from script ... */
133
134                                 "register_tmcb",
135 #ifndef DEPRECATE_OLD_STUFF
136                                 T_UAC,
137 #endif
138                                 T_UAC_DLG,
139                                 "load_tm",
140                                 "t_newdlg"
141                         },
142         (cmd_function[]){
143                                         w_t_newtran,
144                                         w_t_check,
145                                         w_t_reply,
146 #ifdef _OBSO
147                                         w_t_reply_unsafe,
148 #endif
149                                         w_t_retransmit_reply,
150                                         w_t_release,
151                                         w_t_relay_to,
152                                         w_t_replicate,
153                                         w_t_relay,
154                                         w_t_forward_nonack,
155                                         w_t_on_negative,
156
157                                         (cmd_function) register_tmcb,
158 #ifndef DEPRECATE_OLD_STUFF
159                                         (cmd_function) t_uac,
160 #endif
161                                         (cmd_function) t_uac_dlg,
162                                         (cmd_function) load_tm,
163                                         w_t_newdlg,
164                                         },
165         (int[]){
166                                 0, /* t_newtran */
167                                 0, /* t_lookup_request */
168                                 2, /* t_reply */
169 #ifdef _OBSO
170                                 2, /* t_reply_unsafe */
171 #endif
172                                 0, /* t_retransmit_reply */
173                                 0, /* t_release */
174                                 2, /* t_relay_to */
175                                 2, /* t_replicate */
176                                 0, /* t_relay */
177                                 2, /* t_forward_nonack */
178                                 1, /* t_on_negative */
179                                 NO_SCRIPT /* register_tmcb */,
180 #ifndef DEPRECATE_OLD_STUFF
181                                 NO_SCRIPT /* t_uac */,
182 #endif
183                                 NO_SCRIPT /* t_uac_dlg */,
184                                 NO_SCRIPT /* load_tm */,
185                                 0 /* t_newdlg */
186                         },
187         (fixup_function[]){
188                                 0,                                              /* t_newtran */
189                                 0,                                              /* t_lookup_request */
190                                 fixup_t_send_reply,             /* t_reply */
191 #ifdef _OBSO
192                                 fixup_t_send_reply,             /* t_reply_unsafe */
193 #endif
194                                 0,                                              /* t_retransmit_reply */
195                                 0,                                              /* t_release */
196                                 fixup_hostport2proxy,   /* t_relay_to */
197                                 fixup_hostport2proxy,   /* t_replicate */
198                                 0,                                              /* t_relay */
199                                 fixup_hostport2proxy,   /* t_forward_nonack */
200                                 fixup_str2int,                  /* t_on_negative */
201                                 0,                                              /* register_tmcb */
202 #ifndef DEPRECATE_OLD_STUFF
203                                 0,                                              /* t_uac */
204 #endif
205                                 0,                                              /* t_uac_dlg */
206                                 0,                                              /* load_tm */
207                                 0                                               /* t_newdlg */
208         
209                 },
210 #ifndef DEPRECATE_OLD_STUFF
211         1+
212 #endif
213 #ifdef _OBSO
214         15,
215 #else
216         14,
217 #endif
218
219         /* ------------ exported variables ---------- */
220         (char *[]) { /* Module parameter names */
221                 "ruri_matching",
222                 "fr_timer",
223                 "fr_inv_timer",
224                 "wt_timer",
225                 "delete_timer",
226                 "retr_timer1p1",
227                 "retr_timer1p2",
228                 "retr_timer1p3",
229                 "retr_timer2",
230                 "noisy_ctimer"
231 #ifndef DEPRECATE_OLD_STUFF
232                 ,"uac_from"
233 #endif
234         },
235         (modparam_t[]) { /* variable types */
236                 INT_PARAM, /* ruri_matching */
237                 INT_PARAM, /* fr_timer */
238                 INT_PARAM, /* fr_inv_timer */
239                 INT_PARAM, /* wt_timer */
240                 INT_PARAM, /* delete_timer */
241                 INT_PARAM,/* retr_timer1p1 */
242                 INT_PARAM, /* retr_timer1p2 */
243                 INT_PARAM, /* retr_timer1p3 */
244                 INT_PARAM, /* retr_timer2 */
245                 INT_PARAM /* noisy_ctimer */
246 #ifndef DEPRECATE_OLD_STUFF
247                 ,STR_PARAM /* uac_from */
248 #endif
249         },
250         (void *[]) { /* variable pointers */
251                 &ruri_matching,
252                 &(timer_id2timeout[FR_TIMER_LIST]),
253                 &(timer_id2timeout[FR_INV_TIMER_LIST]),
254                 &(timer_id2timeout[WT_TIMER_LIST]),
255                 &(timer_id2timeout[DELETE_LIST]),
256                 &(timer_id2timeout[RT_T1_TO_1]),
257                 &(timer_id2timeout[RT_T1_TO_2]),
258                 &(timer_id2timeout[RT_T1_TO_3]),
259                 &(timer_id2timeout[RT_T2]),
260                 &noisy_ctimer
261 #ifndef DEPRECATE_OLD_STUFF
262                 ,&uac_from
263 #endif
264         },
265 #ifndef DEPRECATE_OLD_STUFF
266         1+
267 #endif
268         10,      /* Number of module paramers */
269
270         mod_init, /* module initialization function */
271         (response_function) t_on_reply,
272         (destroy_function) tm_shutdown,
273         0, /* w_onbreak, */
274         child_init /* per-child init function */
275 };
276
277 inline static int fixup_str2int( void** param, int param_no)
278 {
279         unsigned int go_to;
280         int err;
281
282         if (param_no==1) {
283                 go_to=str2s(*param, strlen(*param), &err );
284                 if (err==0) {
285                         free(*param);
286                         *param=(void *)go_to;
287                         return 0;
288                 } else {
289                         LOG(L_ERR, "ERROR: fixup_str2int: bad number <%s>\n",
290                                 (char *)(*param));
291                         return E_CFG;
292                 }
293         }
294         return 0;
295 }
296
297 static int w_t_unref( struct sip_msg *foo, void *bar)
298 {
299         return t_unref(foo);
300 }
301
302 static int script_init( struct sip_msg *foo, void *bar)
303 {   
304         /* we primarily reset all private memory here to make sure
305            private values left over from previous message will
306            not be used again
307     */
308
309         /* make sure the new message will not inherit previous
310            message's t_on_negative value
311         */
312         t_on_negative( 0 );
313
314         return 1;
315 }
316
317 static int mod_init(void)
318 {
319
320         DBG( "TM - initializing...\n");
321         /* checking if we have sufficient bitmap capacity for given
322            maximum number of  branches */
323         if (MAX_BRANCHES+1>31) {
324                 LOG(L_CRIT, "Too many max UACs for UAC branch_bm_t bitmap: %d\n",
325                         MAX_BRANCHES );
326                 return -1;
327         }
328
329
330 #ifndef DEPRECATE_OLD_STUFF
331         if (register_fifo_cmd(fifo_uac, "t_uac", 0)<0) {
332                 LOG(L_CRIT, "cannot register fifo uac\n");
333                 return -1;
334         }
335         if (register_fifo_cmd(fifo_uac_from, "t_uac_from", 0)<0) {
336                 LOG(L_CRIT, "cannot register fifo uac\n");
337                 return -1;
338         }
339 #endif
340         if (register_fifo_cmd(fifo_uac_dlg, "t_uac_dlg", 0)<0) {
341                 LOG(L_CRIT, "cannot register fifo uac\n");
342                 return -1;
343         }
344         if (register_fifo_cmd(fifo_hash, "t_hash", 0)<0) {
345                 LOG(L_CRIT, "cannot register hash\n");
346                 return -1;
347         }
348
349         if (!init_hash_table()) {
350                 LOG(L_ERR, "ERROR: mod_init: initializing hash_table failed\n");
351                 return -1;
352         }
353
354
355         /* init static hidden values */
356         init_t();
357
358         if (!tm_init_timers()) {
359                 LOG(L_ERR, "ERROR: mod_init: timer init failed\n");
360                 return -1;
361         }
362         /* register the timer function */
363         register_timer( timer_routine , 0 /* empty attr */, 1 );
364
365         /* init_tm_stats calls process_count, which should
366          * NOT be called from mod_init, because one does not
367          * now, if a timer is used and thus how many processes
368          * will be started; however we started already our
369          * timers, so we know and process_count should not
370          * change any more
371          */     
372         if (init_tm_stats()<0) {
373                 LOG(L_CRIT, "ERROR: mod_init: failed to init stats\n");
374                 return -1;
375         }
376
377         /* building the hash table*/
378
379         if (uac_init()==-1) {
380                 LOG(L_ERR, "ERROR: mod_init: uac_init failed\n");
381                 return -1;
382         }
383 #ifdef _OBSO
384         register_tmcb( TMCB_ON_NEGATIVE, on_negative_reply, 
385                         0 /* empty param */);
386 #endif
387         /* register post-script clean-up function */
388         register_script_cb( w_t_unref, POST_SCRIPT_CB, 
389                         0 /* empty param */ );
390         register_script_cb( script_init, PRE_SCRIPT_CB , 
391                         0 /* empty param */ );
392
393         tm_init_tags();
394
395         return 0;
396 }
397
398 static int child_init(int rank) {
399         if (uac_child_init(rank)==-1) {
400                 LOG(L_ERR, "ERROR: child_init: uac_child_init error\n");
401                 return -1;
402         }
403         return 1;
404 }
405
406
407 /* (char *hostname, char *port_nr) ==> (struct proxy_l *, -)  */
408
409 inline static int fixup_hostport2proxy(void** param, int param_no)
410 {
411         unsigned int port;
412         char *host;
413         int err;
414         struct proxy_l *proxy;
415         str s;
416         
417         DBG("TM module: fixup_t_forward(%s, %d)\n", (char*)*param, param_no);
418         if (param_no==1){
419                 DBG("TM module: fixup_t_forward: param 1.. do nothing, wait for #2\n");
420                 return 0;
421         } else if (param_no==2) {
422
423                 host=(char *) (*(param-1)); 
424                 port=str2s(*param, strlen(*param), &err);
425                 if (err!=0) {
426                         LOG(L_ERR, "TM module:fixup_t_forward: bad port number <%s>\n",
427                                 (char*)(*param));
428                          return E_UNSPEC;
429                 }
430                 s.s = host;
431                 s.len = strlen(host);
432                 proxy=mk_proxy(&s, port);
433                 if (proxy==0) {
434                         LOG(L_ERR, "ERROR: fixup_t_forwardv6: bad host name in URI <%s>\n",
435                                 host );
436                         return E_BAD_ADDRESS;
437                 }
438                 /* success -- fix the first parameter to proxy now ! */
439
440                 /* FIXME: janakj, mk_proxy doesn't make copy of host !! */
441                 free( *(param-1));
442                 *(param-1)=proxy;
443                 return 0;
444         } else {
445                 LOG(L_ERR, "ERROR: fixup_t_forwardv6 called with parameter #<>{1,2}\n");
446                 return E_BUG;
447         }
448 }
449
450
451 /* (char *code, char *reason_phrase)==>(int code, r_p as is) */
452 inline static int fixup_t_send_reply(void** param, int param_no)
453 {
454         unsigned int code;
455         int err;
456
457         if (param_no==1){
458                 code=str2s(*param, strlen(*param), &err);
459                 if (err==0){
460                         free(*param);
461                         *param=(void*)code;
462                         return 0;
463                 }else{
464                         LOG(L_ERR, "TM module:fixup_t_send_reply: bad  number <%s>\n",
465                                         (char*)(*param));
466                         return E_UNSPEC;
467                 }
468         }
469         /* second param => no conversion*/
470         return 0;
471 }
472
473
474
475
476 inline static int w_t_check(struct sip_msg* msg, char* str, char* str2)
477 {
478         return t_check( msg , 0  ) ? 1 : -1;
479 }
480
481
482
483 inline static int w_t_forward_nonack(struct sip_msg* msg, char* proxy, char* _foo)
484 {
485         struct cell *t;
486         if (t_check( msg , 0 )==-1) return -1;
487         t=get_t();
488         if ( t && t!=T_UNDEFINED ) {
489                 if (msg->REQ_METHOD==METHOD_ACK) {
490                         LOG(L_WARN,"WARNING: you don't really want to fwd hbh ACK\n");
491                         return -1;
492                 }
493                 return t_forward_nonack(t, msg, ( struct proxy_l *) proxy );
494         } else {
495                 DBG("DEBUG: t_forward_nonack: no transaction found\n");
496                 return -1;
497         }
498 }
499
500
501
502 inline static int w_t_reply(struct sip_msg* msg, char* str, char* str2)
503 {
504         struct cell *t;
505
506         if (msg->REQ_METHOD==METHOD_ACK) {
507                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
508                 return -1;
509         }
510         if (t_check( msg , 0 )==-1) return -1;
511         t=get_t();
512         if (!t) {
513                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
514                         "for which no T-state has been established\n");
515                 return -1;
516         }
517         /* if called from reply_route, make sure that unsafe version
518          * is called; we are already in a mutex and another mutex in
519          * the safe version would lead to a deadlock
520          */
521         if (rmode==MODE_ONREPLY_REQUEST) { 
522                 DBG("DEBUG: t_reply_unsafe called from w_t_reply\n");
523                 return t_reply_unsafe(t, msg, (unsigned int) str, str2);
524         } else {
525                 return t_reply( t, msg, (unsigned int) str, str2);
526         }
527 }
528
529 #ifdef _OBSOLETED
530 inline static int w_t_reply_unsafe(struct sip_msg* msg, char* str, char* str2)
531 {
532         struct cell *t;
533
534         if (msg->REQ_METHOD==METHOD_ACK) {
535                 LOG(L_WARN, "WARNING: t_reply: ACKs are not replied\n");
536                 return -1;
537         }
538         if (t_check( msg , 0 )==-1) return -1;
539         t=get_t();
540         if (!t) {
541                 LOG(L_ERR, "ERROR: t_reply: cannot send a t_reply to a message "
542                         "for which no T-state has been established\n");
543                 return -1;
544         }
545         return t_reply_unsafe(t, msg, (unsigned int) str, str2);
546 }
547 #endif
548
549
550 inline static int w_t_release(struct sip_msg* msg, char* str, char* str2)
551 {
552         struct cell *t;
553         if (t_check( msg  , 0  )==-1) return -1;
554         t=get_t();
555         if ( t && t!=T_UNDEFINED ) 
556                 return t_release_transaction( t );
557         return 1;
558 }
559
560
561
562
563 inline static int w_t_retransmit_reply( struct sip_msg* p_msg, char* foo, char* bar)
564 {
565         struct cell *t;
566
567
568         if (t_check( p_msg  , 0 )==-1) 
569                 return 1;
570         t=get_t();
571         if (t) {
572                 if (p_msg->REQ_METHOD==METHOD_ACK) {
573                         LOG(L_WARN, "WARNING: : ACKs ansmit_replies not replied\n");
574                         return -1;
575                 }
576                 return t_retransmit_reply( t );
577         } else 
578                 return -1;
579         return 1;
580 }
581
582
583
584
585
586 inline static int w_t_newdlg( struct sip_msg* p_msg, char* foo, char* bar ) 
587 {
588         return t_newdlg( p_msg );
589 }
590
591 inline static int w_t_newtran( struct sip_msg* p_msg, char* foo, char* bar ) 
592 {
593         /* t_newtran returns 0 on error (negative value means
594            'transaction exists'
595         */
596         return t_newtran( p_msg );
597 }
598
599
600 inline static int w_t_on_negative( struct sip_msg* msg, char *go_to, char *foo )
601 {
602         return t_on_negative( (unsigned int ) go_to );
603 }
604
605 inline static int w_t_relay_to( struct sip_msg  *p_msg , 
606         char *proxy, /* struct proxy_l *proxy expected */
607         char *_foo       /* nothing expected */ )
608 {
609         return t_relay_to( p_msg, ( struct proxy_l *) proxy,
610         0 /* no replication */ );
611 }
612
613 inline static int w_t_replicate( struct sip_msg  *p_msg , 
614         char *proxy, /* struct proxy_l *proxy expected */
615         char *_foo       /* nothing expected */ )
616 {
617         return t_replicate(p_msg, ( struct proxy_l *) proxy );
618 }
619
620 inline static int w_t_relay( struct sip_msg  *p_msg , 
621                                                 char *_foo, char *_bar)
622 {
623         return t_relay_to( p_msg, 
624                 (struct proxy_l *) 0 /* no proxy */,
625                 0 /* no replication */ );
626 }
627
628