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