modules: several small doxygen bug fixes
[sip-router] / modules_k / rr / record.c
1 /*
2  * $Id$
3  *
4  * Copyright (C) 2001-2003 FhG Fokus
5  *
6  * This file is part of Kamailio, a free SIP server.
7  *
8  * Kamailio is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version
12  *
13  * Kamailio is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License 
19  * along with this program; if not, write to the Free Software 
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  */
22
23 /*!
24  * \file
25  * \brief Route & Record-Route module, loose routing support
26  * \ingroup rr
27  */
28
29 /*!
30  * \defgroup rr RR :: Route & Record-Route Module
31  * This module contains record routing logic, as described in RFC 3261
32  * (see chapter 16.12 and 12.1.1 - UAS behavior).
33  */
34
35 #include <string.h>
36 #include "../../mem/mem.h"
37 #include "../../dprint.h"
38 #include "../../parser/parse_uri.h"
39 #include "../../parser/parse_from.h"
40 #include "../../str.h"
41 #include "../../data_lump.h"
42 #include "record.h"
43 #include "rr_mod.h"
44
45
46 #define RR_PREFIX "Record-Route: <sip:"
47 #define RR_PREFIX_LEN (sizeof(RR_PREFIX)-1)
48
49 #define RR_LR ";lr"
50 #define RR_LR_LEN (sizeof(RR_LR)-1)
51
52 #define RR_LR_FULL ";lr=on"
53 #define RR_LR_FULL_LEN (sizeof(RR_LR_FULL)-1)
54
55 #define RR_FROMTAG ";ftag="
56 #define RR_FROMTAG_LEN (sizeof(RR_FROMTAG)-1)
57
58 #define RR_R2 ";r2=on"
59 #define RR_R2_LEN (sizeof(RR_R2)-1)
60
61 #define RR_TERM ">"CRLF
62 #define RR_TERM_LEN (sizeof(RR_TERM)-1)
63
64 #define INBOUND  1      /*!< Insert inbound Record-Route */
65 #define OUTBOUND 0      /*!< Insert outbound Record-Route */
66
67 #define RR_PARAM_BUF_SIZE 512 /*!< buffer for RR parameter */
68
69
70 /*!
71  * \brief RR param buffer 
72  * \note used for storing RR param which are added before RR insertion
73  */
74 static char rr_param_buf_ptr[RR_PARAM_BUF_SIZE];
75 static str rr_param_buf = {rr_param_buf_ptr,0};
76 static unsigned int rr_param_msg;
77
78
79 /*!
80  * \brief Extract username from the Request URI
81  *
82  * Extract username from the Request URI. First try to look at the original
83  * Request URI and if there is no username use the new Request URI.
84  * \param _m SIP message
85  * \param _user username
86  * \return 0 on success, negative on errors
87  */
88 static inline int get_username(struct sip_msg* _m, str* _user)
89 {
90         struct sip_uri puri;
91
92              /* first try to look at r-uri for a username */
93         if (parse_uri(_m->first_line.u.request.uri.s, _m->first_line.u.request.uri.len, &puri) < 0) {
94                 LM_ERR("failed to parse R-URI\n");
95                 return -1;
96         }
97
98         /* no username in original uri -- hmm; maybe it is a uri
99          * with just host address and username is in a preloaded route,
100          * which is now no rewritten r-uri (assumed rewriteFromRoute
101          * was called somewhere in script's beginning) 
102          */
103         if (!puri.user.len && _m->new_uri.s) {
104                 if (parse_uri(_m->new_uri.s, _m->new_uri.len, &puri) < 0) {
105                         LM_ERR("failed to parse new_uri\n");
106                         return -2;
107                 }
108         }
109
110         _user->s = puri.user.s;
111         _user->len = puri.user.len;
112         return 0;
113 }
114
115
116 /*!
117  * \brief Insert RR parameter lump in new allocated private memory
118  * \param before lump list
119  * \param s parameter string
120  * \param l parameter string length
121  * \return pointer to new lump on success, NULL on failure
122  */
123 static inline struct lump *insert_rr_param_lump(struct lump *before,
124                                                 char *s, int l)
125 {
126         struct lump *rrp_l;
127         char *s1;
128
129         /* duplicate data in pkg mem */
130         s1 = (char*)pkg_malloc(l);
131         if (s1==0) {
132                 LM_ERR("no more pkg mem (%d)\n",l);
133                 return 0;
134         }
135         memcpy( s1, s, l);
136
137         /* add lump */
138         rrp_l = insert_new_lump_before( before, s1, l, HDR_RECORDROUTE_T);
139         if (rrp_l==0) {
140                 LM_ERR("failed to add before lump\n");
141                 pkg_free(s1);
142                 return 0;
143         }
144         return rrp_l;
145 }
146
147
148 /*!
149  * \brief Build a Record-Route header field
150  *
151 * Build a Record-Route header field, allocates new private memory for this.
152  * \param _l first lump
153  * \param _l2 second lump
154  * \param user user parameter
155  * \param tag tag parameter
156  * \param params parameter
157  * \param _inbound inbound request
158  * \return 0 on success, negative on failure
159  */
160 static inline int build_rr(struct lump* _l, struct lump* _l2, str* user,
161                                                 str *tag, str *params, int _inbound)
162 {
163         char* prefix, *suffix, *term, *r2;
164         int suffix_len, prefix_len;
165         char *p;
166
167         prefix_len = RR_PREFIX_LEN + (user->len ? (user->len + 1) : 0);
168         if (enable_full_lr) {
169                 suffix_len = RR_LR_FULL_LEN + (params?params->len:0) +
170                                 ((tag && tag->len) ? (RR_FROMTAG_LEN + tag->len) : 0);
171         } else {
172                 suffix_len = RR_LR_LEN + (params?params->len:0) +
173                                 ((tag && tag->len) ? (RR_FROMTAG_LEN + tag->len) : 0);
174         }
175
176         prefix = pkg_malloc(prefix_len);
177         suffix = pkg_malloc(suffix_len);
178         term = pkg_malloc(RR_TERM_LEN);
179         r2 = pkg_malloc(RR_R2_LEN);
180
181         if (!prefix || !suffix || !term || !r2) {
182                 LM_ERR("No more pkg memory\n");
183                 if (suffix) pkg_free(suffix);
184                 if (prefix) pkg_free(prefix);
185                 if (term) pkg_free(term);
186                 if (r2) pkg_free(r2);
187                 return -3;
188         }
189         
190         memcpy(prefix, RR_PREFIX, RR_PREFIX_LEN);
191         if (user->len) {
192                 memcpy(prefix + RR_PREFIX_LEN, user->s, user->len);
193 #ifdef ENABLE_USER_CHECK
194                 /* don't add the ignored user into a RR */
195                 if(i_user.len && i_user.len == user->len && 
196                                 !strncmp(i_user.s, user->s, i_user.len))
197                 {
198                         if(prefix[RR_PREFIX_LEN]=='x')
199                                 prefix[RR_PREFIX_LEN]='y';
200                         else
201                                 prefix[RR_PREFIX_LEN]='x';
202                 }
203 #endif
204                 prefix[RR_PREFIX_LEN + user->len] = '@';
205         }
206
207         p = suffix;
208         if (enable_full_lr) {
209                 memcpy( p, RR_LR_FULL, RR_LR_FULL_LEN);
210                 p += RR_LR_FULL_LEN;
211         } else {
212                 memcpy( p, RR_LR, RR_LR_LEN);
213                 p += RR_LR_LEN;
214         }
215         if (tag && tag->len) {
216                 memcpy(p, RR_FROMTAG, RR_FROMTAG_LEN);
217                 p += RR_FROMTAG_LEN;
218                 memcpy(p, tag->s, tag->len);
219                 p += tag->len;
220         }
221         if (params && params->len) {
222                 memcpy(p, params->s, params->len);
223                 p += params->len;
224         }
225         
226         memcpy(term, RR_TERM, RR_TERM_LEN);
227         memcpy(r2, RR_R2, RR_R2_LEN);
228
229         if (!(_l = insert_new_lump_after(_l, prefix, prefix_len, 0))) 
230                 goto lump_err;
231         prefix = 0;
232         _l = insert_subst_lump_after(_l, _inbound?SUBST_RCV_ALL:SUBST_SND_ALL, 0);
233         if (_l ==0 )
234                 goto lump_err;
235         if (enable_double_rr) {
236                 if (!(_l = insert_cond_lump_after(_l, COND_IF_DIFF_REALMS, 0)))
237                         goto lump_err;
238                 if (!(_l = insert_new_lump_after(_l, r2, RR_R2_LEN, 0)))
239                         goto lump_err;
240                 r2 = 0;
241         } else {
242                 pkg_free(r2);
243                 r2 = 0;
244         }
245         _l2 = insert_new_lump_before(_l2, suffix, suffix_len, HDR_RECORDROUTE_T);
246         if (_l2 == 0)
247                 goto lump_err;
248         if (rr_param_buf.len) {
249                 _l2 = insert_rr_param_lump(_l2, rr_param_buf.s, rr_param_buf.len);
250                 if (_l2 == 0)
251                         goto lump_err;
252         }
253         suffix = 0;
254         if (!(_l2 = insert_new_lump_before(_l2, term, RR_TERM_LEN, 0)))
255                 goto lump_err;
256         term = 0;
257         return 0;
258         
259 lump_err:
260         LM_ERR("failed to insert lumps\n");
261         if (prefix) pkg_free(prefix);
262         if (suffix) pkg_free(suffix);
263         if (r2) pkg_free(r2);
264         if (term) pkg_free(term);
265         return -4;
266 }
267
268
269 /*!
270  * \brief Insert a new Record-Route header field with lr parameter
271  *
272  * Insert a new Record-Route header field and also 2nd one if it is enabled
273  * and the realm changed so the 2nd record-route header will be necessary.
274  * \param _m SIP message
275  * \param params RR parameter
276  * \return 0 on success, negative on failure
277  */
278 int record_route(struct sip_msg* _m, str *params)
279 {
280         struct lump* l, *l2;
281         str user;
282         struct to_body* from = NULL;
283         str* tag;
284         
285         user.len = 0;
286         
287         if (add_username) {
288                 if (get_username(_m, &user) < 0) {
289                         LM_ERR("failed to extract username\n");
290                         return -1;
291                 }
292         }
293
294         if (append_fromtag) {
295                 if (parse_from_header(_m) < 0) {
296                         LM_ERR("From parsing failed\n");
297                         return -2;
298                 }
299                 from = (struct to_body*)_m->from->parsed;
300                 tag = &from->tag_value;
301         } else {
302                 tag = 0;
303         }
304
305         if (rr_param_buf.len && rr_param_msg!=_m->id) {
306                 /* rr_params were set for a different message -> reset buffer */
307                 rr_param_buf.len = 0;
308         }
309
310         if (enable_double_rr) {
311                 l = anchor_lump(_m, _m->headers->name.s - _m->buf,0,HDR_RECORDROUTE_T);
312                 l2 = anchor_lump(_m, _m->headers->name.s - _m->buf, 0, 0);
313                 if (!l || !l2) {
314                         LM_ERR("failed to create an anchor\n");
315                         return -5;
316                 }
317                 l = insert_cond_lump_after(l, COND_IF_DIFF_REALMS, 0);
318                 l2 = insert_cond_lump_before(l2, COND_IF_DIFF_REALMS, 0);
319                 if (!l || !l2) {
320                         LM_ERR("failed to insert conditional lump\n");
321                         return -6;
322                 }
323                 if (build_rr(l, l2, &user, tag, params, OUTBOUND) < 0) {
324                         LM_ERR("failed to insert outbound Record-Route\n");
325                         return -7;
326                 }
327         }
328         
329         l = anchor_lump(_m, _m->headers->name.s - _m->buf, 0, HDR_RECORDROUTE_T);
330         l2 = anchor_lump(_m, _m->headers->name.s - _m->buf, 0, 0);
331         if (!l || !l2) {
332                 LM_ERR("failed to create an anchor\n");
333                 return -3;
334         }
335         
336         if (build_rr(l, l2, &user, tag, params, INBOUND) < 0) {
337                 LM_ERR("failed to insert inbound Record-Route\n");
338                 return -4;
339         }
340
341         /* reset the rr_param buffer */
342         rr_param_buf.len = 0;
343         return 0;
344 }
345
346
347 /*!
348  * \brief Insert manually created Record-Route header
349  *
350  * Insert manually created Record-Route header, no checks, no restrictions,
351  * always adds lr parameter, only fromtag is added automatically when requested.
352  * Allocates new private memory for this.
353  * \param _m SIP message
354  * \param _data manually created RR header
355  * \return 1 on success, negative on failure
356  */
357 int record_route_preset(struct sip_msg* _m, str* _data)
358 {
359         str user;
360         struct to_body* from;
361         struct lump* l;
362         char* hdr, *p;
363         int hdr_len;
364
365         from = 0;
366         user.len = 0;
367         user.s = 0;
368
369         if (add_username) {
370                 if (get_username(_m, &user) < 0) {
371                         LM_ERR("failed to extract username\n");
372                         return -1;
373                 }
374         }
375
376         if (append_fromtag) {
377                 if (parse_from_header(_m) < 0) {
378                         LM_ERR("From parsing failed\n");
379                         return -2;
380                 }
381                 from = (struct to_body*)_m->from->parsed;
382         }
383         
384         l = anchor_lump(_m, _m->headers->name.s - _m->buf, 0, HDR_RECORDROUTE_T);
385         if (!l) {
386                 LM_ERR("failed to create lump anchor\n");
387                 return -3;
388         }
389
390         hdr_len = RR_PREFIX_LEN;
391         if (user.len)
392                 hdr_len += user.len + 1; /* @ */
393         hdr_len += _data->len;
394
395         if (append_fromtag && from->tag_value.len) {
396                 hdr_len += RR_FROMTAG_LEN + from->tag_value.len;
397         }
398         
399         if (enable_full_lr) {
400                 hdr_len += RR_LR_FULL_LEN;
401         } else {
402                 hdr_len += RR_LR_LEN;
403         }
404
405         hdr_len += RR_TERM_LEN;
406
407         hdr = pkg_malloc(hdr_len);
408         if (!hdr) {
409                 LM_ERR("no pkg memory left\n");
410                 return -4;
411         }
412
413         p = hdr;
414         memcpy(p, RR_PREFIX, RR_PREFIX_LEN);
415         p += RR_PREFIX_LEN;
416
417         if (user.len) {
418                 memcpy(p, user.s, user.len);
419                 p += user.len;
420                 *p = '@';
421                 p++;
422         }
423
424         memcpy(p, _data->s, _data->len);
425         p += _data->len;
426         
427         if (append_fromtag && from->tag_value.len) {
428                 memcpy(p, RR_FROMTAG, RR_FROMTAG_LEN);
429                 p += RR_FROMTAG_LEN;
430                 memcpy(p, from->tag_value.s, from->tag_value.len);
431                 p += from->tag_value.len;
432         }
433
434         if (enable_full_lr) {
435                 memcpy(p, RR_LR_FULL, RR_LR_FULL_LEN);
436                 p += RR_LR_FULL_LEN;
437         } else {
438                 memcpy(p, RR_LR, RR_LR_LEN);
439                 p += RR_LR_LEN;
440         }
441
442         memcpy(p, RR_TERM, RR_TERM_LEN);
443
444         if (!insert_new_lump_after(l, hdr, hdr_len, 0)) {
445                 LM_ERR("failed to insert new lump\n");
446                 pkg_free(hdr);
447                 return -5;
448         }
449         return 1;
450 }
451
452
453 /*!
454  * \brief Get the RR parameter lump
455  * \param root root of the lump list
456  * \return pointer to the RR parameter lump, or NULL if not found
457  */
458 static struct lump *get_rr_param_lump( struct lump** root)
459 {
460         struct lump *r, *crt, *last;
461         /* look on the "before" branch for the last added lump */
462
463         last = 0;
464         for( crt=*root ; crt && !last ; crt=crt->next,(*root)=crt ) {
465                 /* check on before list */
466                 for( r=crt->before ; r ; r=r->before ) {
467                         /* we are looking for the lump that adds the 
468                          * suffix of the RR header */
469                         if ( r->type==HDR_RECORDROUTE_T && r->op==LUMP_ADD)
470                                 last = r;
471                 }
472         }
473         return last;
474 }
475
476
477 /*!
478  * \brief Appends a new Record-Route parameter
479  * \param msg SIP message
480  * \param rr_param RR parameter
481  * \return 0 on success, -1 on failure
482  */
483 int add_rr_param(struct sip_msg* msg, str* rr_param)
484 {
485         struct lump *last_param;
486         struct lump *root;
487
488         root = msg->add_rm;
489         last_param = get_rr_param_lump( &root );
490         if (last_param) {
491                 /* RR was already done -> have to add a new lump before this one */
492                 if (insert_rr_param_lump( last_param, rr_param->s, rr_param->len)==0) {
493                         LM_ERR("failed to add lump\n");
494                         goto error;
495                 }
496                 /* double routing enabled? */
497                 if (enable_double_rr) {
498                         if (root==0 || (last_param=get_rr_param_lump(&root))==0) {
499                                 LM_CRIT("failed to locate double RR lump\n");
500                                 goto error;
501                         }
502                         if (insert_rr_param_lump(last_param,rr_param->s,rr_param->len)==0){
503                                 LM_ERR("failed to add 2nd lump\n");
504                                 goto error;
505                         }
506                 }
507         } else {
508                 /* RR not done yet -> store the param in the static buffer */
509                 if (rr_param_msg!=msg->id) {
510                         /* it's about a different message -> reset buffer */
511                         rr_param_buf.len = 0;
512                         rr_param_msg = msg->id;
513                 }
514                 if (rr_param_buf.len+rr_param->len>RR_PARAM_BUF_SIZE) {
515                         LM_ERR("maximum size of rr_param_buf exceeded\n");
516                         goto error;
517                 }
518                 memcpy( rr_param_buf.s+rr_param_buf.len, rr_param->s, rr_param->len);
519                 rr_param_buf.len += rr_param->len;
520                 LM_DBG("rr_param_buf=<%.*s>\n",rr_param_buf.len, rr_param_buf.s);
521         }
522         return 0;
523
524 error:
525         return -1;
526 }