tm: auto-correct timeout values in K compat mode
[sip-router] / modules / tm / t_funcs.c
1 /*
2  * $Id$
3  *
4  * transaction maintenance functions
5  *
6  * Copyright (C) 2001-2003 FhG Fokus
7  *
8  * This file is part of ser, a free SIP server.
9  *
10  * ser is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version
14  *
15  * For a license to use the ser software under conditions
16  * other than those described here, or to purchase support for this
17  * software, please contact iptel.org by e-mail at the following addresses:
18  *    info@iptel.org
19  *
20  * ser is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License 
26  * along with this program; if not, write to the Free Software 
27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
28  */
29 /*
30  * History:
31  * -------
32  *  2003-03-31  200 for INVITE/UAS resent even for UDP (jiri)
33  *               info only if compiling w/ -DEXTRA_DEBUG (andrei)
34  *  2003-03-19  replaced all mallocs/frees w/ pkg_malloc/pkg_free (andrei)
35  *  2003-03-13  send_pr_buffer is called w/ file/function/line debugging
36  *  2003-03-01  start_retr changed to retransmit only for UDP
37  *  2003-02-13  modified send_pr_buffer to use msg_send & rb->dst (andrei)
38  *  2003-04-14  use protocol from uri (jiri)
39  *  2003-04-25  do it (^) really everywhere (jiri)
40  *  2003-04-26  do it (^) really really really everywhere (jiri)
41  *  2003-07-07  added get_proto calls when proxy!=0 (andrei)
42  *  2004-02-13  t->is_invite and t->local replaced with flags (bogdan)
43  *  2005-02-16  fr_*_timer acceps full AVP specifications; empty AVP
44  *              desable variable timer feature (bogdan)
45  *  2005-12-11  t_relay doesn't return 0 (stop script) on send error 
46  *              anymore (andrei)
47  *  2006-08-11  updated forward_request usage (andrei)
48  *              t_relay_to releases the transaction if t_forward_non_ack
49  *              fails and t_kill fails or this is a failed replication (andrei)
50  *  2007-05-02  t_relay_to() uses now t_forward_cancel for cancels (andrei)
51  *  2007-06-05  delay t_relay() replies till script end so that they can be
52  *               overwritten by the script user; generate 100 automatically
53  *               only if T_NO_100 is not set (andrei)
54  */
55
56 #include <limits.h>
57 #include <string.h>
58 #include <stdio.h>
59 #include <errno.h>
60 #include <stdlib.h>
61
62 #include "../../dprint.h"
63 #include "../../hash_func.h"
64 #include "../../dset.h"
65 #include "../../mem/mem.h"
66 #include "../../sr_compat.h"
67 #include "../../pvar.h"
68 #include "defs.h"
69 #include "t_funcs.h"
70 #include "t_fwd.h"
71 #include "t_lookup.h"
72 #include "config.h"
73 #include "t_stats.h"
74
75 /* if defined t_relay* error reply generation will be delayed till script
76  * end (this allows the script writter to send its own error reply) */
77 #define TM_DELAYED_REPLY
78
79 /* fr_timer AVP specs */
80 static int     fr_timer_avp_type = 0;
81 static int_str fr_timer_avp = {0};
82 static str     fr_timer_str;
83 static int     fr_timer_index = 0;
84 int     fr_inv_timer_avp_type = 0;
85 int_str fr_inv_timer_avp = {0};
86 static str     fr_inv_timer_str;
87 static int     fr_inv_timer_index = 0;
88 int     contacts_avp_type = 0;
89 int_str contacts_avp = {0};
90 static str     contacts_avp_str;
91 static int     contacts_avp_index = 0;
92
93 int tm_error = 0; /* delayed tm error */
94
95 struct msgid_var user_cell_set_flags;   /* extra cell->flags to be set */
96 struct msgid_var user_cell_reset_flags; /* extra cell->flags to be reset */
97
98 /* ----------------------------------------------------- */
99 int send_pr_buffer(     struct retr_buf *rb, void *buf, int len
100 #ifdef EXTRA_DEBUG
101                                                 , char* file, const char *function, int line
102 #endif
103                                         )
104 {
105         if (buf && len && rb )
106                 return msg_send( &rb->dst, buf, len);
107         else {
108 #ifdef EXTRA_DEBUG
109                 LOG(L_CRIT, "ERROR: send_pr_buffer: sending an empty buffer"
110                                 "from %s: %s (%d)\n", file, function, line );
111 #else
112                 LOG(L_CRIT, "ERROR: send_pr_buffer: attempt to send an "
113                                 "empty buffer\n");
114 #endif
115                 return -1;
116         }
117 }
118
119 void tm_shutdown()
120 {
121
122         DBG("DEBUG: tm_shutdown : start\n");
123
124         /* destroy the hash table */
125         DBG("DEBUG: tm_shutdown : emptying hash table\n");
126         free_hash_table( );
127         DBG("DEBUG: tm_shutdown : removing semaphores\n");
128         lock_cleanup();
129         DBG("DEBUG: tm_shutdown : destroying tmcb lists\n");
130         destroy_tmcb_lists();
131         free_tm_stats();
132         DBG("DEBUG: tm_shutdown : done\n");
133 }
134
135
136 /*   returns 1 if everything was OK or -1 for error
137 */
138 int t_release_transaction( struct cell *trans )
139 {
140         set_kr(REQ_RLSD);
141
142         stop_rb_timers(&trans->uas.response);
143         cleanup_uac_timers( trans );
144         
145         put_on_wait( trans );
146         return 1;
147 }
148
149
150 /* -----------------------HELPER FUNCTIONS----------------------- */
151
152
153 /*
154   */
155 void put_on_wait(  struct cell  *Trans  )
156 {
157
158 #ifdef EXTRA_DEBUG
159         DBG("DEBUG: put on WAIT \n");
160 #endif
161
162
163         /* we put the transaction on wait timer; we do it only once
164            in transaction's timelife because putting it multiple-times
165            might result in a second instance of a wait timer to be
166            set after the first one fired; on expiration of the second
167            instance, the transaction would be re-deleted
168
169                         PROCESS1                PROCESS2                TIMER PROCESS
170                 0. 200/INVITE rx;
171                    put_on_wait
172                 1.                                      200/INVITE rx;
173                 2.                                                                      WAIT fires; transaction
174                                                                                         about to be deleted
175                 3.                                      avoid putting
176                                                         on WAIT again
177                 4.                                                                      WAIT timer executed,
178                                                                                         transaction deleted
179         */
180         if (timer_add(&Trans->wait_timer, cfg_get(tm, tm_cfg, wait_timeout))==0){
181                 /* sucess */
182                 t_stats_wait();
183         }else{
184                 DBG("tm: put_on_wait: transaction %p already on wait\n", Trans);
185         }
186 }
187
188
189
190 /* WARNING: doesn't work from failure route (deadlock, uses t_reply =>
191  *  tries to get the reply lock again) */
192 int kill_transaction( struct cell *trans, int error )
193 {
194         char err_buffer[128];
195         int sip_err;
196         int reply_ret;
197         int ret;
198
199         /*  we reply statefully and enter WAIT state since error might
200                 have occurred in middle of forking and we do not
201                 want to put the forking burden on upstream client;
202                 however, it may fail too due to lack of memory */
203
204         ret=err2reason_phrase(error, &sip_err,
205                 err_buffer, sizeof(err_buffer), "TM" );
206         if (ret>0) {
207                 reply_ret=t_reply( trans, trans->uas.request, 
208                         sip_err, err_buffer);
209                 /* t_release_transaction( T ); */
210                 return reply_ret;
211         } else {
212                 LOG(L_ERR, "ERROR: kill_transaction: err2reason failed\n");
213                 return -1;
214         }
215 }
216
217 /* unsafe version of kill_transaction() that works
218  * in failure route 
219  * WARNING: assumes that the reply lock is held!
220  */
221 int kill_transaction_unsafe( struct cell *trans, int error )
222 {
223         char err_buffer[128];
224         int sip_err;
225         int reply_ret;
226         int ret;
227
228         /*  we reply statefully and enter WAIT state since error might
229                 have occurred in middle of forking and we do not
230                 want to put the forking burden on upstream client;
231                 however, it may fail too due to lack of memory */
232
233         ret=err2reason_phrase(error, &sip_err,
234                 err_buffer, sizeof(err_buffer), "TM" );
235         if (ret>0) {
236                 reply_ret=t_reply_unsafe( trans, trans->uas.request, 
237                         sip_err, err_buffer);
238                 /* t_release_transaction( T ); */
239                 return reply_ret;
240         } else {
241                 LOG(L_ERR, "ERROR: kill_transaction_unsafe: err2reason failed\n");
242                 return -1;
243         }
244 }
245
246
247 /* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
248  *  to get the reply lock again */
249 int t_relay_to( struct sip_msg  *p_msg , struct proxy_l *proxy, int proto,
250                                 int replicate)
251 {
252         int ret;
253         int new_tran;
254         /* struct hdr_field *hdr; */
255         struct cell *t;
256         struct dest_info dst;
257         unsigned short port;
258         str host;
259         short comp;
260 #ifndef TM_DELAYED_REPLY
261         int reply_ret;
262 #endif
263
264         ret=0;
265         
266         /* special case for CANCEL */
267         if ( p_msg->REQ_METHOD==METHOD_CANCEL){
268                 ret=t_forward_cancel(p_msg, proxy, proto, &t);
269                 if (t) goto handle_ret;
270                 goto done;
271         }
272         new_tran = t_newtran( p_msg );
273         
274         /* parsing error, memory alloc, whatever ... if via is bad
275            and we are forced to reply there, return with 0 (->break),
276            pass error status otherwise
277            MMA: return value E_SCRIPT means that transaction was already started
278            from the script so continue with that transaction
279         */
280         if (likely(new_tran!=E_SCRIPT)) {
281                 if (new_tran<0) {
282                         ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
283                         goto done;
284                 }
285                 /* if that was a retransmission, return we are happily done */
286                 if (new_tran==0) {
287                         ret = 1;
288                         goto done;
289                 }
290         }else if (unlikely(p_msg->REQ_METHOD==METHOD_ACK)) {
291                         /* transaction previously found (E_SCRIPT) and msg==ACK
292                             => ack to neg. reply  or ack to local trans.
293                             => process it and exit */
294                         /* FIXME: there's no way to distinguish here between acks to
295                            local trans. and neg. acks */
296                         /* in normal operation we should never reach this point, if we
297                            do WARN(), it might hide some real bug (apart from possibly
298                            hiding a bug the most harm done is calling the TMCB_ACK_NEG
299                            callbacks twice) */
300                         WARN("negative or local ACK caught, please report\n");
301                         t=get_t();
302                         if (unlikely(has_tran_tmcbs(t, TMCB_ACK_NEG_IN)))
303                                 run_trans_callbacks(TMCB_ACK_NEG_IN, t, p_msg, 0, 
304                                                                                 p_msg->REQ_METHOD);
305                         t_release_transaction(t);
306                         ret=1;
307                         goto done;
308         }
309
310         /* new transaction */
311
312         /* at this point if the msg is an ACK it is an e2e ACK and
313            e2e ACKs do not establish a transaction and are fwd-ed statelessly */
314         if ( p_msg->REQ_METHOD==METHOD_ACK) {
315                 DBG( "SER: forwarding ACK  statelessly \n");
316                 if (proxy==0) {
317                         init_dest_info(&dst);
318                         dst.proto=proto;
319                         if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
320                                                                         &dst.proto, &comp)!=0){
321                                 ret=E_BAD_ADDRESS;
322                                 goto done;
323                         }
324 #ifdef USE_COMP
325                         dst.comp=comp;
326 #endif
327                         /* dst->send_sock not set, but forward_request will take care
328                          * of it */
329                         ret=forward_request(p_msg, &host, port, &dst);
330                 } else {
331                         init_dest_info(&dst);
332                         dst.proto=get_proto(proto, proxy->proto);
333                         proxy2su(&dst.to, proxy);
334                         /* dst->send_sock not set, but forward_request will take care
335                          * of it */
336                         ret=forward_request( p_msg , 0, 0, &dst) ;
337                 }
338                 goto done;
339         }
340
341         /* if replication flag is set, mark the transaction as local
342            so that replies will not be relayed */
343         t=get_t();
344         if (replicate) t->flags|=T_IS_LOCAL_FLAG;
345
346         /* INVITE processing might take long, particularly because of DNS
347            look-ups -- let upstream know we're working on it */
348         if (p_msg->REQ_METHOD==METHOD_INVITE && (t->flags&T_AUTO_INV_100)
349                 && (t->uas.status < 100)
350         ) {
351                 DBG( "SER: new INVITE\n");
352                 if (!t_reply( t, p_msg , 100 ,
353                         cfg_get(tm, tm_cfg, tm_auto_inv_100_r)))
354                                 DBG("SER: ERROR: t_reply (100)\n");
355         } 
356
357         /* now go ahead and forward ... */
358         ret=t_forward_nonack(t, p_msg, proxy, proto);
359 handle_ret:
360         if (ret<=0) {
361                 DBG( "ERROR:tm:t_relay_to:  t_forward_nonack returned error \n");
362                 /* we don't want to pass upstream any reply regarding replicating
363                  * a request; replicated branch must stop at us*/
364                 if (likely(!replicate)) {
365 #ifdef TM_DELAYED_REPLY
366                         /* current error in tm_error */
367                         tm_error=ser_error;
368                         set_kr(REQ_ERR_DELAYED);
369                         DBG("%d error reply generation delayed \n", ser_error);
370 #else
371                         reply_ret=kill_transaction( t, ser_error );
372                         if (reply_ret>0) {
373                                 /* we have taken care of all -- do nothing in
374                                 script */
375                                 DBG("ERROR: generation of a stateful reply "
376                                         "on error succeeded\n");
377                                 /*ret=0; -- we don't want to stop the script */
378                         }  else {
379                                 DBG("ERROR: generation of a stateful reply "
380                                         "on error failed\n");
381                                 t_release_transaction(t);
382                         }
383 #endif /* TM_DELAYED_REPLY */
384                 }else{
385                         t_release_transaction(t); /* kill it  silently */
386                 }
387         } else {
388                 DBG( "SER: new transaction fwd'ed\n");
389         }
390
391 done:
392         return ret;
393 }
394
395
396
397 /*
398  * Initialize parameters containing the ID of
399  * AVPs with various timers
400  */
401 int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param,
402                                         char* contacts_avp_param)
403 {
404         pv_spec_t avp_spec;
405
406         if (fr_timer_param && *fr_timer_param) {
407                 fr_timer_str.s = fr_timer_param;
408                 fr_timer_str.len = strlen(fr_timer_str.s);
409
410                 if(sr_cfg_compat==SR_COMPAT_KAMAILIO) {
411                         if (pv_parse_spec(&fr_timer_str, &avp_spec)==0
412                                 || avp_spec.type!=PVT_AVP) {
413                                 LM_ERR("malformed or non AVP %s AVP definition\n",
414                                                         fr_timer_param);
415                                 return -1;
416                         }
417
418                         if(pv_get_avp_name(0, &avp_spec.pvp, &fr_timer_avp, 
419                                                 (unsigned short*)&fr_timer_avp_type)!=0)
420                         {
421                                 LM_ERR("[%s]- invalid AVP definition\n", fr_timer_param);
422                                 return -1;
423                         }
424                 } else {
425                         if (parse_avp_spec( &fr_timer_str, &fr_timer_avp_type,
426                         &fr_timer_avp, &fr_timer_index)<0) {
427                                 LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_timer "
428                                         "AVP specs \"%s\"\n", fr_timer_param);
429                                 return -1;
430                         }
431                 }
432         }
433
434         if (fr_inv_timer_param && *fr_inv_timer_param) {
435                 fr_inv_timer_str.s = fr_inv_timer_param;
436                 fr_inv_timer_str.len = strlen(fr_inv_timer_str.s);
437
438                 if(sr_cfg_compat==SR_COMPAT_KAMAILIO) {
439                         if (pv_parse_spec(&fr_inv_timer_str, &avp_spec)==0
440                                         || avp_spec.type!=PVT_AVP) {
441                                 LM_ERR("malformed or non AVP %s AVP definition\n",
442                                         fr_inv_timer_param);
443                                 return -1;
444                         }
445
446                         if(pv_get_avp_name(0, &avp_spec.pvp, &fr_inv_timer_avp,
447                                                 (unsigned short*)&fr_inv_timer_avp_type)!=0)
448                         {
449                                 LM_ERR("[%s]- invalid AVP definition\n", fr_inv_timer_param);
450                                 return -1;
451                         }
452                 } else {
453                         if (parse_avp_spec( &fr_inv_timer_str, &fr_inv_timer_avp_type, 
454                         &fr_inv_timer_avp, &fr_inv_timer_index)<0) {
455                                 LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_inv_timer "
456                                         "AVP specs \"%s\"\n", fr_inv_timer_param);
457                                 return -1;
458                         }
459                 }
460         }
461
462         if (contacts_avp_param && *contacts_avp_param) {
463                 contacts_avp_str.s = contacts_avp_param;
464                 contacts_avp_str.len = strlen(contacts_avp_str.s);
465
466                 if(sr_cfg_compat==SR_COMPAT_KAMAILIO) {
467                         if ((pv_parse_spec(&contacts_avp_str, &avp_spec) == 0) 
468                                         || (avp_spec.type != PVT_AVP)) {
469                                 LM_ERR("malformed or non AVP definition <%s>\n",
470                                         contacts_avp_param);
471                                 return -1;
472                         }
473
474                         if(pv_get_avp_name(0, &(avp_spec.pvp), &contacts_avp,
475                                                 (unsigned short*)&contacts_avp_type) != 0) {
476                                 LM_ERR("invalid AVP definition <%s>\n", contacts_avp_param);
477                                 return -1;
478                         }
479                 } else {
480                         if (parse_avp_spec( &contacts_avp_str, &contacts_avp_type,
481                                                                 &contacts_avp, &contacts_avp_index)<0) {
482                                 LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid contact_avp_params "
483                                         "AVP specs \"%s\"\n", contacts_avp_param);
484                                 return -1;
485                         }
486                 }
487         }
488
489         return 0;
490 }
491
492
493 /** Get the FR_{INV}_TIMER from corresponding AVP.
494  * @return 0 on success (use *timer) or 1 on failure (avp non-existent,
495  *  avp present  but empty/0, avp value not numeric).
496  */
497 static inline int avp2timer(unsigned int* timer, int type, int_str name)
498 {
499         struct usr_avp *avp;
500         int_str val_istr;
501         int err;
502
503         avp = search_first_avp( type | AVP_TRACK_TO, name, &val_istr, 0);
504         if (!avp) {
505                 /*
506                  DBG("avp2timer: AVP '%.*s' not found\n", param.s->len, ZSW(param.s->s));
507                  */
508                 return 1;
509         }
510         
511         if (avp->flags & AVP_VAL_STR) {
512                 *timer = str2s(val_istr.s.s, val_istr.s.len, &err);
513                 if (err) {
514                         LOG(L_ERR, "avp2timer: Error while converting string to integer\n");
515                         return -1;
516                 }
517         } else {
518                 *timer = val_istr.n;
519         }
520
521         if(sr_cfg_compat==SR_COMPAT_KAMAILIO) {
522                 if(*timer>0 && *timer<=120) {
523                         LM_WARN("too small given timer value: %ums (using T*1000)\n",
524                                         *timer);
525                         *timer *= 1000;
526                 }
527         }
528         return *timer==0; /* 1 if 0 (use default), 0 if !=0 (use *timer) */
529 }
530
531
532 int fr_avp2timer(unsigned int* timer)
533 {
534         if (fr_timer_avp.n!=0)
535                 return avp2timer( timer, fr_timer_avp_type, fr_timer_avp);
536         else
537                 return 1;
538 }
539
540
541 int fr_inv_avp2timer(unsigned int* timer)
542 {
543         if (fr_inv_timer_avp.n!=0)
544                 return avp2timer( timer, fr_inv_timer_avp_type, fr_inv_timer_avp);
545         else
546                 return 1;
547 }
548
549 void unref_cell(struct cell *t)
550 {
551         UNREF(t);
552 }