./sofia-sip/su_tag

Bug Summary

File:	./sofia-sip/su_tag_inline.h
Warning:	line 74, column 7 Access to field 'tc_next' results in a dereference of a null pointer (loaded from field 'tt_class')

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 su_taglist.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 -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/su -ferror-limit 19 -fmessage-length 0 -fobjc-runtime=gcc -fdiagnostics-show-option -analyzer-output=html -o /drone/src/scan-build/2021-08-31-180424-363-1 -x c su_taglist.c -faddrsig

su_taglist.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/**@SU_TAG
*
* @CFILE su_taglist.c
*
* Implementation of tag items and lists.
*
* @author Pekka Pessi <Pekka.Pessi@nokia.com>
*
* @date Created: Tue Feb 20 20:03:38 2001 ppessi
*/

36#include "config.h"

38#include <stdlib.h>
39#include <string.h>
40#include <stdarg.h>
41#include <stdio.h>
42#include <limits.h>

44#if defined(va_copy)
45/* Xyzzy */
46#elif defined(__va_copy)
47#define va_copy(dst, src)__builtin_va_copy(dst, src) __va_copy((dst), (src))__builtin_va_copy((dst),(src))
48#else
49#define va_copy(dst, src)__builtin_va_copy(dst, src) (memcpy(&(dst), &(src), sizeof (va_list)))
50#endif

52#include <assert.h>

54#include <sofia-sip/su_config.h>

56#include <sofia-sip/su_tag.h>
57#include <sofia-sip/su_tag_class.h>
58#include <sofia-sip/su_tag_inline.h>
59#include <sofia-sip/su_tagarg.h>
60#include <sofia-sip/su_string.h>

62#ifndef HAVE_STRTOULL1
63#if !((defined(WIN32) || defined(_WIN32)) && (_MSC_VER >= 1800))
64unsigned longlonglong long strtoull(const char *, char **, int);
65#endif
66#endif

68/**@defgroup su_tag Tag Item Lists
*
* Object-oriented tag routines for Sofia utility library.
*
* The <sofia-sip/su_tag.h> defines a interface to object-oriented tag list routines.
* A tag list is a linear list (array) of tag items, tagi_t structures,
* terminated by a TAG_END() item. Each tag item has a label, tag, (@c
* t_tag) and a value (@c t_value). The tag is a pointer (tag_type_t) to a
* structure defining how the value should be interpreted, in other words,
* the name and the type of the value. The value or pointer to the actual
* value is stored as opaque data (tag_value_t). The tag item structure is
* defined as follows:
*
* @code
* typedef struct {
*   tag_type_t   t_tag;
*   tag_value_t  t_value;
* } tagi_t;
* @endcode
*
* The tag lists are central concept in the Sofia APIs. The tags lists can
* be used to a list of named arguments to a @ref tagarg "@em tagarg"
* function, to store variable amount of data in a memory area, and pass
* data between processes and threads.
*
* The tagged argument lists can be used like named arguments in
* higher-level languages. The argument list consists of tag-value pairs;
* tags specify the name and type of the value. All the tag items are not
* necessarily interpreted by the called function, but it can pass the list
* to other functions. This feature is used also by the Sofia APIs, the
* lower-layer settings and options are frequently passed through the
* upper-layer API in the tag lists.
*
* The tagged argument lists are constructed using special macros that
* expand to two function arguments, tag and value. Each tag item macro
* checks its arguments type so the tagged argument lists are typesafe if
* the list is correctly constructed.
*
* Each function documents the tags it accepts and also the tags it may pass
* to the lower layers (at least in theory).
*
* @par Special Tags
*
* There are a new special tags that are used to control and modify the tag
* list processing itself. These special tags are as follows:
* - TAG_NULL() or TAG_END() - indicates the end of tag list
* - TAG_SKIP() - indicates an empty (overwritten) tag item
* - TAG_NEXT() - contains a pointer to the next tag list.
*
* The tag type structures are declared as tag_typedef_t. They can be
* defined by the macros found in <sofia-sip/su_tag_class.h>. See nta_tag.c or
* su_tag_test.c for an example.
*
*/

123/**@class tag_class_s sofia-sip/su_tag_class.h <sofia-sip/su_tag_class.h>
*
* @brief Virtual function table for @ref su_tag "tags".
*
* The struct tag_class_s contains virtual function table for tags,
* specifying non-default behaviour of different tags. It provides functions
* for copying, matching, printing and converting the tagged values.
*/

132#ifdef longlonglong long
133typedef longlonglong long unsigned llu;
134#else
135typedef long unsigned llu;
136#endif

138/** Print a tag. */
139int t_snprintf(tagi_t const *t, char b[], size_t size)
140{
tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
int n, m;

n = snprintf(b, size, "%s::%s: ",
             tt->tt_ns ? tt->tt_ns : "",
      tt->tt_name ? tt->tt_name : "null");
if (n < 0)
  return n;

if ((size_t)n > size)
  size = n;

if (tt->tt_snprintftt_class->tc_snprintf)
  m = tt->tt_snprintftt_class->tc_snprintf(t, b + n, size - n);
else
  m = snprintf(b + n, size - n, "%llx", (llu)t->t_value);

if (m < 0)
  return m;

if (m == 0 && 0 < n && (size_t)n < size)
  b[--n] = '\0';

return n + m;
165}

167/** Get next tag item from list.
*/
169tagi_t *tl_next(tagi_t const *t)
170{
tag_type_t tt;

t = t_next(t);

for (tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null); t && tt->tt_nexttt_class->tc_next; tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null)) {
  t = tt->tt_nexttt_class->tc_next(t);
}

return (tagi_t *)t;
180}

182/**Move a tag list.
*
* The function tl_tmove() moves the tag list arguments to @a dst.  The @a
* dst must have big enough for all arguments.
*
* @param dst   pointer to the destination buffer
* @param size  sizeof @a dst
* @param t_tag,t_value,... tag list
*
* @return
* The function tl_tmove() returns number of tag list items initialized.
*/
194size_t tl_tmove(tagi_t *dst, size_t size,
tag_type_t t_tag, tag_value_t t_value, ...)
196{
size_t n = 0, N = size / sizeof(tagi_t);
tagi_t tagi[1];
va_list ap;

va_start(ap, t_value)__builtin_va_start(ap, t_value);

tagi->t_tag = t_tag, tagi->t_value = t_value;

for (;;) {
  assert((size_t)((char *)&dst[n] - (char *)dst) < size)((void) sizeof (((size_t)((char *)&dst[n] - (char *)dst) <
 size) ? 1 : 0), __extension__ ({ if ((size_t)((char *)&dst
[n] - (char *)dst) < size) ; else __assert_fail ("(size_t)((char *)&dst[n] - (char *)dst) < size"
, "su_taglist.c", 206, __extension__ __PRETTY_FUNCTION__); })
);
  if (n < N)
    dst[n] = *tagi;
  n++;
  if (t_end(tagi))
    break;

  tagi->t_tag = va_arg(ap, tag_type_t)__builtin_va_arg(ap, tag_type_t);
  tagi->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);
}

va_end(ap)__builtin_va_end(ap);

return n;
220}

222/**Move a tag list.
*
* The function tl_move() copies the tag list @a src to the buffer @a
* dst. The size of the @a dst list must be at least @c tl_len(src) bytes.
*
* @param dst pointer to the destination buffer
* @param src tag list to be moved
*
* @return
* The function tl_move() returns a pointer to the @a dst list after last
* moved element.
*/
234tagi_t *tl_move(tagi_t *dst, tagi_t const src[])
235{
do {
  dst = t_move(dst, src);
}
while ((src = t_next(src)));

return dst;
242}

244/** Calculate effective length of a tag list as bytes. */
245size_t tl_len(tagi_t const lst[])
246{
size_t len = 0;

do {
  len += t_len(lst);
}
while ((lst = t_next(lst)));

return len;
255}

257/** Calculate the size of extra memory areas associated with tag list. */
258size_t tl_xtra(tagi_t const lst[], size_t offset)
259{
size_t xtra = offset;

for (; lst; lst = t_next(lst))
  xtra += t_xtra(lst, xtra);

return xtra - offset;
266}

268/** Duplicate a tag list.
*
* Deep copy the tag list @a src to the buffer @a dst. Memory areas
* associated with @a src are copied to buffer at @a **bb.
*
* This is a rather low-level function. See tl_adup() for a more convenient
* functionality.
*
* The size of the @a dst buffer must be at least @c tl_len(src) bytes.  The
* size of buffer @a **bb must be at least @c tl_dup_xtra(src) bytes.
*
* @param[out] dst pointer to the destination buffer
* @param[in] src tag list to be duplicated
* @param[in,out] bb  pointer to pointer to buffer
*
* @return
* A pointer to the @a dst list after last
* duplicated taglist element.
*
* The pointer at @a *bb is updated to the byte after last duplicated memory
* area.
*/
290tagi_t *tl_dup(tagi_t dst[], tagi_t const src[], void **bb)
291{
do {
  dst = t_dup(dst, src, bb);
} while ((src = t_next(src)));

return dst;
297}


300/** Free a tag list.
*
* The function tl_free() frees resources associated with a tag list.
* In other words, it calls t_free on each tag item on the list.
*
*/
306void tl_free(tagi_t list[])
307{
while (list)
  list = t_free(list);
310}

312/** Allocate and duplicate a tag list using memory home. */
313tagi_t *tl_adup(su_home_t *home, tagi_t const lst[])
314{
size_t len = tl_len(lst);
size_t xtra = tl_xtra(lst, 0);
void *b = su_alloc(home, len + xtra);
tagi_t *d, *newlst = b;

void *end = (char *)b + len + xtra;
tagi_t *tend = (tagi_t*)((char *)b + len);

b = (char *)b + len;

d = tl_dup(newlst, lst, &b);

assert(b == end)((void) sizeof ((b == end) ? 1 : 0), __extension__ ({ if (b ==
 end) ; else __assert_fail ("b == end", "su_taglist.c", 327, __extension__
 __PRETTY_FUNCTION__); })); assert(tend == d)((void) sizeof ((tend == d) ? 1 : 0), __extension__ ({ if (tend
 == d) ; else __assert_fail ("tend == d", "su_taglist.c", 327
, __extension__ __PRETTY_FUNCTION__); })); (void)end; (void)tend;

return newlst;
330}

332/** Allocate and duplicate tagged arguments as a tag list using memory home. */
333tagi_t *tl_tlist(su_home_t *home, tag_type_t tag, tag_value_t value, ...)
334{
tagi_t *tl;
ta_list ta;

ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);
tl = tl_adup(home, ta_args(ta)(ta).tl);
ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));

return tl;
343}

345/** Find first tag item with type @a tt from list. */
346tagi_t *tl_find(tagi_t const lst[], tag_type_t tt)
347{
return (tagi_t *)t_find(tt, lst);
349}

351/** Find last tag item with type @a tt from list. */
352tagi_t *tl_find_last(tagi_t const lst[], tag_type_t tt)
353{
tagi_t const *last, *next;

for (next = last = t_find(tt, lst); next; next = t_find(tt, t_next(last)))
  last = next;

return (tagi_t *)last;
360}

362su_inlinestatic inline
363int t_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
364{
if (value == NULL((void*)0))
  return 0;

if (tt->tt_class->tc_ref_set)
  return tt->tt_class->tc_ref_set(tt, ref, value);

*(tag_value_t *)ref = value->t_value;

return 1;
374}

376static int tl_get(tag_type_t tt, void *p, tagi_t const lst[])
377{
tagi_t const *t, *latest = NULL((void*)0);

assert(tt)((void) sizeof ((tt) ? 1 : 0), __extension__ ({ if (tt) ; else
 __assert_fail ("tt", "su_taglist.c", 380, __extension__ __PRETTY_FUNCTION__
); }));

if (tt == NULL((void*)0) || p == NULL((void*)0))
  return 0;

if (tt->tt_class == ref_tag_class)
  tt = (tag_type_t)tt->tt_magic;

for (t = t_find(tt, lst); t; t = t_find(tt, t_next(t)))
  latest = t;

return t_ref_set(tt, p, latest);
392}

394/** Find tags from given list. */
395int tl_gets(tagi_t const lst[], tag_type_t tag, tag_value_t value, ...)
396{
int n = 0;
tagi_t *t;
ta_list ta;

ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);
1
Within the expansion of the macro 'ta_start':
→
a
Assuming 'ta_start__tag' is not equal to ta_start

for (t = ta_args(ta)(ta).tl; t; t = (tagi_t *)t_next(t)) {
2
←
Loop condition is true.  Entering loop body→
6
←
Calling 't_next'→
  tag_type_t tt = t->t_tag;

  if (!tt)
3
←
Taking false branch→
    continue;

  if (tt->tt_class == ref_tag_class) {
4
←
Taking false branch→
    assert(((tag_type_t)tt->tt_magic)->tt_class->tc_ref_set)((void) sizeof ((((tag_type_t)tt->tt_magic)->tt_class->
tc_ref_set) ? 1 : 0), __extension__ ({ if (((tag_type_t)tt->
tt_magic)->tt_class->tc_ref_set) ; else __assert_fail (
"((tag_type_t)tt->tt_magic)->tt_class->tc_ref_set", "su_taglist.c"
, 410, __extension__ __PRETTY_FUNCTION__); }));
    n += tl_get(tt, (void *)t->t_value, lst);
  }
413#if !defined(NDEBUG)
  else if (tt->tt_class && tt->tt_class->tc_ref_set) {
5
←
Assuming pointer value is null→
    fprintf(stderrstderr, "WARNING: tag %s::%s directly used by tl_gets()\n",
	  tt->tt_ns ? tt->tt_ns : "", tt->tt_name ? tt->tt_name : "");
    assert(tt->tt_class == ref_tag_class)((void) sizeof ((tt->tt_class == ref_tag_class) ? 1 : 0), __extension__
 ({ if (tt->tt_class == ref_tag_class) ; else __assert_fail
 ("tt->tt_class == ref_tag_class", "su_taglist.c", 417, __extension__
 __PRETTY_FUNCTION__); }));
  }
419#endif
}

ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));

return n;
425}

427/** Find tags from given list.
*
* Copies values of argument tag list into the reference tags in the tag
* list @a lst.
*
* @sa tl_gets()
*/
434int tl_tgets(tagi_t lst[], tag_type_t tag, tag_value_t value, ...)
435{
int n = 0;
tagi_t *t;

ta_list ta;
ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);

for (t = lst; t; t = (tagi_t *)t_next(t)) {
  tag_type_t tt = t->t_tag;

  if (!tt)
    continue;

  if (tt->tt_class == ref_tag_class) {
    assert(((tag_type_t)tt->tt_magic)->tt_class->tc_ref_set)((void) sizeof ((((tag_type_t)tt->tt_magic)->tt_class->
tc_ref_set) ? 1 : 0), __extension__ ({ if (((tag_type_t)tt->
tt_magic)->tt_class->tc_ref_set) ; else __assert_fail (
"((tag_type_t)tt->tt_magic)->tt_class->tc_ref_set", "su_taglist.c"
, 449, __extension__ __PRETTY_FUNCTION__); }));
    n += tl_get(tt, (void *)t->t_value, ta_args(ta)(ta).tl);
  }
452#if !defined(NDEBUG)
  else if (tt->tt_class->tc_ref_set) {
    fprintf(stderrstderr, "WARNING: tag %s::%s used in tl_tgets(lst)\n",
     tt->tt_ns, tt->tt_name);
    assert(tt->tt_class == ref_tag_class)((void) sizeof ((tt->tt_class == ref_tag_class) ? 1 : 0), __extension__
 ({ if (tt->tt_class == ref_tag_class) ; else __assert_fail
 ("tt->tt_class == ref_tag_class", "su_taglist.c", 456, __extension__
 __PRETTY_FUNCTION__); }));
  }
458#endif
}

ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));

return n;
464}


467/** Filter an element in tag list */
468tagi_t *t_filter(tagi_t *dst,
 tagi_t const filter[],
 tagi_t const *src,
 void **bb)
472{
tag_type_t tt = TAG_TYPE_OF(src)((src) && (src)->t_tag ? (src)->t_tag : tag_null
);
tagi_t const *f;

if (dst) {
  for (f = filter; f; f = t_next(f)) {
    if (TAG_TYPE_OF(f)((f) && (f)->t_tag ? (f)->t_tag : tag_null)->tt_filtertt_class->tc_filter)
dst = TAG_TYPE_OF(f)((f) && (f)->t_tag ? (f)->t_tag : tag_null)->tt_filtertt_class->tc_filter(dst, f, src, bb);
    else if (f->t_tag == tt)
dst = t_dup(dst, src, bb);
  }
}
else {
  size_t d = 0;

  for (f = filter; f; f = t_next(f)) {
    tag_type_t tt_f = TAG_TYPE_OF(f)((f) && (f)->t_tag ? (f)->t_tag : tag_null);
    if (tt_f->tt_filtertt_class->tc_filter)
d += (size_t)tt_f->tt_filtertt_class->tc_filter(NULL((void*)0), f, src, bb);
    else if (tt == f->t_tag) {
d += t_len(src);
*bb = (char *)*bb + t_xtra(src, (size_t)*bb);
    }
  }

  dst = (tagi_t *)d;
}

return dst;
501}

503/** Make filtered copy of a tag list @a src with @a filter to @a dst.
*
* Each tag in @a src is checked against tags in list @a filter. If the tag
* is in the @a filter list, or there is a special filter tag in the list
* which matches with the tag in @a src, the tag is duplicated to @a dst using
* memory buffer in @a b.
*
* When @a dst is NULL, this function calculates the size of the filtered list.
*
* @sa tl_afilter(), tl_tfilter(), tl_filtered_tlist(),
* TAG_FILTER(), TAG_ANY(), #ns_tag_class
*/
515tagi_t *tl_filter(tagi_t dst[],
  tagi_t const filter[],
  tagi_t const src[],
  void **b)
519{
tagi_t const *s;
tagi_t *d;

if (dst) {
  for (s = src, d = dst; s; s = t_next(s))
    d = t_filter(d, filter, s, b);
}
else {
  size_t rv = 0;

  for (s = src, d = dst; s; s = t_next(s)) {
    d = t_filter(NULL((void*)0), filter, s, b);
    rv += (char *)d - (char *)NULL((void*)0);
  }

  d = (tagi_t *)rv;
}

return d;
539}



543/**Filter a tag list.
*
* The function tl_afilter() will build a tag list containing tags specified
* in @a filter and extracted from @a src.  It will allocate the memory used by
* tag list via the specified memory @a home, which may be also @c NULL.
*
* @sa tl_afilter(), tl_tfilter(), tl_filtered_tlist(),
* TAG_FILTER(), TAG_ANY(), #ns_tag_class
*/
552tagi_t *tl_afilter(su_home_t *home, tagi_t const filter[], tagi_t const src[])
553{
tagi_t *dst, *d, *t_end = NULL((void*)0);
void *b, *end = NULL((void*)0);
size_t len;

/* Calculate length of the result */
t_end = tl_filter(NULL((void*)0), filter, src, &end);
len = ((char *)t_end - (char *)NULL((void*)0)) + ((char *)end - (char*)NULL((void*)0));

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

/* Allocate the result */
if (!(dst = su_alloc(home, len)))
  return NULL((void*)0);

/* Build the result */
b = (dst + (t_end - (tagi_t *)NULL((void*)0)));
d = tl_filter(dst, filter, src, (void **)&b);

/* Ensure that everything is consistent */
assert(d == dst + (t_end - (tagi_t *)NULL))((void) sizeof ((d == dst + (t_end - (tagi_t *)((void*)0))) ?
: 0), __extension__ ({ if (d == dst + (t_end - (tagi_t *)(
(void*)0))) ; else __assert_fail ("d == dst + (t_end - (tagi_t *)NULL)"
, "su_taglist.c", 574, __extension__ __PRETTY_FUNCTION__); })
);
assert(b == (char *)dst + len)((void) sizeof ((b == (char *)dst + len) ? 1 : 0), __extension__
 ({ if (b == (char *)dst + len) ; else __assert_fail ("b == (char *)dst + len"
, "su_taglist.c", 575, __extension__ __PRETTY_FUNCTION__); })
);

return dst;
578}

580/** Filter tag list @a src with given tags.
*
* @sa tl_afilter(), tl_filtered_tlist(), TAG_FILTER(), TAG_ANY(), #ns_tag_class
*/
584tagi_t *tl_tfilter(su_home_t *home, tagi_t const src[],
   tag_type_t tag, tag_value_t value, ...)
586{
tagi_t *tl;
ta_list ta;
ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);
tl = tl_afilter(home, ta_args(ta)(ta).tl, src);
ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));
return tl;
593}

595/** Create a filtered tag list.
*
* @sa tl_afilter(), tl_tfilter(), TAG_FILTER(), TAG_ANY(), #ns_tag_class
*/
599tagi_t *tl_filtered_tlist(su_home_t *home, tagi_t const filter[],
	  tag_type_t tag, tag_value_t value, ...)
601{
tagi_t *tl;
ta_list ta;

ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);
tl = tl_afilter(home, filter, ta_args(ta)(ta).tl);
ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));

return tl;
610}


613/** Remove listed tags from the list @a lst. */
614int tl_tremove(tagi_t lst[], tag_type_t tag, tag_value_t value, ...)
615{
tagi_t *l, *l_next;
int retval = 0;
ta_list ta;

ta_start(ta, tag, value)do { tag_type_t ta_start__tag = (tag); tag_value_t ta_start__value
 = (value); __builtin_va_start((ta).ap, (value)); while ((ta_start__tag
) == tag_next && (ta_start__value) != 0) { ta_start__tag
 = ((tagi_t *)ta_start__value)->t_tag; if (ta_start__tag ==
 tag_null || ta_start__tag == ((void*)0)) break; if (ta_start__tag
 == tag_next) { ta_start__value = ((tagi_t *)ta_start__value)
->t_value; } else { ta_start__tag = tag_next; break; } } (
ta).tl->t_tag = ta_start__tag; (ta).tl->t_value = ta_start__value
; if (ta_start__tag != ((void*)0) && ta_start__tag !=
 tag_null && ta_start__tag != tag_next) { va_list ta_start__ap
; __builtin_va_copy((ta_start__ap), ((ta).ap)); (ta).tl[1].t_tag
 = tag_next; (ta).tl[1].t_value = (tag_value_t)tl_vlist(ta_start__ap
); __builtin_va_end(ta_start__ap); } else { (ta).tl[1].t_value
 = 0; (ta).tl[1].t_value = (tag_value_t)0; } } while(0);

for (l = lst; l; l = l_next) {
  if ((l_next = (tagi_t *)t_next(l))) {
    if (tl_find(ta_args(ta)(ta).tl, l->t_tag))
l->t_tag = tag_skip;
    else
retval++;
  }
}

ta_end(ta)((((ta).tl[1].t_value) ? (tl_vfree((tagi_t *)((ta).tl[1].t_value
))) : (void)0), (ta).tl[1].t_value = 0, __builtin_va_end((ta)
.ap));

return retval;
634}

636/** Calculate length of a tag list with a @c va_list. */
637size_t tl_vlen(va_list ap)
638{
size_t len = 0;
tagi_t tagi[2] = {{ NULL((void*)0) }};

do {
  tagi->t_tag = va_arg(ap, tag_type_t )__builtin_va_arg(ap, tag_type_t);
  tagi->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);
  len += sizeof(tagi_t);
} while (!t_end(tagi));

return len;
649}

651/** Convert va_list to tag list */
652tagi_t *tl_vlist(va_list ap)
653{
tagi_t *t, *rv;
va_list aq;

va_copy(aq, ap)__builtin_va_copy(aq, ap);
rv = malloc(tl_vlen(aq));
va_end(aq)__builtin_va_end(aq);

for (t = rv; t; t++) {
  t->t_tag = va_arg(ap, tag_type_t)__builtin_va_arg(ap, tag_type_t);
  t->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);

  if (t_end(t))
    break;
}

return rv;
670}

672tagi_t *tl_vlist2(tag_type_t tag, tag_value_t value, va_list ap)
673{
tagi_t *t, *rv;
tagi_t tagi[1];
size_t size;

tagi->t_tag = tag, tagi->t_value = value;

if (!t_end(tagi)) {
  va_list aq;
  va_copy(aq, ap)__builtin_va_copy(aq, ap);
  size = sizeof(tagi) + tl_vlen(aq);
  va_end(aq)__builtin_va_end(aq);
}
else
  size = sizeof(tagi);

t = rv = malloc(size);

for (;t;) {
  *t++ = *tagi;

  if (t_end(tagi))
    break;

  tagi->t_tag = va_arg(ap, tag_type_t)__builtin_va_arg(ap, tag_type_t);
  tagi->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);
}

assert((char *)rv + size == (char *)t)((void) sizeof (((char *)rv + size == (char *)t) ? 1 : 0), __extension__
 ({ if ((char *)rv + size == (char *)t) ; else __assert_fail (
"(char *)rv + size == (char *)t", "su_taglist.c", 701, __extension__
 __PRETTY_FUNCTION__); }));

return rv;
704}

706/** Make a tag list until TAG_NEXT() or TAG_END() */
707tagi_t *tl_list(tag_type_t tag, tag_value_t value, ...)
708{
va_list ap;
tagi_t *t;

va_start(ap, value)__builtin_va_start(ap, value);
t = tl_vlist2(tag, value, ap);
va_end(ap)__builtin_va_end(ap);

return t;
717}

719/** Calculate length of a linear tag list. */
720size_t tl_vllen(tag_type_t tag, tag_value_t value, va_list ap)
721{
size_t len = sizeof(tagi_t);
tagi_t const *next;
tagi_t tagi[3];

tagi[0].t_tag = tag;
tagi[0].t_value = value;
tagi[1].t_tag = tag_any;
tagi[1].t_value = 0;

for (;;) {
  next = tl_next(tagi);
  if (next != tagi + 1)
    break;

  if (tagi->t_tag != tag_skip)
    len += sizeof(tagi_t);
  tagi->t_tag = va_arg(ap, tag_type_t)__builtin_va_arg(ap, tag_type_t);
  tagi->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);
}

for (; next; next = tl_next(next))
  len += sizeof(tagi_t);

return len;
746}

748/** Make a linear tag list. */
749tagi_t *tl_vllist(tag_type_t tag, tag_value_t value, va_list ap)
750{
va_list aq;
tagi_t *t, *rv;
tagi_t const *next;
tagi_t tagi[2];

size_t size;

va_copy(aq, ap)__builtin_va_copy(aq, ap);
size = tl_vllen(tag, value, aq);
va_end(aq)__builtin_va_end(aq);

t = rv = malloc(size);
if (rv == NULL((void*)0))
  return rv;

tagi[0].t_tag = tag;
tagi[0].t_value = value;
tagi[1].t_tag = tag_any;
tagi[1].t_value = 0;

for (;;) {
  next = tl_next(tagi);
  if (next != tagi + 1)
    break;

  if (tagi->t_tag != tag_skip)
    *t++ = *tagi;

  tagi->t_tag = va_arg(ap, tag_type_t)__builtin_va_arg(ap, tag_type_t);
  tagi->t_value = va_arg(ap, tag_value_t)__builtin_va_arg(ap, tag_value_t);
}

for (; next; next = tl_next(next))
  *t++ = *next;

t->t_tag = NULL((void*)0); t->t_value = 0; t++;

assert((char *)rv + size == (char *)t)((void) sizeof (((char *)rv + size == (char *)t) ? 1 : 0), __extension__
 ({ if ((char *)rv + size == (char *)t) ; else __assert_fail (
"(char *)rv + size == (char *)t", "su_taglist.c", 788, __extension__
 __PRETTY_FUNCTION__); }));

return rv;
791}

793/** Make a linear tag list until TAG_END().
*
*/
796tagi_t *tl_llist(tag_type_t tag, tag_value_t value, ...)
797{
va_list ap;
tagi_t *t;

va_start(ap, value)__builtin_va_start(ap, value);
t = tl_vllist(tag, value, ap);
va_end(ap)__builtin_va_end(ap);

return t;
806}

808/** Free a tag list allocated by tl_list(), tl_llist() or tl_vlist(). */
809void tl_vfree(tagi_t *t)
810{
if (t)
  free(t);
813}

815/** Convert a string to the a value of a tag. */
816int t_scan(tag_type_t tt, su_home_t *home, char const *s,
  tag_value_t *return_value)
818{
if (tt == NULL((void*)0) || s == NULL((void*)0) || return_value == NULL((void*)0))
  return -1;

if (tt->tt_class->tc_scan) {
  return tt->tt_class->tc_scan(tt, home, s, return_value);
}
else {			/* Not implemented */
  *return_value = (tag_value_t)0;
  return -2;
}
829}


832/* ====================================================================== */
833/* null tag */

835static
836tagi_t const *t_null_next(tagi_t const *t)
837{
return NULL((void*)0);
839}

841static
842tagi_t *t_null_move(tagi_t *dst, tagi_t const *src)
843{
memset(dst, 0, sizeof(*dst));
return dst + 1;
846}

848static
849tagi_t *t_null_dup(tagi_t *dst, tagi_t const *src, void **bb)
850{
memset(dst, 0, sizeof(*dst));
return dst + 1;
853}

855static
856tagi_t const * t_null_find(tag_type_t tt, tagi_t const lst[])
857{
return NULL((void*)0);
859}

861tagi_t *t_null_filter(tagi_t *dst,
      tagi_t const filter[],
      tagi_t const *src,
      void **bb)
865{
if (TAG_TYPE_OF(src)((src) && (src)->t_tag ? (src)->t_tag : tag_null
) == tag_null) {
  if (dst) {
    dst->t_tag = NULL((void*)0);
    dst->t_value = 0;
  }
  return dst + 1;
}
return dst;
874}

876tag_class_t null_tag_class[1] =
{{
  sizeof(null_tag_class),
  /* tc_next */     t_null_next,
  /* tc_len */      NULL((void*)0),
  /* tc_move */     t_null_move,
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      t_null_dup,
  /* tc_free */     NULL((void*)0),
  /* tc_find */     t_null_find,
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_null_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

892tag_typedef_t tag_null = TAG_TYPEDEF(tag_null, null){{ "", "tag_null", null_tag_class, 0 }};

894/* ====================================================================== */
895/* end tag */

897tagi_t *t_end_filter(tagi_t *dst,
     tagi_t const filter[],
     tagi_t const *src,
     void **bb)
901{
return dst;
903}

905tag_class_t end_tag_class[1] =
{{
  sizeof(end_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_end_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

921/* ====================================================================== */
922/* skip tag - placeholder in tag list */

924static
925tagi_t const *t_skip_next(tagi_t const *t)
926{
return t + 1;
928}

930static
931tagi_t *t_skip_move(tagi_t *dst, tagi_t const *src)
932{
return dst;
934}

936static
937size_t t_skip_len(tagi_t const *t)
938{
return 0;
940}

942static
943tagi_t *t_skip_dup(tagi_t *dst, tagi_t const *src, void **bb)
944{
return dst;
946}

948static
949tagi_t *t_skip_filter(tagi_t *dst,
    tagi_t const filter[],
    tagi_t const *src,
    void **bb)
953{
return dst;
955}

957tag_class_t skip_tag_class[1] =
{{
  sizeof(skip_tag_class),
  /* tc_next */     t_skip_next,
  /* tc_len */      t_skip_len,
  /* tc_move */     t_skip_move,
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      t_skip_dup,
  /* tc_free */     NULL((void*)0),
  /* tc_find */     t_null_find,
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_skip_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

973tag_typedef_t tag_skip = TAG_TYPEDEF(tag_skip, skip){{ "", "tag_skip", skip_tag_class, 0 }};

975/* ====================================================================== */
976/* next tag - jump to next tag list */

978static
979tagi_t const *t_next_next(tagi_t const *t)
980{
return (tagi_t *)(t->t_value);
982}

984static
985tagi_t *t_next_move(tagi_t *dst, tagi_t const *src)
986{
if (!src->t_value)
  return t_null_move(dst, src);
return dst;
990}

992static
993size_t t_next_len(tagi_t const *t)
994{
if (!t->t_value)
  return sizeof(*t);
return 0;
998}

1000static
1001tagi_t *t_next_dup(tagi_t *dst, tagi_t const *src, void **bb)
1002{
if (!src->t_value)
  return t_null_dup(dst, src, bb);
return dst;
1006}

1008static
1009tagi_t *t_next_filter(tagi_t *dst,
    tagi_t const filter[],
    tagi_t const *src,
    void **bb)
1013{
return dst;
1015}

1017tag_class_t next_tag_class[1] =
{{
  sizeof(next_tag_class),
  /* tc_next */     t_next_next,
  /* tc_len */      t_next_len,
  /* tc_move */     t_next_move,
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      t_next_dup,
  /* tc_free */     NULL((void*)0),
  /* tc_find */     t_null_find,
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_next_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

1033tag_typedef_t tag_next = TAG_TYPEDEF(tag_next, next){{ "", "tag_next", next_tag_class, 0 }};

1035/* ====================================================================== */
1036/* filter tag  - use function to filter tag */

1038static
1039tagi_t *t_filter_with(tagi_t *dst,
      tagi_t const *t,
      tagi_t const *src,
      void **bb)
1043{
tag_filter_f *function;

if (!src || !t)
  return dst;

function = (tag_filter_f *)t->t_value;

if (!function || !function(t, src))
  return dst;

if (dst) {
  return t_dup(dst, src, bb);
}
else {
  dst = (tagi_t *)((char *)dst + t_len(src));
  *bb = (char *)*bb + t_xtra(src, (size_t)*bb);
  return dst;
}
1062}

1064tag_class_t filter_tag_class[1] =
{{
  sizeof(filter_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_filter_with,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

1080/** Filter tag - apply function in order to filter tag. */
1081tag_typedef_t tag_filter = TAG_TYPEDEF(tag_filter, filter){{ "", "tag_filter", filter_tag_class, 0 }};

1083/* ====================================================================== */
1084/* any tag - match to any tag when filtering */

1086static
1087tagi_t *t_any_filter(tagi_t *dst,
     tagi_t const filter[],
     tagi_t const *src,
     void **bb)
1091{
if (!src)
  return dst;
else if (dst) {
  return t_dup(dst, src, bb);
}
else {
  dst = (tagi_t *)((char *)dst + t_len(src));
  *bb = (char *)*bb + t_xtra(src, (size_t)*bb);
  return dst;
}
1102}

1104tag_class_t any_tag_class[1] =
{{
  sizeof(any_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_any_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

1120/** Any tag - match any tag when filtering. */
1121tag_typedef_t tag_any = TAG_TYPEDEF(tag_any, any){{ "", "tag_any", any_tag_class, 0 }};

1123/* ====================================================================== */
1124/* ns tag - match to any tag with same namespace when filtering */

1126static
1127tagi_t *t_ns_filter(tagi_t *dst,
    tagi_t const filter[],
    tagi_t const *src,
    void **bb)
1131{
char const *match, *ns;

if (!src)
  return dst;

assert(filter)((void) sizeof ((filter) ? 1 : 0), __extension__ ({ if (filter
) ; else __assert_fail ("filter", "su_taglist.c", 1137, __extension__
 __PRETTY_FUNCTION__); }));

match = TAG_TYPE_OF(filter)((filter) && (filter)->t_tag ? (filter)->t_tag :
 tag_null)->tt_ns;
ns = TAG_TYPE_OF(src)((src) && (src)->t_tag ? (src)->t_tag : tag_null
)->tt_ns;

if (match == NULL((void*)0))
  /* everything matches with this */;
else if (match == ns)
  /* namespaces matche */;
else if (ns == NULL((void*)0))
  /* no match */
  return dst;
else if (strcmp(match, ns))
  /* no match */
  return dst;

if (dst) {
  return t_dup(dst, src, bb);
}
else {
  dst = (tagi_t *)((char *)dst + t_len(src));
  *bb = (char *)*bb + t_xtra(src, (size_t)*bb);
  return dst;
}
1161}

1163/** Namespace filtering class */
1164tag_class_t ns_tag_class[1] =
{{
  sizeof(ns_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ NULL((void*)0),
  /* tc_filter */   t_ns_filter,
  /* tc_ref_set */  NULL((void*)0),
  /* tc_scan */     NULL((void*)0),
}};

1180/* ====================================================================== */
1181/* int tag - pass integer value */

1183int t_int_snprintf(tagi_t const *t, char b[], size_t size)
1184{
return snprintf(b, size, "%i", (int)t->t_value);
1186}

1188int t_int_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1189{
*(int *)ref = (int)value->t_value;

return 1;
1193}

1195int t_int_scan(tag_type_t tt, su_home_t *home,
      char const *s,
      tag_value_t *return_value)
1198{
int value;
char *rest;

value = strtol(s, &rest, 0);

if (s != rest) {
  *return_value = (tag_value_t)value;
  return 1;
}
else {
  *return_value = (tag_value_t)0;
  return -1;
}
1212}

1214tag_class_t int_tag_class[1] =
{{
  sizeof(int_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_int_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_int_ref_set,
  /* tc_scan */     t_int_scan,
}};

1230/* ====================================================================== */
1231/* uint tag - pass unsigned integer value */

1233int t_uint_snprintf(tagi_t const *t, char b[], size_t size)
1234{
return snprintf(b, size, "%u", (unsigned)t->t_value);
1236}

1238int t_uint_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1239{
*(unsigned *)ref = (unsigned)value->t_value;

return 1;
1243}

1245int t_uint_scan(tag_type_t tt, su_home_t *home,
      char const *s,
      tag_value_t *return_value)
1248{
unsigned value;
char *rest;

value = strtoul(s, &rest, 0);

if (s != rest) {
  *return_value = (tag_value_t)value;
  return 1;
}
else {
  *return_value = (tag_value_t)0;
  return -1;
}
1262}

1264tag_class_t uint_tag_class[1] =
{{
  sizeof(int_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_uint_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_uint_ref_set,
  /* tc_scan */     t_uint_scan,
}};


1281/* ====================================================================== */
1282/* size tag - pass size_t value @NEW_1_12_5 */

1284static
1285int t_size_snprintf(tagi_t const *t, char b[], size_t size)
1286{
return snprintf(b, size, MOD_ZU"%zu", (size_t)t->t_value);
1288}

1290static
1291int t_size_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1292{
*(size_t *)ref = (size_t)value->t_value;

return 1;
1296}

1298static
1299int t_size_scan(tag_type_t tt, su_home_t *home,
 char const *s,
 tag_value_t *return_value)
1302{
unsigned longlonglong long value;
char *rest;

value = strtoull(s, &rest, 0);

if (s != rest && value <= SIZE_MAX(18446744073709551615UL)) {
  *return_value = (tag_value_t)value;
  return 1;
}
else {
  *return_value = (tag_value_t)0;
  return -1;
}
1316}

1318/** Tag class for tags with size_t value. @NEW_1_12_5. */
1319tag_class_t size_tag_class[1] =
{{
  sizeof(int_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_size_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_size_ref_set,
  /* tc_scan */     t_size_scan,
}};

1335/* ====================================================================== */
1336/* usize tag - pass usize_t value */

1338static
1339int t_usize_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1340{
*(usize_t *)ref = (usize_t)value->t_value;

return 1;
1344}

1346static
1347int t_usize_scan(tag_type_t tt, su_home_t *home,
 char const *s,
 tag_value_t *return_value)
1350{
unsigned longlonglong long value;
char *rest;

value = strtoull(s, &rest, 0);

if (s != rest && value <= USIZE_MAX(2147483647 *2U +1U)) {
  *return_value = (tag_value_t)value;
  return 1;
}
else {
  *return_value = (tag_value_t)0;
  return -1;
}
1364}

1366/** Tag class for tags with usize_t value. @NEW_1_12_5. */
1367tag_class_t usize_tag_class[1] =
{{
  sizeof(int_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_size_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_usize_ref_set,
  /* tc_scan */     t_usize_scan,
}};


1384/* ====================================================================== */
1385/* bool tag - pass boolean value */

1387int t_bool_snprintf(tagi_t const *t, char b[], size_t size)
1388{
return snprintf(b, size, "%s", t->t_value ? "true" : "false");
1390}

1392int t_bool_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1393{
*(int *)ref = (value->t_value != 0);

return 1;
1397}

1399int t_bool_scan(tag_type_t tt, su_home_t *home,
      char const *s,
      tag_value_t *return_value)
1402{
int retval;
int value = 0;

if (su_casenmatch(s, "true", 4)
    && strlen(s + 4) == strspn(s + 4, " \t\r\n")) {
  value = 1, retval = 1;
} else if (su_casenmatch(s, "false", 5)
    && strlen(s + 5) == strspn(s + 5, " \t\r\n")) {
  value = 0, retval = 1;
} else {
  retval = t_int_scan(tt, home, s, return_value);
  value = *return_value != 0;
}

if (retval == 1)
  *return_value = (tag_value_t)value;
else
  *return_value = (tag_value_t)0;

return retval;
1423}

1425tag_class_t bool_tag_class[1] =
{{
  sizeof(bool_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_bool_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_bool_ref_set,
  /* tc_scan */     t_bool_scan,
}};

1441/* ====================================================================== */
1442/* ptr tag - pass pointer value */

1444int t_ptr_snprintf(tagi_t const *t, char b[], size_t size)
1445{
return snprintf(b, size, "%p", (void *)t->t_value);
1447}

1449int t_ptr_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1450{
*(void **)ref = (void *)value->t_value;

return 1;
1454}

1456/* This is not usually very safe, so it is not used */
1457int t_ptr_scan(tag_type_t tt, su_home_t *home,
      char const *s,
      tag_value_t *return_value)
1460{
int retval;
void *ptr;

retval = sscanf(s, "%p", &ptr);

if (retval == 1)
  *return_value = (tag_value_t)ptr;
else
  *return_value = (tag_value_t)NULL((void*)0);

return retval;
1472}

1474tag_class_t ptr_tag_class[1] =
{{
  sizeof(ptr_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_ptr_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_ptr_ref_set,
  /* tc_scan */     NULL((void*)0),
}};

1490/* ====================================================================== */
1491/* socket tag - pass socket */

1493#include <sofia-sip/su.h>

1495int t_socket_snprintf(tagi_t const *t, char b[], size_t size)
1496{
/* socket can be int or DWORD (or QWORD on win64?) */
return snprintf(b, size, LLI"%lli", (longlonglong long)t->t_value);
1499}

1501int t_socket_ref_set(tag_type_t tt, void *ref, tagi_t const value[])
1502{
*(su_socket_t *)ref = (su_socket_t)value->t_value;

return 1;
1506}

1508tag_class_t socket_tag_class[1] =
{{
  sizeof(socket_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_socket_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_socket_ref_set,
  /* tc_scan */     NULL((void*)0),
}};

1524/* ====================================================================== */
1525/* str tag - pass string value */

1527int t_str_snprintf(tagi_t const *t, char b[], size_t size)
1528{
if (t->t_value)
  return snprintf(b, size, "\"%s\"", (char const *)t->t_value);
else
  return snprintf(b, size, "<null>");
1533}

1535int t_str_scan(tag_type_t tt, su_home_t *home,
      char const *s,
      tag_value_t *return_value)
1538{
int retval;

s = su_strdup(home, s);

if (s)
  *return_value = (tag_value_t)s, retval = 1;
else
  *return_value = (tag_value_t)NULL((void*)0), retval = -1;

return retval;
1549}

1551tagi_t *t_str_dup(tagi_t *dst, tagi_t const *src, void **bb)
1552{
dst->t_tag = src->t_tag;
if (src->t_value) {
  char const *s = (char const *)src->t_value;
  size_t len = strlen(s) + 1;
  dst->t_value = (tag_value_t)strcpy(*bb, s);
  *bb = (char *)*bb + len;
}
else
  dst->t_value = (tag_value_t)0;

return dst + 1;
1564}

1566size_t t_str_xtra(tagi_t const *t, size_t offset)
1567{
return t->t_value ? strlen((char *)t->t_value) + 1 : 0;
1569}

1571tag_class_t str_tag_class[1] =
{{
  sizeof(str_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     t_str_xtra,
  /* tc_dup */      t_str_dup,
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_str_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_ptr_ref_set,
  /* tc_scan */     t_str_scan,
}};

1587/* ====================================================================== */
1588/* cstr tag - pass constant string value (no need to dup) */

1590/** Tag class for constant strings */
1591tag_class_t cstr_tag_class[1] =
{{
  sizeof(cstr_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_str_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_ptr_ref_set,
  /* tc_scan */     t_str_scan,
}};

1607/* ====================================================================== */
1608/* ref tag - pass reference */

1610tag_class_t ref_tag_class[1] =
{{
  sizeof(ref_tag_class),
  /* tc_next */     NULL((void*)0),
  /* tc_len */      NULL((void*)0),
  /* tc_move */     NULL((void*)0),
  /* tc_xtra */     NULL((void*)0),
  /* tc_dup */      NULL((void*)0),
  /* tc_free */     NULL((void*)0),
  /* tc_find */     NULL((void*)0),
  /* tc_snprintf */ t_ptr_snprintf,
  /* tc_filter */   NULL((void*)0),
  /* tc_ref_set */  t_ptr_ref_set,
  /* tc_scan */     NULL((void*)0),
}};



←

./sofia-sip/su_tag_inline.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 SU_TAG_INLINE_H
26/** Defined when <sofia-sip/su_tag_inline.h> has been included */
27#define SU_TAG_INLINE_H
28/**@SU_TAG
29 * @file sofia-sip/su_tag_inline.h
30 * Inline functions for object tags and tag lists.
31 *
32 * @author Pekka Pessi <Pekka.Pessi@nokia.com>
33 *
34 * @date Created: Tue Feb 20 19:48:18 2001 ppessi
35 */
36 
37#ifndef SU_TAG_H
38#include <sofia-sip/su_tag.h>
39#endif
40#ifndef SU_TAG_CLASS_H
41#include <sofia-sip/su_tag_class.h>
42#endif
43 
44SOFIA_BEGIN_DECLS
45 
46#define tt_nexttt_class->tc_next     tt_class->tc_next
47#define tt_lentt_class->tc_len      tt_class->tc_len
48#define tt_movett_class->tc_move     tt_class->tc_move
49#define tt_xtratt_class->tc_xtra     tt_class->tc_xtra
50#define tt_duptt_class->tc_dup      tt_class->tc_dup
51#define tt_freett_class->tc_free     tt_class->tc_free
52#define tt_findtt_class->tc_find     tt_class->tc_find
53#define tt_snprintftt_class->tc_snprintf tt_class->tc_snprintf
54#define tt_filtertt_class->tc_filter   tt_class->tc_filter
55 
56#define TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null) ((t) && (t)->t_tag ? (t)->t_tag : tag_null)
57 
58/** Check if the tag item is last in current list */
59su_inlinestatic inline int t_end(tagi_t const *t)
60{
61  tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
62 
63  /* XXX - virtualize this */
64 
65  return tt == tag_null || tt == tag_next;
66}
67 
68su_inlinestatic inline tagi_t const *t_next(tagi_t const *t)
69{
70  tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
71 
72  assert(tt)((void) sizeof ((tt) ? 1 : 0), __extension__ ({ if (tt) ; else
 __assert_fail ("tt", "./sofia-sip/su_tag_inline.h", 72, __extension__
 __PRETTY_FUNCTION__); }));
73 
74  if (tt->tt_nexttt_class->tc_next)
7
←
Access to field 'tc_next' results in a dereference of a null pointer (loaded from field 'tt_class')
75    return tt->tt_nexttt_class->tc_next(t);
76  else
77    return t + 1;
78}
79 
80su_inlinestatic inline tagi_t *t_move(tagi_t *dst, tagi_t const *src)
81{
82  tag_type_t tt = TAG_TYPE_OF(src)((src) && (src)->t_tag ? (src)->t_tag : tag_null
);
83 
84  if (tt->tt_movett_class->tc_move)
85    return tt->tt_movett_class->tc_move(dst, src);
86 
87  *dst = *src;
88  return dst + 1;
89}
90 
91su_inlinestatic inline size_t t_xtra(tagi_t const *t, size_t offset)
92{
93  tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
94 
95  if (tt->tt_xtratt_class->tc_xtra)
96    return tt->tt_xtratt_class->tc_xtra(t, offset);
97 
98  return 0;
99}
100 
101su_inlinestatic inline tagi_t *t_dup(tagi_t *dst, tagi_t const *src, void **bb)
102{
103  tag_type_t tt = TAG_TYPE_OF(src)((src) && (src)->t_tag ? (src)->t_tag : tag_null
);
104 
105  if (tt->tt_duptt_class->tc_dup)
106    return tt->tt_duptt_class->tc_dup(dst, src, bb);
107 
108  *dst = *src;
109  return dst + 1;
110}
111 
112su_inlinestatic inline tagi_t const *t_find(tag_type_t tt, tagi_t const *lst)
113{
114  if (!tt)
115    return NULL((void*)0);
116 
117  if (tt->tt_findtt_class->tc_find)
118    return tt->tt_findtt_class->tc_find(tt, lst);
119 
120  for (; lst; lst = t_next(lst)) {
121    if (tt == lst->t_tag)
122      return lst;
123  }
124 
125  return NULL((void*)0);
126}
127 
128su_inlinestatic inline tagi_t *t_free(tagi_t *t)
129{
130  tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
131 
132  if (tt->tt_freett_class->tc_free)
133    return tt->tt_freett_class->tc_free(t);
134  else if (tt->tt_nexttt_class->tc_next)
135    return (tagi_t *)tt->tt_nexttt_class->tc_next(t);
136  else
137    return t + 1;
138}
139 
140su_inlinestatic inline size_t t_len(tagi_t const *t)
141{
142  tag_type_t tt = TAG_TYPE_OF(t)((t) && (t)->t_tag ? (t)->t_tag : tag_null);
143 
144  if (tt->tt_lentt_class->tc_len)
145    return tt->tt_lentt_class->tc_len(t);
146 
147  return sizeof(*t);
148}
149 
150SOFIA_END_DECLS
151 
152#endif /* !defined(SU_TAG_INLINE_H) */