- e2ecancel is sent hop by hop (closes SER-68)
[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 "defs.h"
67 #include "t_funcs.h"
68 #include "t_fwd.h"
69 #include "t_lookup.h"
70 #include "config.h"
71 #include "t_stats.h"
72
73 /* if defined t_relay* error reply generation will be delayed till script
74  * end (this allows the script writter to send its own error reply) */
75 #define TM_DELAYED_REPLY
76
77 /* fr_timer AVP specs */
78 static int     fr_timer_avp_type = 0;
79 static int_str fr_timer_avp = {0};
80 static str     fr_timer_str;
81 static int     fr_timer_index = 0;
82 static int     fr_inv_timer_avp_type = 0;
83 static int_str fr_inv_timer_avp = {0};
84 static str     fr_inv_timer_str;
85 static int     fr_inv_timer_index = 0;
86
87 int tm_error = 0; /* delayed tm error */
88
89 int tm_auto_inv_100=1; /* automatically send 100 to an INVITE, default on*/
90 struct msgid_var user_auto_inv_100;
91
92 /* ----------------------------------------------------- */
93 int send_pr_buffer(     struct retr_buf *rb, void *buf, int len
94 #ifdef EXTRA_DEBUG
95                                                 , char* file, const char *function, int line
96 #endif
97                                         )
98 {
99         if (buf && len && rb )
100                 return msg_send( &rb->dst, buf, len);
101         else {
102 #ifdef EXTRA_DEBUG
103                 LOG(L_CRIT, "ERROR: send_pr_buffer: sending an empty buffer"
104                                 "from %s: %s (%d)\n", file, function, line );
105 #else
106                 LOG(L_CRIT, "ERROR: send_pr_buffer: attempt to send an "
107                                 "empty buffer\n");
108 #endif
109                 return -1;
110         }
111 }
112
113 void tm_shutdown()
114 {
115
116         DBG("DEBUG: tm_shutdown : start\n");
117
118         /* destroy the hash table */
119         DBG("DEBUG: tm_shutdown : emptying hash table\n");
120         free_hash_table( );
121         DBG("DEBUG: tm_shutdown : removing semaphores\n");
122         lock_cleanup();
123         DBG("DEBUG: tm_shutdown : destroying tmcb lists\n");
124         destroy_tmcb_lists();
125         free_tm_stats();
126         DBG("DEBUG: tm_shutdown : done\n");
127 }
128
129
130 /*   returns 1 if everything was OK or -1 for error
131 */
132 int t_release_transaction( struct cell *trans )
133 {
134         set_kr(REQ_RLSD);
135
136         stop_rb_timers(&trans->uas.response);
137         cleanup_uac_timers( trans );
138         
139         put_on_wait( trans );
140         return 1;
141 }
142
143
144 /* -----------------------HELPER FUNCTIONS----------------------- */
145
146
147 /*
148   */
149 void put_on_wait(  struct cell  *Trans  )
150 {
151
152 #ifdef EXTRA_DEBUG
153         DBG("DEBUG: put on WAIT \n");
154 #endif
155
156
157         /* we put the transaction on wait timer; we do it only once
158            in transaction's timelife because putting it multiple-times
159            might result in a second instance of a wait timer to be
160            set after the first one fired; on expiration of the second
161            instance, the transaction would be re-deleted
162
163                         PROCESS1                PROCESS2                TIMER PROCESS
164                 0. 200/INVITE rx;
165                    put_on_wait
166                 1.                                      200/INVITE rx;
167                 2.                                                                      WAIT fires; transaction
168                                                                                         about to be deleted
169                 3.                                      avoid putting
170                                                         on WAIT again
171                 4.                                                                      WAIT timer executed,
172                                                                                         transaction deleted
173         */
174         if (timer_add(&Trans->wait_timer, wait_timeout)==0){
175                 /* sucess */
176                 t_stats_wait();
177         }else{
178                 DBG("tm: put_on_wait: transaction %p already on wait\n", Trans);
179         }
180 }
181
182
183
184 /* WARNING: doesn't work from failure route (deadlock, uses t_reply =>
185  *  tries to get the reply lock again) */
186 int kill_transaction( struct cell *trans, int error )
187 {
188         char err_buffer[128];
189         int sip_err;
190         int reply_ret;
191         int ret;
192
193         /*  we reply statefully and enter WAIT state since error might
194                 have occurred in middle of forking and we do not
195                 want to put the forking burden on upstream client;
196                 however, it may fail too due to lack of memory */
197
198         ret=err2reason_phrase(error, &sip_err,
199                 err_buffer, sizeof(err_buffer), "TM" );
200         if (ret>0) {
201                 reply_ret=t_reply( trans, trans->uas.request, 
202                         sip_err, err_buffer);
203                 /* t_release_transaction( T ); */
204                 return reply_ret;
205         } else {
206                 LOG(L_ERR, "ERROR: kill_transaction: err2reason failed\n");
207                 return -1;
208         }
209 }
210
211
212
213 /* WARNING: doesn't work from failure route (deadlock, uses t_reply => tries
214  *  to get the reply lock again */
215 int t_relay_to( struct sip_msg  *p_msg , struct proxy_l *proxy, int proto,
216                                 int replicate)
217 {
218         int ret;
219         int new_tran;
220         /* struct hdr_field *hdr; */
221         struct cell *t;
222         struct dest_info dst;
223         unsigned short port;
224         str host;
225         short comp;
226 #ifndef TM_DELAYED_REPLY
227         int reply_ret;
228 #endif
229
230         ret=0;
231         
232         /* special case for CANCEL */
233         if ( p_msg->REQ_METHOD==METHOD_CANCEL){
234                 ret=t_forward_cancel(p_msg, proxy, proto, &t);
235                 if (t) goto handle_ret;
236                 goto done;
237         }
238         new_tran = t_newtran( p_msg );
239         
240         /* parsing error, memory alloc, whatever ... if via is bad
241            and we are forced to reply there, return with 0 (->break),
242            pass error status otherwise
243
244        MMA: return value E_SCRIPT means that transaction was already started from the script
245            so continue with that transaction
246         */
247         if (new_tran!=E_SCRIPT) {
248                 if (new_tran<0) {
249                         ret = (ser_error==E_BAD_VIA && reply_to_via) ? 0 : new_tran;
250                         goto done;
251                 }
252                 /* if that was a retransmission, return we are happily done */
253                 if (new_tran==0) {
254                         ret = 1;
255                         goto done;
256                 }
257         }
258
259         /* new transaction */
260
261         /* ACKs do not establish a transaction and are fwd-ed statelessly */
262         if ( p_msg->REQ_METHOD==METHOD_ACK) {
263                 DBG( "SER: forwarding ACK  statelessly \n");
264                 if (proxy==0) {
265                         init_dest_info(&dst);
266                         dst.proto=proto;
267                         if (get_uri_send_info(GET_NEXT_HOP(p_msg), &host, &port,
268                                                                         &dst.proto, &comp)!=0){
269                                 ret=E_BAD_ADDRESS;
270                                 goto done;
271                         }
272 #ifdef USE_COMP
273                         dst.comp=comp;
274 #endif
275                         /* dst->send_sock not set, but forward_request will take care
276                          * of it */
277                         ret=forward_request(p_msg, &host, port, &dst);
278                 } else {
279                         init_dest_info(&dst);
280                         dst.proto=get_proto(proto, proxy->proto);
281                         proxy2su(&dst.to, proxy);
282                         /* dst->send_sock not set, but forward_request will take care
283                          * of it */
284                         ret=forward_request( p_msg , 0, 0, &dst) ;
285                 }
286                 goto done;
287         }
288
289         /* if replication flag is set, mark the transaction as local
290            so that replies will not be relayed */
291         t=get_t();
292         if (replicate) t->flags|=T_IS_LOCAL_FLAG;
293
294         /* INVITE processing might take long, particularly because of DNS
295            look-ups -- let upstream know we're working on it */
296         if (p_msg->REQ_METHOD==METHOD_INVITE && (t->flags&T_AUTO_INV_100))
297         {
298                 DBG( "SER: new INVITE\n");
299                 if (!t_reply( t, p_msg , 100 ,
300                         "trying -- your call is important to us"))
301                                 DBG("SER: ERROR: t_reply (100)\n");
302         } 
303
304         /* now go ahead and forward ... */
305         ret=t_forward_nonack(t, p_msg, proxy, proto);
306 handle_ret:
307         if (ret<=0) {
308                 DBG( "ERROR:tm:t_relay_to:  t_forward_nonack returned error \n");
309                 /* we don't want to pass upstream any reply regarding replicating
310                  * a request; replicated branch must stop at us*/
311                 if (likely(!replicate)) {
312 #ifdef TM_DELAYED_REPLY
313                         /* current error in tm_error */
314                         tm_error=ser_error;
315                         set_kr(REQ_ERR_DELAYED);
316                         DBG("%d error reply generation delayed \n", ser_error);
317 #else
318                         reply_ret=kill_transaction( t, ser_error );
319                         if (reply_ret>0) {
320                                 /* we have taken care of all -- do nothing in
321                                 script */
322                                 DBG("ERROR: generation of a stateful reply "
323                                         "on error succeeded\n");
324                                 /*ret=0; -- we don't want to stop the script */
325                         }  else {
326                                 DBG("ERROR: generation of a stateful reply "
327                                         "on error failed\n");
328                                 t_release_transaction(t);
329                         }
330 #endif /* TM_DELAYED_REPLY */
331                 }else{
332                         t_release_transaction(t); /* kill it  silently */
333                 }
334         } else {
335                 DBG( "SER: new transaction fwd'ed\n");
336         }
337
338 done:
339         return ret;
340 }
341
342
343
344 /*
345  * Initialize parameters containing the ID of
346  * AVPs with variable timers
347  */
348 int init_avp_params(char *fr_timer_param, char *fr_inv_timer_param)
349 {
350         if (fr_timer_param && *fr_timer_param) {
351                 fr_timer_str.s = fr_timer_param;
352                 fr_timer_str.len = strlen(fr_timer_str.s);
353                 if (parse_avp_spec( &fr_timer_str, &fr_timer_avp_type,
354                 &fr_timer_avp, &fr_timer_index)<0) {
355                         LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_timer "
356                                 "AVP specs \"%s\"\n", fr_timer_param);
357                         return -1;
358                 }
359         }
360
361         if (fr_inv_timer_param && *fr_inv_timer_param) {
362                 fr_inv_timer_str.s = fr_inv_timer_param;
363                 fr_inv_timer_str.len = strlen(fr_inv_timer_str.s);
364                 if (parse_avp_spec( &fr_inv_timer_str, &fr_inv_timer_avp_type, 
365                 &fr_inv_timer_avp, &fr_inv_timer_index)<0) {
366                         LOG(L_CRIT,"ERROR:tm:init_avp_params: invalid fr_inv_timer "
367                                 "AVP specs \"%s\"\n", fr_inv_timer_param);
368                         return -1;
369                 }
370         }
371         return 0;
372 }
373
374
375 /*
376  * Get the FR_{INV}_TIMER from corresponding AVP
377  */
378 static inline int avp2timer(unsigned int* timer, int type, int_str name)
379 {
380         struct usr_avp *avp;
381         int_str val_istr;
382         int err;
383
384         avp = search_first_avp( type | AVP_TRACK_TO, name, &val_istr, 0);
385         if (!avp) {
386                 /*
387                  DBG("avp2timer: AVP '%.*s' not found\n", param.s->len, ZSW(param.s->s));
388                  */
389                 return 1;
390         }
391         
392         if (avp->flags & AVP_VAL_STR) {
393                 *timer = str2s(val_istr.s.s, val_istr.s.len, &err);
394                 if (err) {
395                         LOG(L_ERR, "avp2timer: Error while converting string to integer\n");
396                         return -1;
397                 }
398         } else {
399                 *timer = val_istr.n;
400         }
401
402         return 0;
403 }
404
405
406 int fr_avp2timer(unsigned int* timer)
407 {
408         if (fr_timer_avp.n!=0)
409                 return avp2timer( timer, fr_timer_avp_type, fr_timer_avp);
410         else
411                 return 1;
412 }
413
414
415 int fr_inv_avp2timer(unsigned int* timer)
416 {
417         if (fr_inv_timer_avp.n!=0)
418                 return avp2timer( timer, fr_inv_timer_avp_type, fr_inv_timer_avp);
419         else
420                 return 1;
421 }
422
423