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