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