core: fix another bunch of 'no real prototype' warnings, add doxygen docs
[sip-router] / dset.c
1 /*
2  * $Id$
3  *
4  * destination set
5  *
6  * Copyright (C) 2001-2004 FhG FOKUS
7  *
8  * This file is part of ser, a free SIP server.
9  *
10  * ser is free software; you can redistribute it and/or modify
11  * it under the terms of the GNU General Public License as published by
12  * the Free Software Foundation; either version 2 of the License, or
13  * (at your option) any later version
14  *
15  * For a license to use the ser software under conditions
16  * other than those described here, or to purchase support for this
17  * software, please contact iptel.org by e-mail at the following addresses:
18  *    info@iptel.org
19  *
20  * ser is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License 
26  * along with this program; if not, write to the Free Software 
27  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
28  */
29
30 /** destination set / branches support.
31  * @file dset.c
32  * @ingroup core
33  * Module: @ref core
34  */
35
36 #include <string.h>
37 #include "dprint.h"
38 #include "config.h"
39 #include "parser/parser_f.h"
40 #include "parser/msg_parser.h"
41 #include "ut.h"
42 #include "hash_func.h"
43 #include "error.h"
44 #include "dset.h"
45 #include "mem/mem.h"
46 #include "ip_addr.h"
47
48 #define CONTACT "Contact: "
49 #define CONTACT_LEN (sizeof(CONTACT) - 1)
50
51 #define CONTACT_DELIM ", "
52 #define CONTACT_DELIM_LEN (sizeof(CONTACT_DELIM) - 1)
53
54 #define Q_PARAM ">;q="
55 #define Q_PARAM_LEN (sizeof(Q_PARAM) - 1)
56
57
58 /* 
59  * Where we store URIs of additional transaction branches
60  * (-1 because of the default branch, #0)
61  */
62 static struct branch branches[MAX_BRANCHES - 1];
63
64 /* how many of them we have */
65 unsigned int nr_branches = 0;
66
67 /* branch iterator */
68 static int branch_iterator = 0;
69
70 /* used to mark ruris "consumed" when branching (1 new, 0 consumed) */
71 int ruri_is_new = 0;
72
73 /* The q parameter of the Request-URI */
74 static qvalue_t ruri_q = Q_UNSPECIFIED;
75
76 /* Branch flags of the Request-URI */
77 static flag_t ruri_bflags;
78
79
80 /*! \brief
81  * Return pointer to branch[idx] structure
82  * @param idx - branch index
83  *
84  * @return  pointer to branch or NULL if invalid branch
85  */
86 branch_t *get_sip_branch(int idx)
87 {
88         if(nr_branches==0)
89                 return NULL;
90         if(idx<0)
91         {
92                 if(nr_branches + idx >= 0)
93                         return &branches[nr_branches+idx];
94                 return NULL;
95         }
96         if(idx < nr_branches)
97                 return &branches[idx];
98         return 0;
99 }
100
101 /*! \brief
102  * Drop branch[idx]
103  * @param idx - branch index
104  *
105  * @return  0 on success, -1 on error
106  */
107 int drop_sip_branch(int idx)
108 {
109         if(nr_branches==0 || idx>=nr_branches)
110                 return 0;
111         if(idx<0 && nr_branches+idx<0)
112                 return 0;
113         /* last branch */
114         if(idx==nr_branches-1)
115         {
116                 nr_branches--;
117                 return 0;
118         }
119         if(idx<0)
120                 idx = nr_branches+idx;
121         /* shift back one position */
122         for(; idx<nr_branches-1; idx++)
123                 memcpy(&branches[idx], &branches[idx+1], sizeof(branch_t));
124         nr_branches--;
125         return 0;
126 }
127
128 static inline flag_t* get_bflags_ptr(unsigned int branch)
129 {
130         if (branch == 0) return &ruri_bflags;
131         if (branch - 1 < nr_branches) return &branches[branch - 1].flags;
132         return NULL;
133 }
134
135
136 int setbflag(unsigned int branch, flag_t flag)
137 {
138         flag_t* flags;
139
140         if ((flags = get_bflags_ptr(branch)) == NULL) return -1;
141         (*flags) |= 1 << flag;
142         return 1;
143 }
144
145
146 int isbflagset(unsigned int branch, flag_t flag)
147 {
148         flag_t* flags;
149
150         if ((flags = get_bflags_ptr(branch)) == NULL) return -1;
151         return ((*flags) & (1 << flag)) ? 1 : -1;
152 }
153
154
155 int resetbflag(unsigned int branch, flag_t flag)
156 {
157         flag_t* flags;
158
159         if ((flags = get_bflags_ptr(branch)) == NULL) return -1;
160         (*flags) &= ~ (1 << flag);
161         return 1;
162 }
163
164
165 int getbflagsval(unsigned int branch, flag_t* res)
166 {
167         flag_t* flags;
168         if (res == NULL) return -1;
169         if ((flags = get_bflags_ptr(branch)) == NULL) return -1;
170         *res = *flags;
171         return 1;
172 }
173
174
175 int setbflagsval(unsigned int branch, flag_t val)
176 {
177         flag_t* flags;
178         if ((flags = get_bflags_ptr(branch)) == NULL) return -1;
179         *flags = val;
180         return 1;
181 }
182
183
184 /*
185  * Initialize the branch iterator, the next
186  * call to next_branch will return the first
187  * contact from the dset array
188  */
189 void init_branch_iterator(void)
190 {
191         branch_iterator = 0;
192 }
193
194 int get_branch_iterator(void)
195 {
196         return branch_iterator;
197 }
198
199
200
201 /** \brief Get a branch from the destination set
202  * \return Return the 'i' branch from the dset
203  * array, 0 is returned if there are no
204  * more branches
205  */
206 char* get_branch(unsigned int i, int* len, qvalue_t* q, str* dst_uri,
207                                  str* path, unsigned int *flags,
208                                  struct socket_info** force_socket)
209 {
210         if (i < nr_branches) {
211                 *len = branches[i].len;
212                 *q = branches[i].q;
213                 if (dst_uri) {
214                         dst_uri->len = branches[i].dst_uri_len;
215                         dst_uri->s = (dst_uri->len)?branches[i].dst_uri:0;
216                 }
217                 if (path) {
218                         path->len = branches[i].path_len;
219                         path->s = (path->len)?branches[i].path:0;
220                 }
221                 if (force_socket)
222                         *force_socket = branches[i].force_send_socket;
223                 if (flags)
224                         *flags = branches[i].flags;
225                 return branches[i].uri;
226         } else {
227                 *len = 0;
228                 *q = Q_UNSPECIFIED;
229                 if (dst_uri) {
230                         dst_uri->s = 0;
231                         dst_uri->len = 0;
232                 }
233                 if (path) {
234                         path->s = 0;
235                         path->len = 0;
236                 }
237                 if (force_socket)
238                         *force_socket = 0;
239                 if (flags)
240                         *flags = 0;
241                 return 0;
242         }
243 }
244
245
246
247 /** Return the next branch from the dset array.
248  * 0 is returned if there are no more branches
249  */
250 char* next_branch(int* len, qvalue_t* q, str* dst_uri, str* path,
251                                         unsigned int* flags, struct socket_info** force_socket)
252 {
253         char* ret;
254         
255         ret=get_branch(branch_iterator, len, q, dst_uri, path, flags,
256                                         force_socket);
257         if (likely(ret))
258                 branch_iterator++;
259         return ret;
260 }
261
262
263 /*
264  * Empty the dset array
265  */
266 void clear_branches(void)
267 {
268         nr_branches = 0;
269         ruri_q = Q_UNSPECIFIED;
270         ruri_bflags = 0;
271         ruri_mark_consumed();
272 }
273
274
275
276 /**  Add a new branch to the current transaction.
277  * @param msg - sip message, used for getting the uri if not specified (0).
278  * @param uri - uri, can be 0 (in which case the uri is taken from msg)
279  * @param dst_uri - destination uri, can be 0.
280  * @param path - path vector (passed in a string), can be 0.
281  * @param q  - q value.
282  * @param flags - per branch flags.
283  * @param force_socket - socket that should be used when sending.
284  *
285  * @return  <0 (-1) on failure, 1 on success (script convention).
286  */
287 int append_branch(struct sip_msg* msg, str* uri, str* dst_uri, str* path,
288                 qvalue_t q, unsigned int flags, struct socket_info* force_socket)
289 {
290         str luri;
291
292         /* if we have already set up the maximum number
293          * of branches, don't try new ones 
294          */
295         if (unlikely(nr_branches == MAX_BRANCHES - 1)) {
296                 LOG(L_ERR, "max nr of branches exceeded\n");
297                 ser_error = E_TOO_MANY_BRANCHES;
298                 return -1;
299         }
300
301         /* if not parameterized, take current uri */
302         if (uri==0 || uri->len==0 || uri->s==0) {
303                 if (msg->new_uri.s)
304                         luri = msg->new_uri;
305                 else
306                         luri = msg->first_line.u.request.uri;
307         } else {
308                 luri = *uri;
309         }
310
311         if (unlikely(luri.len > MAX_URI_SIZE - 1)) {
312                 LOG(L_ERR, "too long uri: %.*s\n", luri.len, luri.s);
313                 return -1;
314         }
315
316         /* copy the dst_uri */
317         if (dst_uri && dst_uri->len && dst_uri->s) {
318                 if (unlikely(dst_uri->len > MAX_URI_SIZE - 1)) {
319                         LOG(L_ERR, "too long dst_uri: %.*s\n", dst_uri->len, dst_uri->s);
320                         return -1;
321                 }
322                 memcpy(branches[nr_branches].dst_uri, dst_uri->s, dst_uri->len);
323                 branches[nr_branches].dst_uri[dst_uri->len] = 0;
324                 branches[nr_branches].dst_uri_len = dst_uri->len;
325         } else {
326                 branches[nr_branches].dst_uri[0] = '\0';
327                 branches[nr_branches].dst_uri_len = 0;
328         }
329
330         /* copy the path string */
331         if (unlikely(path && path->len && path->s)) {
332                 if (unlikely(path->len > MAX_PATH_SIZE - 1)) {
333                         LOG(L_ERR, "too long path: %.*s\n", path->len, path->s);
334                         return -1;
335                 }
336                 memcpy(branches[nr_branches].path, path->s, path->len);
337                 branches[nr_branches].path[path->len] = 0;
338                 branches[nr_branches].path_len = path->len;
339         } else {
340                 branches[nr_branches].path[0] = '\0';
341                 branches[nr_branches].path_len = 0;
342         }
343
344         /* copy the ruri */
345         memcpy(branches[nr_branches].uri, luri.s, luri.len);
346         branches[nr_branches].uri[luri.len] = 0;
347         branches[nr_branches].len = luri.len;
348         branches[nr_branches].q = q;
349
350         branches[nr_branches].force_send_socket = force_socket;
351         branches[nr_branches].flags = flags;
352
353         nr_branches++;
354         return 1;
355 }
356
357
358 /*
359  * Create a Contact header field from the dset
360  * array
361  */
362 char* print_dset(struct sip_msg* msg, int* len) 
363 {
364         int cnt, i;
365         unsigned int qlen;
366         qvalue_t q;
367         str uri;
368         char* p, *qbuf;
369         static char dset[MAX_REDIRECTION_LEN];
370
371         if (msg->new_uri.s) {
372                 cnt = 1;
373                 *len = msg->new_uri.len;
374                 if (ruri_q != Q_UNSPECIFIED) {
375                         *len += 1 + Q_PARAM_LEN + len_q(ruri_q);
376                 }
377         } else {
378                 cnt = 0;
379                 *len = 0;
380         }
381
382         init_branch_iterator();
383         while ((uri.s = next_branch(&uri.len, &q, 0, 0, 0, 0))) {
384                 cnt++;
385                 *len += uri.len;
386                 if (q != Q_UNSPECIFIED) {
387                         *len += 1 + Q_PARAM_LEN + len_q(q);
388                 }
389         }
390
391         if (cnt == 0) return 0; 
392
393         *len += CONTACT_LEN + CRLF_LEN + (cnt - 1) * CONTACT_DELIM_LEN;
394
395         if (*len + 1 > MAX_REDIRECTION_LEN) {
396                 LOG(L_ERR, "ERROR: redirection buffer length exceed\n");
397                 return 0;
398         }
399
400         memcpy(dset, CONTACT, CONTACT_LEN);
401         p = dset + CONTACT_LEN;
402         if (msg->new_uri.s) {
403                 if (ruri_q != Q_UNSPECIFIED) {
404                         *p++ = '<';
405                 }
406
407                 memcpy(p, msg->new_uri.s, msg->new_uri.len);
408                 p += msg->new_uri.len;
409
410                 if (ruri_q != Q_UNSPECIFIED) {
411                         memcpy(p, Q_PARAM, Q_PARAM_LEN);
412                         p += Q_PARAM_LEN;
413
414                         qbuf = q2str(ruri_q, &qlen);
415                         memcpy(p, qbuf, qlen);
416                         p += qlen;
417                 }
418                 i = 1;
419         } else {
420                 i = 0;
421         }
422
423         init_branch_iterator();
424         while ((uri.s = next_branch(&uri.len, &q, 0, 0, 0, 0))) {
425                 if (i) {
426                         memcpy(p, CONTACT_DELIM, CONTACT_DELIM_LEN);
427                         p += CONTACT_DELIM_LEN;
428                 }
429
430                 if (q != Q_UNSPECIFIED) {
431                         *p++ = '<';
432                 }
433
434                 memcpy(p, uri.s, uri.len);
435                 p += uri.len;
436                 if (q != Q_UNSPECIFIED) {
437                         memcpy(p, Q_PARAM, Q_PARAM_LEN);
438                         p += Q_PARAM_LEN;
439
440                         qbuf = q2str(q, &qlen);
441                         memcpy(p, qbuf, qlen);
442                         p += qlen;
443                 }
444                 i++;
445         }
446
447         memcpy(p, CRLF " ", CRLF_LEN + 1);
448         return dset;
449 }
450
451
452 /*
453  * Sets the q parameter of the Request-URI
454  */
455 void set_ruri_q(qvalue_t q)
456 {
457         ruri_q = q;
458 }
459
460
461 /*
462  * Return the q value of the Request-URI
463  */
464 qvalue_t get_ruri_q(void)
465 {
466         return ruri_q;
467 }
468
469
470
471 /*
472  * Rewrite Request-URI
473  */
474 int rewrite_uri(struct sip_msg* _m, str* _s)
475 {
476         char* buf;
477
478         buf = (char*)pkg_malloc(_s->len + 1);
479         if (!buf) {
480                 LOG(L_ERR, "ERROR: rewrite_uri: No memory left\n");
481                 return -1;
482         }
483
484         memcpy(buf, _s->s, _s->len);
485         buf[_s->len] = '\0';
486
487         _m->parsed_uri_ok = 0;
488         if (_m->new_uri.s) {
489                 pkg_free(_m->new_uri.s);
490         }
491
492         _m->new_uri.s = buf;
493         _m->new_uri.len = _s->len;
494         /* mark ruri as new and available for forking */
495         ruri_mark_new();
496
497         return 1;
498 }
499