enum aligned to use of dset.c rewrite_uri
[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 #include <string.h>
31 #include "dprint.h"
32 #include "config.h"
33 #include "parser/parser_f.h"
34 #include "parser/msg_parser.h"
35 #include "ut.h"
36 #include "hash_func.h"
37 #include "error.h"
38 #include "dset.h"
39 #include "mem/mem.h"
40
41 #define CONTACT "Contact: "
42 #define CONTACT_LEN (sizeof(CONTACT) - 1)
43
44 #define CONTACT_DELIM ", "
45 #define CONTACT_DELIM_LEN (sizeof(CONTACT_DELIM) - 1)
46
47 #define Q_PARAM ">;q="
48 #define Q_PARAM_LEN (sizeof(Q_PARAM) - 1)
49
50 struct branch
51 {
52         char uri[MAX_URI_SIZE];
53         unsigned int len;
54
55              /* Real destination of the request */
56         char dst_uri[MAX_URI_SIZE];
57         unsigned int dst_uri_len;
58
59         int q; /* Preference of the contact among
60                 * contact within the array */
61 };
62
63
64 /* 
65  * Where we store URIs of additional transaction branches
66  * (-1 because of the default branch, #0)
67  */
68 static struct branch branches[MAX_BRANCHES - 1];
69
70 /* how many of them we have */
71 static unsigned int nr_branches = 0;
72
73 /* branch iterator */
74 static int branch_iterator = 0;
75
76 /* The q parameter of the Request-URI */
77 static qvalue_t ruri_q = Q_UNSPECIFIED; 
78
79
80 /*
81  * Initialize the branch iterator, the next
82  * call to next_branch will return the first
83  * contact from the dset array
84  */
85 void init_branch_iterator(void)
86 {
87         branch_iterator = 0;
88 }
89
90
91 /*
92  * Return the next branch from the dset
93  * array, 0 is returned if there are no
94  * more branches
95  */
96 char* next_branch(int* len, qvalue_t* q, char** dst_uri, int* dst_len)
97 {
98         unsigned int i;
99
100         i = branch_iterator;
101         if (i < nr_branches) {
102                 branch_iterator++;
103                 *len = branches[i].len;
104                 *q = branches[i].q;
105                 if (dst_uri && dst_len) {
106                         *dst_uri = branches[i].dst_uri;
107                         *dst_len = branches[i].dst_uri_len;
108                 }
109                 return branches[i].uri;
110         } else {
111                 *len = 0;
112                 *q = Q_UNSPECIFIED;
113                 if (dst_uri && dst_len) {
114                         *dst_uri = 0;
115                         *dst_len = 0;
116                 }
117                 return 0;
118         }
119 }
120
121
122 /*
123  * Empty the dset array
124  */
125 void clear_branches(void)
126 {
127         nr_branches = 0;
128         ruri_q = Q_UNSPECIFIED;
129 }
130
131
132 /* 
133  * Add a new branch to current transaction 
134  */
135 int append_branch(struct sip_msg* msg, char* uri, int uri_len, char* dst_uri, int dst_uri_len, qvalue_t q)
136 {
137              /* if we have already set up the maximum number
138               * of branches, don't try new ones 
139               */
140         if (nr_branches == MAX_BRANCHES - 1) {
141                 LOG(L_ERR, "ERROR: append_branch: max nr of branches exceeded\n");
142                 ser_error = E_TOO_MANY_BRANCHES;
143                 return -1;
144         }
145
146         if (uri_len > MAX_URI_SIZE - 1) {
147                 LOG(L_ERR, "ERROR: append_branch: too long uri: %.*s\n",
148                     uri_len, uri);
149                 return -1;
150         }
151
152              /* if not parameterized, take current uri */
153         if (uri == 0) {
154                 if (msg->new_uri.s) { 
155                         uri = msg->new_uri.s;
156                         uri_len = msg->new_uri.len;
157                 } else {
158                         uri = msg->first_line.u.request.uri.s;
159                         uri_len = msg->first_line.u.request.uri.len;
160                 }
161         }
162         
163         memcpy(branches[nr_branches].uri, uri, uri_len);
164              /* be safe -- add zero termination */
165         branches[nr_branches].uri[uri_len] = 0;
166         branches[nr_branches].len = uri_len;
167         branches[nr_branches].q = q;
168         
169         if (dst_uri) {
170                 memcpy(branches[nr_branches].dst_uri, dst_uri, dst_uri_len);
171                 branches[nr_branches].dst_uri[dst_uri_len] = 0;
172                 branches[nr_branches].dst_uri_len = dst_uri_len;
173         }
174
175         nr_branches++;
176         return 1;
177 }
178
179
180 /*
181  * Create a Contact header field from the dset
182  * array
183  */
184 char* print_dset(struct sip_msg* msg, int* len) 
185 {
186         int cnt, i, qlen;
187         qvalue_t q;
188         str uri;
189         char* p, *qbuf;
190         static char dset[MAX_REDIRECTION_LEN];
191
192         if (msg->new_uri.s) {
193                 cnt = 1;
194                 *len = msg->new_uri.len;
195                 if (ruri_q != Q_UNSPECIFIED) {
196                         *len += 1 + Q_PARAM_LEN + len_q(ruri_q);
197                 }
198         } else {
199                 cnt = 0;
200                 *len = 0;
201         }
202
203         init_branch_iterator();
204         while ((uri.s = next_branch(&uri.len, &q, 0, 0))) {
205                 cnt++;
206                 *len += uri.len;
207                 if (q != Q_UNSPECIFIED) {
208                         *len += 1 + Q_PARAM_LEN + len_q(q);
209                 }
210         }
211
212         if (cnt == 0) return 0; 
213
214         *len += CONTACT_LEN + CRLF_LEN + (cnt - 1) * CONTACT_DELIM_LEN;
215
216         if (*len + 1 > MAX_REDIRECTION_LEN) {
217                 LOG(L_ERR, "ERROR: redirection buffer length exceed\n");
218                 return 0;
219         }
220
221         memcpy(dset, CONTACT, CONTACT_LEN);
222         p = dset + CONTACT_LEN;
223         if (msg->new_uri.s) {
224                 if (ruri_q != Q_UNSPECIFIED) {
225                         *p++ = '<';
226                 }
227
228                 memcpy(p, msg->new_uri.s, msg->new_uri.len);
229                 p += msg->new_uri.len;
230
231                 if (ruri_q != Q_UNSPECIFIED) {
232                         memcpy(p, Q_PARAM, Q_PARAM_LEN);
233                         p += Q_PARAM_LEN;
234
235                         qbuf = q2str(ruri_q, &qlen);
236                         memcpy(p, qbuf, qlen);
237                         p += qlen;
238                 }
239                 i = 1;
240         } else {
241                 i = 0;
242         }
243
244         init_branch_iterator();
245         while ((uri.s = next_branch(&uri.len, &q, 0, 0))) {
246                 if (i) {
247                         memcpy(p, CONTACT_DELIM, CONTACT_DELIM_LEN);
248                         p += CONTACT_DELIM_LEN;
249                 }
250
251                 if (q != Q_UNSPECIFIED) {
252                         *p++ = '<';
253                 }
254
255                 memcpy(p, uri.s, uri.len);
256                 p += uri.len;
257                 if (q != Q_UNSPECIFIED) {
258                         memcpy(p, Q_PARAM, Q_PARAM_LEN);
259                         p += Q_PARAM_LEN;
260
261                         qbuf = q2str(q, &qlen);
262                         memcpy(p, qbuf, qlen);
263                         p += qlen;
264                 }
265                 i++;
266         }
267
268         memcpy(p, CRLF " ", CRLF_LEN + 1);
269         return dset;
270 }
271
272
273 /*
274  * Sets the q parameter of the Request-URI
275  */
276 void set_ruri_q(qvalue_t q)
277 {
278         ruri_q = q;
279 }
280
281
282 /*
283  * Return the q value of the Request-URI
284  */
285 qvalue_t get_ruri_q(void)
286 {
287         return ruri_q;
288 }
289
290
291
292 /*
293  * Get actual Request-URI
294  */
295 int get_request_uri(struct sip_msg* _m, str* _u)
296 {
297              /* Use new_uri if present */
298         if (_m->new_uri.s) {
299                 _u->s = _m->new_uri.s;
300                 _u->len = _m->new_uri.len;
301         } else {
302                 _u->s = _m->first_line.u.request.uri.s;
303                 _u->len = _m->first_line.u.request.uri.len;
304         }
305
306         return 0;
307 }
308
309
310 /*
311  * Rewrite Request-URI
312  */
313 int rewrite_uri(struct sip_msg* _m, str* _s)
314 {
315         char* buf;
316
317         buf = (char*)pkg_malloc(_s->len + 1);
318         if (!buf) {
319                 LOG(L_ERR, "ERROR: TOI: rewrite_uri: No memory left\n");
320                 return -1;
321         }
322
323         memcpy(buf, _s->s, _s->len);
324         buf[_s->len] = '\0';
325
326         _m->parsed_uri_ok = 0;
327         if (_m->new_uri.s) {
328                 pkg_free(_m->new_uri.s);
329         }
330
331         _m->new_uri.s = buf;
332         _m->new_uri.len = _s->len;
333
334         DBG("TOI: rewrite_uri: Rewriting Request-URI with '%.*s'\n", _s->len, 
335                                                                                                                                                    buf);
336         return 1;
337 }
338