Coverage Report

Created: 2026-11-12 06:28

next uncovered line (L), next uncovered region (R), next uncovered branch (B)
/src/opensips/parser/parse_uri.c
Line
Count
Source
1
/*
2
 * Copyright (C) 2001-2003 FhG Fokus
3
 *
4
 * This file is part of opensips, a free SIP server.
5
 *
6
 * opensips 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
 * opensips 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
 * History:
21
 * --------
22
 * 2003-04-04  convenience inbound-uri parser parse_orig_ruri
23
 *             introduced (jiri)
24
 * 2003-04-11  new parse_uri introduced (better, parses also some parameters,
25
 *              works in one pass) (andrei)
26
 * 2003-04-11  ser_error is now set in parse_uri (andrei)
27
 * 2003-04-26  ZSW (jiri)
28
 * 2003-07-03  sips:, r2, lr=on support added (andrei)
29
 * 2005-02-25  preliminary tel uri support (andrei)
30
 * 2005-03-03  more tel uri fixes (andrei)
31
 * 2006-11-28  Added statistic support for the number of bad URI's
32
 *             (Jeffrey Magder - SOMA Networks)
33
 *  2011-04-20  added support for URI unknown parameters (osas)
34
 */
35
36
37
#include "parse_uri.h"
38
#include <string.h>
39
#include "../dprint.h"
40
#include "../ut.h"   /* q_memchr */
41
#include "../error.h"
42
#include "../errinfo.h"
43
#include "../core_stats.h"
44
#include "../strcommon.h"
45
46
static const str uri_type_names[7] = {
47
  {NULL, 0}, /*This is the error type*/
48
  str_init("sip"),
49
  str_init("sips"),
50
  str_init("tel"),
51
  str_init("tels"),
52
  str_init("urn:service"),
53
  str_init("urn:nena:service")
54
};
55
56
char* uri_type2str(const uri_type type, char *result)
57
0
{
58
0
  if (type == ERROR_URI_T)
59
0
    return NULL;
60
61
0
  memcpy(result, uri_type_names[type].s, uri_type_names[type].len);
62
0
  return result + uri_type_names[type].len;
63
0
}
64
65
int uri_typestrlen(const uri_type type)
66
0
{
67
0
  return uri_type_names[type].len;
68
0
}
69
70
uri_type str2uri_type(char * buf)
71
0
{
72
0
  int scheme = 0;
73
0
  uri_type type = ERROR_URI_T;
74
0
  scheme=buf[0]+(buf[1]<<8)+(buf[2]<<16)+(buf[3]<<24);
75
0
  scheme|=0x20202020;
76
0
  if (scheme==SIP_SCH){
77
0
    type=SIP_URI_T;
78
0
  }else if(scheme==SIPS_SCH){
79
0
    if(buf[4]==':')
80
0
      type=SIPS_URI_T;
81
0
    else type = ERROR_URI_T;
82
0
  }else if (scheme==TEL_SCH){
83
0
    type=TEL_URI_T;
84
0
  }else if (scheme==URN_SERVICE_SCH){
85
0
    if (memcmp(buf+3,URN_SERVICE_STR,URN_SERVICE_STR_LEN) == 0) {
86
0
      type=URN_SERVICE_URI_T;
87
0
    }
88
0
    else if (memcmp(buf+3,URN_NENA_SERVICE_STR,URN_NENA_SERVICE_STR_LEN) == 0) {
89
0
      type=URN_NENA_SERVICE_URI_T;
90
0
    }
91
0
  }
92
0
  return type;
93
0
}
94
95
int parse_uri_headers(str headers, str h_name[], str h_val[], int h_size)
96
0
{
97
0
  enum states {URI_H_HEADER, URI_H_VALUE};
98
0
  register enum states state;
99
0
  char* h; /* header start */
100
0
  char* v; /* header value start */
101
0
  str* header;    /* current header */
102
0
  str* header_val;  /* current header val */
103
0
  register char* p;
104
0
  char* end;
105
0
  unsigned int i = 0;
106
107
  /* init */
108
0
  end = headers.s + headers.len;
109
0
  p = h = headers.s;
110
0
  v = NULL;
111
0
  header = &h_name[0];
112
0
  header_val = &h_val[0];
113
0
  state = URI_H_HEADER;
114
0
  memset(h_name, 0, h_size * sizeof(str));
115
0
  memset(h_val, 0, h_size * sizeof(str));
116
117
0
  for(;p<end; p++){
118
0
    switch((unsigned char)state){
119
0
    case URI_H_HEADER:
120
0
      switch(*p){
121
0
      case '=':
122
0
        v = p+1;
123
0
        header->s = h;
124
0
        header->len = p-h;
125
0
        state = URI_H_VALUE;
126
0
        break;
127
0
      case '?':
128
0
        LM_ERR("Header without value\n");
129
0
        h = p+1;
130
0
        header->s = h;
131
0
        header->len = p-h;
132
0
        header_val->s = NULL;
133
0
        header_val->len = 0;
134
135
        /* advance header and header_val */
136
0
        i++;
137
0
        if(i<h_size){
138
0
          header = &h_name[i];
139
0
          header_val = &h_val[i];
140
0
        } else {
141
0
          LM_ERR("To many URI headers\n");
142
0
          return -1;
143
0
        }
144
0
        break;
145
0
      }
146
0
      break;
147
0
    case URI_H_VALUE:
148
0
      switch(*p){
149
0
      case '=':
150
0
        LM_ERR("Ignoring unexpected '=' inside URI header value\n");
151
0
        break;
152
0
      case '?':
153
0
        h = p+1;
154
0
        header_val->s = v;
155
0
        header_val->len = p-v;
156
0
        state = URI_H_HEADER;
157
158
        /* advance header and header_val */
159
0
        i++;
160
0
        if(i<h_size){
161
0
          header = &h_name[i];
162
0
          header_val = &h_val[i];
163
0
        } else {
164
0
          LM_ERR("To many URI headers\n");
165
0
          return -1;
166
0
        }
167
0
        break;
168
0
      }
169
0
      break;
170
0
    default:
171
0
      LM_ERR("Unexpected state [%d]\n", state);
172
0
      return -1;
173
0
    }
174
0
  }
175
176
0
  switch(state){
177
0
  case URI_H_HEADER:
178
0
    LM_ERR("Header without value\n");
179
0
    header->s = h;
180
0
    header->len = p-h;
181
0
    header_val->s = NULL;
182
0
    header_val->len = 0;
183
0
    break;
184
0
  case URI_H_VALUE:
185
0
    header_val->s = v;
186
0
    header_val->len = p-v;
187
0
    break;
188
0
  }
189
190
#ifdef EXTRA_DEBUG
191
  for(i=0; i<h_size && h_name[i].s; i++)
192
    LM_DBG("header=[%p]-><%.*s> val=[%p]-><%.*s>\n",
193
      h_name[i].s, h_name[i].len, h_name[i].s,
194
      h_val[i].s, h_val[i].len, h_val[i].s);
195
#endif
196
197
0
  return 0;
198
0
}
199
200
int print_uri(struct sip_uri *uri, str *out_buf)
201
0
{
202
0
#define append_str_chunk(field) \
203
0
  do { \
204
0
    if (bytes + uri->field.len > out_buf->len) { \
205
0
      LM_ERR("no more space left! printed so far: '%.*s'\n", \
206
0
               bytes, out_buf->s); \
207
0
      return -1; \
208
0
    } \
209
0
    memcpy(out_buf->s + bytes, uri->field.s, uri->field.len); \
210
0
    bytes += uri->field.len; \
211
0
  } while (0)
212
213
0
#define append_char(ch) \
214
0
  do { \
215
0
    if (bytes + 1 > out_buf->len) { \
216
0
      LM_ERR("no more space left! printed so far: '%.*s'\n", \
217
0
               bytes, out_buf->s); \
218
0
      return -1; \
219
0
    } \
220
0
    out_buf->s[bytes++] = ch; \
221
0
  } while (0)
222
223
0
#define VAL(p) p##_val
224
225
0
#define append_param(p) \
226
0
  do { \
227
0
    if (uri->p.s) { \
228
0
      append_char(';'); \
229
0
      append_str_chunk(p); \
230
0
    } \
231
0
  } while (0)
232
233
0
#define append_uk_param(idx) \
234
0
  do { \
235
0
    if (uri->u_name[idx].s) { \
236
0
      append_char(';'); \
237
0
      if (bytes + uri->u_name[idx].len > out_buf->len) { \
238
0
        LM_ERR("no more space left! printed so far: '%.*s'\n", \
239
0
                 bytes, out_buf->s); \
240
0
        return -1; \
241
0
      } \
242
0
      memcpy(out_buf->s + bytes, uri->u_name[idx].s, uri->u_name[idx].len); \
243
0
      bytes += uri->u_name[idx].len; \
244
0
      if (uri->u_val[idx].s) { \
245
0
        append_char('='); \
246
0
        if (bytes + uri->u_val[idx].len > out_buf->len) { \
247
0
          LM_ERR("no more space left! printed so far: '%.*s'\n", \
248
0
                   bytes, out_buf->s); \
249
0
          return -1; \
250
0
        } \
251
0
        memcpy(out_buf->s + bytes, uri->u_val[idx].s, uri->u_val[idx].len); \
252
0
        bytes += uri->u_val[idx].len; \
253
0
      } \
254
0
    } \
255
0
  } while (0)
256
257
0
  int bytes = 0;
258
0
  int i;
259
260
0
  memcpy(out_buf->s, uri_type_names[uri->type].s, uri_type_names[uri->type].len);
261
0
  bytes += uri_type_names[uri->type].len;
262
0
  append_char(':');
263
0
  append_str_chunk(user);
264
0
  if (uri->passwd.s) {
265
0
    append_char(':');
266
0
    append_str_chunk(passwd);
267
0
  }
268
0
  if (uri->host.s) {
269
0
    append_char('@');
270
0
    append_str_chunk(host);
271
0
  }
272
0
  if (uri->port.s) {
273
0
    append_char(':');
274
0
    append_str_chunk(port);
275
0
  }
276
277
0
  append_param(transport);
278
0
  append_param(ttl);
279
0
  append_param(user_param);
280
0
  append_param(maddr);
281
0
  append_param(method);
282
0
  append_param(lr);
283
0
  append_param(r2);
284
0
  append_param(gr);
285
0
  append_param(pn_provider);
286
0
  append_param(pn_prid);
287
0
  append_param(pn_param);
288
0
  append_param(pn_purr);
289
290
0
  for (i = 0; i < uri->u_params_no; i++)
291
0
    append_uk_param(i);
292
293
0
  out_buf->len = bytes;
294
295
0
  return 0;
296
0
#undef append_str_chunk
297
0
#undef append_char
298
0
#undef VAL
299
0
#undef append_param
300
0
#undef append_uk_param
301
0
}
302
303
/* buf= pointer to beginning of uri (sip:x@foo.bar:5060;a=b?h=i)
304
 * len= len of uri
305
 * returns: fills uri & returns <0 on error or 0 if ok
306
 */
307
int parse_uri(char* buf, int len, struct sip_uri* uri)
308
132k
{
309
132k
  enum states  {  URI_INIT, URI_USER, URI_PASSWORD, URI_PASSWORD_ALPHA,
310
132k
          URI_HOST, URI_HOST_P,
311
132k
          URI_HOST6_P, URI_HOST6_END, URI_PORT,
312
132k
          URI_PARAM, URI_PARAM_P, URI_PARAM_VAL_P,
313
132k
          URI_VAL_P, URI_HEADERS,
314
          /* param states */
315
          /* transport */
316
132k
          PT_T, PT_R, PT_A, PT_N, PT_S, PT_P, PT_O, PT_R2, PT_T2,
317
132k
          PT_eq,
318
          /* ttl */
319
132k
          PTTL_T2, PTTL_L, PTTL_eq,
320
          /* user */
321
132k
          PU_U, PU_S, PU_E, PU_R, PU_eq,
322
          /* method */
323
132k
          PM_M, PM_E, PM_T, PM_H, PM_O, PM_D, PM_eq,
324
          /* maddr */
325
132k
          PMA_A, PMA_D, PMA_D2, PMA_R, PMA_eq,
326
          /* lr */
327
132k
          PLR_L, PLR_R_FIN, PLR_eq,
328
          /* gr */
329
132k
          PG_G, PG_G_FIN, PG_eq,
330
          /* r2 */
331
132k
          PR2_R, PR2_2_FIN, PR2_eq,
332
          /* transport values */
333
          /* udp */
334
132k
          VU_U, VU_D, VU_P_FIN,
335
          /* tcp */
336
132k
          VT_T, VT_C, VT_P_FIN,
337
          /* tls */
338
132k
          VTLS_L, VTLS_S_FIN,
339
          /* sctp */
340
132k
          VS_S, VS_C, VS_T, VS_P_FIN,
341
          /* ws */
342
132k
          VW_W, VW_S, VW_S_FIN, VWS_S_FIN,
343
344
          /* pn-{provider, prid, param, purr} (RFC 8599 - SIP PN) */
345
132k
          PN_P, PN_N, PN_dash, PN_P2, PN_PR,
346
132k
          PN1_O, PN1_V, PN1_I, PN1_D, PN1_E, PN1_FIN, PN1_eq,
347
132k
          PN2_I, PN2_D, PN2_eq,
348
132k
          PN3_A, PN3_R, PN3_A2, PN3_M, PN3_eq,
349
132k
          PN4_U, PN4_R, PN4_R2, PN4_eq,
350
351
132k
  };
352
132k
  register enum states state;
353
132k
  char* s;
354
132k
  char* b; /* param start */
355
132k
  char *v; /* value start */
356
132k
  str* param; /* current param */
357
132k
  str* param_val; /* current param val */
358
132k
  str user;
359
132k
  str password;
360
132k
  unsigned int port_no;
361
132k
  register char* p;
362
132k
  char* end;
363
132k
  char* pass;
364
132k
  int found_user;
365
132k
  int error_headers;
366
132k
  unsigned int scheme;
367
132k
  uri_type backup;
368
#ifdef EXTRA_DEBUG
369
  int i;
370
#endif
371
372
132k
#define case_port( ch, var, ovf_check1, ovf_check2) \
373
132k
  case ch: \
374
67.3k
      if (ovf_check1) \
375
67.3k
        (var)=(var)*10+(ch-'0'); \
376
67.3k
      if (ovf_check2 && (var) > USHRT_MAX) \
377
67.3k
        goto error_bad_port; \
378
67.3k
      break
379
380
132k
#define still_at_user  \
381
132k
            if (found_user==0){ \
382
25.5k
              user.s=uri->host.s; \
383
25.5k
              if (pass){\
384
10.3k
                user.len=pass-user.s; \
385
10.3k
                password.s=pass+1; \
386
10.3k
                password.len=p-password.s; \
387
15.1k
              }else{ \
388
15.1k
                user.len=p-user.s; \
389
15.1k
              }\
390
              /* save the uri type/scheme */ \
391
25.5k
              backup=uri->type; \
392
              /* everything else is 0 */ \
393
25.5k
              memset(uri, 0, sizeof(struct sip_uri)); \
394
              /* restore the scheme, copy user & pass */ \
395
25.5k
              uri->type=backup; \
396
25.5k
              uri->user=user; \
397
25.5k
              if (pass) uri->passwd=password;  \
398
25.5k
              s=p+1; \
399
25.5k
              found_user=1;\
400
25.5k
              error_headers=0; \
401
25.5k
              state=URI_HOST; \
402
25.5k
            }else goto error_bad_char
403
404
132k
#define check_host_end \
405
132k
          case ':': \
406
            /* found the host */ \
407
3.01k
            uri->host.s=s; \
408
3.01k
            uri->host.len=p-s; \
409
3.01k
            state=URI_PORT; \
410
3.01k
            s=p+1; \
411
3.01k
            break; \
412
13.1k
          case ';': \
413
13.1k
            uri->host.s=s; \
414
13.1k
            uri->host.len=p-s; \
415
13.1k
            state=URI_PARAM; \
416
13.1k
            s=p+1; \
417
13.1k
            break; \
418
13.1k
          case '?': \
419
220
            uri->host.s=s; \
420
220
            uri->host.len=p-s; \
421
220
            state=URI_HEADERS; \
422
220
            s=p+1; \
423
220
            break; \
424
220
          case '&': \
425
450
          case '@': \
426
450
            goto error_bad_char
427
428
429
132k
#define param_set(t_start, v_start) \
430
132k
          param->s=(t_start);\
431
80.0k
          param->len=(p-(t_start));\
432
80.0k
          param_val->s=(v_start); \
433
80.0k
          param_val->len=(p-(v_start))
434
435
132k
#define u_param_set(t_start, v_start) \
436
585k
      if (uri->u_params_no < URI_MAX_U_PARAMS){ \
437
140k
        if((v_start)>(t_start)){ \
438
6.56k
          uri->u_name[uri->u_params_no].s=(t_start); \
439
6.56k
          uri->u_name[uri->u_params_no].len=((v_start)-(t_start)-1); \
440
6.56k
          if(p>(v_start)) { \
441
4.92k
            uri->u_val[uri->u_params_no].s=(v_start); \
442
4.92k
            uri->u_val[uri->u_params_no].len=(p-(v_start)); \
443
4.92k
          } \
444
134k
        } else { \
445
134k
          uri->u_name[uri->u_params_no].s=(t_start); \
446
134k
          uri->u_name[uri->u_params_no].len=(p-(t_start)); \
447
134k
        } \
448
140k
        uri->u_params_no++; \
449
444k
      } else { \
450
444k
        LM_ERR("unknown URI param list excedeed\n"); \
451
444k
      }
452
453
132k
#define semicolon_case \
454
729k
          case';': \
455
729k
            if (pass){ \
456
10.2k
              found_user=1;/* no user, pass cannot contain ';'*/ \
457
10.2k
              pass=0; \
458
10.2k
            } \
459
729k
            state=URI_PARAM   /* new param */
460
461
132k
#define question_case \
462
132k
          case '?': \
463
17.2k
            uri->params.s=s; \
464
17.2k
            uri->params.len=p-s; \
465
17.2k
            state=URI_HEADERS; \
466
17.2k
            s=p+1; \
467
17.2k
            if (pass){ \
468
4.02k
              found_user=1;/* no user, pass cannot contain '?'*/ \
469
4.02k
              pass=0; \
470
4.02k
            }
471
472
132k
#define colon_case \
473
150k
          case ':': \
474
150k
            if (found_user==0){ \
475
              /*might be pass but only if user not found yet*/ \
476
17.8k
              if (pass){ \
477
893
                found_user=1; /* no user */ \
478
893
                pass=0; \
479
16.9k
              }else{ \
480
16.9k
                pass=p; \
481
16.9k
              } \
482
17.8k
            } \
483
150k
            state=URI_PARAM_P /* generic param */
484
485
132k
#define param_common_cases \
486
132k
          case '@': \
487
            /* ughhh, this is still the user */ \
488
7.01k
            still_at_user; \
489
3.62k
            break; \
490
79.2k
          semicolon_case; \
491
79.2k
            break; \
492
79.2k
          question_case; \
493
3.38k
            break; \
494
23.4k
          colon_case; \
495
23.4k
            break
496
497
132k
#define u_param_common_cases \
498
132k
          case '@': \
499
            /* ughhh, this is still the user */ \
500
22.9k
            still_at_user; \
501
14.0k
            break; \
502
569k
          semicolon_case; \
503
569k
            u_param_set(b, v); \
504
569k
            break; \
505
569k
          question_case; \
506
11.0k
            u_param_set(b, v); \
507
11.0k
            break; \
508
95.3k
          colon_case; \
509
95.3k
            break
510
511
132k
#define value_common_cases \
512
132k
          case '@': \
513
            /* ughhh, this is still the user */ \
514
3.35k
            still_at_user; \
515
1.81k
            break; \
516
72.2k
          semicolon_case; \
517
72.2k
            param_set(b, v); \
518
72.2k
            break; \
519
72.2k
          question_case; \
520
1.59k
            param_set(b, v); \
521
1.59k
            break; \
522
22.4k
          colon_case; \
523
22.4k
            state=URI_VAL_P; \
524
22.4k
            break
525
526
132k
#define param_switch(old_state, c1, c2, new_state) \
527
2.31M
      case old_state: \
528
2.31M
        switch(*p){ \
529
996k
          case c1: \
530
1.92M
          case c2: \
531
1.92M
            state=(new_state); \
532
1.92M
            break; \
533
996k
          u_param_common_cases; \
534
93.7k
          default: \
535
93.7k
            state=URI_PARAM_P; \
536
2.31M
        } \
537
2.31M
        break
538
132k
#define param_switch1(old_state, c1, new_state) \
539
399k
      case old_state: \
540
399k
        switch(*p){ \
541
358k
          case c1: \
542
358k
            state=(new_state); \
543
358k
            break; \
544
836
          param_common_cases; \
545
14.9k
          default: \
546
14.9k
            state=URI_PARAM_P; \
547
399k
        } \
548
399k
        break
549
132k
#define param_xswitch1(old_state, c1, new_state) \
550
132k
      case old_state: \
551
10.9k
        switch(*p){ \
552
10.6k
          case c1: \
553
10.6k
            state=(new_state); \
554
10.6k
            break; \
555
296
          default: \
556
296
            goto error_bad_char; \
557
10.9k
        } \
558
10.9k
        break
559
132k
#define param_switch_big(old_state, c1, c2, d1, d2, new_state_c, new_state_d) \
560
448k
      case old_state : \
561
448k
        switch(*p){ \
562
284k
          case c1: \
563
323k
          case c2: \
564
323k
            state=(new_state_c); \
565
323k
            break; \
566
284k
          case d1: \
567
61.4k
          case d2: \
568
61.4k
            state=(new_state_d); \
569
61.4k
            break; \
570
53.6k
          u_param_common_cases; \
571
41.2k
          default: \
572
41.2k
            state=URI_PARAM_P; \
573
448k
        } \
574
448k
        break
575
132k
#define param_switch_bigger(old_state, c1, c2, d1, d2, e1, e2, new_state_c, new_state_d, new_state_e) \
576
260k
      case old_state : \
577
260k
        switch(*p){ \
578
163k
          case c1: \
579
189k
          case c2: \
580
189k
            state=(new_state_c); \
581
189k
            break; \
582
163k
          case d1: \
583
39.8k
          case d2: \
584
39.8k
            state=(new_state_d); \
585
39.8k
            break; \
586
5.93k
          case e1: \
587
22.8k
          case e2: \
588
22.8k
            state=(new_state_e); \
589
22.8k
            break; \
590
5.93k
          u_param_common_cases; \
591
4.64k
          default: \
592
4.64k
            state=URI_PARAM_P; \
593
260k
        } \
594
260k
        break
595
132k
#define value_switch(old_state, c1, c2, new_state) \
596
132k
      case old_state: \
597
84.0k
        switch(*p){ \
598
24.0k
          case c1: \
599
42.7k
          case c2: \
600
42.7k
            state=(new_state); \
601
42.7k
            break; \
602
24.0k
          value_common_cases; \
603
10.4k
          default: \
604
10.4k
            state=URI_VAL_P; \
605
84.0k
        } \
606
84.0k
        break
607
132k
#define value_switch_big(old_state, c1, c2, d1, d2, new_state_c, new_state_d) \
608
132k
      case old_state: \
609
20.5k
        switch(*p){ \
610
7.12k
          case c1: \
611
9.89k
          case c2: \
612
9.89k
            state=(new_state_c); \
613
9.89k
            break; \
614
7.12k
          case d1: \
615
8.43k
          case d2: \
616
8.43k
            state=(new_state_d); \
617
8.43k
            break; \
618
2.61k
          value_common_cases; \
619
743
          default: \
620
743
            state=URI_VAL_P; \
621
20.5k
        } \
622
20.5k
        break
623
624
132k
#define transport_fin(c_state, proto_no) \
625
132k
      case c_state: \
626
23.5k
        switch(*p){ \
627
574
          case '@': \
628
574
            still_at_user; \
629
574
            break; \
630
4.43k
          semicolon_case; \
631
4.43k
            param_set(b, v); \
632
4.43k
            uri->proto=(proto_no); \
633
4.43k
            break; \
634
766
          question_case; \
635
766
            param_set(b, v); \
636
766
            uri->proto=(proto_no); \
637
766
            break; \
638
7.46k
          colon_case;  \
639
17.7k
          default: \
640
17.7k
            state=URI_VAL_P; \
641
17.7k
            break; \
642
23.5k
        } \
643
23.5k
        break
644
645
646
647
  /* init */
648
132k
  end=buf+len;
649
132k
  p=buf+4;
650
132k
  found_user=0;
651
132k
  error_headers=0;
652
132k
  b=v=0;
653
132k
  param=param_val=0;
654
132k
  pass=0;
655
132k
  password.s = 0;
656
132k
  password.len = 0;
657
132k
  port_no=0;
658
132k
  state=URI_INIT;
659
132k
  memset(uri, 0, sizeof(struct sip_uri)); /* zero it all, just to be sure*/
660
  /*look for sip:, sips: or tel:*/
661
132k
  if (len<5) goto error_too_short;
662
62.7k
  scheme=(unsigned)(unsigned char)buf[0]
663
62.7k
      + (((unsigned)(unsigned char)buf[1])<<8)
664
62.7k
      + (((unsigned)(unsigned char)buf[2])<<16)
665
62.7k
      + (((unsigned)(unsigned char)buf[3])<<24);
666
62.7k
  scheme|=0x20202020;
667
62.7k
  if (scheme==SIP_SCH){
668
51.9k
    uri->type=SIP_URI_T;
669
51.9k
  }else if(scheme==SIPS_SCH){
670
779
    if(buf[4]==':'){ p++; uri->type=SIPS_URI_T;}
671
160
    else goto error_bad_uri;
672
10.0k
  }else if (scheme==TEL_SCH){
673
5.46k
    uri->type=TEL_URI_T;
674
5.46k
  }else if (scheme==URN_SERVICE_SCH){
675
957
    if ((end-(buf+3)) >= URN_SERVICE_STR_LEN
676
879
            && memcmp(buf+3,URN_SERVICE_STR,URN_SERVICE_STR_LEN) == 0) {
677
47
      p+= URN_SERVICE_STR_LEN-1;
678
47
      uri->type=URN_SERVICE_URI_T;
679
47
    }
680
910
    else if ((end-(buf+3)) >= URN_NENA_SERVICE_STR_LEN
681
677
            && memcmp(buf+3,URN_NENA_SERVICE_STR,URN_NENA_SERVICE_STR_LEN) == 0) {
682
60
      p+= URN_NENA_SERVICE_STR_LEN-1;
683
60
      uri->type=URN_NENA_SERVICE_URI_T;
684
850
    }else goto error_bad_uri;
685
3.58k
  }else goto error_bad_uri;
686
687
58.1k
  s=p;
688
7.68M
  for(;p<end; p++){
689
7.65M
    switch((unsigned char)state){
690
58.0k
      case URI_INIT:
691
58.0k
        switch(*p){
692
2.01k
          case '[':
693
            /* uri =  [ipv6address]... */
694
2.01k
            state=URI_HOST6_P;
695
2.01k
            s=p;
696
2.01k
            break;
697
39
          case ']':
698
            /* invalid, no uri can start with ']' */
699
114
          case ':':
700
            /* the same as above for ':' */
701
114
            goto error_bad_char;
702
67
          case '@': /* error no user part */
703
67
            goto error_bad_char;
704
55.8k
          default:
705
55.8k
            state=URI_USER;
706
58.0k
        }
707
57.8k
        break;
708
127k
      case URI_USER:
709
127k
        switch(*p){
710
1.85k
          case '@':
711
            /* found the user*/
712
1.85k
            uri->user.s=s;
713
1.85k
            uri->user.len=p-s;
714
1.85k
            state=URI_HOST;
715
1.85k
            found_user=1;
716
1.85k
            s=p+1; /* skip '@' */
717
1.85k
            break;
718
12.1k
          case ':':
719
            /* found the user, or the host? */
720
12.1k
            uri->user.s=s;
721
12.1k
            uri->user.len=p-s;
722
12.1k
            state=URI_PASSWORD;
723
12.1k
            s=p+1; /* skip ':' */
724
12.1k
            break;
725
40.1k
          case ';':
726
            /* this could be still the user or
727
             * params?*/
728
40.1k
            uri->host.s=s;
729
40.1k
            uri->host.len=p-s;
730
40.1k
            state=URI_PARAM;
731
40.1k
            s=p+1;
732
40.1k
            break;
733
1.60k
          case '?': /* still user or headers? */
734
1.60k
            uri->host.s=s;
735
1.60k
            uri->host.len=p-s;
736
1.60k
            state=URI_HEADERS;
737
1.60k
            s=p+1;
738
1.60k
            break;
739
            /* almost anything permitted in the user part */
740
39
          case '[':
741
92
          case ']': /* the user part cannot contain "[]" */
742
92
            goto error_bad_char;
743
127k
        }
744
127k
        break;
745
127k
      case URI_PASSWORD: /* this can also be the port (missing user)*/
746
65.1k
        switch(*p){
747
511
          case '@':
748
            /* found the password*/
749
511
            uri->passwd.s=s;
750
511
            uri->passwd.len=p-s;
751
511
            port_no=0;
752
511
            state=URI_HOST;
753
511
            found_user=1;
754
511
            s=p+1; /* skip '@' */
755
511
            break;
756
5.56k
          case ';':
757
            /* upps this is the port */
758
5.56k
            uri->port.s=s;
759
5.56k
            uri->port.len=p-s;
760
5.56k
            uri->port_no=port_no;
761
            /* user contains in fact the host */
762
5.56k
            uri->host.s=uri->user.s;
763
5.56k
            uri->host.len=uri->user.len;
764
5.56k
            uri->user.s=0;
765
5.56k
            uri->user.len=0;
766
5.56k
            state=URI_PARAM;
767
5.56k
            found_user=1; /*  there is no user part */
768
5.56k
            s=p+1;
769
5.56k
            break;
770
137
          case '?':
771
            /* upps this is the port */
772
137
            uri->port.s=s;
773
137
            uri->port.len=p-s;
774
137
            uri->port_no=port_no;
775
            /* user contains in fact the host */
776
137
            uri->host.s=uri->user.s;
777
137
            uri->host.len=uri->user.len;
778
137
            uri->user.s=0;
779
137
            uri->user.len=0;
780
137
            state=URI_HEADERS;
781
137
            found_user=1; /*  there is no user part */
782
137
            s=p+1;
783
137
            break;
784
6.40k
          case_port('0', port_no, port_no < INT_MAX / 10, 0);
785
6.80k
          case_port('1', port_no, port_no < INT_MAX / 10, 0);
786
6.80k
          case_port('2', port_no, port_no < INT_MAX / 10, 0);
787
6.39k
          case_port('3', port_no, port_no < INT_MAX / 10, 0);
788
6.80k
          case_port('4', port_no, port_no < INT_MAX / 10, 0);
789
6.80k
          case_port('5', port_no, port_no < INT_MAX / 10, 0);
790
5.45k
          case_port('6', port_no, port_no < INT_MAX / 10, 0);
791
4.71k
          case_port('7', port_no, port_no < INT_MAX / 10, 0);
792
5.95k
          case_port('8', port_no, port_no < INT_MAX / 10, 0);
793
5.95k
          case_port('9', port_no, port_no < INT_MAX / 10, 0);
794
5.66k
          case '[':
795
190
          case ']':
796
285
          case ':':
797
285
            goto error_bad_char;
798
1.22k
          default:
799
            /* it can't be the port, non number found */
800
1.22k
            port_no=0;
801
1.22k
            state=URI_PASSWORD_ALPHA;
802
65.1k
        }
803
64.8k
        break;
804
64.8k
      case URI_PASSWORD_ALPHA:
805
4.81k
        switch(*p){
806
129
          case '@':
807
            /* found the password*/
808
129
            uri->passwd.s=s;
809
129
            uri->passwd.len=p-s;
810
129
            state=URI_HOST;
811
129
            found_user=1;
812
129
            s=p+1; /* skip '@' */
813
129
            break;
814
137
          case ';': /* contains non-numbers => cannot be port no*/
815
195
          case '?':
816
195
            goto error_bad_port;
817
39
          case '[':
818
96
          case ']':
819
274
          case ':':
820
274
            goto error_bad_char;
821
4.81k
        }
822
4.34k
        break;
823
16.7k
      case URI_HOST:
824
16.7k
        switch(*p){
825
183
          case '[':
826
183
            state=URI_HOST6_P;
827
183
            break;
828
303
          case ':':
829
593
          case ';':
830
756
          case '?': /* null host name ->invalid */
831
809
          case '&':
832
1.02k
          case '@': /*chars not allowed in hosts names */
833
1.02k
            goto error_bad_host;
834
15.5k
          default:
835
15.5k
            state=URI_HOST_P;
836
16.7k
        }
837
15.7k
        break;
838
57.7k
      case URI_HOST_P:
839
57.7k
        switch(*p){
840
57.7k
          check_host_end;
841
57.7k
        }
842
57.4k
        break;
843
57.4k
      case URI_HOST6_END:
844
1.84k
        switch(*p){
845
1.51k
          check_host_end;
846
57
          default: /*no chars allowed after [ipv6] */
847
57
            goto error_bad_host;
848
1.84k
        }
849
1.70k
        break;
850
3.13k
      case URI_HOST6_P:
851
3.13k
        switch(*p){
852
1.85k
          case ']':
853
1.85k
            state=URI_HOST6_END;
854
1.85k
            break;
855
43
          case '[':
856
82
          case '&':
857
121
          case '@':
858
174
          case ';':
859
213
          case '?':
860
213
            goto error_bad_host;
861
3.13k
        }
862
2.92k
        break;
863
11.6k
      case URI_PORT:
864
11.6k
        switch(*p){
865
630
          case ';':
866
630
            uri->port.s=s;
867
630
            uri->port.len=p-s;
868
630
            uri->port_no=port_no;
869
630
            state=URI_PARAM;
870
630
            s=p+1;
871
630
            break;
872
45
          case '?':
873
45
            uri->port.s=s;
874
45
            uri->port.len=p-s;
875
45
            uri->port_no=port_no;
876
45
            state=URI_HEADERS;
877
45
            s=p+1;
878
45
            break;
879
1.55k
          case_port('0', port_no, 1, 1);
880
1.41k
          case_port('1', port_no, 1, 1);
881
718
          case_port('2', port_no, 1, 1);
882
831
          case_port('3', port_no, 1, 1);
883
1.00k
          case_port('4', port_no, 1, 1);
884
1.43k
          case_port('5', port_no, 1, 1);
885
1.51k
          case_port('6', port_no, 1, 1);
886
1.44k
          case_port('7', port_no, 1, 1);
887
899
          case_port('8', port_no, 1, 1);
888
783
          case_port('9', port_no, 1, 1);
889
663
          case '&':
890
32
          case '@':
891
176
          case ':':
892
972
          default:
893
972
            goto error_bad_port;
894
11.6k
        }
895
9.71k
        break;
896
787k
      case URI_PARAM: /* beginning of a new param */
897
787k
        switch(*p){
898
5.04k
          param_common_cases;
899
          /* recognized params */
900
140k
          case 't':
901
170k
          case 'T':
902
170k
            b=p;
903
170k
            state=PT_T;
904
170k
            break;
905
5.85k
          case 'u':
906
22.2k
          case 'U':
907
22.2k
            b=p;
908
22.2k
            state=PU_U;
909
22.2k
            break;
910
31.9k
          case 'm':
911
87.9k
          case 'M':
912
87.9k
            b=p;
913
87.9k
            state=PM_M;
914
87.9k
            break;
915
25.9k
          case 'l':
916
29.4k
          case 'L':
917
29.4k
            b=p;
918
29.4k
            state=PLR_L;
919
29.4k
            break;
920
6.18k
          case 'g':
921
12.1k
          case 'G':
922
12.1k
            b=p;
923
12.1k
            state=PG_G;
924
12.1k
            break;
925
8.51k
          case 'r':
926
14.7k
          case 'R':
927
14.7k
            b=p;
928
14.7k
            state=PR2_R;
929
14.7k
            break;
930
264k
          case 'p':
931
292k
          case 'P':
932
292k
            b=p;
933
292k
            state=PN_P;
934
292k
            break;
935
104k
          default:
936
104k
            b=p;
937
104k
            state=URI_PARAM_P;
938
787k
        }
939
784k
        break;
940
2.21M
      case URI_PARAM_P: /* ignore current param */
941
        /* supported params:
942
         *  maddr, transport, ttl, lr, user, method, r2  */
943
2.21M
        switch(*p){
944
17.6k
          u_param_common_cases;
945
60.0k
          case '=':
946
60.0k
            v=p + 1;
947
60.0k
            state=URI_PARAM_VAL_P;
948
60.0k
            break;
949
2.21M
        };
950
2.20M
        break;
951
294k
      case URI_PARAM_VAL_P: /* value of the ignored current param */
952
294k
        switch(*p){
953
294k
          u_param_common_cases;
954
294k
        };
955
293k
        break;
956
      /* ugly but fast param names parsing */
957
      /*transport */
958
170k
      param_switch_big(PT_T,  'r', 'R', 't', 'T', PT_R, PTTL_T2);
959
170k
      param_switch(PT_R,  'a', 'A', PT_A);
960
122k
      param_switch(PT_A,  'n', 'N', PT_N);
961
114k
      param_switch(PT_N,  's', 'S', PT_S);
962
103k
      param_switch(PT_S,  'p', 'P', PT_P);
963
97.6k
      param_switch(PT_P,  'o', 'O', PT_O);
964
88.3k
      param_switch(PT_O,  'r', 'R', PT_R2);
965
83.7k
      param_switch(PT_R2, 't', 'T', PT_T2);
966
77.3k
      param_switch1(PT_T2, '=',  PT_eq);
967
      /* value parsing */
968
73.7k
      case PT_eq:
969
70.9k
        param=&uri->transport;
970
70.9k
        param_val=&uri->transport_val;
971
70.9k
        uri->proto = PROTO_OTHER;
972
70.9k
        switch (*p){
973
110
          param_common_cases;
974
3.95k
          case 'u':
975
11.8k
          case 'U':
976
11.8k
            v=p;
977
11.8k
            state=VU_U;
978
11.8k
            break;
979
17.3k
          case 't':
980
20.5k
          case 'T':
981
20.5k
            v=p;
982
20.5k
            state=VT_T;
983
20.5k
            break;
984
3.63k
          case 's':
985
12.9k
          case 'S':
986
12.9k
            v=p;
987
12.9k
            state=VS_S;
988
12.9k
            break;
989
9.69k
          case 'w':
990
22.0k
          case 'W':
991
22.0k
            v=p;
992
22.0k
            state=VW_W;
993
22.0k
            break;
994
1.88k
          default:
995
1.88k
            v=p;
996
1.88k
            state=URI_VAL_P;
997
70.9k
        }
998
70.8k
        break;
999
        /* generic value */
1000
228k
      case URI_VAL_P:
1001
228k
        switch(*p){
1002
228k
          value_common_cases;
1003
228k
        }
1004
226k
        break;
1005
      /* udp */
1006
226k
      value_switch(VU_U,  'd', 'D', VU_D);
1007
11.7k
      value_switch(VU_D,  'p', 'P', VU_P_FIN);
1008
7.97k
      transport_fin(VU_P_FIN, PROTO_UDP);
1009
      /* tcp */
1010
20.5k
      value_switch_big(VT_T,  'c', 'C', 'l', 'L', VT_C, VTLS_L);
1011
20.4k
      value_switch(VT_C,  'p', 'P', VT_P_FIN);
1012
9.84k
      transport_fin(VT_P_FIN, PROTO_TCP);
1013
      /* tls */
1014
8.41k
      value_switch(VTLS_L, 's', 'S', VTLS_S_FIN);
1015
8.37k
      transport_fin(VTLS_S_FIN, PROTO_TLS);
1016
      /* sctp */
1017
12.9k
      value_switch(VS_S, 'c', 'C', VS_C);
1018
12.8k
      value_switch(VS_C, 't', 'T', VS_T);
1019
6.52k
      value_switch(VS_T, 'p', 'P', VS_P_FIN);
1020
4.43k
      transport_fin(VS_P_FIN, PROTO_SCTP);
1021
      /* ws */
1022
22.0k
      value_switch(VW_W, 's', 'S', VW_S);
1023
21.9k
      case VW_S:
1024
11.0k
        if (*p == 's' || *p == 'S') {
1025
2.05k
          state=(VWS_S_FIN);
1026
2.05k
          break;
1027
2.05k
        }
1028
        /* if not a 's' transiting to VWS_S_FIN, fallback
1029
         * to testing as existing VW_S_FIN (NOTE the missing break) */
1030
9.02k
        state=(VW_S_FIN);
1031
9.02k
      transport_fin(VW_S_FIN, PROTO_WS);
1032
8.98k
      transport_fin(VWS_S_FIN, PROTO_WSS);
1033
1034
      /* ttl */
1035
11.3k
      param_switch(PTTL_T2,  'l', 'L', PTTL_L);
1036
11.2k
      param_switch1(PTTL_L,  '=', PTTL_eq);
1037
6.76k
      case PTTL_eq:
1038
4.51k
        param=&uri->ttl;
1039
4.51k
        param_val=&uri->ttl_val;
1040
4.51k
        switch(*p){
1041
82
          param_common_cases;
1042
3.19k
          default:
1043
3.19k
            v=p;
1044
3.19k
            state=URI_VAL_P;
1045
4.51k
        }
1046
4.47k
        break;
1047
1048
      /* user param */
1049
22.2k
      param_switch(PU_U, 's', 'S', PU_S);
1050
22.1k
      param_switch(PU_S, 'e', 'E', PU_E);
1051
13.4k
      param_switch(PU_E, 'r', 'R', PU_R);
1052
9.71k
      param_switch1(PU_R, '=', PU_eq);
1053
5.05k
      case PU_eq:
1054
2.05k
        param=&uri->user_param;
1055
2.05k
        param_val=&uri->user_param_val;
1056
2.05k
        switch(*p){
1057
96
          param_common_cases;
1058
685
          default:
1059
685
            v=p;
1060
685
            state=URI_VAL_P;
1061
2.05k
        }
1062
2.01k
        break;
1063
1064
      /* method*/
1065
87.9k
      param_switch_big(PM_M, 'e', 'E', 'a', 'A', PM_E, PMA_A);
1066
87.8k
      param_switch(PM_E, 't', 'T', PM_T);
1067
22.4k
      param_switch(PM_T, 'h', 'H', PM_H);
1068
18.0k
      param_switch(PM_H, 'o', 'O', PM_O);
1069
14.1k
      param_switch(PM_O, 'd', 'D', PM_D);
1070
9.80k
      param_switch1(PM_D, '=', PM_eq);
1071
3.76k
      case PM_eq:
1072
1.62k
        param=&uri->method;
1073
1.62k
        param_val=&uri->method_val;
1074
1.62k
        switch(*p){
1075
82
          param_common_cases;
1076
436
          default:
1077
436
            v=p;
1078
436
            state=URI_VAL_P;
1079
1.62k
        }
1080
1.58k
        break;
1081
1082
      /*maddr*/
1083
42.8k
      param_switch(PMA_A,  'd', 'D', PMA_D);
1084
42.7k
      param_switch(PMA_D,  'd', 'D', PMA_D2);
1085
32.0k
      param_switch(PMA_D2, 'r', 'R', PMA_R);
1086
23.9k
      param_switch1(PMA_R, '=', PMA_eq);
1087
16.7k
      case PMA_eq:
1088
2.64k
        param=&uri->maddr;
1089
2.64k
        param_val=&uri->maddr_val;
1090
2.64k
        switch(*p){
1091
96
          param_common_cases;
1092
725
          default:
1093
725
            v=p;
1094
725
            state=URI_VAL_P;
1095
2.64k
        }
1096
2.60k
        break;
1097
1098
      /* lr */
1099
29.4k
      param_switch(PLR_L,  'r', 'R', PLR_R_FIN);
1100
29.3k
      case PLR_R_FIN:
1101
20.3k
        switch(*p){
1102
96
          case '@':
1103
96
            still_at_user;
1104
57
            break;
1105
17.0k
          case '=':
1106
17.0k
            state=PLR_eq;
1107
17.0k
            break;
1108
1.08k
          semicolon_case;
1109
1.08k
            uri->lr.s=b;
1110
1.08k
            uri->lr.len=(p-b);
1111
1.08k
            break;
1112
130
          question_case;
1113
130
            uri->lr.s=b;
1114
130
            uri->lr.len=(p-b);
1115
130
            break;
1116
471
          colon_case;
1117
471
            break;
1118
1.44k
          default:
1119
1.44k
            state=URI_PARAM_P;
1120
20.3k
        }
1121
20.2k
        break;
1122
        /* handle lr=something case */
1123
20.2k
      case PLR_eq:
1124
17.0k
        param=&uri->lr;
1125
17.0k
        param_val=&uri->lr_val;
1126
17.0k
        switch(*p){
1127
96
          param_common_cases;
1128
2.80k
          default:
1129
2.80k
            v=p;
1130
2.80k
            state=URI_VAL_P;
1131
17.0k
        }
1132
17.0k
        break;
1133
1134
      /* r2 */
1135
17.0k
      param_switch1(PR2_R,  '2', PR2_2_FIN);
1136
14.6k
      case PR2_2_FIN:
1137
4.57k
        switch(*p){
1138
96
          case '@':
1139
96
            still_at_user;
1140
43
            break;
1141
2.67k
          case '=':
1142
2.67k
            state=PR2_eq;
1143
2.67k
            break;
1144
546
          semicolon_case;
1145
546
            uri->r2.s=b;
1146
546
            uri->r2.len=(p-b);
1147
546
            break;
1148
130
          question_case;
1149
130
            uri->r2.s=b;
1150
130
            uri->r2.len=(p-b);
1151
130
            break;
1152
556
          colon_case;
1153
556
            break;
1154
572
          default:
1155
572
            state=URI_PARAM_P;
1156
4.57k
        }
1157
4.51k
        break;
1158
        /* handle r2=something case */
1159
4.51k
      case PR2_eq:
1160
2.65k
        param=&uri->r2;
1161
2.65k
        param_val=&uri->r2_val;
1162
2.65k
        switch(*p){
1163
110
          param_common_cases;
1164
1.21k
          default:
1165
1.21k
            v=p;
1166
1.21k
            state=URI_VAL_P;
1167
2.65k
        }
1168
2.58k
        break;
1169
1170
1171
      /* gr */
1172
12.1k
      param_switch(PG_G,  'r', 'R', PG_G_FIN);
1173
12.0k
      case PG_G_FIN:
1174
5.50k
        switch(*p){
1175
104
          case '@':
1176
104
            still_at_user;
1177
61
            break;
1178
2.75k
          case '=':
1179
2.75k
            state=PG_eq;
1180
2.75k
            break;
1181
1.17k
          semicolon_case;
1182
1.17k
            uri->gr.s=b;
1183
1.17k
            uri->gr.len=(p-b);
1184
1.17k
            break;
1185
144
          question_case;
1186
144
            uri->gr.s=b;
1187
144
            uri->gr.len=(p-b);
1188
144
            break;
1189
519
          colon_case;
1190
519
            break;
1191
808
          default:
1192
808
            state=URI_PARAM_P;
1193
5.50k
        }
1194
5.46k
        break;
1195
        /* handle gr=something case */
1196
5.46k
      case PG_eq:
1197
2.74k
        param=&uri->gr;
1198
2.74k
        param_val=&uri->gr_val;
1199
2.74k
        switch(*p){
1200
96
          param_common_cases;
1201
1.30k
          default:
1202
1.30k
            v=p;
1203
1.30k
            state=URI_VAL_P;
1204
2.74k
        }
1205
2.70k
        break;
1206
1207
1208
      /* pn-* */
1209
292k
      param_switch(PN_P, 'n', 'N', PN_N);
1210
292k
      param_switch1(PN_N, '-', PN_dash);
1211
278k
      param_switch(PN_dash, 'p', 'P', PN_P2);
1212
1213
271k
      param_switch_bigger(PN_P2, 'r', 'R', 'a', 'A', 'u', 'U',
1214
260k
                          PN_PR, PN3_A, PN4_U);
1215
260k
      param_switch_big(PN_PR, 'o', 'O', 'i', 'I', PN1_O, PN2_I);
1216
1217
      /* pn-provider */
1218
189k
      param_switch(PN1_O, 'v', 'V', PN1_V);
1219
178k
      param_switch(PN1_V, 'i', 'I', PN1_I);
1220
171k
      param_switch(PN1_I, 'd', 'D', PN1_D);
1221
160k
      param_switch(PN1_D, 'e', 'E', PN1_E);
1222
156k
      param_switch(PN1_E, 'r', 'R', PN1_FIN);
1223
9.70k
      case PN1_FIN:
1224
6.21k
        param=&uri->pn_provider;
1225
6.21k
        switch(*p){
1226
82
          case '@':
1227
82
            still_at_user;
1228
43
            break;
1229
3.89k
          case '=':
1230
3.89k
            state=PN1_eq;
1231
3.89k
            break;
1232
1.00k
          semicolon_case;
1233
1.00k
            uri->pn_provider.s=b;
1234
1.00k
            uri->pn_provider.len=(p-b);
1235
1.00k
            break;
1236
130
          question_case;
1237
130
            uri->pn_provider.s=b;
1238
130
            uri->pn_provider.len=(p-b);
1239
130
            break;
1240
630
          colon_case;
1241
630
            break;
1242
475
          default:
1243
475
            state=URI_PARAM_P;
1244
6.21k
        }
1245
6.17k
        break;
1246
        /* handle pn-provider=something case */
1247
6.17k
      case PN1_eq:
1248
3.88k
        param=&uri->pn_provider;
1249
3.88k
        param_val=&uri->pn_provider_val;
1250
3.88k
        switch(*p){
1251
82
          param_common_cases;
1252
2.20k
          default:
1253
2.20k
            v=p;
1254
2.20k
            state=URI_VAL_P;
1255
3.88k
        }
1256
3.84k
        break;
1257
1258
      /* pn-prid */
1259
6.86k
      param_switch(PN2_I, 'd', 'D', PN2_D);
1260
6.82k
      param_xswitch1(PN2_D, '=', PN2_eq);
1261
2.95k
      case PN2_eq:
1262
2.91k
        param=&uri->pn_prid;
1263
2.91k
        param_val=&uri->pn_prid_val;
1264
2.91k
        switch(*p){
1265
96
          param_common_cases;
1266
586
          default:
1267
586
            v=p;
1268
586
            state=URI_VAL_P;
1269
2.91k
        }
1270
2.85k
        break;
1271
1272
      /* pn-param */
1273
39.8k
      param_switch(PN3_A, 'r', 'R', PN3_R);
1274
39.8k
      param_switch(PN3_R, 'a', 'A', PN3_A2);
1275
35.8k
      param_switch(PN3_A2, 'm', 'M', PN3_M);
1276
4.80k
      param_xswitch1(PN3_M, '=', PN3_eq);
1277
2.19k
      case PN3_eq:
1278
2.15k
        param=&uri->pn_param;
1279
2.15k
        param_val=&uri->pn_param_val;
1280
2.15k
        switch(*p){
1281
82
          param_common_cases;
1282
466
          default:
1283
466
            v=p;
1284
466
            state=URI_VAL_P;
1285
2.15k
        }
1286
2.11k
        break;
1287
1288
      /* pn-purr */
1289
22.8k
      param_switch(PN4_U, 'r', 'R', PN4_R);
1290
22.7k
      param_switch(PN4_R, 'r', 'R', PN4_R2);
1291
12.3k
      param_xswitch1(PN4_R2, '=', PN4_eq);
1292
5.50k
      case PN4_eq:
1293
5.47k
        param=&uri->pn_purr;
1294
5.47k
        param_val=&uri->pn_purr_val;
1295
5.47k
        switch(*p){
1296
108
          param_common_cases;
1297
1.12k
          default:
1298
1.12k
            v=p;
1299
1.12k
            state=URI_VAL_P;
1300
5.47k
        }
1301
5.41k
        break;
1302
1303
1304
71.6k
      case URI_HEADERS:
1305
        /* for now nobody needs them so we completely ignore the
1306
         * headers (they are not allowed in request uri) --andrei */
1307
71.6k
        switch(*p){
1308
8.17k
          case '@':
1309
            /* yak, we are still at user */
1310
8.17k
            still_at_user;
1311
5.52k
            break;
1312
12.1k
          case ';':
1313
            /* we might be still parsing user, try it */
1314
12.1k
            if (found_user) goto error_bad_char;
1315
5.67k
            error_headers=1; /* if this is not the user
1316
                      we have an error */
1317
            /* if pass is set => it cannot be user:pass
1318
             * => error (';') is illegal in a header */
1319
5.67k
            if (pass) goto error_headers;
1320
5.55k
            break;
1321
5.55k
          case ':':
1322
3.89k
            if (found_user==0){
1323
              /*might be pass but only if user not found yet*/
1324
2.27k
              if (pass){
1325
80
                found_user=1; /* no user */
1326
80
                pass=0;
1327
2.19k
              }else{
1328
2.19k
                pass=p;
1329
2.19k
              }
1330
2.27k
            }
1331
3.89k
            break;
1332
2.29k
          case '?':
1333
2.29k
            if (pass){
1334
63
              found_user=1; /* no user, pass cannot contain '?'*/
1335
63
              pass=0;
1336
63
            }
1337
2.29k
            break;
1338
71.6k
        }
1339
62.3k
        break;
1340
62.3k
      default:
1341
0
        goto error_bug;
1342
7.65M
    }
1343
7.65M
  }
1344
1345
  /*end of uri */
1346
29.5k
  switch (state){
1347
69
    case URI_INIT: /* error empty uri */
1348
69
      goto error_too_short;
1349
92
    case URI_USER:
1350
      /* this is the host, it can't be the user */
1351
92
      if (found_user) goto error_bad_uri;
1352
92
      uri->host.s=s;
1353
92
      uri->host.len=p-s;
1354
92
      state=URI_HOST;
1355
92
      break;
1356
4.38k
    case URI_PASSWORD:
1357
      /* this is the port, it can't be the passwd */
1358
4.38k
      if (found_user) goto error_bad_port;
1359
4.38k
      if (port_no > USHRT_MAX) goto error_bad_port;
1360
261
      uri->port.s=s;
1361
261
      uri->port.len=p-s;
1362
261
      uri->port_no=port_no;
1363
261
      uri->host=uri->user;
1364
261
      uri->user.s=0;
1365
261
      uri->user.len=0;
1366
261
      break;
1367
622
    case URI_PASSWORD_ALPHA:
1368
      /* this is the port, it can't be the passwd */
1369
622
      goto error_bad_port;
1370
538
    case URI_HOST_P:
1371
554
    case URI_HOST6_END:
1372
554
      uri->host.s=s;
1373
554
      uri->host.len=p-s;
1374
554
      break;
1375
11.2k
    case URI_HOST: /* error: null host */
1376
11.3k
    case URI_HOST6_P: /* error: unterminated ipv6 reference*/
1377
11.3k
      goto error_bad_host;
1378
420
    case URI_PORT:
1379
420
      uri->port.s=s;
1380
420
      uri->port.len=p-s;
1381
420
      uri->port_no=port_no;
1382
420
      break;
1383
1.95k
    case URI_PARAM:
1384
4.46k
    case URI_PARAM_P:
1385
4.53k
    case URI_PARAM_VAL_P:
1386
4.53k
      u_param_set(b, v);
1387
    /* intermediate param states */
1388
4.56k
    case PT_T: /* transport */
1389
4.60k
    case PT_R:
1390
4.63k
    case PT_A:
1391
4.65k
    case PT_N:
1392
4.68k
    case PT_S:
1393
4.70k
    case PT_P:
1394
4.73k
    case PT_O:
1395
4.75k
    case PT_R2:
1396
4.77k
    case PT_T2:
1397
4.79k
    case PT_eq: /* ignore empty transport params */
1398
4.81k
    case PTTL_T2: /* ttl */
1399
4.84k
    case PTTL_L:
1400
4.86k
    case PTTL_eq:
1401
4.88k
    case PU_U:  /* user */
1402
4.91k
    case PU_S:
1403
4.94k
    case PU_E:
1404
4.96k
    case PU_R:
1405
4.98k
    case PU_eq:
1406
5.02k
    case PM_M: /* method */
1407
5.05k
    case PM_E:
1408
5.08k
    case PM_T:
1409
5.11k
    case PM_H:
1410
5.13k
    case PM_O:
1411
5.16k
    case PM_D:
1412
5.17k
    case PM_eq:
1413
5.20k
    case PLR_L: /* lr */
1414
5.24k
    case PR2_R:  /* r2 */
1415
5.27k
    case PG_G: /* gr */
1416
5.27k
      uri->params.s=s;
1417
5.27k
      uri->params.len=p-s;
1418
5.27k
      break;
1419
    /* fin param states */
1420
31
    case PLR_R_FIN:
1421
39
    case PLR_eq:
1422
39
      uri->params.s=s;
1423
39
      uri->params.len=p-s;
1424
39
      uri->lr.s=b;
1425
39
      uri->lr.len=p-b;
1426
39
      break;
1427
20
    case PR2_2_FIN:
1428
39
    case PR2_eq:
1429
39
      uri->params.s=s;
1430
39
      uri->params.len=p-s;
1431
39
      uri->r2.s=b;
1432
39
      uri->r2.len=p-b;
1433
39
      break;
1434
29
    case PG_G_FIN:
1435
38
    case PG_eq:
1436
38
      uri->params.s=s;
1437
38
      uri->params.len=p-s;
1438
38
      uri->gr.s=b;
1439
38
      uri->gr.len=p-b;
1440
38
      break;
1441
17
    case PN1_FIN:
1442
32
    case PN1_eq:
1443
32
      uri->params.s=s;
1444
32
      uri->params.len=p-s;
1445
32
      uri->pn_provider.s=b;
1446
32
      uri->pn_provider.len=p-b;
1447
32
      break;
1448
685
    case URI_VAL_P:
1449
    /* intermediate value states */
1450
707
    case VU_U:
1451
731
    case VU_D:
1452
751
    case VT_T:
1453
771
    case VT_C:
1454
789
    case VTLS_L:
1455
812
    case VS_S:
1456
834
    case VS_C:
1457
856
    case VW_W:
1458
876
    case VS_T:
1459
876
      uri->params.s=s;
1460
876
      uri->params.len=p-s;
1461
876
      param_set(b, v);
1462
876
      break;
1463
    /* fin value states */
1464
21
    case VU_P_FIN:
1465
21
      uri->params.s=s;
1466
21
      uri->params.len=p-s;
1467
21
      param_set(b, v);
1468
21
      uri->proto=PROTO_UDP;
1469
21
      break;
1470
18
    case VT_P_FIN:
1471
18
      uri->params.s=s;
1472
18
      uri->params.len=p-s;
1473
18
      param_set(b, v);
1474
18
      uri->proto=PROTO_TCP;
1475
18
      break;
1476
21
    case VTLS_S_FIN:
1477
21
      uri->params.s=s;
1478
21
      uri->params.len=p-s;
1479
21
      param_set(b, v);
1480
21
      uri->proto=PROTO_TLS;
1481
21
      break;
1482
20
    case VS_P_FIN:
1483
20
      uri->params.s=s;
1484
20
      uri->params.len=p-s;
1485
20
      param_set(b, v);
1486
20
      uri->proto=PROTO_SCTP;
1487
20
      break;
1488
26
    case VW_S:
1489
26
    case VW_S_FIN:
1490
26
      uri->params.s=s;
1491
26
      uri->params.len=p-s;
1492
26
      param_set(b, v);
1493
26
      uri->proto=PROTO_WS;
1494
26
      break;
1495
15
    case VWS_S_FIN:
1496
15
      uri->params.s=s;
1497
15
      uri->params.len=p-s;
1498
15
      param_set(b, v);
1499
15
      uri->proto=PROTO_WSS;
1500
15
      break;
1501
    /* headers */
1502
4.50k
    case URI_HEADERS:
1503
4.50k
      uri->headers.s=s;
1504
4.50k
      uri->headers.len=p-s;
1505
4.50k
      if (error_headers) goto error_headers;
1506
2.01k
      break;
1507
    /* intermediate PN param states */
1508
2.01k
    case PN_P:
1509
82
    case PN_N:
1510
105
    case PN_dash:
1511
128
    case PN_P2:
1512
154
    case PN_PR:
1513
182
    case PN1_O:
1514
209
    case PN1_V:
1515
229
    case PN1_I:
1516
251
    case PN1_D:
1517
272
    case PN1_E:
1518
297
    case PN2_I:
1519
324
    case PN3_A:
1520
351
    case PN3_R:
1521
376
    case PN3_A2:
1522
399
    case PN4_U:
1523
422
    case PN4_R:
1524
422
      uri->params.s=s;
1525
422
      uri->params.len=p-s;
1526
422
      break;
1527
107
    case PN2_D:
1528
150
    case PN2_eq:
1529
202
    case PN3_M:
1530
246
    case PN3_eq:
1531
278
    case PN4_R2:
1532
302
    case PN4_eq:
1533
302
      goto error_bad_uri;
1534
414
    default:
1535
414
      goto error_bug;
1536
29.5k
  }
1537
10.1k
  switch(uri->type){
1538
4.14k
    case TEL_URI_T:
1539
4.14k
    case TELS_URI_T:
1540
      /* fix tel uris, move the number in uri and empty the host */
1541
4.14k
      uri->user=uri->host;
1542
      /* TEL does not have a host part, still most of the code expects
1543
       * one, so lets keep the pointer, but set a 0 length */
1544
4.14k
      uri->host.len=0;
1545
4.14k
      break;
1546
5.96k
    case SIP_URI_T:
1547
5.99k
    case SIPS_URI_T:
1548
6.00k
    case URN_SERVICE_URI_T:
1549
      /* nothing to do for these URIs */
1550
6.00k
      break;
1551
21
    case URN_NENA_SERVICE_URI_T:
1552
21
      uri->user.s=0;
1553
21
      uri->user.len=0;
1554
      /* keep the service name as host part */
1555
21
      break;
1556
0
    case ERROR_URI_T:
1557
0
      LM_ERR("unexpected error (BUG?)\n");
1558
0
      goto error_bad_uri;
1559
0
      break; /* do nothing, avoids a compilation warning */
1560
10.1k
  }
1561
#ifdef EXTRA_DEBUG
1562
  /* do stuff */
1563
  LM_DBG("parsed uri:\n type=%d user=<%.*s>(%d)\n passwd=<%.*s>(%d)\n"
1564
      " host=<%.*s>(%d)\n port=<%.*s>(%d): %d\n params=<%.*s>(%d)\n"
1565
      " headers=<%.*s>(%d)\n",
1566
      uri->type,
1567
      uri->user.len, ZSW(uri->user.s), uri->user.len,
1568
      uri->passwd.len, ZSW(uri->passwd.s), uri->passwd.len,
1569
      uri->host.len, ZSW(uri->host.s), uri->host.len,
1570
      uri->port.len, ZSW(uri->port.s), uri->port.len, uri->port_no,
1571
      uri->params.len, ZSW(uri->params.s), uri->params.len,
1572
      uri->headers.len, ZSW(uri->headers.s), uri->headers.len
1573
    );
1574
  LM_DBG(" uri params:\n   transport=<%.*s>, val=<%.*s>, proto=%d\n",
1575
      uri->transport.len, ZSW(uri->transport.s), uri->transport_val.len,
1576
      ZSW(uri->transport_val.s), uri->proto);
1577
  LM_DBG("   user-param=<%.*s>, val=<%.*s>\n",
1578
      uri->user_param.len, ZSW(uri->user_param.s),
1579
      uri->user_param_val.len, ZSW(uri->user_param_val.s));
1580
  LM_DBG("   method=<%.*s>, val=<%.*s>\n",
1581
      uri->method.len, ZSW(uri->method.s),
1582
      uri->method_val.len, ZSW(uri->method_val.s));
1583
  LM_DBG("   ttl=<%.*s>, val=<%.*s>\n",
1584
      uri->ttl.len, ZSW(uri->ttl.s),
1585
      uri->ttl_val.len, ZSW(uri->ttl_val.s));
1586
  LM_DBG("   maddr=<%.*s>, val=<%.*s>\n",
1587
      uri->maddr.len, ZSW(uri->maddr.s),
1588
      uri->maddr_val.len, ZSW(uri->maddr_val.s));
1589
  LM_DBG("   lr=<%.*s>, val=<%.*s>\n", uri->lr.len, ZSW(uri->lr.s),
1590
      uri->lr_val.len, ZSW(uri->lr_val.s));
1591
  LM_DBG("   r2=<%.*s>, val=<%.*s>\n", uri->r2.len, ZSW(uri->r2.s),
1592
      uri->r2_val.len, ZSW(uri->r2_val.s));
1593
  for(i=0; i<URI_MAX_U_PARAMS && uri->u_name[i].s; i++)
1594
    LM_DBG("uname=[%p]-><%.*s> uval=[%p]-><%.*s>\n",
1595
      uri->u_name[i].s, uri->u_name[i].len, uri->u_name[i].s,
1596
      uri->u_val[i].s, uri->u_val[i].len, uri->u_val[i].s);
1597
  if (i!=uri->u_params_no)
1598
    LM_ERR("inconsisten # of u_name:[%d]!=[%d]\n", i, uri->u_params_no);
1599
#endif
1600
10.1k
  return 0;
1601
1602
69.6k
error_too_short:
1603
69.6k
  LM_ERR("uri too short: <%.*s> (%d)\n",
1604
69.6k
      len, ZSW(buf), len);
1605
69.6k
  goto error_exit;
1606
25.0k
error_bad_char:
1607
25.0k
  LM_ERR("bad char '%c' in state %d"
1608
25.0k
      " parsed: <%.*s> (%d) / <%.*s> (%d)\n",
1609
25.0k
      p < end ? *p : *(buf+len-1), state, (int)(p-buf), ZSW(buf),
1610
0
      (int)(p-buf), len, ZSW(buf), len);
1611
25.0k
  goto error_exit;
1612
12.6k
error_bad_host:
1613
12.6k
  LM_ERR("bad host in uri (error at char %c in"
1614
12.6k
      " state %d) parsed: <%.*s>(%d) /<%.*s> (%d)\n",
1615
12.6k
      p < end ? *p : *(buf+len-1), state, (int)(p-buf), ZSW(buf),
1616
0
      (int)(p-buf), len, ZSW(buf), len);
1617
12.6k
  goto error_exit;
1618
6.85k
error_bad_port:
1619
6.85k
  LM_ERR("bad port in uri (error at char '%c' in"
1620
6.85k
      " state %d) parsed: <%.*s>(%d) /<%.*s> (%d)\n",
1621
6.85k
      p < end ? *p : *(buf+len-1), state, (int)(p-buf), ZSW(buf),
1622
0
      (int)(p-buf), len, ZSW(buf), len);
1623
6.85k
  goto error_exit;
1624
4.90k
error_bad_uri:
1625
4.90k
  LM_ERR("bad uri, state %d parsed: <%.*s> (%d) / <%.*s> (%d)\n",
1626
4.90k
       state, (int)(p-buf), ZSW(buf), (int)(p-buf), len,
1627
0
       ZSW(buf), len);
1628
4.90k
  goto error_exit;
1629
2.61k
error_headers:
1630
2.61k
  LM_ERR("bad uri headers: <%.*s>(%d) / <%.*s>(%d)\n",
1631
2.61k
      uri->headers.len, ZSW(uri->headers.s), uri->headers.len,
1632
0
      len, ZSW(buf), len);
1633
2.61k
  goto error_exit;
1634
414
error_bug:
1635
414
  LM_ERR("bad state %d parsed: <%.*s> (%d) / <%.*s> (%d)\n",
1636
414
       state, (int)(p-buf), ZSW(buf), (int)(p-buf), len, ZSW(buf), len);
1637
122k
error_exit:
1638
122k
  ser_error=E_BAD_URI;
1639
122k
  uri->type=ERROR_URI_T;
1640
122k
  update_stat(bad_URIs, 1);
1641
122k
  return E_BAD_URI;
1642
414
}
1643
1644
/* Trim a URI userinfo str at the first ';'; see trim_user_params() in
1645
 * parse_uri.h for the full contract and caveats. */
1646
void trim_user_params(str *user)
1647
0
{
1648
0
  char *semi = q_memchr(user->s, ';', user->len);
1649
1650
0
  if (semi)
1651
0
    user->len = semi - user->s;
1652
0
}
1653
1654
1655
int parse_sip_msg_uri(struct sip_msg* msg)
1656
67.2k
{
1657
67.2k
  char* tmp;
1658
67.2k
  int tmp_len;
1659
67.2k
  if (msg->parsed_uri_ok) return 1;
1660
1661
67.2k
  if (msg->new_uri.s){
1662
0
    tmp=msg->new_uri.s;
1663
0
    tmp_len=msg->new_uri.len;
1664
67.2k
  }else{
1665
67.2k
    tmp=msg->first_line.u.request.uri.s;
1666
67.2k
    tmp_len=msg->first_line.u.request.uri.len;
1667
67.2k
  }
1668
67.2k
  if (parse_uri(tmp, tmp_len, &msg->parsed_uri)<0){
1669
65.3k
    LM_ERR("bad uri <%.*s>\n", tmp_len, tmp);
1670
65.3k
    msg->parsed_uri_ok=0;
1671
65.3k
    set_err_info(OSER_EC_PARSER, OSER_EL_MEDIUM, "error parsing r-uri");
1672
65.3k
    set_err_reply(400, "bad r-uri");
1673
65.3k
    return -1;
1674
65.3k
  }
1675
1.88k
  msg->parsed_uri_ok=1;
1676
1.88k
  return 0;
1677
67.2k
}
1678
1679
1680
int parse_orig_ruri(struct sip_msg* msg)
1681
50.8k
{
1682
50.8k
  str *uri;
1683
1684
50.8k
  if (msg->parsed_orig_ruri_ok)
1685
0
    return 1;
1686
1687
50.8k
  uri = &REQ_LINE(msg).uri;
1688
1689
50.8k
  if (parse_uri(uri->s, uri->len, &msg->parsed_orig_ruri)<0) {
1690
48.9k
    LM_ERR("bad uri <%.*s>\n", uri->len, ZSW(uri->s));
1691
48.9k
    msg->parsed_orig_ruri_ok = 0;
1692
48.9k
    set_err_info(OSER_EC_PARSER, OSER_EL_MEDIUM,
1693
48.9k
        "error parsing incoming uri");
1694
48.9k
    set_err_reply(400, "bad i-uri");
1695
48.9k
    return -1;
1696
48.9k
  }
1697
1698
1.88k
  msg->parsed_orig_ruri_ok = 1;
1699
1.88k
  return 0;
1700
50.8k
}
1701
1702
#define compare_uri_val(field,cmpfunc) \
1703
0
  do { \
1704
0
    if (first.field.len != second.field.len) \
1705
0
    { \
1706
0
      LM_DBG("Different URI field - " #field "\n"); \
1707
0
      return 1; \
1708
0
    } \
1709
0
    else \
1710
0
    { \
1711
0
      if (first.field.len != 0) \
1712
0
        if (cmpfunc(first.field.s,second.field.s,first.field.len)) \
1713
0
        { \
1714
0
          LM_DBG("Different URI field - " #field "\n"); \
1715
0
          return 1; \
1716
0
        } \
1717
0
    } \
1718
0
  } while (0)
1719
1720
/* Compare 2 SIP URIs according to RFC 3261
1721
 *
1722
 * Return value : 0 if URIs match
1723
 *          1 if URIs don't match
1724
 *         -1 if errors have occurred
1725
 */
1726
int compare_uris(str *raw_uri_a,struct sip_uri* parsed_uri_a,
1727
          str *raw_uri_b,struct sip_uri *parsed_uri_b)
1728
0
{
1729
0
  #define UNESCAPED_BUF_LEN 1024
1730
0
  char unescaped_a[UNESCAPED_BUF_LEN], unescaped_b[UNESCAPED_BUF_LEN];
1731
1732
0
  str unescaped_userA={unescaped_a, UNESCAPED_BUF_LEN};
1733
0
  str unescaped_userB={unescaped_b, UNESCAPED_BUF_LEN};
1734
1735
0
  struct sip_uri first;
1736
0
  struct sip_uri second;
1737
0
  char matched[URI_MAX_U_PARAMS];
1738
0
  int i,j;
1739
1740
0
  if ( (!raw_uri_a && !parsed_uri_a) || (!raw_uri_b && !parsed_uri_b) )
1741
0
  {
1742
0
    LM_ERR("Provide either a raw or parsed form of a SIP URI\n");
1743
0
    return -1;
1744
0
  }
1745
1746
0
  if (raw_uri_a && raw_uri_b)
1747
0
  {
1748
1749
    /* maybe we're lucky and straight-forward comparison succeeds */
1750
0
    if (raw_uri_a->len == raw_uri_b->len)
1751
0
      if (strncasecmp(raw_uri_a->s,raw_uri_b->s,raw_uri_a->len) == 0)
1752
0
      {
1753
0
        LM_DBG("straight-forward URI match\n");
1754
0
        if (parse_uri(raw_uri_a->s,raw_uri_a->len,&first) < 0)
1755
0
        {
1756
0
          LM_ERR("Failed to parse first URI\n");
1757
0
          return -1;
1758
0
        }
1759
0
        if (parse_uri(raw_uri_b->s,raw_uri_b->len,&second) < 0)
1760
0
        {
1761
0
          LM_ERR("Failed to parse second URI\n");
1762
0
          return -1;
1763
0
        }
1764
0
        if (unescape_user(&first.user, &unescaped_userA) < 0 ||
1765
0
            unescape_user(&second.user, &unescaped_userB) < 0) {
1766
0
          LM_ERR("Failed to unescape user!\n");
1767
0
          return -1;
1768
0
        }
1769
0
        first.user = unescaped_userA;
1770
0
        second.user = unescaped_userB;
1771
0
        compare_uri_val(user,strncmp);
1772
0
        compare_uri_val(passwd,strncmp);
1773
0
        return 0;
1774
0
      }
1775
0
  }
1776
1777
  /* XXX - maybe if we have two parsed sip_uris,
1778
   * or only one parsed and one raw,
1779
   * it should be possible to do a straight-forward
1780
   * URI match ? */
1781
1782
0
  if (parsed_uri_a)
1783
0
    first = *parsed_uri_a;
1784
0
  else
1785
0
  {
1786
0
    if (parse_uri(raw_uri_a->s,raw_uri_a->len,&first) < 0)
1787
0
    {
1788
0
      LM_ERR("Failed to parse first URI\n");
1789
0
      return -1;
1790
0
    }
1791
0
  }
1792
1793
0
  if (parsed_uri_b)
1794
0
    second = *parsed_uri_b;
1795
0
  else
1796
0
  {
1797
0
    if (parse_uri(raw_uri_b->s,raw_uri_b->len,&second) < 0)
1798
0
    {
1799
0
      LM_ERR("Failed to parse second URI\n");
1800
0
      return -1;
1801
0
    }
1802
0
  }
1803
1804
0
  if (first.type != second.type)
1805
0
  {
1806
0
    LM_DBG("Different uri types\n");
1807
0
    return 1;
1808
0
  }
1809
1810
0
  if (unescape_user(&first.user, &unescaped_userA) < 0 ||
1811
0
      unescape_user(&second.user, &unescaped_userB) < 0) {
1812
0
    LM_ERR("Failed to unescape user!\n");
1813
0
    return -1;
1814
0
  }
1815
1816
0
  first.user = unescaped_userA;
1817
0
  second.user = unescaped_userB;
1818
1819
0
  compare_uri_val(user,strncmp);
1820
0
  compare_uri_val(passwd,strncmp);
1821
0
  compare_uri_val(host,strncasecmp);
1822
0
  compare_uri_val(port,strncmp);
1823
1824
0
  compare_uri_val(transport_val,strncasecmp);
1825
0
  compare_uri_val(ttl_val,strncasecmp);
1826
0
  compare_uri_val(user_param_val,strncasecmp);
1827
0
  compare_uri_val(maddr_val,strncasecmp);
1828
0
  compare_uri_val(method_val,strncasecmp);
1829
0
  compare_uri_val(lr_val,strncasecmp);
1830
0
  compare_uri_val(r2_val,strncasecmp);
1831
0
  compare_uri_val(gr_val,strncasecmp);
1832
0
  compare_uri_val(pn_provider_val,strncasecmp);
1833
0
  compare_uri_val(pn_prid_val,strncasecmp);
1834
0
  compare_uri_val(pn_param_val,strncasecmp);
1835
0
  compare_uri_val(pn_purr_val,strncasecmp);
1836
1837
0
  if (first.u_params_no == 0 || second.u_params_no == 0)
1838
    /* one URI doesn't have other params,
1839
     * automatically all unknown params in other URI match
1840
     */
1841
0
    goto headers_check;
1842
1843
0
  memset(matched,0,URI_MAX_U_PARAMS);
1844
1845
0
  for (i=0;i<first.u_params_no;i++)
1846
0
    for (j=0;j<second.u_params_no;j++)
1847
0
      if (matched[j] == 0 &&
1848
0
        (first.u_name[i].len == second.u_name[j].len &&
1849
0
                strncasecmp(first.u_name[i].s,second.u_name[j].s,
1850
0
              first.u_name[i].len) == 0))
1851
0
        {
1852
                    /* point of no return - matching unknown parameter values */
1853
0
          if (first.u_val[i].len != second.u_val[j].len)
1854
0
          {
1855
0
            LM_DBG("Different URI param value for param %.*s\n",
1856
0
                first.u_name[i].len,first.u_name[i].s);
1857
0
            return 1;
1858
0
          }
1859
0
          else
1860
0
          {
1861
0
            if (first.u_val[i].len == 0)
1862
0
            {
1863
              /* no value for unknown params - match */
1864
0
              matched[j] = 1;
1865
0
              break;
1866
0
            }
1867
1868
0
            if (strncasecmp(first.u_val[i].s,second.u_val[j].s,
1869
0
              second.u_val[j].len))
1870
0
            {
1871
0
              LM_DBG("Different URI param value for param %.*s\n",
1872
0
                first.u_name[i].len,first.u_name[i].s);
1873
0
              return 1;
1874
0
            }
1875
0
            else
1876
0
            {
1877
0
              matched[j] = 1;
1878
0
              break;
1879
0
            }
1880
0
          }
1881
0
        }
1882
1883
  /* got here, it means all unknown params in first URI have been resolved
1884
    => first URI matched second URI, and the other way around
1885
  */
1886
1887
0
headers_check:
1888
   /* XXX Do we really care ? */
1889
0
  compare_uri_val(headers,strncasecmp);
1890
0
  return 0;
1891
0
}