133bcfe3f3b22913d11784ec3303a7b742258b4b
[sip-router] / modules / tm / t_fwd.c
1 /*
2  * $Id$
3  *
4  *
5  * Copyright (C) 2001-2003 FhG Fokus
6  *
7  * This file is part of ser, a free SIP server.
8  *
9  * ser is free software; you can redistribute it and/or modify
10  * it under the terms of the GNU General Public License as published by
11  * the Free Software Foundation; either version 2 of the License, or
12  * (at your option) any later version
13  *
14  * For a license to use the ser software under conditions
15  * other than those described here, or to purchase support for this
16  * software, please contact iptel.org by e-mail at the following addresses:
17  *    info@iptel.org
18  *
19  * ser is distributed in the hope that it will be useful,
20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
22  * GNU General Public License for more details.
23  *
24  * You should have received a copy of the GNU General Public License 
25  * along with this program; if not, write to the Free Software 
26  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
27  */
28 /*
29  * History:
30  * -------
31  *  2003-02-13  proto support added (andrei)
32  *  2003-02-24  s/T_NULL/T_NULL_CELL/ to avoid redefinition conflict w/
33  *              nameser_compat.h (andrei)
34  *  2003-03-01  kr set through a function now (jiri)
35  *  2003-03-06  callbacks renamed; "blind UAC" introduced, which makes
36  *              transaction behave as if it was forwarded even if it was
37  *              not -- good for local UAS, like VM (jiri)
38  *  2003-03-19  replaced all the mallocs/frees w/ pkg_malloc/pkg_free (andrei)
39  *  2003-03-30  we now watch downstream delivery and if it fails, send an
40  *              error message upstream (jiri)
41  *  2003-04-14  use protocol from uri (jiri)
42  *  2003-12-04  global TM callbacks switched to per transaction callbacks
43  *              (bogdan)
44  *  2004-02-13: t->is_invite and t->local replaced with flags (bogdan)
45  */
46
47 #include "defs.h"
48
49
50 #include "../../dprint.h"
51 #include "../../config.h"
52 #include "../../parser/parser_f.h"
53 #include "../../ut.h"
54 #include "../../timer.h"
55 #include "../../hash_func.h"
56 #include "../../globals.h"
57 #include "../../mem/mem.h"
58 #include "../../dset.h"
59 #include "t_funcs.h"
60 #include "t_hooks.h"
61 #include "t_msgbuilder.h"
62 #include "ut.h"
63 #include "t_cancel.h"
64 #include "t_lookup.h"
65 #include "t_fwd.h"
66 #include "fix_lumps.h"
67 #include "config.h"
68
69
70 char *print_uac_request( struct cell *t, struct sip_msg *i_req,
71         int branch, str *uri, unsigned int *len, struct socket_info *send_sock,
72         enum sip_protos proto )
73 {
74         char *buf, *shbuf;
75
76         shbuf=0;
77
78         /* ... we calculate branch ... */       
79         if (!t_calc_branch(t, branch, i_req->add_to_branch_s,
80                         &i_req->add_to_branch_len ))
81         {
82                 LOG(L_ERR, "ERROR: print_uac_request: branch computation failed\n");
83                 goto error01;
84         }
85
86         /* ... update uri ... */
87         i_req->new_uri=*uri;
88
89         /* run the specific callbacks for this transaction */
90         run_trans_callbacks( TMCB_REQUEST_FWDED , t, i_req, 0, -i_req->REQ_METHOD);
91
92         /* ... and build it now */
93         buf=build_req_buf_from_sip_req( i_req, len, send_sock, proto );
94 #ifdef DBG_MSG_QA
95         if (buf[*len-1]==0) {
96                 LOG(L_ERR, "ERROR: print_uac_request: sanity check failed\n");
97                 abort();
98         }
99 #endif
100         if (!buf) {
101                 LOG(L_ERR, "ERROR: print_uac_request: no pkg_mem\n"); 
102                 ser_error=E_OUT_OF_MEM;
103                 goto error01;
104         }
105         /*      clean Via's we created now -- they would accumulate for
106                 other branches  and for  shmem i_req they would mix up
107                 shmem with pkg_mem
108         */
109         free_via_clen_lump(&i_req->add_rm);
110
111         shbuf=(char *)shm_malloc(*len);
112         if (!shbuf) {
113                 ser_error=E_OUT_OF_MEM;
114                 LOG(L_ERR, "ERROR: print_uac_request: no shmem\n");
115                 goto error02;
116         }
117         memcpy( shbuf, buf, *len );
118
119 error02:
120         pkg_free( buf );
121 error01:
122         return shbuf;
123 }
124
125 /* introduce a new uac, which is blind -- it only creates the
126    data structures and starts FR timer, but that's it; it does
127    not print messages and send anything anywhere; that is good
128    for FIFO apps -- the transaction must look operationally
129    and FR must be ticking, whereas the request is "forwarded"
130    using a non-SIP way and will be replied the same way
131 */
132 int add_blind_uac( /*struct cell *t*/ )
133 {
134         unsigned short branch;
135         struct cell *t;
136
137         t=get_t();
138         if (t==T_UNDEFINED || !t ) {
139                 LOG(L_ERR, "ERROR: add_blind_uac: no transaction context\n");
140                 return -1;
141         }
142
143         branch=t->nr_of_outgoings;      
144         if (branch==MAX_BRANCHES) {
145                 LOG(L_ERR, "ERROR: add_blind_uac: "
146                         "maximum number of branches exceeded\n");
147                 return -1;
148         }
149         /* make sure it will be replied */
150         t->flags |= T_NOISY_CTIMER_FLAG;
151         t->nr_of_outgoings++;
152         /* start FR timer -- protocol set by default to PROTO_NONE,
153        which means retransmission timer will not be started
154     */
155         start_retr(&t->uac[branch].request);
156         /* we are on a timer -- don't need to put on wait on script
157            clean-up     
158         */
159         set_kr(REQ_FWDED); 
160
161         return 1; /* success */
162 }
163
164 /* introduce a new uac to transaction; returns its branch id (>=0)
165    or error (<0); it doesn't send a message yet -- a reply to it
166    might interfere with the processes of adding multiple branches
167 */
168 int add_uac( struct cell *t, struct sip_msg *request, str *uri, str* next_hop,
169         struct proxy_l *proxy, int proto )
170 {
171
172         int ret;
173         short temp_proxy;
174         union sockaddr_union to;
175         unsigned short branch;
176         struct socket_info* send_sock;
177         char *shbuf;
178         unsigned int len;
179
180         branch=t->nr_of_outgoings;
181         if (branch==MAX_BRANCHES) {
182                 LOG(L_ERR, "ERROR: add_uac: maximum number of branches exceeded\n");
183                 ret=E_CFG;
184                 goto error;
185         }
186
187         /* check existing buffer -- rewriting should never occur */
188         if (t->uac[branch].request.buffer) {
189                 LOG(L_CRIT, "ERROR: add_uac: buffer rewrite attempt\n");
190                 ret=ser_error=E_BUG;
191                 goto error;
192         }
193
194         /* check DNS resolution */
195         if (proxy){
196                 temp_proxy=0;
197                 proto=get_proto(proto, proxy->proto);
198         }else {
199                 proxy=uri2proxy( next_hop ? next_hop : uri, proto );
200                 if (proxy==0)  {
201                         ret=E_BAD_ADDRESS;
202                         goto error;
203                 }
204                 proto=proxy->proto; /* uri2proxy will fix it for us */
205                 temp_proxy=1;
206         }
207
208         if (proxy->ok==0) {
209                 if (proxy->host.h_addr_list[proxy->addr_idx+1])
210                         proxy->addr_idx++;
211                 else proxy->addr_idx=0;
212                 proxy->ok=1;
213         }
214
215         hostent2su( &to, &proxy->host, proxy->addr_idx, 
216                 proxy->port ? proxy->port:SIP_PORT);
217
218         send_sock=get_send_socket( &to , proto);
219         if (send_sock==0) {
220                 LOG(L_ERR, "ERROR: add_uac: can't fwd to af %d, proto %d "
221                         " (no corresponding listening socket)\n",
222                         to.s.sa_family, proto );
223                 ret=ser_error=E_NO_SOCKET;
224                 goto error01;
225         }
226
227         /* now message printing starts ... */
228         shbuf=print_uac_request( t, request, branch, uri, 
229                 &len, send_sock, proto );
230         if (!shbuf) {
231                 ret=ser_error=E_OUT_OF_MEM;
232                 goto error01;
233         }
234
235         /* things went well, move ahead and install new buffer! */
236         t->uac[branch].request.dst.to=to;
237         t->uac[branch].request.dst.send_sock=send_sock;
238         t->uac[branch].request.dst.proto=proto;
239         t->uac[branch].request.dst.proto_reserved1=0;
240         t->uac[branch].request.buffer=shbuf;
241         t->uac[branch].request.buffer_len=len;
242         t->uac[branch].uri.s=t->uac[branch].request.buffer+
243                 request->first_line.u.request.method.len+1;
244         t->uac[branch].uri.len=uri->len;
245         t->nr_of_outgoings++;
246
247         /* update stats */
248         proxy->tx++;
249         proxy->tx_bytes+=len;
250
251         /* done! */     
252         ret=branch;
253                 
254 error01:
255         if (temp_proxy) {
256                 free_proxy( proxy );
257                 pkg_free( proxy );
258         }
259 error:
260         return ret;
261 }
262
263 int e2e_cancel_branch( struct sip_msg *cancel_msg, struct cell *t_cancel, 
264         struct cell *t_invite, int branch )
265 {
266         int ret;
267         char *shbuf;
268         unsigned int len;
269
270         if (t_cancel->uac[branch].request.buffer) {
271                 LOG(L_CRIT, "ERROR: e2e_cancel_branch: buffer rewrite attempt\n");
272                 ret=ser_error=E_BUG;
273                 goto error;
274         }       
275
276         /* note -- there is a gap in proxy stats -- we don't update 
277            proxy stats with CANCEL (proxy->ok, proxy->tx, etc.)
278         */
279
280         /* print */
281         shbuf=print_uac_request( t_cancel, cancel_msg, branch, 
282                 &t_invite->uac[branch].uri, &len, 
283                 t_invite->uac[branch].request.dst.send_sock,
284                 t_invite->uac[branch].request.dst.proto);
285         if (!shbuf) {
286                 LOG(L_ERR, "ERROR: e2e_cancel_branch: printing e2e cancel failed\n");
287                 ret=ser_error=E_OUT_OF_MEM;
288                 goto error;
289         }
290         
291         /* install buffer */
292         t_cancel->uac[branch].request.dst=t_invite->uac[branch].request.dst;
293         t_cancel->uac[branch].request.buffer=shbuf;
294         t_cancel->uac[branch].request.buffer_len=len;
295         t_cancel->uac[branch].uri.s=t_cancel->uac[branch].request.buffer+
296                 cancel_msg->first_line.u.request.method.len+1;
297         t_cancel->uac[branch].uri.len=t_invite->uac[branch].uri.len;
298         
299
300         /* success */
301         ret=1;
302
303
304 error:
305         return ret;
306 }
307
308 void e2e_cancel( struct sip_msg *cancel_msg, 
309         struct cell *t_cancel, struct cell *t_invite )
310 {
311         branch_bm_t cancel_bm;
312         int i;
313         int lowest_error;
314         str backup_uri;
315         int ret;
316
317         cancel_bm=0;
318         lowest_error=0;
319
320         backup_uri=cancel_msg->new_uri;
321         /* determine which branches to cancel ... */
322         which_cancel( t_invite, &cancel_bm );
323         t_cancel->nr_of_outgoings=t_invite->nr_of_outgoings;
324         /* fix label -- it must be same for reply matching */
325         t_cancel->label=t_invite->label;
326         /* ... and install CANCEL UACs */
327         for (i=0; i<t_invite->nr_of_outgoings; i++)
328                 if (cancel_bm & (1<<i)) {
329                         ret=e2e_cancel_branch(cancel_msg, t_cancel, t_invite, i);
330                         if (ret<0) cancel_bm &= ~(1<<i);
331                         if (ret<lowest_error) lowest_error=ret;
332                 }
333         cancel_msg->new_uri=backup_uri;
334
335         /* send them out */
336         for (i=0; i<t_cancel->nr_of_outgoings; i++) {
337                 if (cancel_bm & (1<<i)) {
338                         if (SEND_BUFFER( &t_cancel->uac[i].request)==-1) {
339                                 LOG(L_ERR, "ERROR: e2e_cancel: send failed\n");
340                         }
341                         start_retr( &t_cancel->uac[i].request );
342                 }
343         }
344
345
346         /* if error occurred, let it know upstream (final reply
347            will also move the transaction on wait state
348         */
349         if (lowest_error<0) {
350                 LOG(L_ERR, "ERROR: cancel error\n");
351                 t_reply( t_cancel, cancel_msg, 500, "cancel error");
352         /* if there are pending branches, let upstream know we
353            are working on it
354         */
355         } else if (cancel_bm) {
356                 DBG("DEBUG: e2e_cancel: e2e cancel proceeding\n");
357                 t_reply( t_cancel, cancel_msg, 200, CANCELING );
358         /* if the transaction exists, but there is no more pending
359            branch, tell upstream we're done
360         */
361         } else {
362                 DBG("DEBUG: e2e_cancel: e2e cancel -- no more pending branches\n");
363                 t_reply( t_cancel, cancel_msg, 200, CANCEL_DONE );
364         }
365
366 #ifdef LOCAL_487
367
368         /* local 487s have been deprecated -- it better handles
369          * race conditions (UAS sending 200); hopefully there are
370          * no longer UACs who go crazy waiting for the 487 whose
371          * forwarding is being blocked by other unresponsive branch
372          */
373
374         /* we could await downstream UAS's 487 replies; however,
375            if some of the branches does not do that, we could wait
376            long time and annoy upstream UAC which wants to see 
377            a result of CANCEL quickly
378         */
379         DBG("DEBUG: e2e_cancel: sending 487\n");
380         /* in case that something in the meantime has been sent upstream
381            (like if FR hit at the same time), don't try to send */
382         if (t_invite->uas.status>=200) return;
383         /* there is still a race-condition -- the FR can hit now; that's
384            not too bad -- we take care in t_reply's REPLY_LOCK; in
385            the worst case, both this t_reply and other replier will
386            try, and the later one will result in error message 
387            "can't reply twice"
388         */
389         t_reply(t_invite, t_invite->uas.request, 487, CANCELED );
390 #endif
391 }
392
393
394 /* function returns:
395  *       1 - forward successful
396  *      -1 - error during forward
397  */
398 int t_forward_nonack( struct cell *t, struct sip_msg* p_msg , 
399         struct proxy_l * proxy, int proto)
400 {
401         str          backup_uri;
402         int branch_ret, lowest_ret;
403         str current_uri;
404         branch_bm_t     added_branches;
405         int first_branch;
406         int i, q;
407         struct cell *t_invite;
408         int success_branch;
409         int try_new;
410
411         /* make -Wall happy */
412         current_uri.s=0;
413
414         set_kr(REQ_FWDED);
415
416         if (p_msg->REQ_METHOD==METHOD_CANCEL) {
417                 t_invite=t_lookupOriginalT(  p_msg );
418                 if (t_invite!=T_NULL_CELL) {
419                         e2e_cancel( p_msg, t, t_invite );
420                         UNREF(t_invite);
421                         return 1;
422                 }
423         }
424
425         /* backup current uri ... add_uac changes it */
426         backup_uri = p_msg->new_uri;
427         /* if no more specific error code is known, use this */
428         lowest_ret=E_BUG;
429         /* branches added */
430         added_branches=0;
431         /* branch to begin with */
432         first_branch=t->nr_of_outgoings;
433
434         /* on first-time forwarding, use current uri, later only what
435            is in additional branches (which may be continuously refilled
436         */
437         if (first_branch==0) {
438                 try_new=1;
439                 branch_ret=add_uac( t, p_msg, GET_RURI(p_msg), GET_NEXT_HOP(p_msg), proxy, proto );
440                 if (branch_ret>=0) 
441                         added_branches |= 1<<branch_ret;
442                 else
443                         lowest_ret=branch_ret;
444         } else try_new=0;
445
446         init_branch_iterator();
447         while((current_uri.s=next_branch( &current_uri.len, &q))) {
448                 try_new++;
449                 branch_ret=add_uac( t, p_msg, &current_uri, 
450                                     (p_msg->dst_uri.len) ? (&p_msg->dst_uri) : &current_uri, 
451                                     proxy, proto);
452                 /* pick some of the errors in case things go wrong;
453                    note that picking lowest error is just as good as
454                    any other algorithm which picks any other negative
455                    branch result */
456                 if (branch_ret>=0) 
457                         added_branches |= 1<<branch_ret;
458                 else
459                         lowest_ret=branch_ret;
460         }
461         /* consume processed branches */
462         clear_branches();
463
464         /* restore original URI */
465         p_msg->new_uri=backup_uri;
466
467         /* don't forget to clear all branches processed so far */
468
469         /* things went wrong ... no new branch has been fwd-ed at all */
470         if (added_branches==0) {
471                 if (try_new==0) {
472                         LOG(L_ERR, "ERROR: t_forward_nonack: no branched for forwarding\n");
473                         return -1;
474                 }
475                 LOG(L_ERR, "ERROR: t_forward_nonack: failure to add branches\n");
476                 return lowest_ret;
477         }
478
479         /* send them out now */
480         success_branch=0;
481         for (i=first_branch; i<t->nr_of_outgoings; i++) {
482                 if (added_branches & (1<<i)) {
483                         if (SEND_BUFFER( &t->uac[i].request)==-1) {
484                                 LOG(L_ERR, "ERROR: t_forward_nonack: sending request failed\n");
485                                 if (proxy) { proxy->errors++; proxy->ok=0; }
486                         } else {
487                                 success_branch++;
488                         }
489                         start_retr( &t->uac[i].request );
490                 }
491         }
492         if (success_branch<=0) {
493                 ser_error=E_SEND;
494                 return -1;
495         }
496         return 1;
497 }       
498
499 int t_replicate(struct sip_msg *p_msg,  struct proxy_l *proxy, int proto )
500 {
501         /* this is a quite horrible hack -- we just take the message
502            as is, including Route-s, Record-route-s, and Vias ,
503            forward it downstream and prevent replies received
504            from relaying by setting the replication/local_trans bit;
505
506                 nevertheless, it should be good enough for the primary
507                 customer of this function, REGISTER replication
508
509                 if we want later to make it thoroughly, we need to
510                 introduce delete lumps for all the header fields above
511         */
512         return t_relay_to(p_msg, proxy, proto, 1 /* replicate */);
513 }