e9138985f315b58bf512af7f3909eca194d71374
[kamailio] / src / modules / rr / loose.c
1 /*
2  * Copyright (C) 2001-2004 FhG Fokus
3  *
4  * This file is part of Kamailio, a free SIP server.
5  *
6  * Kamailio is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version
10  *
11  * Kamailio is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License 
17  * along with this program; if not, write to the Free Software 
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  */
20
21 /*!
22  * \file
23  * \brief Route & Record-Route module, loose routing support
24  * \ingroup rr
25  */
26
27
28
29 #include <string.h>
30 #include "../../core/ut.h"
31 #include "../../core/str.h"
32 #include "../../core/dprint.h"
33 #include "../../core/forward.h"
34 #include "../../core/data_lump.h"
35 #include "../../core/socket_info.h"
36 #include "../../core/parser/parse_rr.h"
37 #include "../../core/parser/parse_uri.h"
38 #include "../../core/parser/parse_from.h"
39 #include "../../core/mem/mem.h"
40 #include "../../core/dset.h"
41 #include "loose.h"
42 #include "rr_cb.h"
43 #include "rr_mod.h"
44
45
46 #define RR_ERROR -1             /*!< An error occurred while processing route set */
47 #define RR_DRIVEN 1             /*!< The next hop is determined from the route set */
48 #define RR_OB_DRIVEN 2          /*!< The next hop is determined from the route set based on flow-token */
49 #define NOT_RR_DRIVEN -1        /*!< The next hop is not determined from the route set */
50 #define FLOW_TOKEN_BROKEN -2    /*!< Outbound flow-token shows evidence of tampering */
51 #define RR_PRELOADED -3         /*!< The next hop is determined from a preloaded route set */
52
53 #define RR_ROUTE_PREFIX ROUTE_PREFIX "<"
54 #define RR_ROUTE_PREFIX_LEN (sizeof(RR_ROUTE_PREFIX)-1)
55
56 #define ROUTE_SUFFIX ">\r\n"  /*!< SIP header suffix */
57 #define ROUTE_SUFFIX_LEN (sizeof(ROUTE_SUFFIX)-1)
58
59 /*! variables used to hook the param part of the local route */
60 static unsigned int routed_msg_id = 0;
61 static int routed_msg_pid = 0;
62 static str routed_params = {0,0};
63
64 extern int rr_force_send_socket;
65
66 /*!
67  * \brief Test whether we are processing pre-loaded route set by looking at the To tag
68  * \param msg SIP message
69  * \return -1 on failure, 0 on success
70  */
71 static int is_preloaded(struct sip_msg* msg)
72 {
73         str tag;
74
75         if (!msg->to && parse_headers(msg, HDR_TO_F, 0) == -1) {
76                 LM_ERR("failed to parse To header field\n");
77                 return -1;
78         }
79
80         if (!msg->to) {
81                 LM_ERR("To header field not found\n");
82                 return -1;
83         }
84
85         tag = get_to(msg)->tag_value;
86         if (tag.s == 0 || tag.len == 0) {
87                 LM_DBG("is_preloaded: Yes\n");
88                 return 1;
89         }
90
91         LM_DBG("is_preloaded: No\n");
92         return 0;
93 }
94
95
96 /*!
97  * \brief Parse the message and find first occurrence of Route header field.
98  * \param _m SIP message 
99  * \return -1 or -2 on a parser error, 0 if there is a Route HF and 1 if there is no Route HF
100  */
101 static inline int find_first_route(struct sip_msg* _m)
102 {
103         if (parse_headers(_m, HDR_ROUTE_F, 0) == -1) {
104                 LM_ERR("failed to parse headers\n");
105                 return -1;
106         } else {
107                 if (_m->route) {
108                         if (parse_rr(_m->route) < 0) {
109                                 LM_ERR("failed to parse Route HF\n");
110                                 return -2;
111                         }
112                         return 0;
113                 } else {
114                         LM_DBG("No Route headers found\n");
115                         return 1;
116                 }
117         }
118 }
119
120
121 /*!
122  * \brief Check if URI is myself
123  * \param _host host
124  * \param _port port
125  * \return 0 if the URI is not myself, 1 otherwise
126  */
127 static inline int is_myself(sip_uri_t *_puri)
128 {
129         int ret;
130
131         ret = check_self(&_puri->host,
132                         _puri->port_no?_puri->port_no:SIP_PORT, 0);/* match all protos*/
133         if (ret < 0) return 0;
134
135 #ifdef ENABLE_USER_CHECK
136         if(ret==1 && i_user.len && i_user.len==_puri->user.len
137                         && strncmp(i_user.s, _puri->user.s, _puri->user.len)==0)
138         {
139                 LM_DBG("ignore user matched - URI is not to the server itself\n");
140                 return 0;
141         }
142 #endif
143
144         if(ret==1) {
145                 /* match on host:port, but if gruu, then fail */
146                 if(_puri->gr.s!=NULL)
147                         return 0;
148         }
149
150         return ret;
151 }
152
153
154 /*!
155  * \brief Find and parse next Route header field
156  * \param _m SIP message
157  * \param _hdr SIP header
158  * \return negative on failure, 0 if the Route header was already parsed, 1 if no next
159  * Route header could be found
160  */
161 static inline int find_next_route(struct sip_msg* _m, struct hdr_field** _hdr)
162 {
163         struct hdr_field* ptr;
164
165         ptr = (*_hdr)->next;
166
167         /* Try to find already parsed Route headers */
168         while(ptr) {
169                 if (ptr->type == HDR_ROUTE_T) goto found;
170                 ptr = ptr->next;
171         }
172
173         /* There are no already parsed Route headers, try to find next
174          * occurrence of Route header
175          */
176         if (parse_headers(_m, HDR_ROUTE_F, 1) == -1) {
177                 LM_ERR("failed to parse headers\n");
178                 return -1;
179         }
180
181         if ((_m->last_header->type!=HDR_ROUTE_T) || (_m->last_header==*_hdr)) {
182                 LM_DBG("No next Route HF found\n");
183                 return 1;
184         }
185
186         ptr = _m->last_header;
187
188  found:
189         if (parse_rr(ptr) < 0) {
190                 LM_ERR("failed to parse Route body\n");
191                 return -2;
192         }
193
194         *_hdr = ptr;
195         return 0;
196 }
197
198
199 /*!
200  * \brief Check if the given uri contains lr parameter which marks loose routers
201  * \param _params URI string
202  * \return 1 if URI contains no lr parameter, 0 if it contains a lr parameter
203  */
204 static inline int is_strict(str* _params)
205 {
206         str s;
207         int i, state = 0;
208
209         if (_params->len == 0) return 1;
210
211         s.s = _params->s;
212         s.len = _params->len;
213
214         for(i = 0; i < s.len; i++) {
215                 switch(state) {
216                 case 0:
217                         switch(s.s[i]) {
218                         case ' ':
219                         case '\r':
220                         case '\n':
221                         case '\t':           break;
222                         case 'l':
223                         case 'L': state = 1; break;
224                         default:  state = 4; break;
225                         }
226                         break;
227
228                 case 1:
229                         switch(s.s[i]) {
230                         case 'r':
231                         case 'R': state = 2; break;
232                         default:  state = 4; break;
233                         }
234                         break;
235
236                 case 2:
237                         switch(s.s[i]) {
238                         case ';':  return 0;
239                         case '=':  return 0;
240                         case ' ':
241                         case '\r':
242                         case '\n':
243                         case '\t': state = 3; break;
244                         default:   state = 4; break;
245                         }
246                         break;
247
248                 case 3:
249                         switch(s.s[i]) {
250                         case ';':  return 0;
251                         case '=':  return 0;
252                         case ' ':
253                         case '\r':
254                         case '\n':
255                         case '\t': break;
256                         default:   state = 4; break;
257                         }
258                         break;
259
260                 case 4:
261                         switch(s.s[i]) {
262                         case '\"': state = 5; break;
263                         case ';':  state = 0; break;
264                         default:              break;
265                         }
266                         break;
267                         
268                 case 5:
269                         switch(s.s[i]) {
270                         case '\\': state = 6; break;
271                         case '\"': state = 4; break;
272                         default:              break;
273                         }
274                         break;
275
276                 case 6: state = 5; break;
277                 }
278         }
279         
280         if ((state == 2) || (state == 3)) return 0;
281         else return 1;
282 }
283
284
285 /*!
286  * \brief Set Request-URI as last Route header of a SIP
287  *
288  * Set Request-URI as last Route header of a SIP message,
289  * this is necessary when forwarding to a strict router.
290  * Allocates memory for message lump in private memory.
291  * \param _m SIP message
292  * \return negative on failure, 0 on success
293  */
294 static inline int save_ruri(struct sip_msg* _m)
295 {
296         struct lump* anchor;
297         char *s;
298         int len;
299
300         /* We must parse the whole message header here, because
301          * the Request-URI must be saved in last Route HF in the message
302          */
303         if (parse_headers(_m, HDR_EOH_F, 0) == -1) {
304                 LM_ERR("failed to parse message\n");
305                 return -1;
306         }
307
308         /* Create an anchor */
309         anchor = anchor_lump(_m, _m->unparsed - _m->buf, 0, 0);
310         if (anchor == 0) {
311                 LM_ERR("failed to get anchor\n");
312                 return -2;
313         }
314
315         /* Create buffer for new lump */
316         len = RR_ROUTE_PREFIX_LEN + _m->first_line.u.request.uri.len
317                         + ROUTE_SUFFIX_LEN;
318         s = (char*)pkg_malloc(len);
319         if (!s) {
320                 LM_ERR("No memory pkg left\n");
321                 return -3;
322         }
323
324         /* Create new header field */
325         memcpy(s, RR_ROUTE_PREFIX, RR_ROUTE_PREFIX_LEN);
326         memcpy(s + RR_ROUTE_PREFIX_LEN, _m->first_line.u.request.uri.s,
327                         _m->first_line.u.request.uri.len);
328         memcpy(s + RR_ROUTE_PREFIX_LEN + _m->first_line.u.request.uri.len,
329                         ROUTE_SUFFIX, ROUTE_SUFFIX_LEN);
330
331         LM_DBG("New header: '%.*s'\n", len, ZSW(s));
332
333         /* Insert it */
334         if (insert_new_lump_before(anchor, s, len, 0) == 0) {
335                 pkg_free(s);
336                 LM_ERR("failed to insert lump\n");
337                 return -4;
338         }
339
340         return 0;
341 }
342
343
344 /*!
345  * \brief Parse URI and check if it has a maddr parameter
346  * \param uri URI to be checked if it has maddr, and also the output URI
347  * \param puri parsed URI
348  * \return -1 on failure, 0 on success
349  */
350 static inline int get_maddr_uri(str *uri, struct sip_uri *puri)
351 {
352         /* The max length of the maddr parameter is 127 */
353         static char builturi[127+1];
354         struct sip_uri turi;
355
356         if(uri==NULL || uri->s==NULL)
357                 return RR_ERROR;
358         if(puri==NULL)
359         {
360                 if (parse_uri(uri->s, uri->len, &turi) < 0)
361                 {
362                         LM_ERR("failed to parse the URI\n");
363                         return RR_ERROR;
364                 }
365                 puri = &turi;
366         }
367
368         if(puri->maddr.s==NULL)
369                 return 0;
370
371         /* sip: + maddr + : + port */
372         if( (puri->maddr_val.len) > (127 - 10) )
373         {
374                 LM_ERR( "Too long maddr parameter\n");
375                 return RR_ERROR;
376         }
377         memcpy( builturi, "sip:", 4 );
378         memcpy( builturi+4, puri->maddr_val.s, puri->maddr_val.len );
379                 
380         if( puri->port.len > 0 )
381         {
382                 builturi[4+puri->maddr_val.len] =':';
383                 memcpy(builturi+5+puri->maddr_val.len, puri->port.s,
384                                 puri->port.len);
385         }
386
387         uri->len = 4+puri->maddr_val.len
388                                         + ((puri->port.len>0)?(1+puri->port.len):0);
389         builturi[uri->len]='\0';
390         uri->s = builturi;
391
392         LM_DBG("uri is %s\n", builturi );
393         return 0;
394 }
395
396
397 /*!
398  * \brief Necessary logic to forward request to strict routers
399  * \param _m SIP message
400  * \param _hdr SIP header field
401  * \param _r Route & Record-Route header field body
402  * \return 0 on success, negative on an error
403  */
404 static inline int handle_sr(struct sip_msg* _m, struct hdr_field* _hdr, rr_t* _r)
405 {
406         str uri;
407         char* rem_off;
408         int rem_len;
409
410         /* Next hop is strict router, save R-URI here */
411         if (save_ruri(_m) < 0) {
412                 LM_ERR("failed to save Request-URI\n");
413                 return -1;
414         }
415         
416         /* Put the first Route in Request-URI */
417         uri = _r->nameaddr.uri;
418         if(get_maddr_uri(&uri, 0)!=0) {
419                 LM_ERR("failed to check maddr\n");
420                 return RR_ERROR;
421         }
422         if (rewrite_uri(_m, &uri) < 0) {
423                 LM_ERR("failed to rewrite request URI\n");
424                 return -2;
425         }
426
427         if (!_r->next) {
428                 rem_off = _hdr->name.s;
429                 rem_len = _hdr->len;
430         } else {
431                 rem_off = _hdr->body.s;
432                 rem_len = _r->next->nameaddr.name.s - _hdr->body.s;
433         }
434
435         if (!del_lump(_m, rem_off - _m->buf, rem_len, 0)) {
436                 LM_ERR("failed to remove Route HF\n");
437                 return -9;
438         }                       
439
440         return 0;
441 }
442
443
444 /*!
445  * \brief Find last route in the last Route header field
446  *
447  * Find last route in the last Route header field, if there was a previous
448  * route in the last Route header field, it will be saved in _p parameter
449  * \param _m SIP message
450  * \param _h SIP header field
451  * \param _l Route & Record-Route header field body
452  * \param _p Route & Record-Route header field body
453  * \return negative on failure, 0 on success
454  */
455 static inline int find_rem_target(struct sip_msg* _m, struct hdr_field** _h, rr_t** _l, rr_t** _p)
456 {
457         struct hdr_field* ptr, *last;
458
459         if (parse_headers(_m, HDR_EOH_F, 0) == -1) {
460                 LM_ERR("failed to parse message header\n");
461                 return -1;
462         }
463
464         ptr = _m->route;
465         last = 0;
466
467         while(ptr) {
468                 if (ptr->type == HDR_ROUTE_T) last = ptr;
469                 ptr = ptr->next;
470         }
471
472         if (last) {
473                 if (parse_rr(last) < 0) {
474                         LM_ERR("failed to parse last Route HF\n");
475                         return -2;
476                 }
477
478                 *_p = 0;
479                 *_l = (rr_t*)last->parsed;
480                 *_h = last;
481                 while ((*_l)->next) {
482                         *_p = *_l;
483                         *_l = (*_l)->next;
484                 }
485                 return 0;
486         } else {
487                 LM_ERR("search for last Route HF failed\n");
488                 return 1;
489         }
490 }
491
492 /* Largest route URI is of the form:
493         sip:[1234:5678:9012:3456:7890:1234:5678:9012]:12345;transport=sctp
494    this is 66 characters long */
495 #define MAX_ROUTE_URI_LEN       66
496 static char uri_buf[MAX_ROUTE_URI_LEN];
497
498 /*!
499  * \brief Perform outbound processing - force local socket and set destination URI
500  * \param _m SIP message
501  * \param flow_token string containing the flow-token extracted from the Route: header
502  * \param dst_uri string to write the destination URI to (extracted from flow-token)
503  * \return -1 on error, 0 when outbound not in use, 1 when outbound in use
504  */
505 static inline int process_outbound(struct sip_msg *_m, str flow_token)
506 {
507         int ret;
508         struct receive_info *rcv = NULL;
509         struct socket_info *si;
510         str dst_uri;
511
512         if (!rr_obb.decode_flow_token)
513                 return 0;
514
515         ret = rr_obb.decode_flow_token(_m, &rcv, flow_token);
516
517         if (ret == -2) {
518                 LM_DBG("no flow token found - outbound not in use\n");
519                 return 0;
520         } else if (ret == -1) {
521                 LM_INFO("failed to decode flow token\n");
522                 return -1;
523         } else if (!ip_addr_cmp(&rcv->src_ip, &_m->rcv.src_ip)
524                         || rcv->src_port != _m->rcv.src_port) {
525                 LM_DBG("\"incoming\" request found. Using flow-token for "
526                         "routing\n");
527
528                 /* First, force the local socket */
529                 si = find_si(&rcv->dst_ip, rcv->dst_port, rcv->proto);
530                 if (si)
531                         set_force_socket(_m, si);
532                 else {
533                         LM_INFO("cannot find socket from flow-token\n");
534                         return -1;
535                 }
536
537                 /* Second, override the destination URI */
538                 dst_uri.s = uri_buf;
539                 dst_uri.len = 0;
540
541                 dst_uri.len += snprintf(dst_uri.s + dst_uri.len,
542                                         MAX_ROUTE_URI_LEN - dst_uri.len,
543                                         "sip:%s",
544                                         rcv->src_ip.af == AF_INET6 ? "[" : "");
545                 dst_uri.len += ip_addr2sbuf(&rcv->src_ip,
546                                         dst_uri.s + dst_uri.len,
547                                         MAX_ROUTE_URI_LEN - dst_uri.len);
548                 dst_uri.len += snprintf(dst_uri.s + dst_uri.len,
549                                         MAX_ROUTE_URI_LEN - dst_uri.len,
550                                         "%s:%d;transport=%s",
551                                         rcv->src_ip.af == AF_INET6 ? "]" : "",
552                                         rcv->src_port,
553                                         get_proto_name(rcv->proto));
554
555                 if (set_dst_uri(_m, &dst_uri) < 0) {
556                         LM_ERR("failed to set dst_uri\n");
557                         return -1;
558                 }
559                 ruri_mark_new();
560
561                 return 1;
562         }
563
564         LM_DBG("Not using flow-token for routing\n");
565         return 0;
566 }
567
568 /*!
569  * \brief Previous hop was a strict router, handle this case
570  * \param _m SIP message
571  * \return -1 on error, 1 on success
572  */
573 static inline int after_strict(struct sip_msg* _m)
574 {
575         int res, rem_len;
576         struct hdr_field* hdr;
577         struct sip_uri puri;
578         rr_t* rt, *prev;
579         char* rem_off;
580         str uri;
581         struct socket_info *si;
582
583         hdr = _m->route;
584         rt = (rr_t*)hdr->parsed;
585         uri = rt->nameaddr.uri;
586
587         /* reset rr handling static vars for safety in error case */
588         routed_msg_id = 0;
589         routed_msg_pid = 0;
590         routed_params.s = NULL;
591         routed_params.len = 0;
592
593         if (parse_uri(uri.s, uri.len, &puri) < 0) {
594                 LM_ERR("failed to parse the first route URI\n");
595                 return RR_ERROR;
596         }
597
598         if ( enable_double_rr && is_2rr(&puri.params) && is_myself(&puri)) {
599                 /* double route may occure due different IP and port, so force as
600                  * send interface the one advertise in second Route */
601                 si = grep_sock_info( &puri.host, puri.port_no, puri.proto);
602                 if (si) {
603                         set_force_socket(_m, si);
604                 } else {
605                         if (enable_socket_mismatch_warning)
606                                 LM_WARN("no socket found for match second RR\n");
607                 }
608
609                 if (!rt->next) {
610                         /* No next route in the same header, remove the whole header
611                          * field immediately
612                          */
613                         if (!del_lump(_m, hdr->name.s - _m->buf, hdr->len, 0)) {
614                                 LM_ERR("failed to remove Route HF\n");
615                                 return RR_ERROR;
616                         }
617                         res = find_next_route(_m, &hdr);
618                         if (res < 0) {
619                                 LM_ERR("searching next route failed\n");
620                                 return RR_ERROR;
621                         }
622                         if (res > 0) { /* No next route found */
623                                 LM_DBG("after_strict: No next URI found\n");
624                                 return NOT_RR_DRIVEN;
625                         }
626                         rt = (rr_t*)hdr->parsed;
627                 } else rt = rt->next;
628
629                 /* parse the new found uri */
630                 uri = rt->nameaddr.uri;
631                 if (parse_uri(uri.s, uri.len, &puri) < 0) {
632                         LM_ERR("failed to parse URI\n");
633                         return RR_ERROR;
634                 }
635         }
636
637         /* set the hooks for the param
638          * important note: RURI is already parsed by the above function, so 
639          * we just used it without any checking */
640         routed_msg_id = _m->id;
641         routed_msg_pid = _m->pid;
642         routed_params = _m->parsed_uri.params;
643
644         if (is_strict(&puri.params)) {
645                 LM_DBG("Next hop: '%.*s' is strict router\n", uri.len, ZSW(uri.s));
646                 /* Previous hop was a strict router and the next hop is strict
647                  * router too. There is no need to save R-URI again because it
648                  * is saved already. In fact, in this case we will behave exactly
649                  * like a strict router. */
650
651                 /* Note: when there is only one Route URI left (endpoint), it will
652                  * always be a strict router because endpoints don't use ;lr parameter
653                  * In this case we will simply put the URI in R-URI and forward it, 
654                  * which will work perfectly */
655                 if(get_maddr_uri(&uri, &puri)!=0) {
656                         LM_ERR("failed to check maddr\n");
657                         return RR_ERROR;
658                 }
659                 if (rewrite_uri(_m, &uri) < 0) {
660                         LM_ERR("failed to rewrite request URI\n");
661                         return RR_ERROR;
662                 }
663                 
664                 if (rt->next) {
665                         rem_off = hdr->body.s;
666                         rem_len = rt->next->nameaddr.name.s - hdr->body.s;
667                 } else {
668                         rem_off = hdr->name.s;
669                         rem_len = hdr->len;
670                 }
671                 if (!del_lump(_m, rem_off - _m->buf, rem_len, 0)) {
672                         LM_ERR("failed to remove Route HF\n");
673                         return RR_ERROR;
674                 }
675         } else {
676                 LM_DBG("Next hop: '%.*s' is loose router\n",
677                         uri.len, ZSW(uri.s));
678
679                 if(get_maddr_uri(&uri, &puri)!=0) {
680                         LM_ERR("failed to check maddr\n");
681                         return RR_ERROR;
682                 }
683                 if (set_dst_uri(_m, &uri) < 0) {
684                         LM_ERR("failed to set dst_uri\n");
685                         return RR_ERROR;
686                 }
687
688                 /* Next hop is a loose router - Which means that is is not endpoint yet
689                  * In This case we have to recover from previous strict routing, that 
690                  * means we have to find the last Route URI and put in in R-URI and 
691                  * remove the last Route URI. */
692                 if (rt != hdr->parsed) {
693                         /* There is a previous route uri which was 2nd uri of mine
694                          * and must be removed here */
695                         rem_off = hdr->body.s;
696                         rem_len = rt->nameaddr.name.s - hdr->body.s;
697                         if (!del_lump(_m, rem_off - _m->buf, rem_len, 0)) {
698                                 LM_ERR("failed to remove Route HF\n");
699                                 return RR_ERROR;
700                         }
701                 }
702
703
704                 res = find_rem_target(_m, &hdr, &rt, &prev);
705                 if (res < 0) {
706                         LM_ERR("searching for last Route URI failed\n");
707                         return RR_ERROR;
708                 } else if (res > 0) {
709                         /* No remote target is an error */
710                         return RR_ERROR;
711                 }
712
713                 uri = rt->nameaddr.uri;
714                 if(get_maddr_uri(&uri, 0)!=0) {
715                         LM_ERR("checking maddr failed\n");
716                         return RR_ERROR;
717                 }
718                 if (rewrite_uri(_m, &uri) < 0) {
719                         LM_ERR("failed to rewrite R-URI\n");
720                         return RR_ERROR;
721                 }
722
723                 /* The first character if uri will be either '<' when it is the 
724                  * only URI in a Route header field or ',' if there is more than 
725                  * one URI in the header field */
726                 LM_DBG("The last route URI: '%.*s'\n", rt->nameaddr.uri.len,
727                                 ZSW(rt->nameaddr.uri.s));
728
729                 if (prev) {
730                         rem_off = prev->nameaddr.name.s + prev->len;
731                         rem_len = rt->nameaddr.name.s + rt->len - rem_off;
732                 } else {
733                         rem_off = hdr->name.s;
734                         rem_len = hdr->len;
735                 }
736                 if (!del_lump(_m, rem_off - _m->buf, rem_len, 0)) {
737                         LM_ERR("failed to remove Route HF\n");
738                         return RR_ERROR;
739                 }
740         }
741
742         /* run RR callbacks only if we have Route URI parameters */
743         if(routed_params.len > 0)
744                 run_rr_callbacks( _m, &routed_params );
745
746         return RR_DRIVEN;
747 }
748
749
750 static inline void rr_do_force_send_socket(sip_msg_t *_m, sip_uri_t *puri,
751                 rr_t* rt, int rr2on)
752 {
753         socket_info_t *si;
754
755         if ((si = grep_sock_info(&puri->host,
756                                 puri->port_no?puri->port_no:proto_default_port(puri->proto),
757                                 puri->proto)) != 0) {
758                 set_force_socket(_m, si);
759         } else if ((si = grep_sock_info(&puri->host, puri->port_no,
760                                         puri->proto)) != 0) {
761                 set_force_socket(_m, si);
762         } else {
763                 if (enable_socket_mismatch_warning && rr2on) {
764                         LM_WARN("no socket found to match second RR (%.*s)\n",
765                                         rt->nameaddr.uri.len, ZSW(rt->nameaddr.uri.s));
766                         if(!is_myself(puri)) {
767                                 LM_WARN("second RR uri is not myself (%.*s)\n",
768                                                 rt->nameaddr.uri.len, ZSW(rt->nameaddr.uri.s));
769                         }
770                 }
771         }
772 }
773
774 /*!
775  * \brief Previous hop was a loose router, handle this case
776  * \param _m SIP message
777  * \param preloaded do we have a preloaded route set
778  * \return -1 on failure, 1 on success
779  */
780 static inline int after_loose(struct sip_msg* _m, int preloaded)
781 {
782         struct hdr_field* hdr;
783         struct sip_uri puri;
784         rr_t* rt;
785         int res;
786         int status = RR_DRIVEN;
787         str uri;
788         int uri_is_myself;
789         int use_ob = 0;
790         str rparams;
791
792         hdr = _m->route;
793         rt = (rr_t*)hdr->parsed;
794         uri = rt->nameaddr.uri;
795
796         /* reset rr handling static vars for safety in error case */
797         routed_msg_id = 0;
798         routed_msg_pid = 0;
799
800         if (parse_uri(uri.s, uri.len, &puri) < 0) {
801                 LM_ERR("failed to parse the first route URI (%.*s)\n",
802                                 uri.len, ZSW(uri.s));
803                 return RR_ERROR;
804         }
805
806         routed_params = puri.params;
807         uri_is_myself = is_myself(&puri);
808
809         /* IF the URI was added by me, remove it */
810         if (uri_is_myself>0)
811         {
812                 LM_DBG("Topmost route URI: '%.*s' is me\n",
813                         uri.len, ZSW(uri.s));
814                 /* set the hooks for the params */
815                 routed_msg_id = _m->id;
816                 routed_msg_pid = _m->pid;
817
818                 if ((use_ob = process_outbound(_m, puri.user)) < 0) {
819                         LM_INFO("failed to process outbound flow-token\n");
820                         return FLOW_TOKEN_BROKEN;
821                 }
822
823                 if (rr_force_send_socket && !use_ob) {
824                         if (!enable_double_rr || !is_2rr(&puri.params)) {
825                                 rr_do_force_send_socket(_m, &puri, rt, 0);
826                         }
827                 }
828                 if (!rt->next) {
829                         /* No next route in the same header, remove the whole header
830                          * field immediately
831                          */
832                         if (!del_lump(_m, hdr->name.s - _m->buf, hdr->len, 0)) {
833                                 LM_ERR("failed to remove Route HF\n");
834                                 return RR_ERROR;
835                         }
836
837                         res = find_next_route(_m, &hdr);
838                         if (res < 0) {
839                                 LM_ERR("failed to find next route\n");
840                                 return RR_ERROR;
841                         }
842                         if (res > 0) { /* No next route found */
843                                 LM_DBG("No next URI found\n");
844                                 status = (preloaded ? RR_PRELOADED : RR_DRIVEN);
845                                 goto done;
846                         }
847                         rt = (rr_t*)hdr->parsed;
848                 } else rt = rt->next;
849
850                 if (enable_double_rr && is_2rr(&puri.params)) {
851                         /* double route may occure due different IP and port, so force as
852                          * send interface the one advertise in second Route */
853                         if (parse_uri(rt->nameaddr.uri.s,rt->nameaddr.uri.len,&puri)<0) {
854                                 LM_ERR("failed to parse the double route URI (%.*s)\n",
855                                                 rt->nameaddr.uri.len, ZSW(rt->nameaddr.uri.s));
856                                 return RR_ERROR;
857                         }
858
859                         if (!use_ob) {
860                                 rr_do_force_send_socket(_m, &puri, rt, 1);
861                         }
862
863                         if (!rt->next) {
864                                 /* No next route in the same header, remove the whole header
865                                  * field immediately */
866                                 if (!del_lump(_m, hdr->name.s - _m->buf, hdr->len, 0)) {
867                                         LM_ERR("failed to remove Route HF\n");
868                                         return RR_ERROR;
869                                 }
870                                 res = find_next_route(_m, &hdr);
871                                 if (res < 0) {
872                                         LM_ERR("failed to find next route\n");
873                                         return RR_ERROR;
874                                         }
875                                 if (res > 0) { /* No next route found */
876                                         LM_DBG("no next URI found\n");
877                                         status = (preloaded ? RR_PRELOADED : RR_DRIVEN);
878                                         goto done;
879                                 }
880                                 rt = (rr_t*)hdr->parsed;
881                         } else rt = rt->next;
882                 }
883
884                 uri = rt->nameaddr.uri;
885                 if (parse_uri(uri.s, uri.len, &puri) < 0) {
886                         LM_ERR("failed to parse the next route URI (%.*s)\n",
887                                         uri.len, ZSW(uri.s));
888                         return RR_ERROR;
889                 }
890         } else {
891 #ifdef ENABLE_USER_CHECK
892                 /* check if it the ignored user */
893                 if(uri_is_myself < 0)
894                         return NOT_RR_DRIVEN;
895 #endif
896                 LM_DBG("Topmost URI is NOT myself\n");
897                 routed_params.s = NULL;
898                 routed_params.len = 0;
899         }
900
901         LM_DBG("URI to be processed: '%.*s'\n", uri.len, ZSW(uri.s));
902         if (is_strict(&puri.params)) {
903                 LM_DBG("Next URI is a strict router\n");
904                 if (handle_sr(_m, hdr, rt) < 0) {
905                         LM_ERR("failed to handle strict router\n");
906                         return RR_ERROR;
907                 }
908         } else {
909                 /* Next hop is loose router */
910                 LM_DBG("Next URI is a loose router\n");
911
912                 if (!use_ob) {
913                         if(get_maddr_uri(&uri, &puri)!=0) {
914                                 LM_ERR("checking maddr failed\n");
915                                 return RR_ERROR;
916                         }
917
918                         if (set_dst_uri(_m, &uri) < 0) {
919                                 LM_ERR("failed to set dst_uri\n");
920                                 return RR_ERROR;
921                         }
922                         /* dst_uri changed, so it makes sense to re-use the current uri for
923                         forking */
924                         ruri_mark_new(); /* re-use uri for serial forking */
925                 }
926
927                 /* There is a previous route uri which was 2nd uri of mine
928                  * and must be removed here */
929                 if (rt != hdr->parsed) {
930                         if (!del_lump(_m, hdr->body.s - _m->buf,
931                         rt->nameaddr.name.s - hdr->body.s, 0)) {
932                                 LM_ERR("failed to remove Route HF\n");
933                                 return RR_ERROR;
934                         }
935                 }
936         }
937
938 done:
939         if (use_ob == 1)
940                 status = RR_OB_DRIVEN;
941
942         /* run RR callbacks only if we have Route URI parameters */
943         if(routed_params.len > 0) {
944                 rparams = routed_params;
945                 run_rr_callbacks( _m, &rparams );
946         }
947         return status;
948 }
949
950
951 /*!
952  * \brief Do loose routing as per RFC3261
953  * \param _m SIP message
954  * \return -1 on failure, 1 on success
955  */
956 int loose_route(struct sip_msg* _m)
957 {
958         int ret;
959
960         if (find_first_route(_m) != 0) {
961                 LM_DBG("There is no Route HF\n");
962                 return -1;
963         }
964
965         if (parse_sip_msg_uri(_m)<0) {
966                 LM_ERR("failed to parse Request URI\n");
967                 return -1;
968         }
969
970         ret = is_preloaded(_m);
971         if (ret < 0) {
972                 return -1;
973         } else if (ret == 1) {
974                 return after_loose(_m, 1);
975         } else {
976                 if (is_myself(&_m->parsed_uri)) {
977                         return after_strict(_m);
978                 } else {
979                         return after_loose(_m, 0);
980                 }
981         }
982 }
983
984 /**
985  *
986  */
987 int redo_route_params(sip_msg_t *msg)
988 {
989         hdr_field_t *hdr;
990         sip_uri_t puri;
991         rr_t* rt;
992         str uri;
993         int uri_is_myself;
994
995         int redo = 0;
996
997         if(msg->first_line.type != SIP_REQUEST) {
998                 return -1;
999         }
1000
1001         if(msg->route==NULL) {
1002                 return -1;
1003         }
1004
1005         if(msg->route->parsed==NULL) {
1006                 if (parse_rr(msg->route) < 0) {
1007                         LM_ERR("failed to parse Route HF\n");
1008                         return -1;
1009                 }
1010         }
1011
1012         if(msg->route->parsed==NULL) {
1013                 LM_ERR("NULL parsed Route header\n");
1014                 return -1;
1015         }
1016
1017         /* check if the hooked params belong to the same message */
1018         if (routed_msg_id != msg->id || routed_msg_pid != msg->pid) {
1019                 redo = 1;
1020         }
1021         if((redo==0) && (routed_params.s==NULL || routed_params.len<=0)) {
1022                 redo = 1;
1023         }
1024         if((redo==0) && (routed_params.s<msg->buf
1025                                 || routed_params.s>msg->buf+msg->len)) {
1026                 redo = 1;
1027         }
1028         if(redo==1) {
1029                 hdr = msg->route;
1030                 rt = (rr_t*)hdr->parsed;
1031                 uri = rt->nameaddr.uri;
1032
1033                 /* reset rr handling static vars for safety in error case */
1034                 routed_msg_id = 0;
1035                 routed_msg_pid = 0;
1036
1037                 if (parse_uri(uri.s, uri.len, &puri) < 0) {
1038                         LM_ERR("failed to parse the first route URI (%.*s)\n",
1039                                         uri.len, ZSW(uri.s));
1040                         return -1;
1041                 }
1042
1043                 uri_is_myself = is_myself(&puri);
1044
1045                 /* if the URI was added by me, remove it */
1046                 if (uri_is_myself>0) {
1047                         LM_DBG("Topmost route URI: '%.*s' is me\n",
1048                                 uri.len, ZSW(uri.s));
1049                         /* set the hooks for the params */
1050                         routed_msg_id = msg->id;
1051                         routed_msg_pid = msg->pid;
1052                         routed_params = puri.params;
1053                         return 0;
1054                 } else {
1055                         return -1;
1056                 }
1057         }
1058         return 0;
1059 }
1060
1061 /*!
1062  * \brief Check if the route hdr has the required parameter
1063  *
1064  * The function checks for the request "msg" if the URI parameters
1065  * of the local Route header (corresponding to the local server)
1066  * matches the given regular expression "re". It must be call
1067  * after the loose_route was done.
1068  *
1069  * \param msg SIP message request that will has the Route header parameters checked
1070  * \param re compiled regular expression to be checked against the Route header parameters
1071  * \return -1 on failure, 1 on success
1072  */
1073 int check_route_param(sip_msg_t * msg, regex_t* re)
1074 {
1075         regmatch_t pmatch;
1076         char bk;
1077         str params;
1078         str rruri;
1079
1080         /* check if the hooked params belong to the same message */
1081         if(redo_route_params(msg)<0) {
1082                 return -1;
1083         }
1084
1085         /* check if params are present */
1086         if ( !routed_params.s || routed_params.len<=0 ) {
1087                 return -1;
1088         }
1089         rruri = ((rr_t*)(msg->route->parsed))->nameaddr.uri;
1090
1091         /* include also the first ';' */
1092         for( params=routed_params ;
1093                         params.s>rruri.s && params.s[0]!=';' ;
1094                         params.s--,params.len++ );
1095
1096         LM_DBG("route params checking against [%.*s] (orig: [%.*s])\n",
1097                         params.len, params.s, routed_params.len, routed_params.s);
1098
1099         /* do the well-known trick to convert to null terminted */
1100         bk = params.s[params.len];
1101         params.s[params.len] = 0;
1102         LM_DBG("params are <%s>\n", params.s);
1103         if (regexec( re, params.s, 1, &pmatch, 0)!=0) {
1104                 params.s[params.len] = bk;
1105                 return -1;
1106         } else {
1107                 params.s[params.len] = bk;
1108                 return 0;
1109         }
1110 }
1111
1112
1113 /*!
1114  * \brief Gets the value of a route parameter
1115  *
1116  * The function search in to the "msg"'s Route header parameters
1117  * the parameter called "name" and returns its value into "val".
1118  * It must be call only after the loose_route is done.
1119  *
1120  * \param msg - request that will have the Route header parameter searched
1121  * \param name - contains the Route header parameter to be serached
1122  * \param val returns the value of the searched Route header parameter if found.
1123  * It might be an empty string if the parameter had no value.
1124  * \return 0 if parameter was found (even if it has no value), -1 otherwise
1125  */
1126 int get_route_param(sip_msg_t *msg, str *name, str *val)
1127 {
1128         char *p;
1129         char *end;
1130         char c;
1131         int quoted;
1132
1133         /* check if the hooked params belong to the same message */
1134         if(redo_route_params(msg)<0) {
1135                 goto notfound;
1136         }
1137
1138         /* check if params are present */
1139         if ( !routed_params.s || routed_params.len<=0 )
1140                 goto notfound;
1141
1142         end = routed_params.s + routed_params.len;
1143         p = routed_params.s;
1144
1145
1146         /* parse the parameters string and find the "name" param */
1147         while ( end-p>name->len+2 ) {
1148                 if (p!=routed_params.s) {
1149                         /* go to first ';' char */
1150                         for( quoted=0 ; p<end && !(*p==';' && !quoted) ; p++ )
1151                                 if ( (*p=='"' || *p=='\'') && *(p-1)!='\\' )
1152                                         quoted ^= 0x1;
1153                         if (p==end)
1154                                 goto notfound;
1155                         p++;
1156                 }
1157                 /* get first non space char */
1158                 while( p<end && (*p==' ' || *p=='\t') )
1159                         p++;
1160                 /* check the name - length first and content after */
1161                 if ( end-p<name->len+2 )
1162                         goto notfound;
1163                 if ( memcmp(p,name->s,name->len)!=0 ) {
1164                         p++;
1165                         continue;
1166                 }
1167                 p+=name->len;
1168                 while( p<end && (*p==' ' || *p=='\t') )
1169                         p++;
1170                 if (p==end|| *p==';') {
1171                         /* empty val */
1172                         val->len = 0;
1173                         val->s = 0;
1174                         goto found;
1175                 }
1176                 if (*(p++)!='=')
1177                         continue;
1178                 while( p<end && (*p==' ' || *p=='\t') )
1179                         p++;
1180                 if (p==end)
1181                         goto notfound;
1182                 /* get value */
1183                 if ( *p=='\'' || *p=='"') {
1184                         for( val->s = ++p ; p<end ; p++) {
1185                                 if ((*p=='"' || *p=='\'') && *(p-1)!='\\' )
1186                                         break;
1187                         }
1188                 } else {
1189                         for( val->s=p ; p<end ; p++) {
1190                                 if ( (c=*p)==';' || c==' ' || c=='\t' )
1191                                         break;
1192                         }
1193                 }
1194                 val->len = p-val->s;
1195                 if (val->len==0)
1196                         val->s = 0;
1197                 goto found;
1198         }
1199
1200 notfound:
1201         return -1;
1202 found:
1203         return 0;
1204 }
1205
1206
1207 /*!
1208  * \brief Check the direction of the message
1209  *
1210  * The function checks the flow direction of the request "msg". As
1211  * for checking it's used the "ftag" Route header parameter, the
1212  * append_fromtag module parameter must be enables.
1213  * Also this must be call only after the loose_route is done.
1214
1215  * \param msg SIP message request that will have the direction checked
1216  * \param dir direction to be checked against. It may be RR_FLOW_UPSTREAM or RR_FLOW_DOWNSTREAM
1217  * \return 0 if the request flow direction is the same as the given direction, -1 otherwise
1218  */
1219 int is_direction(struct sip_msg * msg, int dir)
1220 {
1221         static str ftag_param = {"ftag",4};
1222         static unsigned int last_id = (unsigned int)-1;
1223         static unsigned int last_dir = 0;
1224         str ftag_val;
1225         str tag;
1226
1227         if ( last_id==msg->id && last_dir!=0) {
1228                 if (last_dir==RR_FLOW_UPSTREAM)
1229                         goto upstream;
1230                 else
1231                         goto downstream;
1232         }
1233
1234         ftag_val.s = 0;
1235         ftag_val.len = 0;
1236
1237         if (get_route_param( msg, &ftag_param, &ftag_val)!=0) {
1238                 LM_DBG("param ftag not found\n");
1239                 goto downstream;
1240         }
1241
1242         if ( ftag_val.s==0 || ftag_val.len==0 ) {
1243                 LM_DBG("param ftag has empty val\n");
1244                 goto downstream;
1245         }
1246
1247         /* get the tag value from FROM hdr */
1248         if ( parse_from_header(msg)!=0 )
1249                 goto downstream;
1250
1251         tag = ((struct to_body*)msg->from->parsed)->tag_value;
1252         if (tag.s==0 || tag.len==0)
1253                 goto downstream;
1254
1255         /* compare the 2 strings */
1256         if (tag.len!=ftag_val.len || memcmp(tag.s,ftag_val.s,ftag_val.len))
1257                 goto upstream;
1258
1259 downstream:
1260         last_id = msg->id;
1261         last_dir = RR_FLOW_DOWNSTREAM;
1262         return (dir==RR_FLOW_DOWNSTREAM)?0:-1;
1263 upstream:
1264         last_id = msg->id;
1265         last_dir = RR_FLOW_UPSTREAM;
1266         return (dir==RR_FLOW_UPSTREAM)?0:-1;
1267 }