./../bnf/sofia-sip/bnf.h

Bug Summary

File:	url/./../bnf/sofia-sip/bnf.h
Warning:	line 266, column 10 Array subscript is undefined

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name url.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-eagerly-assume -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -mrelocation-model pic -pic-level 2 -mthread-model posix -mdisable-fp-elim -fmath-errno -masm-verbose -mconstructor-aliases -munwind-tables -fuse-init-array -target-cpu x86-64 -dwarf-column-info -debugger-tuning=gdb -resource-dir /usr/lib/llvm-7/lib/clang/7.0.1 -D HAVE_CONFIG_H -I . -I ../.. -I ../../libsofia-sip-ua/su/sofia-sip -I ./../bnf -I ../bnf -I ./../ipt -I ../ipt -I ./../su -I ../su -D SU_DEBUG=0 -D PIC -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-7/lib/clang/7.0.1/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -fdebug-compilation-dir /drone/src/libsofia-sip-ua/url -ferror-limit 19 -fmessage-length 0 -fobjc-runtime=gcc -fdiagnostics-show-option -analyzer-output=html -o /drone/src/scan-build/2021-08-31-093522-363-1 -x c url.c -faddrsig

url.c

→

1/*
* This file is part of the Sofia-SIP package
*
* Copyright (C) 2005 Nokia Corporation.
*
* Contact: Pekka Pessi <pekka.pessi@nokia.com>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public License
* as published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful, but
* WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA
*
*/

25/**@CFILE url.c
*
* Implementation of basic URL parsing and handling.
*
* @author Pekka Pessi <Pekka.Pessi@nokia.com>
*
* @date Created: Thu Jun 29 22:44:37 2000 ppessi
*/

34#include "config.h"

36#include <sofia-sip/su_alloc.h>
37#include <sofia-sip/bnf.h>
38#include <sofia-sip/hostdomain.h>
39#include <sofia-sip/url.h>

41#include <sofia-sip/string0.h>

43#include <stdio.h>
44#include <string.h>
45#include <stdlib.h>
46#include <assert.h>
47#include <ctype.h>
48#include <limits.h>

50/**@def URL_PRINT_FORMAT
* Format string used when printing url with printf().
*
* The macro URL_PRINT_FORMAT is used in format string of printf() or
* similar printing functions.  A URL can be printed like this:
* @code
*   printf("%s received URL " URL_PRINT_FORMAT "\n",
*          my_name, URL_PRINT_ARGS(url));
* @endcode
*/

61/** @def URL_PRINT_ARGS(u)
* Argument list used when printing url with printf().
*
* The macro URL_PRINT_ARGS() is used to create a stdarg list for printf()
* or similar printing functions.  Using it, a URL can be printed like this:
*
* @code
*   printf("%s received URL " URL_PRINT_FORMAT "\n",
*          my_name, URL_PRINT_ARGS(url));
* @endcode
*/

73#define RESERVED";/?:@&=+$,"        ";/?:@&=+$,"
74#define DELIMS"<>#%\""          "<>#%\""
75#define UNWISE"{}|\\^[]`"		"{}|\\^[]`"

77#define EXCLUDED";/?:@&=+$," "<>#%\"" "{}|\\^[]`"	RESERVED";/?:@&=+$," DELIMS"<>#%\"" UNWISE"{}|\\^[]`"

79#define UNRESERVED"ABCDEFGHIJKLMNOPQRSTUVWXYZ" "abcdefghijklmnopqrstuvwxyz" "0123456789"
 "-_.!~*'()"    	"ABCDEFGHIJKLMNOPQRSTUVWXYZ" \
                    	"abcdefghijklmnopqrstuvwxyz" \
                    	"0123456789" \
                    	"-_.!~*'()"

84#define IS_EXCLUDED(u, m32, m64, m96)(u <= ' ' || u >= '\177' || (u < 64 ? (m32 & (1 <<
 (63 - u))) : (u < 96 ? (m64 & (1 << (95 - u))) :
 (m96 & (1 << (127 - u))))) != 0)			\
(u <= ' '						\
 || u >= '\177'					\
 || (u < 64 ? (m32 & (1 << (63 - u)))			\
     : (u < 96 ? (m64 & (1 << (95 - u)))		\
 : /*u < 128*/ (m96 & (1 << (127 - u))))) != 0)

91#define MASKS_WITH_RESERVED(reserved, m32, m64, m96)if (reserved == ((void*)0)) { m32 = 0xbe19003f, m64 = 0x8000001e
, m96 = 0x8000001d; } else do { m32 = 0xb400000a, m64 = 0x0000001e
, m96 = 0x8000001d; for (;reserved[0]; reserved++) { unsigned
 r = reserved[0]; if (r < 32) ; else if (r < 64) m32 |=
 1U << (63 - r); else if (r < 96) m64 |= 1U <<
 (95 - r); else if (r < 128) m96 |= 1U << (127 - r);
 } } while (0)		\
if (reserved == NULL((void*)0)) {					\
  m32 = 0xbe19003f, m64 = 0x8000001e, m96 = 0x8000001d;	\
} else do {							\
  m32 = 0xb400000a, m64 = 0x0000001e, m96 = 0x8000001d;	\
  								\
  for (;reserved[0]; reserved++) {				\
    unsigned r = reserved[0];					\
    RESERVE(r, m32, m64, m96)if (r < 32) ; else if (r < 64) m32 |= 1U << (63 -
 r); else if (r < 96) m64 |= 1U << (95 - r); else if
 (r < 128) m96 |= 1U << (127 - r);				\
  }								\
} while (0)

103#define RESERVE(reserved, m32, m64, m96)if (r < 32) ; else if (r < 64) m32 |= 1U << (63 -
 r); else if (r < 96) m64 |= 1U << (95 - r); else if
 (r < 128) m96 |= 1U << (127 - r)				\
if (r < 32)								\
  ;									\
else if (r < 64)							\
  m32 |= 1U << (63 - r);						\
else if (r < 96)							\
  m64 |= 1U << (95 - r);						\
else if (r < 128)							\
  m96 |= 1U << (127 - r)

113#define MASKS_WITH_ALLOWED(allowed, mask32, mask64, mask96)do { if (allowed) { for (;allowed[0]; allowed++) { unsigned a
 = allowed[0]; if (a < 32) ; else if (a < 64) mask32 &=
 ~(1U << (63 - a)); else if (a < 96) mask64 &= ~
(1U << (95 - a)); else if (a < 128) mask96 &= ~(
1U << (127 - a)); } } } while (0)	\
do {								\
  if (allowed) {						\
    for (;allowed[0]; allowed++) {				\
unsigned a = allowed[0];				\
ALLOW(a, mask32, mask64, mask96)if (a < 32) ; else if (a < 64) mask32 &= ~(1U <<
 (63 - a)); else if (a < 96) mask64 &= ~(1U << (
- a)); else if (a < 128) mask96 &= ~(1U << (127
 - a));			\
    }								\
  }								\
} while (0)

123#define ALLOW(a, mask32, mask64, mask96)if (a < 32) ; else if (a < 64) mask32 &= ~(1U <<
 (63 - a)); else if (a < 96) mask64 &= ~(1U << (
- a)); else if (a < 128) mask96 &= ~(1U << (127
 - a))	\
if (a < 32)					\
  ;						\
else if (a < 64)				\
  mask32 &= ~(1U << (63 - a));		\
else if (a < 96)				\
  mask64 &= ~(1U << (95 - a));		\
else if (a < 128)				\
  mask96 &= ~(1U << (127 - a))

133#define NUL'\0' '\0'
134#define NULNULNUL'\0', '\0', '\0' '\0', '\0', '\0'

136#define RMASK10xbe19003f 0xbe19003f
137#define RMASK20x8000001e 0x8000001e
138#define RMASK30x8000001d 0x8000001d

140#define RESERVED_MASK0xbe19003f, 0x8000001e, 0x8000001d 0xbe19003f, 0x8000001e, 0x8000001d
141#define URIC_MASK0xb400000a, 0x0000001e, 0x8000001d     0xb400000a, 0x0000001e, 0x8000001d

143#define IS_EXCLUDED_MASK(u, m)IS_EXCLUDED IS_EXCLUDED(u, m)

145/* Internal prototypes */
146static char *url_canonize(char *d, char const *s, size_t n,
	  unsigned syn33,
	  char const allowed[]);
149static char *url_canonize2(char *d, char const *s, size_t n,
	   unsigned syn33,
	   unsigned m32, unsigned m64, unsigned m96);
152static int url_tel_cmp_numbers(char const *A, char const *B);

154/**Test if string contains excluded or url-reserved characters.
*
*
*
* @param s  string to be searched
*
* @retval 0 if no reserved characters were found.
* @retval l if a reserved character was found.
*/
163int url_reserved_p(char const *s)
164{
if (s)
  while (*s) {
    unsigned char u = *s++;

    if (IS_EXCLUDED(u, RMASK1, RMASK2, RMASK3)(u <= ' ' || u >= '\177' || (u < 64 ? (0xbe19003f &
 (1 << (63 - u))) : (u < 96 ? (0x8000001e & (1 <<
 (95 - u))) : (0x8000001d & (1 << (127 - u))))) != 0
))
return 1;
  }

return 0;
174}

176/** Calculate length of string when escaped with %-notation.
*
* Calculate the length of string @a s when the excluded or reserved
* characters in it have been escaped.
*
* @param s         String with reserved URL characters. [IN
* @param reserved  Optional array of reserved characters [IN]
*
* @return
* The number of characters in corresponding but escaped string.
*
* You can handle a part of URL with reserved characters like this:
*�@code
* if (url_reserved_p(s))  {
*   n = malloc(url_esclen(s, NULL) + 1);
*   if (n) url_escape(n, s);
* } else {
*   n = malloc(strlen(s) + 1);
*   if (n) strcpy(n, s);
* }
* @endcode
*/
198isize_t url_esclen(char const *s, char const reserved[])
199{
size_t n;
unsigned mask32, mask64, mask96;

MASKS_WITH_RESERVED(reserved, mask32, mask64, mask96)if (reserved == ((void*)0)) { mask32 = 0xbe19003f, mask64 = 0x8000001e
, mask96 = 0x8000001d; } else do { mask32 = 0xb400000a, mask64
 = 0x0000001e, mask96 = 0x8000001d; for (;reserved[0]; reserved
++) { unsigned r = reserved[0]; if (r < 32) ; else if (r <
 64) mask32 |= 1U << (63 - r); else if (r < 96) mask64
 |= 1U << (95 - r); else if (r < 128) mask96 |= 1U <<
 (127 - r); } } while (0);

for (n = 0; s && *s; n++) {
  unsigned char u = *s++;

  if (IS_EXCLUDED(u, mask32, mask64, mask96)(u <= ' ' || u >= '\177' || (u < 64 ? (mask32 & (
<< (63 - u))) : (u < 96 ? (mask64 & (1 <<
 (95 - u))) : (mask96 & (1 << (127 - u))))) != 0))
    n += 2;
}

return (isize_t)n;
213}

215/** Escape a string.
*
* The function url_escape() copies the string pointed by @a s to the array
* pointed by @a d, @b excluding the terminating \\0 character.  All reserved
* characters in @a s are copied in hexadecimal format, for instance, @c
* "$%#" is copied as @c "%24%25%23".  The destination array @a d must be
* large enough to receive the escaped copy.
*
* @param d         Destination buffer [OUT]
* @param s         String to be copied [IN]
* @param reserved  Array of reserved characters [IN]
*
* @return Pointer to the destination array.
*/
229char *url_escape(char *d, char const *s, char const reserved[])
230{
char *retval = d;
unsigned mask32, mask64, mask96;

MASKS_WITH_RESERVED(reserved, mask32, mask64, mask96)if (reserved == ((void*)0)) { mask32 = 0xbe19003f, mask64 = 0x8000001e
, mask96 = 0x8000001d; } else do { mask32 = 0xb400000a, mask64
 = 0x0000001e, mask96 = 0x8000001d; for (;reserved[0]; reserved
++) { unsigned r = reserved[0]; if (r < 32) ; else if (r <
 64) mask32 |= 1U << (63 - r); else if (r < 96) mask64
 |= 1U << (95 - r); else if (r < 128) mask96 |= 1U <<
 (127 - r); } } while (0);

while (s && *s) {
  unsigned char u = *s++;

  if (IS_EXCLUDED(u, mask32, mask64, mask96)(u <= ' ' || u >= '\177' || (u < 64 ? (mask32 & (
<< (63 - u))) : (u < 96 ? (mask64 & (1 <<
 (95 - u))) : (mask96 & (1 << (127 - u))))) != 0)) {
240#     define URL_HEXIFY(u) ((u) + '0' + ((u) >= 10 ? 'A' - '0' - 10 : 0))

    *d++ = '%';
    *d++ = URL_HEXIFY(u >> 4);
    *d++ = URL_HEXIFY(u & 15);

246#     undef URL_HEXIFY
  }
  else {
    *d++ = u;
  }
}

*d = '\0';

return retval;
256}


259/**Unescape url-escaped string fragment.
*
* Unescape @a n characters from string @a s to the buffer @a d, including
* the terminating \\0 character. All %-escaped triplets in @a s are
* unescaped, for instance, @c "%40%25%23" is copied as @c "@%#". The
* destination array @a d must be large enough to receive the escaped copy
* (@a n bytes is always enough).
*
* @param d  destination buffer
* @param s  string to be unescaped
* @param n  maximum number of characters to unescape
*
* @return Length of unescaped string
*
* @NEW_1_12_4.
*/
275size_t url_unescape_to(char *d, char const *s, size_t n)
276{
size_t i = 0, j = 0;

if (s == NULL((void*)0))
  return 0;

i = j = strncspn(s, n, "%");

if (d && d != s)
  memmove(d, s, i);

for (; i < n;) {
  char c = s[i++];

  if (c == '\0')
    break;

  if (c == '%' && i + 1 < n && IS_HEX(s[i])(((s[i]) >= '0' && (s[i]) <= '9') || ((s[i]) >=
 'A' && (s[i]) <= 'F') || ((s[i]) >= 'a' &&
 (s[i]) <= 'f')) && IS_HEX(s[i + 1])(((s[i + 1]) >= '0' && (s[i + 1]) <= '9') || ((
s[i + 1]) >= 'A' && (s[i + 1]) <= 'F') || ((s[i
 + 1]) >= 'a' && (s[i + 1]) <= 'f'))) {
294#define   UNHEX(a) (a - (a >= 'a' ? 'a' - 10 : (a >= 'A' ? 'A' - 10 : '0')))
    c = (UNHEX(s[i]) << 4) | UNHEX(s[i + 1]);
296#undef    UNHEX
    i += 2;
  }

  if (d)
    d[j] = c;
  j++;
}

return j;
306}

308/**Unescape url-escaped string.
*
* Unescape string @a s to the buffer @a d, including the terminating \\0
* character. All %-escaped triplets in @a s are unescaped, for instance, @c
* "%40%25%23" is copied as @c "@%#". The destination array @a d must be
* large enough to receive the escaped copy.
*
* @param d  destination buffer
* @param s  string to be copied
*
* @return Pointer to the destination buffer.
*/
320char *url_unescape(char *d, char const *s)
321{
size_t n = url_unescape_to(d, s, SIZE_MAX(18446744073709551615UL));
if (d)
  d[n] = '\0';
return d;
326}

328/** Canonize a URL component */
329static
330char *url_canonize(char *d, char const *s, size_t n,
   unsigned syn33,
   char const allowed[])
333{
unsigned mask32 = 0xbe19003f, mask64 = 0x8000001e, mask96 = 0x8000001d;

MASKS_WITH_ALLOWED(allowed, mask32, mask64, mask96)do { if (allowed) { for (;allowed[0]; allowed++) { unsigned a
 = allowed[0]; if (a < 32) ; else if (a < 64) mask32 &=
 ~(1U << (63 - a)); else if (a < 96) mask64 &= ~
(1U << (95 - a)); else if (a < 128) mask96 &= ~(
1U << (127 - a)); } } } while (0);
14
←
Within the expansion of the macro 'MASKS_WITH_ALLOWED':
→

return url_canonize2(d, s, n, syn33, mask32, mask64, mask96);
15
←
Calling 'url_canonize2'→
18
←
Returning from 'url_canonize2'→
339}

341#define SYN33(c)(1U << (c - 33)) (1U << (c - 33))
342#define IS_SYN33(syn33, c)((syn33 & (1U << (c - 33))) != 0) ((syn33 & (1U << (c - 33))) != 0)

344/** Canonize a URL component (with precomputed mask) */
345static
346char *url_canonize2(char *d, char const * const s, size_t n,
    unsigned syn33,
    unsigned m32, unsigned m64, unsigned m96)
349{
size_t i = 0;

if (d == s)
16
←
Taking false branch→
  for (;s[i] && i < n; d++, i++)
    if (s[i] == '%')
break;

for (;s[i] && i < n; d++, i++) {
17
←
Assuming the condition is false→
  unsigned char c = s[i], h1, h2;

  if (c != '%') {
    if (!IS_SYN33(syn33, c)((syn33 & (1U << (c - 33))) != 0) && IS_EXCLUDED(c, m32, m64, m96)(c <= ' ' || c >= '\177' || (c < 64 ? (m32 & (1 <<
 (63 - c))) : (c < 96 ? (m64 & (1 << (95 - c))) :
 (m96 & (1 << (127 - c))))) != 0))
return NULL((void*)0);
    *d = c;
    continue;
  }

  h1 = s[i + 1], h2 = s[i + 2];

  if (!IS_HEX(h1)(((h1) >= '0' && (h1) <= '9') || ((h1) >= 'A'
 && (h1) <= 'F') || ((h1) >= 'a' && (h1
) <= 'f')) || !IS_HEX(h2)(((h2) >= '0' && (h2) <= '9') || ((h2) >= 'A'
 && (h2) <= 'F') || ((h2) >= 'a' && (h2
) <= 'f'))) {
    *d = '\0';
    return NULL((void*)0);
  }

374#define UNHEX(a) (a - (a >= 'a' ? 'a' - 10 : (a >= 'A' ? 'A' - 10 : '0')))
  c = (UNHEX(h1) << 4) | UNHEX(h2);

  if (!IS_EXCLUDED(c, m32, m64, m96)(c <= ' ' || c >= '\177' || (c < 64 ? (m32 & (1 <<
 (63 - c))) : (c < 96 ? (m64 & (1 << (95 - c))) :
 (m96 & (1 << (127 - c))))) != 0)) {
    /* Convert hex to normal character */
    *d = c, i += 2;
    continue;
  }

  /* Convert hex to uppercase */
  if (h1 >= 'a' /* && h1 <= 'f' */)
    h1 = h1 - 'a' + 'A';
  if (h2 >= 'a' /* && h2 <= 'f' */)
    h2 = h2 - 'a' + 'A';

  d[0] = '%', d[1] = h1, d[2] = h2;

  d +=2, i += 2;
392#undef    UNHEX
}

*d = '\0';

return d;
398}


401/** Canonize a URL component (with precomputed mask).
*
* This version does not flag error if *s contains character that should
* be escaped.
*/
406static
407char *url_canonize3(char *d, char const * const s, size_t n,
    unsigned m32, unsigned m64, unsigned m96)
409{
size_t i = 0;

if (d == s)
  for (;s[i] && i < n; d++, i++)
    if (s[i] == '%')
break;

for (;s[i] && i < n; d++, i++) {
  unsigned char c = s[i], h1, h2;

  if (c != '%') {
    *d = c;
    continue;
  }

  h1 = s[i + 1], h2 = s[i + 2];

  if (!IS_HEX(h1)(((h1) >= '0' && (h1) <= '9') || ((h1) >= 'A'
 && (h1) <= 'F') || ((h1) >= 'a' && (h1
) <= 'f')) || !IS_HEX(h2)(((h2) >= '0' && (h2) <= '9') || ((h2) >= 'A'
 && (h2) <= 'F') || ((h2) >= 'a' && (h2
) <= 'f'))) {
    *d = '\0';
    return NULL((void*)0);
  }

432#define UNHEX(a) (a - (a >= 'a' ? 'a' - 10 : (a >= 'A' ? 'A' - 10 : '0')))
  c = (UNHEX(h1) << 4) | UNHEX(h2);

  if (!IS_EXCLUDED(c, m32, m64, m96)(c <= ' ' || c >= '\177' || (c < 64 ? (m32 & (1 <<
 (63 - c))) : (c < 96 ? (m64 & (1 << (95 - c))) :
 (m96 & (1 << (127 - c))))) != 0)) {
    *d = c, i += 2;
    continue;
  }

  /* Convert hex to uppercase */
  if (h1 >= 'a' /* && h1 <= 'f' */)
    h1 = h1 - 'a' + 'A';
  if (h2 >= 'a' /* && h2 <= 'f' */)
    h2 = h2 - 'a' + 'A';

  d[0] = '%', d[1] = h1, d[2] = h2;

  d +=2, i += 2;
449#undef    UNHEX
}

*d = '\0';

return d;
455}


458/** Get URL scheme. */
459char const* url_scheme(enum url_type_e url_type)
460{
switch (url_type) {
case url_any:    return "*";
case url_sip:    return "sip";
case url_sips:   return "sips";
case url_tel:    return "tel";
case url_fax:    return "fax";
case url_modem:  return "modem";
case url_http:   return "http";
case url_https:  return "https";
case url_ftp:    return "ftp";
case url_file:   return "file";
case url_rtsp:   return "rtsp";
case url_rtspu:  return "rtspu";
case url_mailto: return "mailto";
case url_im:     return "im";
case url_pres:   return "pres";
case url_cid:    return "cid";
case url_msrp:   return "msrp";
case url_msrps:  return "msrps";
case url_urn:    return "urn";
case url_wv:     return "wv";
default:
  assert(url_type == url_unknown)((void) sizeof ((url_type == url_unknown) ? 1 : 0), __extension__
 ({ if (url_type == url_unknown) ; else __assert_fail ("url_type == url_unknown"
, "url.c", 483, __extension__ __PRETTY_FUNCTION__); }));
  return NULL((void*)0);
}
486}

488su_inlinestatic inline
489int url_type_is_opaque(enum url_type_e url_type)
490{
return
  url_type == url_invalid ||
  url_type == url_tel ||
  url_type == url_modem ||
  url_type == url_fax ||
  url_type == url_cid;
497}

499/** Init an url as given type */
500void url_init(url_t *url, enum url_type_e type)
501{
memset(url, 0, sizeof(*url));
url->url_type = type;
if (type > url_unknown) {
  char const *scheme = url_scheme((enum url_type_e)url->url_type);
  if (scheme)
    url->url_scheme = scheme;
}
509}

511/** Get url type */
512su_inlinestatic inline
513enum url_type_e url_get_type(char const *scheme, size_t len)
514{
515#define test_scheme(s) \
 if (len == strlen(#s) && !strncasecmp(scheme, #s, len)) return url_##s

switch (scheme[0]) {
21
←
Control jumps to the 'default' case at line 545→
case '*': if (strcmp(scheme, "*") == 0) return url_any;
case 'c': case 'C':
  test_scheme(cid); break;
case 'f': case 'F':
  test_scheme(ftp); test_scheme(file); test_scheme(fax); break;
case 'h': case 'H':
  test_scheme(http); test_scheme(https); break;
case 'i': case 'I':
  test_scheme(im); break;
case 'm': case 'M':
  test_scheme(mailto); test_scheme(modem);
  test_scheme(msrp); test_scheme(msrps); break;
case 'p': case 'P':
  test_scheme(pres); break;
case 'r': case 'R':
  test_scheme(rtsp); test_scheme(rtspu); break;
case 's': case 'S':
  test_scheme(sip); test_scheme(sips); break;
case 't': case 'T':
  test_scheme(tel); break;
case 'u': case 'U':
  test_scheme(urn); break;
case 'w': case 'W':
  test_scheme(wv); break;


default: break;
22
←
 Execution continues on line 550→
}

548#undef test_scheme

if (len != span_unreserved(scheme))
23
←
Calling 'span_unreserved'→
  return url_invalid;
else
  return url_unknown;
554}

556/**
* Decode a URL.
*
* This function decodes a (SIP) URL string to a url_t structure.
*
* @param url structure to store the parsing result
* @param s   NUL-terminated string to be parsed
*
* @note The parsed string @a s will be modified when parsing it.
*
* @retval 0 if successful,
* @retval -1 otherwise.
*/
569static
570int _url_d(url_t *url, char *s)
571{
size_t n, p;
char rest_c, *host, *user;
int have_authority = 1;

memset(url, 0, sizeof(*url));

if (strcmp(s, "*") == 0) {
  url->url_type = url_any;
  url->url_scheme = "*";
  return 0;
}

n = strcspn(s, ":/?#");

if (n && s[n] == ':') {
  char *scheme;
  url->url_scheme = scheme = s; s[n] = '\0'; s = s + n + 1;

  if (!(scheme = url_canonize(scheme, scheme, SIZE_MAX(18446744073709551615UL), 0, "+")))
    return -1;

  n = scheme - url->url_scheme;

  url->url_type = url_get_type(url->url_scheme, n);

  have_authority = !url_type_is_opaque((enum url_type_e)url->url_type);
}
else {
  url->url_type = url_unknown;
}

user = NULL((void*)0), host = s;

if (url->url_type == url_sip || url->url_type == url_sips) {
  /* SIP URL may have /;? in user part but no path */
  /* user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/" */
  /* Some #*@#* phones include unescaped # there, too */
  n = strcspn(s, "@/;?#");
  p = strcspn(s + n, "@");
  if (s[n + p] == '@') {
    n += p;
    user = s;
    host = s + n + 1;
  }

  n += strcspn(s + n, "/;?#");
}
else if (have_authority) {
  if (url->url_type == url_wv) {
    /* WV URL may have / in user part */
    n = strcspn(s, "@#?;");
    if (s[n] == '@') {
user = s;
host = s + n + 1;
n += strcspn(s + n, ";?#");
    }
  }
  else if (host[0] == '/' && host[1] != '/') {
    /* foo:/bar or /bar - no authority, just path */
    url->url_root = '/';	/* Absolute path */
    host = NULL((void*)0), n = 0;
  }
  else {
    if (host[0] == '/' && host[1] == '/') {
/* We have authority, / / foo or foo */
host += 2; s += 2, url->url_root = '/';
n = strcspn(s, "/?#@[]");
    }
    else
n = strcspn(s, "@;/?#");

    if (s[n] == '@')
user = host, host = user + n + 1;

    n += strcspn(s + n, ";/?#");	/* Find path, query and/or fragment */
  }
}
else /* !have_authority */ {
  user = host, host = NULL((void*)0);
  if (url->url_type != url_invalid)
    n = strcspn(s, "/;?#");	/* Find params, query and/or fragment */
  else
    n = strcspn(s, "#");
}

rest_c = s[n]; s[n] = 0; s = rest_c ? s + n + 1 : NULL((void*)0);

if (user) {
  if (host) host[-1] = '\0';
  url->url_user = user;
  if (url->url_type != url_unknown) {
    n = strcspn(user, ":");
    if (user[n]) {
user[n] = '\0';
url->url_password = user + n + 1;
    }
  }
}

if (host) {
  url->url_host = host;
  /* IPv6 (and in some cases, IPv4) addresses are quoted with [] */
  if (host[0] == '[') {
    n = strcspn(host, "]");
    if (host[n] && (host[n + 1] == '\0' || host[n + 1] == ':'))
n++;
    else
n = 0;
  }
  else {
    n = strcspn(host, ":");
  }

  /* We allow empty host by default */
  if (n == 0) switch (url->url_type) {
  case url_sip:
  case url_sips:
  case url_im:
  case url_pres:
    return -1;
  default:
    break;
  }

  if (host[n] == ':') {
    char *port = host + n + 1;
    url->url_port = port;
    switch (url->url_type) {
    case url_any:
    case url_sip:
    case url_sips:
    case url_http:
    case url_https:
    case url_ftp:
    case url_file:
    case url_rtsp:
    case url_rtspu:
if (!url_canonize2(port, port, SIZE_MAX(18446744073709551615UL), 0, RESERVED_MASK0xbe19003f, 0x8000001e, 0x8000001d))
 return -1;

/* Check that port is really numeric or wildcard */
/* Port can be *digit, empty string or "*" */
while (*port >= '0' && *port <= '9')
 port++;

if (port != url->url_port) {
 if (port[0] != '\0')
   return -1;
}
else if (port[0] == '\0')
 /* empty string */;
else if (port[0] == '*' && port[1] == '\0')
 /* wildcard */;
else
 return -1;
    }
    host[n] = 0;
  }
}

if (rest_c == '/') {
  url->url_path = s; n = strcspn(s, "?#");
  rest_c = s[n]; s[n] = 0; s = rest_c ? s + n + 1 : NULL((void*)0);
}
if (rest_c == ';') {
  url->url_params = s; n = strcspn(s, "?#");
  rest_c = s[n]; s[n] = 0; s = rest_c ? s + n + 1 : NULL((void*)0);
}
if (rest_c == '?') {
  url->url_headers = s; n = strcspn(s, "#");
  rest_c = s[n]; s[n] = 0; s = rest_c ? s + n + 1 : NULL((void*)0);
}
if (rest_c == '#') {
  url->url_fragment = s;
  rest_c = '\0';
}
if (rest_c)
  return -1;

return 0;
752}

754/* Unreserved things */

756/**
* Decode a URL.
*
* This function decodes a URL string to a url_t structure.
*
* @param url structure to store the parsing result
* @param s   NUL-terminated string to be parsed
*
* @note The parsed string @a s will be modified when parsing it.
*
* @retval 0 if successful,
* @retval -1 otherwise.
*/
769int url_d(url_t *url, char *s)
770{
if (url == NULL((void*)0) || _url_d(url, s) < 0)
  return -1;

/* Canonize  URL */
/* scheme is canonized by _url_d() */
if (url->url_type == url_sip || url->url_type == url_sips) {

778#   define SIP_USER_UNRESERVED"&=+$,;?/" "&=+$,;?/"
  s = (char *)url->url_user;
  if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL), 0, SIP_USER_UNRESERVED"&=+$,;?/"))
    return -1;

  /* Having different charset in user and password does not make sense */
  /* but that is how it is defined in RFC 3261 */
785#   define SIP_PASS_UNRESERVED"&=+$," "&=+$,"
  s = (char *)url->url_password;
  if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL), 0, SIP_PASS_UNRESERVED"&=+$,"))
    return -1;

}
else {

793#   define USER_UNRESERVED"&=+$,;" "&=+$,;"
  s = (char *)url->url_user;
  if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL), 0, USER_UNRESERVED"&=+$,;"))
    return -1;

798#   define PASS_UNRESERVED"&=+$,;:" "&=+$,;:"
  s = (char *)url->url_password;
  if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL), 0, PASS_UNRESERVED"&=+$,;:"))
    return -1;
}

s = (char *)url->url_host;
if (s && !url_canonize2(s, s, SIZE_MAX(18446744073709551615UL), 0, RESERVED_MASK0xbe19003f, 0x8000001e, 0x8000001d))
  return -1;

/* port is canonized by _url_d() */
s = (char *)url->url_path;
if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL),
	 /* Allow all URI characters but ? */
	 /* Allow unescaped /;?@, - but do not convert */
	 SYN33('/')(1U << ('/' - 33)) | SYN33(';')(1U << (';' - 33)) | SYN33('=')(1U << ('=' - 33)) | SYN33('@')(1U << ('@' - 33)) |
	 SYN33(',')(1U << (',' - 33)),
	 /* Convert escaped :&+$ to unescaped */
	 ":&+$"))
  return -1;

s = (char *)url->url_params;
if (s && !url_canonize(s, s, SIZE_MAX(18446744073709551615UL),
	 /* Allow all URI characters but ? */
	 /* Allow unescaped ;=@, - but do not convert */
	 SYN33(';')(1U << (';' - 33)) | SYN33('=')(1U << ('=' - 33)) | SYN33('@')(1U << ('@' - 33)) | SYN33(',')(1U << (',' - 33)),
	 /* Convert escaped /:&+$ to unescaped */
	 "/:&+$"))
  return -1;

/* Unhex alphanumeric and unreserved URI characters */
s = (char *)url->url_headers;
if (s && !url_canonize3(s, s, SIZE_MAX(18446744073709551615UL), RESERVED_MASK0xbe19003f, 0x8000001e, 0x8000001d))
  return -1;

/* Allow all URI characters (including reserved ones) */
s = (char *)url->url_fragment;
if (s && !url_canonize2(s, s, SIZE_MAX(18446744073709551615UL), 0, URIC_MASK0xb400000a, 0x0000001e, 0x8000001d))
  return -1;

return 0;
839}

841/** Encode an URL.
*
* The function url_e() combines a URL from substrings in url_t structure
* according the @ref url_syntax "URL syntax" presented above.  The encoded
* @a url is stored in a @a buffer of @a n bytes.
*
* @param buffer memory area to store the encoded @a url.
* @param n      size of @a buffer.
* @param url    URL to be encoded.
*
* @return
* Return the number of bytes in the encoding.
*
* @note The function follows the convention set by C99 snprintf().  Even if
* the result does not fit into the @a buffer and it is truncated, the
* function returns the number of bytes in an untruncated encoding.
*/
858issize_t url_e(char buffer[], isize_t n, url_t const *url)
859{
size_t i;
char *b = buffer;
size_t m = n;
int do_copy = n > 0;

if (url == NULL((void*)0))
  return -1;

if (URL_STRING_P(url)((url) && *((url_string_t*)(url))->us_str != 0)) {
  char const *u = (char *)url;
  i = strlen(u);
  if (!buffer)
    return i;

  if (i >= n) {
    memcpy(buffer, u, n - 2);
    buffer[n - 1] = '\0';
  } else {
    memcpy(buffer, u, i + 1);
  }

  return i;
}


if (url->url_type == url_any) {
  if (b && m > 0) {
    if (m > 1) strcpy(b, "*"); else b[0] = '\0';
  }
  return 1;
}

if (url->url_scheme && url->url_scheme[0]) {
  i = strlen(url->url_scheme) + 1;
  if (do_copy && (do_copy = i <= n)) {
    memcpy(b, url->url_scheme, i - 1);
    b[i - 1] = ':';
  }
  b += i; n -= i;
}

if (url->url_root && (url->url_host || url->url_user)) {
  if (do_copy && (do_copy = 2 <= n))
    memcpy(b, "//", 2);
  b += 2; n -= 2;
}

if (url->url_user) {
  i = strlen(url->url_user);
  if (do_copy && (do_copy = i <= n))
    memcpy(b, url->url_user, i);
  b += i; n -= i;

  if (url->url_password) {
    if (do_copy && (do_copy = 1 <= n))
*b = ':';
    b++; n--;
    i = strlen(url->url_password);
    if (do_copy && (do_copy = i <= n))
memcpy(b, url->url_password, i);
    b += i; n -= i;
  }

  if (url->url_host) {
    if (do_copy && (do_copy = 1 <= n))
*b = '@';
    b++; n--;
  }
}

if (url->url_host) {
  i = strlen(url->url_host);
  if (do_copy && (do_copy = i <= n))
    memcpy(b, url->url_host, i);
  b += i; n -= i;

  if (url->url_port) {
    i = strlen(url->url_port) + 1;
    if (do_copy && (do_copy = i <= n)) {
b[0] = ':';
memcpy(b + 1, url->url_port, i - 1);
    }
    b += i; n -= i;
  }
}

if (url->url_path) {
  if (url->url_root) {
    if (do_copy && (do_copy = 1 <= n))
b[0] = '/';
    b++, n--;
  }
  i = strlen(url->url_path);
  if (do_copy && (do_copy = i < n))
    memcpy(b, url->url_path, i);
  b += i; n -= i;
}

{
  static char const sep[] = ";?#";
  char const *pp[3];
  size_t j;

  pp[0] = url->url_params;
  pp[1] = url->url_headers;
  pp[2] = url->url_fragment;

  for (j = 0; j < 3; j++) {
    char const *p = pp[j];
    if (!p) continue;
    i = strlen(p) + 1;
    if (do_copy && (do_copy = i <= n)) {
*b = sep[j];
memcpy(b + 1, p, i - 1);
    }
    b += i; n -= i;
  }
}

if (do_copy && (do_copy = 1 <= n))
  *b = '\0';
else if (buffer && m > 0)
  buffer[m - 1] = '\0';

assert((size_t)(b - buffer) == (size_t)(m - n))((void) sizeof (((size_t)(b - buffer) == (size_t)(m - n)) ? 1
 : 0), __extension__ ({ if ((size_t)(b - buffer) == (size_t)(
m - n)) ; else __assert_fail ("(size_t)(b - buffer) == (size_t)(m - n)"
, "url.c", 984, __extension__ __PRETTY_FUNCTION__); }));

/* This follows the snprintf(C99) return value,
 * Number of characters written (excluding NUL)
 */
return b - buffer;
990}


993/** Calculate the length of URL when encoded.
*
*/
996isize_t url_len(url_t const * url)
997{
size_t rv = 0;

if (url->url_scheme) rv += strlen(url->url_scheme) + 1; /* plus ':' */
if (url->url_user) {
  rv += strlen(url->url_user);
  if (url->url_password)
    rv += strlen(url->url_password) + 1;   /* plus ':' */
  rv += url->url_host != NULL((void*)0);  /* plus '@' */
}
if (url->url_host) rv += strlen(url->url_host);
if (url->url_port) rv += strlen(url->url_port) + 1;	        /* plus ':' */
if (url->url_path) rv += strlen(url->url_path) + 1;     /* plus initial / */
if (url->url_params) rv += strlen(url->url_params) + 1; /* plus initial ; */
if (url->url_headers) rv += strlen(url->url_headers) + 1;	/* plus '?' */
if (url->url_fragment) rv += strlen(url->url_fragment) + 1;   /* plus '#' */

return rv;
1015}

1017/**@def URL_E(buf, end, url)
* Encode an URL: use @a buf up to @a end.
* @hideinitializer
*/

1022/**
* Calculate the size of strings associated with a #url_t sructure.
*
* @param url pointer to a #url_t structure or string
* @return Number of bytes for URL
*/
1028isize_t url_xtra(url_t const *url)
1029{
size_t xtra;

if (URL_STRING_P(url)((url) && *((url_string_t*)(url))->us_str != 0)) {
  xtra = strlen((char const *)url) + 1;
}
else {
  size_t len_scheme, len_user, len_password,
    len_host, len_port, len_path, len_params,
    len_headers, len_fragment;

  len_scheme = (url->url_type <= url_unknown && url->url_scheme) ?
    strlen(url->url_scheme) + 1 : 0;
  len_user = url->url_user ? strlen(url->url_user) + 1 : 0;
  len_password = url->url_password ? strlen(url->url_password) + 1 : 0;
  len_host = url->url_host ? strlen(url->url_host) + 1 : 0;
  len_port = url->url_port ? strlen(url->url_port) + 1 : 0;
  len_path = url->url_path ? strlen(url->url_path) + 1 : 0;
  len_params = url->url_params ? strlen(url->url_params) + 1 : 0;
  len_headers = url->url_headers ? strlen(url->url_headers) + 1 : 0;
  len_fragment = url->url_fragment ? strlen(url->url_fragment) + 1 : 0;

  xtra =
    len_scheme + len_user + len_password + len_host + len_port +
    len_path + len_params + len_headers + len_fragment;
}

return xtra;
1057}

1059su_inlinestatic inline
1060char *copy(char *buf, char *end, char const *src)
1061{
1062#if HAVE_MEMCCPY1
char *b = memccpy(buf, src, '\0', end - buf);
if (b)
  return b;
else
  return end + strlen(src + (end - buf)) + 1;
1068#else
for (; buf < end && (*buf = *src); buf++, src++)
  ;

if (buf >= end)
  while (*src++)
    buf++;

return buf + 1;
1077#endif
1078}

1080/**
* Duplicate the url.
*
* The function url_dup() copies the url structure @a src and the strings
* attached to it to @a url.  The non-constant strings in @a src are copied
* to @a buf.  If the size of duplicated strings exceed @a bufsize, the
* corresponding string fields in @a url are set to NULL.
*
* The calling function can calculate the size of buffer required by calling
* url_dup() with zero as @a bufsize and NULL as @a dst.

* @param buf     Buffer for non-constant strings copied from @a src.
* @param bufsize Size of @a buf.
* @param dst     Destination URL structure.
*�@param src     Source URL structure.
*
* @return Number of characters required for
* duplicating the strings in @a str, or -1 if an error
* occurred.
*/
1100issize_t url_dup(char *buf, isize_t bufsize, url_t *dst, url_t const *src)
1101{
if (!src && !dst)
  return -1;
else if (URL_STRING_P(src)((src) && *((url_string_t*)(src))->us_str != 0)) {
  size_t n = strlen((char *)src) + 1;
  if (n > bufsize || dst == NULL((void*)0))
    return n;

  strcpy(buf, (char *)src);
  memset(dst, 0, sizeof(*dst));
  if (url_d(dst, buf) < 0)
    return -1;

  return n;
}
else {
  char *b = buf;
  char *end = b + bufsize;
  char const **dstp;
  char const * const *srcp;
  url_t dst0[1];

  if (dst == NULL((void*)0))
    dst = dst0;

  memset(dst, 0, sizeof(*dst));

  if (!src)
    return 0;

  memset(dst->url_pad, 0, sizeof dst->url_pad);
  dst->url_type = src->url_type;
  dst->url_root = src->url_root;

  dstp = &dst->url_scheme;
  srcp = &src->url_scheme;

  if (dst->url_type > url_unknown)
    *dstp = url_scheme((enum url_type_e)dst->url_type);

  if (*dstp != NULL((void*)0))
    dstp++, srcp++;	/* Skip scheme if it is constant */

  if (dst != dst0 && buf != NULL((void*)0) && bufsize != 0)
    for (; srcp <= &src->url_fragment; srcp++, dstp++)
if (*srcp) {
 char *next = copy(b, end, *srcp);

 if (next > end)
   break;

 *dstp = b, b = next;
}

  for (; srcp <= &src->url_fragment; srcp++)
    if (*srcp) {
b += strlen(*srcp) + 1;
    }

  return b - buf;
}
1162}

1164/**@def URL_DUP(buf, end, dst, src)
*  Duplicate the url: use @a buf up to @a end. @HI
*
* The macro URL_DUP() duplicates the url.  The non-constant strings in @a
* src are copied to @a buf.  However, no strings are copied past @a end.
* In other words, the size of buffer is @a end - @a buf.
*
* The macro updates the buffer pointer @a buf, so that it points to the
* first unused byte in the buffer.  The buffer pointer @a buf is updated,
* even if the buffer is too small for the duplicated strings.
*
* @param buf     Buffer for non-constant strings copied from @a src.
* @param end     End of @a buf.
* @param dst     Destination URL structure.
*�@param src     Source URL structure.
*
* @return
* The macro URL_DUP() returns pointer to first unused byte in the
* buffer @a buf.
*/

1185/** Duplicate the url to memory allocated via home.
*
* The function url_hdup() duplicates (deep copies) an #url_t structure.
* Alternatively, it can be passed a string; string is then copied and
* parsed to the #url_t structure.
*
* The function url_hdup() allocates the destination structure from @a home
* as a single memory block. It is possible to free the copied url structure
* and all the associated strings using a single call to su_free().
*
* @param home memory home used to allocate new url object
* @param src  pointer to URL (or string)
*
* @return
* The function url_hdup() returns a pointer to the newly allocated #url_t
* structure, or NULL upon an error.
*/
1202url_t *url_hdup(su_home_t *home, url_t const *src)
1203{
if (src) {
  size_t len = sizeof(*src) + url_xtra(src);
  url_t *dst = su_alloc(home, len);
  if (dst) {
    ssize_t actual;
    actual = url_dup((char *)(dst + 1), len - sizeof(*src), dst, src);
    if (actual < 0)
su_free(home, dst), dst = NULL((void*)0);
    else
assert(len == sizeof(*src) + actual)((void) sizeof ((len == sizeof(*src) + actual) ? 1 : 0), __extension__
 ({ if (len == sizeof(*src) + actual) ; else __assert_fail ("len == sizeof(*src) + actual"
, "url.c", 1213, __extension__ __PRETTY_FUNCTION__); }));
  }
  return dst;
}
else
  return NULL((void*)0);
1219}


1222/** Convert an string to an url */
1223url_t *url_make(su_home_t *h, char const *str)
1224{
return url_hdup(h, URL_STRING_MAKE(str)((url_string_t *)((str) && *((char *)(str)) ? (str) :
 ((void*)0)))->us_url);
1226}

1228/** Print an URL */
1229url_t *url_format(su_home_t *h, char const *fmt, ...)
1230{
url_t *url;
char *us;
va_list ap;

va_start(ap, fmt)__builtin_va_start(ap, fmt);

us = su_vsprintf(h, fmt, ap);

va_end(ap)__builtin_va_end(ap);

if (us == NULL((void*)0))
  return NULL((void*)0);

url = url_hdup(h, URL_STRING_MAKE(us)((url_string_t *)((us) && *((char *)(us)) ? (us) : ((
void*)0)))->us_url);

su_free(h, us);

return url;
1249}


1252/** Convert @a url to a string allocated from @a home.
*
* @param home memory home to allocate the new string
* @param url  url to convert to string
*
* The @a url can be a string, too.
*
* @return Newly allocated conversion result, or NULL upon an error.
*/
1261char *url_as_string(su_home_t *home, url_t const *url)
1262{
if (url) {
  int len = url_e(NULL((void*)0), 0, url);
  char *b = su_alloc(home, len + 1);
  url_e(b, len + 1, url);
  return b;
} else {
  return NULL((void*)0);
}
1271}


1274/** Test if param @a tag matches to parameter string @a p.
*/
1276#define URL_PARAM_MATCH(p, tag)(strncasecmp(p, tag, strlen(tag)) == 0 && (p[strlen(tag
)] == '\0' || p[strlen(tag)] == ';' || p[strlen(tag)] == '=')
) \
(strncasecmp(p, tag, strlen(tag)) == 0 && \
(p[strlen(tag)] == '\0' || p[strlen(tag)] == ';' || p[strlen(tag)] == '='))

1280/**
* Search for a parameter.
*
* This function searches for a parameter from a parameter list.
*
* If you want to test if there is parameter @b user=phone,
* call this function like
* @code if (url_param(url->url_param, "user=phone", NULL, 0))
* @endcode
*
* @param params URL parameter string (excluding first semicolon)
* @param tag    parameter name
* @param value  string to which the parameter value is copied
* @param vlen   length of string reserved for value
*
* @retval positive length of parameter value (including final NUL) if found
* @retval zero     if not found.
*/
1298isize_t url_param(char const *params,
  char const *tag,
  char value[], isize_t vlen)
1301{
size_t n, tlen, flen;
char *p;

if (!params)
  return 0;

tlen = strlen(tag);
if (tlen && tag[tlen - 1] == '=')
  tlen--;

for (p = (char *)params; *p; p += n + 1) {
  n = strcspn(p, ";");
  if (n < tlen) {
    if (p[n]) continue; else break;
  }
  if (strncasecmp(p, tag, tlen) == 0) {
    if (n == tlen) {
if (vlen > 0)
 value[0] = '\0';
return 1;
    }
    if (p[tlen] != '=')
continue;
    flen = n - tlen - 1;
    if (flen >= (size_t)vlen)
return flen + 1;
    memcpy(value, p + tlen + 1, flen);
    value[flen] = '\0';
    return flen + 1;
  }
  if (!p[n])
    break;
}

return 0;
1337}

1339/** Check for a parameter.
*
* @deprecated
* Bad grammar. Use url_has_param().
*/
1344isize_t url_have_param(char const *params, char const *tag)
1345{
return url_param(params, tag, NULL((void*)0), 0);
1347}

1349/** Check for a parameter. */
1350int url_has_param(url_t const *url, char const *tag)
1351{
return url && url->url_params && url_param(url->url_params, tag, NULL((void*)0), 0);
1353}

1355/** Add an parameter. */
1356int url_param_add(su_home_t *h, url_t *url, char const *param)
1357{
/* XXX - should remove existing parameters with same name? */
size_t n = url->url_params ? strlen(url->url_params) + 1: 0;
size_t nn = strlen(param) + 1;
char *s = su_alloc(h, n + nn);

if (!s)
  return -1;

if (url->url_params)
  strcpy(s, url->url_params)[n - 1] = ';';
strcpy(s + n, param);
url->url_params = s;

return 0;
1372}

1374/** Remove a named parameter from url_param string.
*
* Remove a named parameter and its possible value from the URL parameter
* string (url_s##url_param).
*
* @return Pointer to modified string, or NULL if nothing is left in there.
*/
1381char *url_strip_param_string(char *params, char const *name)
1382{
if (params && name) {
  size_t i, n = strlen(name), remove, rest;

  for (i = 0; params[i];) {
    if (strncasecmp(params + i, name, n) ||
 (params[i + n] != '=' && params[i + n] != ';' && params[i + n])) {
i = i + strcspn(params + i, ";");
if (!params[i++])
 break;
continue;
    }
    remove = n + strcspn(params + i + n, ";");
    if (params[i + remove] == ';')
remove++;

    if (i == 0) {
params += remove;
continue;
    }

    rest = strlen(params + i + remove);
    if (!rest) {
if (i == 0)
 return NULL((void*)0);		/* removed everything */
params[i - 1] = '\0';
break;
    }
    memmove(params + i, params + i + remove, rest + 1);
  }

  if (!params[0])
    return NULL((void*)0);
}

return params;
1418}

1420int url_string_p(url_string_t const *url)
1421{
return URL_STRING_P(url)((url) && *((url_string_t*)(url))->us_str != 0);
1423}

1425int url_is_string(url_string_t const *url)
1426{
return URL_IS_STRING(url)((url) && *((url_string_t*)(url))->us_str != 0);
1428}

1430/** Strip transport-specific stuff. */
1431static
1432int url_strip_transport2(url_t *url, int modify)
1433{
char *p, *d;
size_t n;
int semi;

if (url->url_type != url_sip && url->url_type != url_sips)
  return 0;

if (url->url_port != NULL((void*)0)) {
  if (!modify)
    return 1;
  url->url_port = NULL((void*)0);
}

if (!url->url_params)
  return 0;

for (d = p = (char *)url->url_params; *p; p += n + semi) {
  n = strcspn(p, ";");
  semi = (p[n] != '\0');

  if (modify && n == 0)
    continue;
  if (URL_PARAM_MATCH(p, "method")(strncasecmp(p, "method", strlen("method")) == 0 && (
p[strlen("method")] == '\0' || p[strlen("method")] == ';' || p
[strlen("method")] == '=')))
    continue;
  if (URL_PARAM_MATCH(p, "maddr")(strncasecmp(p, "maddr", strlen("maddr")) == 0 && (p[
strlen("maddr")] == '\0' || p[strlen("maddr")] == ';' || p[strlen
("maddr")] == '=')))
    continue;
  if (URL_PARAM_MATCH(p, "ttl")(strncasecmp(p, "ttl", strlen("ttl")) == 0 && (p[strlen
("ttl")] == '\0' || p[strlen("ttl")] == ';' || p[strlen("ttl"
)] == '=')))
    continue;
  if (URL_PARAM_MATCH(p, "transport")(strncasecmp(p, "transport", strlen("transport")) == 0 &&
 (p[strlen("transport")] == '\0' || p[strlen("transport")] ==
 ';' || p[strlen("transport")] == '=')))
    continue;

  if (p != d) {
    if (d != url->url_params)
d++;
    if (p != d) {
if (!modify)
 return 1;
memmove(d, p, n + 1);
    }
  }
  d += n;
}

if (d == p)
  return 0;
else if (d + 1 == p)		/* empty param */
  return 0;
else if (!modify)
  return 1;

if (d != url->url_params)
  *d = '\0';
else
  url->url_params = NULL((void*)0);

return 1;
1490}

1492/** Strip transport-specific stuff.
*
* The function url_strip_transport() removes transport-specific parameters
* from a SIP or SIPS URI.  These parameters include:
* - the port number
* - "maddr=" parameter
* - "transport=" parameter
* - "ttl=" parameter
* - "method=" parameter
*
* @note
* The @a url must be a pointer to a URL structure. It is stripped in-place.
*
* @note
* If the parameter string contains empty parameters, they are stripped, too.
*
* @return
* The function url_strip_transport() returns @e true, if the URL was
* modified, @e false otherwise.
*/
1512int url_strip_transport(url_t *url)
1513{
return url_strip_transport2(url, 1);
1515}

1517/** Check for transport-specific stuff.
*
* The function url_have_transport() tests if there are transport-specific
* parameters in a SIP or SIPS URI. These parameters include:
* - the port number
* - "maddr=" parameters
* - "transport=" parameters
*
* @note
* The @a url must be a pointer to a URL structure.
*
* @return The function url_have_transport() returns @e true, if the URL
* contains transport parameters, @e false otherwise.
*/
1531int url_have_transport(url_t const *url)
1532{
return url_strip_transport2((url_t *)url, 0);
1534}

1536/**Lazily compare two URLs.
*
* Compare essential parts of URLs: schema, host, port, and username.
*
* any_url compares 0 with any other URL.
*
* pres: and im: URIs compares 0 with SIP URIs.
*
* @note
* The @a a and @a b must be pointers to URL structures.
*
* @note Currently, the url parameters are not compared. This is because the
* url_cmp() is used to sort URLs: taking parameters into account makes that
* impossible.
*/
1551int url_cmp(url_t const *a, url_t const *b)
1552{
int rv;
int url_type;

if ((a && a->url_type == url_any) || (b && b->url_type == url_any))
  return 0;

if (!a || !b)
  return (a != NULL((void*)0)) - (b != NULL((void*)0));

if ((rv = a->url_type - b->url_type)) {
1563#if 0
  /* presence and instant messaging URLs match magically with SIP */
  enum url_type_e a_type = a->url_type;
  enum url_type_e b_type = b->url_type;

  if (a_type == url_im || a_type == url_pres)
    a_type = url_sip;

  if (b_type == url_im || b_type == url_pres)
    b_type = url_sip;

  if (a_type != b_type)
1575#endif
    return rv;
}

url_type = a->url_type;	/* Or b->url_type, they are equal! */

if (url_type <= url_unknown &&
    ((rv = !a->url_scheme - !b->url_scheme) ||
     (a->url_scheme && b->url_scheme &&
(rv = strcasecmp(a->url_scheme, b->url_scheme)))))
  return rv;

if ((rv = host_cmp(a->url_host, b->url_host)))
  return rv;

if (a->url_port != b->url_port) {
  char const *a_port;
  char const *b_port;

  if (url_type != url_sip && url_type != url_sips)
    a_port = b_port = url_port_default((enum url_type_e)url_type);
  else if (host_is_ip_address(a->url_host))
    a_port = b_port = url_port_default((enum url_type_e)url_type);
  else
    a_port = b_port = "";

  if (a->url_port) a_port = a->url_port;
  if (b->url_port) b_port = b->url_port;

  if ((rv = strcmp(a_port, b_port)))
    return rv;
}

if (a->url_user != b->url_user) {
  if (a->url_user == NULL((void*)0)) return -1;
  if (b->url_user == NULL((void*)0)) return +1;
  switch (url_type) {
  case url_tel: case url_modem: case url_fax:
    rv = url_tel_cmp_numbers(a->url_user, b->url_user);
    break;
  default:
    rv = strcmp(a->url_user, b->url_user);
    break;
  }
  if (rv)
    return rv;
}

1623#if 0
if (a->url_path != b->url_path) {
  if (a->url_path == NULL((void*)0)) return -1;
  if (b->url_path == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_path, b->url_path)))
    return rv;
}
1630#endif

return 0;
1633}

1635static
1636int url_tel_cmp_numbers(char const *A, char const *B)
1637{
short a, b;
int rv;

while (*A && *B) {
  #define UNHEX(a) (a - (a >= 'a' ? 'a' - 10 : (a >= 'A' ? 'A' - 10 : '0')))
  /* Skip visual-separators */
  do {
    a = *A++;
    if (a == '%' && IS_HEX(A[0])(((A[0]) >= '0' && (A[0]) <= '9') || ((A[0]) >=
 'A' && (A[0]) <= 'F') || ((A[0]) >= 'a' &&
 (A[0]) <= 'f')) && IS_HEX(A[1])(((A[1]) >= '0' && (A[1]) <= '9') || ((A[1]) >=
 'A' && (A[1]) <= 'F') || ((A[1]) >= 'a' &&
 (A[1]) <= 'f')))
a = (UNHEX(A[0]) << 4) | UNHEX(A[1]), A +=2;
  } while (a == ' ' || a == '-' || a == '.' || a == '(' || a == ')');

  if (isupper(a)((*__ctype_b_loc ())[(int) ((a))] & (unsigned short int) _ISupper
))
    a = tolower(a);

  do {
    b = *B++;
    if (b == '%' && IS_HEX(B[0])(((B[0]) >= '0' && (B[0]) <= '9') || ((B[0]) >=
 'A' && (B[0]) <= 'F') || ((B[0]) >= 'a' &&
 (B[0]) <= 'f')) && IS_HEX(B[1])(((B[1]) >= '0' && (B[1]) <= '9') || ((B[1]) >=
 'A' && (B[1]) <= 'F') || ((B[1]) >= 'a' &&
 (B[1]) <= 'f')))
b = (UNHEX(B[0]) << 4) | UNHEX(B[1]), B +=2;
  } while (b == ' ' || b == '-' || b == '.' || b == '(' || b == ')');

  if (isupper(b)((*__ctype_b_loc ())[(int) ((b))] & (unsigned short int) _ISupper
))
    b = tolower(b);

  if ((rv = a - b))
    return rv;
}

return (int)*A - (int)*B;
1667}

1669/**Conservative comparison of urls.
*
* Compare all parts of URLs.
*
* @note
* The @a a and @a b must be pointers to URL structures.
*
*/
1677int url_cmp_all(url_t const *a, url_t const *b)
1678{
int rv, url_type;

if (!a || !b)
  return (a != NULL((void*)0)) - (b != NULL((void*)0));

if ((rv = a->url_type - b->url_type))
  return rv;

url_type = a->url_type;	/* Or b->url_type, they are equal! */

if (url_type <= url_unknown &&
    ((rv = !a->url_scheme - !b->url_scheme) ||
     (a->url_scheme && b->url_scheme &&
(rv = strcasecmp(a->url_scheme, b->url_scheme)))))
  return rv;

if ((rv = a->url_root - b->url_root))
  return rv;

if ((rv = host_cmp(a->url_host, b->url_host)))
  return rv;

if (a->url_port != b->url_port) {
  char const *a_port;
  char const *b_port;

  if (url_type != url_sip && url_type != url_sips)
    a_port = b_port = url_port_default((enum url_type_e)url_type);
  else if (host_is_ip_address(a->url_host))
    a_port = b_port = url_port_default((enum url_type_e)url_type);
  else
    a_port = b_port = "";

  if (a->url_port) a_port = a->url_port;
  if (b->url_port) b_port = b->url_port;

  if ((rv = strcmp(a_port, b_port)))
    return rv;
}

if (a->url_user != b->url_user) {
  if (a->url_user == NULL((void*)0)) return -1;
  if (b->url_user == NULL((void*)0)) return +1;

  switch (url_type) {
  case url_tel: case url_modem: case url_fax:
    rv = url_tel_cmp_numbers(a->url_user, b->url_user);
    break;
  default:
    rv = strcmp(a->url_user, b->url_user);
    break;
  }
  if (rv)
    return rv;
}

if (a->url_path != b->url_path) {
  if (a->url_path == NULL((void*)0)) return -1;
  if (b->url_path == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_path, b->url_path)))
    return rv;
}

if (a->url_params != b->url_params) {
  if (a->url_params == NULL((void*)0)) return -1;
  if (b->url_params == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_params, b->url_params)))
    return rv;
}

if (a->url_headers != b->url_headers) {
  if (a->url_headers == NULL((void*)0)) return -1;
  if (b->url_headers == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_headers, b->url_headers)))
    return rv;
}

if (a->url_headers != b->url_headers) {
  if (a->url_headers == NULL((void*)0)) return -1;
  if (b->url_headers == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_headers, b->url_headers)))
    return rv;
}

if (a->url_fragment != b->url_fragment) {
  if (a->url_fragment == NULL((void*)0)) return -1;
  if (b->url_fragment == NULL((void*)0)) return +1;
  if ((rv = strcmp(a->url_fragment, b->url_fragment)))
    return rv;
}

return 0;
1771}

1773/** Return default port number corresponding to the url type */
1774char const *url_port_default(enum url_type_e url_type)
1775{
switch (url_type) {
case url_sip:			/* "sip:" */
  return "5060";
case url_sips:		/* "sips:" */
  return "5061";
case url_http:		/* "http:" */
  return "80";
case url_https:		/* "https:" */
  return "443";
case url_ftp:			/* "ftp:" */
case url_file:		/* "file:" */
  return "21";
case url_rtsp:		/* "rtsp:" */
case url_rtspu:		/* "rtspu:" */
  return "554";
case url_mailto:		/* "mailto:" */
  return "25";

case url_any:			/* "*" */
  return "*";

case url_msrp:
case url_msrps:
  return "9999";		/* XXXX */

case url_tel:
case url_urn:
case url_fax:
case url_modem:
case url_im:
case url_pres:
case url_cid:
case url_wv:

default:			/* Unknown scheme */
  return "";
}
1813}

1815/** Return default transport name corresponding to the url type */
1816char const *url_tport_default(enum url_type_e url_type)
1817{
switch (url_type) {
case url_sip:
  return "*";
case url_sips:
  return "tls";
case url_http:
  return "tcp";
case url_https:
  return "tls";
case url_ftp:
case url_file:
  return "tcp";
case url_rtsp:
  return "tcp";
case url_rtspu:
  return "udp";
case url_mailto:
  return "tcp";
case url_msrp:
  return "tcp";
case url_msrps:
  return "tls";

case url_any:			/* "*" */
case url_tel:
case url_fax:
case url_modem:
case url_im:
case url_pres:
case url_cid:
case url_urn:
case url_wv:

default:			/* Unknown scheme */
  return "*";
}
1854}


1857/** Return the URL port string */
1858char const *url_port(url_t const *u)
1859{
if (!u)
  return "";
else if (u->url_port && u->url_port[0])
  return u->url_port;

if (u->url_type == url_sips || u->url_type == url_sip)
  if (!host_is_ip_address(u->url_host))
    return "";

return url_port_default((enum url_type_e)u->url_type);
1870}

1872/** Sanitize URL.
*
* The function url_sanitize() adds a scheme to an incomplete URL.  It
* modifies its parameter structure @a url.  Currently, the function follows
* simple heuristics:
*
* - URL with host name starting with @c ftp. is an FTP URL
* - URL with host name starting with @c www. is an HTTP URL
* - URL with host and path, e.g., @c host/foo;bar, is an HTTP URL
* - URL with host name, no path is a SIP URL.
*
* @param url pointer to URL struct to be sanitized (IN/OUT)
*
* @return
* The function url_sanitize() returns 0 if it considers URL to be
* sane, and -1 otherwise.
*/
1889int url_sanitize(url_t *url)
1890{
if (!url)
  return -1;
else if (url->url_scheme != NULL((void*)0))
  /* xyzzy */;
else if (url->url_host == NULL((void*)0))
  return -1;
else if (strncasecmp(url->url_host, "ftp.", strlen("ftp.")) == 0)
  url->url_type = url_ftp, url->url_scheme = "ftp", url->url_root = '/';
else if (strncasecmp(url->url_host, "www.", strlen("www.")) == 0
  || url->url_path)
  url->url_type = url_http, url->url_scheme = "http", url->url_root = '/';
else
  url->url_type = url_sip, url->url_scheme = "sip";

return 0;
1906}

1908#include <sofia-sip/su_md5.h>

1910static
1911void canon_update(su_md5_t *md5, char const *s, size_t n, char const *allow)
1912{
size_t i, j;

for (i = 0, j = 0; i < n && s[i]; i++) {
  char c;

  if (s[i] == '%' && i + 2 < n && IS_HEX(s[i+1])(((s[i+1]) >= '0' && (s[i+1]) <= '9') || ((s[i+
1]) >= 'A' && (s[i+1]) <= 'F') || ((s[i+1]) >=
 'a' && (s[i+1]) <= 'f')) && IS_HEX(s[i+2])(((s[i+2]) >= '0' && (s[i+2]) <= '9') || ((s[i+
2]) >= 'A' && (s[i+2]) <= 'F') || ((s[i+2]) >=
 'a' && (s[i+2]) <= 'f'))) {
1919#define   UNHEX(a) (a - (a >= 'a' ? 'a' - 10 : (a >= 'A' ? 'A' - 10 : '0')))
    c = (UNHEX(s[i+1]) << 4) | UNHEX(s[i+2]);
1921#undef    UNHEX
    if (c != '%' && c > ' ' && c < '\177' &&
 (!strchr(EXCLUDED";/?:@&=+$," "<>#%\"" "{}|\\^[]`", c) || strchr(allow, c))) {
if (i != j)
 su_md5_iupdate(md5, s + j, i - j);
su_md5_iupdate(md5, &c, 1);
j = i + 3;
    }
    i += 2;
  }
}

if (i != j)
  su_md5_iupdate(md5, s + j, i - j);
1935}

1937/** Update MD5 sum with url-string contents */
1938static
1939void url_string_update(su_md5_t *md5, char const *s)
1940{
size_t n, p;
int have_authority = 1;
enum url_type_e type = url_any;
char const *at, *colon;
char schema[48];

if (s == NULL((void*)0) || strlen(s) == 0 || strcmp(s, "*") == 0) {
6
←
Assuming the condition is false→
7
←
Assuming the condition is false→
8
←
Taking false branch→
  su_md5_update(md5, "*\0\0*", 4);
  return;
}

n = strcspn(s, ":/?#");
if (n >= sizeof schema) {
9
←
Assuming the condition is false→
10
←
Taking false branch→
  su_md5_update(md5, ":", 1);
}
else if (n && s[n] == ':' ) {
11
←
Assuming 'n' is not equal to 0→
12
←
Taking true branch→
  at = url_canonize(schema, s, n, 0, "+");
13
←
Calling 'url_canonize'→
19
←
Returning from 'url_canonize'→

  type = url_get_type(schema, at - schema);
20
←
Calling 'url_get_type'→
  su_md5_iupdate(md5, schema, at - schema);

  have_authority = !url_type_is_opaque(type);
  s += n + 1;
}
else {
  su_md5_update(md5, "", 1);
}

if (type == url_sip || type == url_sips) {
  /* SIP URL may have /;? in user part but no path */
  /* user-unreserved  =  "&" / "=" / "+" / "$" / "," / ";" / "?" / "/" */
  /* Some #*@#* phones include unescaped # there, too */
  n = strcspn(s, "@/;?#");
  p = strcspn(s + n, "@");
  if (s[n + p] == '@') {
    n += p;
    /* Ignore password in hash */
    colon = memchr(s, ':', n);
    p = colon ? (size_t)(colon - s) : n;
    canon_update(md5, s, p, SIP_USER_UNRESERVED"&=+$,;?/");
    s += n + 1; n = 0;
  }
  else
    su_md5_iupdate(md5, "", 1);	/* user */
  n += strcspn(s + n, "/;?#");
}
else if (have_authority) {
  if (type == url_wv) {    /* WV URL may have / in user part */
    n = strcspn(s, "@;?#");
  }
  else if (type != url_wv && s[0] == '/' && s[1] != '/') {
    /* foo:/bar */
    su_md5_update(md5, "\0\0", 2); /* user, host */
    su_md5_striupdate(md5, url_port_default(type));
    return;
  }
  else if (s[0] == '/' && s[1] == '/') {
    /* We have authority, / / foo or foo */
    s += 2;
    n = strcspn(s, "/?#@[]");
  }
  else
    n = strcspn(s, "@;/?#");

  if (s[n] == '@') {
    /* Ignore password in hash */
    colon = type != url_unknown ? memchr(s, ':', n) : NULL((void*)0);
    p = colon ? (size_t)(colon - s) : n;
    canon_update(md5, s, p, SIP_USER_UNRESERVED"&=+$,;?/");
    s += n + 1;
    n = strcspn(s, "/;?#");	/* Until path, query or fragment */
  }
  else {
    su_md5_iupdate(md5, "", 1);	/* user */
    n += strcspn(s + n, "/;?#");	/* Until path, query or fragment */
  }
}
else /* if (!have_authority) */ {
  n = strcspn(s, ":/;?#");	/* Until pass, path, query or fragment */

  canon_update(md5, s, n, ""); /* user */
  su_md5_update(md5, "\0", 1); /* host, no port */
  su_md5_striupdate(md5, url_port_default(type));
  return;
}

if (n > 0 && s[0] == '[') {	/* IPv6reference */
  colon = memchr(s, ']', n);
  if (colon == NULL((void*)0) || ++colon == s + n || *colon != ':')
    colon = NULL((void*)0);
}
else
  colon = memchr(s, ':', n);

if (colon) {
  canon_update(md5, s, colon - s, ""); /* host */
  canon_update(md5, colon + 1, (s + n) - (colon + 1), "");
}
else {
  canon_update(md5, s, n, ""); /* host */
  su_md5_strupdate(md5, url_port_default(type));	/* port */
}

/* ignore parameters/path/headers.... */
2045}


2048/** Update md5 digest with contents of URL.
*
*/
2051void url_update(su_md5_t *md5, url_t const *url)
2052{
if (url_string_p((url_string_t *)url)) {
4
←
Taking true branch→
  url_string_update(md5, (char const *)url);
5
←
Calling 'url_string_update'→
}
else {
  SU_MD5_STRI0UPDATE(md5, url->url_scheme)su_md5_iupdate(md5, (url->url_scheme) ? (url->url_scheme
) : "", (url->url_scheme) ? strlen(url->url_scheme) : 1
);
  SU_MD5_STRI0UPDATE(md5, url->url_user)su_md5_iupdate(md5, (url->url_user) ? (url->url_user) :
 "", (url->url_user) ? strlen(url->url_user) : 1);
  SU_MD5_STRI0UPDATE(md5, url->url_host)su_md5_iupdate(md5, (url->url_host) ? (url->url_host) :
 "", (url->url_host) ? strlen(url->url_host) : 1);
  su_md5_striupdate(md5, URL_PORT(url)((url) && (url)->url_port ? (url)->url_port : url_port_default
((url) ? (enum url_type_e)(url)->url_type : url_any)));
  /* XXX - parameters/path.... */
  /* SU_MD5_STRI0UPDATE(md5, url->url_path); */
}
2064}

2066/** Calculate a digest from URL contents. */
2067void url_digest(void *hash, int hsize, url_t const *url, char const *key)
2068{
su_md5_t md5[1];
uint8_t digest[SU_MD5_DIGEST_SIZE16];

su_md5_init(md5);
if (key) su_md5_strupdate(md5, key);
1
Assuming 'key' is null→
2
←
Taking false branch→
url_update(md5, url);
3
←
Calling 'url_update'→
su_md5_digest(md5, digest);

if (hsize > SU_MD5_DIGEST_SIZE16) {
  memset((char *)hash + SU_MD5_DIGEST_SIZE16, 0, hsize - SU_MD5_DIGEST_SIZE16);
  hsize = SU_MD5_DIGEST_SIZE16;
}

memcpy(hash, digest, hsize);
2083}

2085/** Convert a URL query to a header string.
*
* URL query is converted by replacing each "=" in header name "=" value
* pair with semicolon (":"), and the "&" separating header-name-value pairs
* with line feed ("\n"). The "body" pseudoheader is moved last in the
* string. The %-escaping is removed. Note that if the @a query contains %00,
* the resulting string will be truncated.
*
* @param home memory home used to alloate string (if NULL, malloc() it)
* @param query query part from SIP URL
*
* The result string is allocated from @a home, and it can be used as
* argument to msg_header_parse_str(), msg_header_add_str() or
* SIPTAG_HEADER_STR().
*
* @sa msg_header_add_str(), SIPTAG_HEADER_STR(),
* sip_headers_as_url_query(), sip_url_query_as_taglist(),
* @RFC3261 section 19.1.1 "Headers", #url_t, url_s#url_headers,
* url_unescape(), url_unescape_to()
*
* @since New in @VERSION_1_12_4.
*/
2107char *url_query_as_header_string(su_home_t *home,
		 char const *query)
2109{
size_t i, j, n, b_start = 0, b_len = 0;
char *s = su_strdup(home, query);

if (!s)
  return NULL((void*)0);

for (i = 0, j = 0; s[i];) {
  n = strcspn(s + i, "=");
  if (!s[i + n])
    break;
  if (n == 4 && strncasecmp(s + i, "body", 4) == 0) {
    if (b_start)
break;
    b_start = i + n + 1, b_len = strcspn(s + b_start, "&");
    i = b_start + b_len + 1;
    continue;
  }
  if (i != j)
    memmove(s + j, s + i, n);
  s[j + n] = ':';
  i += n + 1, j += n + 1;
  n = strcspn(s + i, "&");
  j += url_unescape_to(s + j, s + i, n);
  i += n;
  if (s[i]) {
    s[j++] = '\n', i++;
  }
}

if (s[i])
  return (void)su_free(home, s), NULL((void*)0);

if (b_start) {
  s[j++] = '\n', s[j++] = '\n';
  j += url_unescape_to(s + j, query + b_start, b_len);
}
s[j] = '\0'; assert(j <= i)((void) sizeof ((j <= i) ? 1 : 0), __extension__ ({ if (j <=
 i) ; else __assert_fail ("j <= i", "url.c", 2146, __extension__
 __PRETTY_FUNCTION__); }));

return s;
2149}

←

./../bnf/sofia-sip/bnf.h

1/*
2 * This file is part of the Sofia-SIP package
3 *
4 * Copyright (C) 2005 Nokia Corporation.
5 *
6 * Contact: Pekka Pessi <pekka.pessi@nokia.com>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 *
23 */
24 
25#ifndef BNF_H  /** Defined when <sofia-sip/bnf.h> has been included. */
26#define BNF_H
27 
28/**@file sofia-sip/bnf.h
29 *
30 * Parsing macros and prototypes for HTTP-like protocols.
31 *
32 * @author Pekka Pessi <Pekka.Pessi@nokia.com>
33 *
34 * @date Created: Tue Jun 06 10:59:34 2000 ppessi
35 *
36 */
37 
38#include <sofia-sip/su_types.h>
39 
40#include <string.h>
41 
42SOFIA_BEGIN_DECLS
43 
44/* Parsing tokens */
45/** Control characters. */
46#define CTL"\001\002\003\004\005\006\007" "\010\011\012\013\014\015\016\017"
 "\020\021\022\023\024\025\026\027" "\030\031\032\033\034\035\036\037"
 "\177" "\0"   "\001\002\003\004\005\006\007" \
47    "\010\011\012\013\014\015\016\017" \
48    "\020\021\022\023\024\025\026\027" \
49    "\030\031\032\033\034\035\036\037" "\177" "\0"
50/** Space */
51#define SP" "      " "
52/** Horizontal tab */
53#define HT"\t"      "\t"
54/** Carriage return */
55/*  CR conflicts with Windows SDK 10, so it is now _CR */
56#define _CR"\r"      "\r"
57/** Line feed */
58#define LF"\n"      "\n"
59/** Line-ending characters */
60#define CRLF"\r" "\n"     _CR"\r" LF"\n"
61/** Whitespace */
62#define WS" " "\t"       SP" " HT"\t"
63/** Linear whitespace */
64#define LWS" " "\t" "\r" "\n"      SP" " HT"\t" _CR"\r" LF"\n"
65/** Lower-case alphabetic characters */
66#define LOALPHA"abcdefghijklmnopqrstuvwxyz" "abcdefghijklmnopqrstuvwxyz"
67/** Upper-case alphabetic characters */
68#define UPALPHA"ABCDEFGHIJKLMNOPQRSTUVWXYZ" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
69/** Alphabetic characters */
70#define ALPHA"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"    LOALPHA"abcdefghijklmnopqrstuvwxyz" UPALPHA"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
71/** Digits */
72#define DIGIT"0123456789"   "0123456789"
73/** RTSP safe characters */
74#define SAFE"$-_."    "$-_." /* RTSP stuff */
75#define ALPHANUM"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" DIGIT"0123456789" ALPHA"abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
76#define HEX"0123456789" "ABCDEF" "abcdef"      DIGIT"0123456789" "ABCDEF" "abcdef"
77 
78/** SIP token characters.
79 * @note $|&^# were token chars in RFC 2543, but no more in RFC 3261.
80 */
81#define SIP_TOKEN"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "-.!%*_+`'~"  ALPHANUM"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "-.!%*_+`'~"
82/** SIP separator characters */
83#define SIP_SEPARATOR"()<>@,;:\\\"/[]?={}" " " "\t"  "()<>@,;:\\\"/[]?={}" SP" " HT"\t"
84 
85/** SIP Word characters (that are not token characters) */
86#define SIP_WORD"()<>:\\\"/[]?{}" "()<>:\\\"/[]?{}"
87 
88/** Skip whitespace (SP HT) */
89#define skip_ws(ss)(*(ss) += strspn(*(ss), " " "\t")) (*(ss) += span_ws(*(ss))strspn(*(ss), " " "\t"))
90 
91/** Skip linear whitespace (SP HT CR LF) */
92#define skip_lws(ss)(*(ss) += span_lws(*(ss))) (*(ss) += span_lws(*(ss)))
93 
94/** Skip [a-zA-Z] */
95#define skip_alpha(ss)(*(ss) += span_alpha(*(ss))) (*(ss) += span_alpha(*(ss)))
96 
97/** Skip digits */
98#define skip_digit(ss)(*(ss) += span_digit(*(ss))) (*(ss) += span_digit(*(ss)))
99 
100/** Skip characters belonging to an RTSP token. */
101#define skip_alpha_digit_safe(ss)(*(ss) += span_alpha_digit_safe(*(ss))) (*(ss) += span_alpha_digit_safe(*(ss)))
102 
103/** Skip characters belonging to a SIP token. */
104#define skip_token(ss)(*(ss) += span_token(*(ss)))  (*(ss) += span_token(*(ss)))
105 
106/** Skip characters belonging to a SIP parameter value. */
107#define skip_param(ss)(*(ss) += span_param(*(ss))) (*(ss) += span_param(*(ss)))
108 
109/** Skip characters belonging to a SIP word. */
110#define skip_word(ss)(*(ss) += span_word(*(ss))) (*(ss) += span_word(*(ss)))
111 
112/** Test if @c is CR or LF */
113#define IS_CRLF(c)((c) == '\r' || (c) == '\n')       ((c) == '\r' || (c) == '\n')
114/** Test if @c is linear whitespace */
115#define IS_LWS(c)((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n')  	 ((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n')
116/*#define IS_LWS(c)  	 ((_bnf_table[(unsigned char)(c)] & bnf_lws))*/
117/** Test if @c is normal whitespace */
118#define IS_WS(c)((c) == ' ' || (c) == '\t')   	 ((c) == ' ' || (c) == '\t')
119/** Test if @c is not whitespace (and not NUL). */
120#define IS_NON_WS(c)(c && !((c) == ' ' || (c) == '\t'))     (c && !IS_WS(c)((c) == ' ' || (c) == '\t'))
121/*#define IS_NON_WS(c)     (c && !(_bnf_table[(unsigned char)c] & bnf_ws))*/
122/** Test if @c is not linear whitespace (and not NUL). */
123#define IS_NON_LWS(c)(c && !((c) == ' ' || (c) == '\t' || (c) == '\r' || (
c) == '\n'))    (c && !IS_LWS(c)((c) == ' ' || (c) == '\t' || (c) == '\r' || (c) == '\n'))
124/*#define IS_NON_LWS(c)    (c && !(_bnf_table[(unsigned char)c] & bnf_lws))*/
125/** Test if @c is a digit. */
126#define IS_DIGIT(c)((c) >= '0' && (c) <= '9')   	 ((c) >= '0' && (c) <= '9')
127/** Test if @c is alphabetic. */
128#define IS_ALPHA(c)(c && ((_bnf_table[(unsigned char)c] & bnf_alpha)
))      (c && ((_bnf_table[(unsigned char)c] & bnf_alpha)))
129/** Test if @c is alphanumeric. */
130#define IS_ALPHANUM(c)(c && (((c) >= '0' && (c) <= '9') || (c
 && ((_bnf_table[(unsigned char)c] & bnf_alpha)))
))   (c && (IS_DIGIT(c)((c) >= '0' && (c) <= '9') || IS_ALPHA(c)(c && ((_bnf_table[(unsigned char)c] & bnf_alpha)
))))
131/** Test if @c is URL-unreserved. */
132#define IS_UNRESERVED(c)((_bnf_table[(unsigned char)c] & bnf_unreserved)) ((_bnf_table[(unsigned char)c] & bnf_unreserved))
133/** Test if @c is URL-reserved. */
134#define IS_RESERVED(c)(c && !(_bnf_table[(unsigned char)c] & bnf_unreserved
))   (c && !(_bnf_table[(unsigned char)c] & bnf_unreserved))
135/** Test if @c is valid in tokens. */
136#define IS_TOKEN(c)((_bnf_table[(unsigned char)c] & bnf_token))      ((_bnf_table[(unsigned char)c] & bnf_token))
137/** Test if @c is valid for SIP parameter value. */
138#define IS_PARAM(c)((_bnf_table[(unsigned char)c] & (bnf_token|bnf_param)))      ((_bnf_table[(unsigned char)c] & (bnf_token|bnf_param)))
139/** Test if @c is a hex digit. */
140#define IS_HEX(c)(((c) >= '0' && (c) <= '9') || ((c) >= 'A' &&
 (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))        (((c) >= '0' && (c) <= '9') || ((c) >= 'A' && (c) <= 'F') || ((c) >= 'a' && (c) <= 'f'))
141/** Test if @c is a linear whitespace or valid in tokens. */
142#define IS_TOKENLWS(c)((_bnf_table[(unsigned char)c] & (bnf_token|bn_lws)))   ((_bnf_table[(unsigned char)c] & (bnf_token|bn_lws)))
143 
144enum {
145  bnf_ws = 1,					/**< Whitespace character  */
146  bnf_crlf = 2,					/**< Line end character */
147  bnf_lws = 3,					/**< Linear whitespace */
148  bnf_alpha = 4,				/**< Alphabetic */
149  bnf_safe = 8,					/**< RTSP safe */
150  bnf_mark = 16,				/**< URL mark */
151  bnf_unreserved = bnf_alpha | bnf_mark,	/**< URL unreserved */
152  bnf_separator = 32,				/**< SIP separator */
153  /** SIP token, not alphabetic (0123456789-.!%*_+`'~) */
154  bnf_token0 = 64 | bnf_safe,
155  bnf_token = bnf_token0 | bnf_alpha,		/**< SIP token */
156  bnf_param0 = 128,				/**< SIP parameter, not token */
157  bnf_param = bnf_token | bnf_param0 /**< SIP/HTTP parameter */
158};
159 
160/** Table for determining class of a character. */
161SOFIAPUBVARextern unsigned char const _bnf_table[256];
162 
163/** Get number of characters before CRLF */
164#define span_non_crlf(s)strcspn(s, "\r" "\n") strcspn(s, _CR"\r" LF"\n")
165 
166/** Get number of characters before whitespace */
167#define span_non_ws(s)strcspn(s, " " "\t") strcspn(s, WS" " "\t")
168 
169/** Get number of whitespace characters */
170#define span_ws(s)strspn(s, " " "\t") strspn(s, WS" " "\t")
171 
172/** Get number of characters before linear whitespace */
173#define span_non_lws(s)strcspn(s, " " "\t" "\r" "\n") strcspn(s, LWS" " "\t" "\r" "\n")
174 
175/** Calculate span of a linear whitespace.
176 * LWS = [*WSP CRLF] 1*WSP
177 */
178su_inlinestatic inline isize_t span_lws(char const *s)
179{
180  char const *e = s;
181  int i = 0;
182  e += strspn(s, WS" " "\t");
183  if (e[i] == '\r') i++;
184  if (e[i] == '\n') i++;
185  if (IS_WS(e[i])((e[i]) == ' ' || (e[i]) == '\t'))
186    e += i + strspn(e + i, WS" " "\t");
187  return e - s;
188}
189 
190/** Calculate span of a token or linear whitespace characters.  */
191su_inlinestatic inline isize_t span_token_lws(char const *s)
192{
193  char const *e = s;
194  while (_bnf_table[(unsigned char)(*e)] & (bnf_token | bnf_lws))
195    e++;
196  return e - s;
197}
198 
199/** Calculate span of a token characters.  */
200su_inlinestatic inline isize_t span_token(char const *s)
201{
202  char const *e = s;
203  while (_bnf_table[(unsigned char)(*e)] & bnf_token)
204    e++;
205  return e - s;
206}
207 
208/** Calculate span of a alphabetic characters.  */
209su_inlinestatic inline isize_t span_alpha(char const *s)
210{
211  char const *e = s;
212  while (_bnf_table[(unsigned char)(*e)] & bnf_alpha)
213    e++;
214  return e - s;
215}
216 
217/** Calculate span of a digits.  */
218su_inlinestatic inline isize_t span_digit(char const *s)
219{
220  char const *e = s;
221  while (*e >= '0' && *e <= '9')
222    e++;
223  return e - s;
224}
225 
226/** Calculate span of a hex.  */
227su_inlinestatic inline isize_t span_hexdigit(char const *s)
228{
229  char const *e = s;
230  while (IS_HEX(*e)(((*e) >= '0' && (*e) <= '9') || ((*e) >= 'A'
 && (*e) <= 'F') || ((*e) >= 'a' && (*e
) <= 'f')))
231    e++;
232  return e - s;
233}
234 
235/** Calculate span of characters belonging to an RTSP token */
236su_inlinestatic inline isize_t span_alpha_digit_safe(char const *s)
237{
238  char const *e = s;
239  while (_bnf_table[(unsigned char)(*e)] & (bnf_alpha | bnf_safe))
240    e++;
241  return e - s;
242}
243 
244/** Calculate span of a characters valid in parameters.  */
245su_inlinestatic inline isize_t span_param(char const *s)
246{
247  char const *e = s;
248  while (IS_PARAM(*e)((_bnf_table[(unsigned char)*e] & (bnf_token|bnf_param))))
249    e++;
250  return e - s;
251}
252 
253/** Calculate span of a SIP word.  */
254su_inlinestatic inline isize_t span_word(char const *s)
255{
256  char const *e = s;
257  while (*e && (IS_TOKEN(*e)((_bnf_table[(unsigned char)*e] & bnf_token)) || strchr(SIP_WORD"()<>:\\\"/[]?{}", *e)))
258    e++;
259  return e - s;
260}
261 
262/** Calculate span of a unreserved characters.  */
263su_inlinestatic inline isize_t span_unreserved(char const *s)
264{
265  char const *e = s;
266  while (IS_UNRESERVED(*e)((_bnf_table[(unsigned char)*e] & bnf_unreserved)))
24
←
Loop condition is true.  Entering loop body→
25
←
Within the expansion of the macro 'IS_UNRESERVED':
a
Array subscript is undefined
267    e++;
268  return e - s;
269}
270 
271/** Calculate span of a double quoted string (with escaped chars inside) */
272su_inlinestatic inline isize_t span_quoted(char const *s)
273{
274  char const *b = s;
275 
276  if (*s++ != '"')
277    return 0;
278 
279  for (;;) {
280    s += strcspn(s, "\\\"");
281    if (!*s)
282      return 0;
283    if (*s++ == '"')
284      return s - b;
285    if (!*s++)
286      return 0;
287  }
288}
289 
290/* RFC 2396 defines URL chars */
291/** Reserved in URLs */
292#define URL_RESERVED";/?:=+$,"        ";/?:=+$,"
293 
294/** Non-alphanumeric characters without syntactical meaning. */
295#define URL_MARK"-_.!~*'()"            "-_.!~*'()"
296 
297/** Unreserved characters. */
298#define URL_UNRESERVED"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "-_.!~*'()" ALPHANUM"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" URL_MARK"-_.!~*'()"
299 
300/** URL hex escape. */
301#define URL_ESCAPED"%"    "%"
302#define URL_DELIMS"<>#%\""     "<>#%\""
303#define URL_UNWISE"{}|\\^[]`"     "{}|\\^[]`"
304#define URL_SCHEME"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "+-."     ALPHANUM"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ" "+-."
305 
306/** Get number of characters belonging to url scheme */
307#define span_url_scheme(s)strspn(s, "0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "+-.") strspn(s, URL_SCHEME"0123456789" "abcdefghijklmnopqrstuvwxyz" "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 "+-.")
308 
309SOFIAPUBFUN int span_ip4_address(char const *host);
310SOFIAPUBFUN int span_ip6_address(char const *host);
311SOFIAPUBFUN int span_ip6_reference(char const *host);
312SOFIAPUBFUN int span_ip_address(char const *host);
313SOFIAPUBFUN isize_t span_domain(char const *host);
314SOFIAPUBFUN isize_t span_host(char const *host);
315 
316SOFIAPUBFUN int scan_ip4_address(char **inout_host);
317SOFIAPUBFUN int scan_ip6_address(char **inout_host);
318SOFIAPUBFUN int scan_ip6_reference(char **inout_host);
319SOFIAPUBFUN int scan_ip_address(char **inout_host);
320SOFIAPUBFUN issize_t scan_domain(char **inout_host);
321SOFIAPUBFUN issize_t scan_host(char **inout_host);
322 
323SOFIA_END_DECLS
324 
325#endif /* !defined BNF_H */