sofia-sip/sip_protos.h

Go to the documentation of this file.

/* -*- C -*-
 *
 * This file is part of the Sofia-SIP package
 *
 * Copyright (C) 2005 Nokia Corporation.
 *
 * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
 *
 * 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
 *
 */

#ifndef SIP_PROTOS_H

#define SIP_PROTOS_H

#include <sofia-sip/su_config.h>

#ifndef SIP_HEADER_H
#include <sofia-sip/sip_header.h>
#endif

#ifndef SIP_HCLASSES_H
#include <sofia-sip/sip_hclasses.h>
#endif

SOFIA_BEGIN_DECLS

#if SU_HAVE_INLINE

su_inline
sip_t *sip_object(msg_t const *msg)
{
  return (sip_t *)msg_public(msg, SIP_PROTOCOL_TAG);
}

su_inline
int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h)
{
  return msg_header_insert(msg, (msg_pub_t *)sip, (msg_header_t *)h);
}

su_inline
int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h)
{
  return msg_header_remove(msg, (msg_pub_t *)sip, (msg_header_t *)h);
}

su_inline
char const *sip_header_name(sip_header_t const *h, int compact)
{
  if (compact && h->sh_class->hc_short[0])
    return h->sh_class->hc_short;
  else
    return h->sh_class->hc_name;
}

su_inline
void *sip_header_data(sip_header_t *h)
{
  return h && h != SIP_NONE ? h->sh_class->hc_size + (char *)h : NULL;
}
#else
sip_t *sip_object(msg_t *msg);
int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h);
int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h);
char const *sip_header_name(sip_header_t const *h, int compact);
void *sip_header_data(sip_header_t *h);
#endif

SOFIAPUBFUN issize_t sip_request_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_request_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_request(sip) \
  ((sip_request_t *)msg_header_access((msg_pub_t*)(sip), sip_request_class))

#define SIP_REQUEST_INIT() SIP_HDR_INIT(request)

#if SU_HAVE_INLINE
su_inline sip_request_t *sip_request_init(sip_request_t x[1])
{
  return SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t));
}
#else
#define sip_request_init(x) \
  SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_request(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_request_hash;
}
#else
int sip_is_request(sip_header_t const *header);
#endif

#define sip_request_p(h) sip_is_request((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_request_t *sip_request_dup(su_home_t *home, sip_request_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_request_t *sip_request_dup(su_home_t *home, sip_request_t const *hdr)
{
  return (sip_request_t *)
    msg_header_dup_as(home, sip_request_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_t *sip_request_copy(su_home_t *home, sip_request_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_request_t *sip_request_copy(su_home_t *home, sip_request_t const *hdr)
{
  return (sip_request_t *)
    msg_header_copy_as(home, sip_request_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_t *sip_request_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_request_t *sip_request_make(su_home_t *home, char const *s)
{
  return (sip_request_t *)sip_header_make(home, sip_request_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_t *sip_request_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_request_t *sip_request_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_request_class, fmt, ap);
  va_end(ap);

  return (sip_request_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_status_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_status_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_status(sip) \
  ((sip_status_t *)msg_header_access((msg_pub_t*)(sip), sip_status_class))

#define SIP_STATUS_INIT() SIP_HDR_INIT(status)

#if SU_HAVE_INLINE
su_inline sip_status_t *sip_status_init(sip_status_t x[1])
{
  return SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t));
}
#else
#define sip_status_init(x) \
  SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_status(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_status_hash;
}
#else
int sip_is_status(sip_header_t const *header);
#endif

#define sip_status_p(h) sip_is_status((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_status_t *sip_status_dup(su_home_t *home, sip_status_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_status_t *sip_status_dup(su_home_t *home, sip_status_t const *hdr)
{
  return (sip_status_t *)
    msg_header_dup_as(home, sip_status_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_status_t *sip_status_copy(su_home_t *home, sip_status_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_status_t *sip_status_copy(su_home_t *home, sip_status_t const *hdr)
{
  return (sip_status_t *)
    msg_header_copy_as(home, sip_status_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_status_t *sip_status_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_status_t *sip_status_make(su_home_t *home, char const *s)
{
  return (sip_status_t *)sip_header_make(home, sip_status_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_status_class, fmt, ap);
  va_end(ap);

  return (sip_status_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_via_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_via_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_via(sip) \
  ((sip_via_t *)msg_header_access((msg_pub_t*)(sip), sip_via_class))

#define SIP_VIA_INIT() SIP_HDR_INIT(via)

#if SU_HAVE_INLINE
su_inline sip_via_t *sip_via_init(sip_via_t x[1])
{
  return SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t));
}
#else
#define sip_via_init(x) \
  SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_via(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_via_hash;
}
#else
int sip_is_via(sip_header_t const *header);
#endif

#define sip_via_p(h) sip_is_via((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
{
  return (sip_via_t *)
    msg_header_dup_as(home, sip_via_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
{
  return (sip_via_t *)
    msg_header_copy_as(home, sip_via_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_via_t *sip_via_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_via_t *sip_via_make(su_home_t *home, char const *s)
{
  return (sip_via_t *)sip_header_make(home, sip_via_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_via_class, fmt, ap);
  va_end(ap);

  return (sip_via_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_route_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_route_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_route(sip) \
  ((sip_route_t *)msg_header_access((msg_pub_t*)(sip), sip_route_class))

#define SIP_ROUTE_INIT() SIP_HDR_INIT(route)

#if SU_HAVE_INLINE
su_inline sip_route_t *sip_route_init(sip_route_t x[1])
{
  return SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t));
}
#else
#define sip_route_init(x) \
  SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_route(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_route_hash;
}
#else
int sip_is_route(sip_header_t const *header);
#endif

#define sip_route_p(h) sip_is_route((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_route_t *sip_route_dup(su_home_t *home, sip_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_route_t *sip_route_dup(su_home_t *home, sip_route_t const *hdr)
{
  return (sip_route_t *)
    msg_header_dup_as(home, sip_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_route_t *sip_route_copy(su_home_t *home, sip_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_route_t *sip_route_copy(su_home_t *home, sip_route_t const *hdr)
{
  return (sip_route_t *)
    msg_header_copy_as(home, sip_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_route_t *sip_route_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_route_t *sip_route_make(su_home_t *home, char const *s)
{
  return (sip_route_t *)sip_header_make(home, sip_route_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_route_class, fmt, ap);
  va_end(ap);

  return (sip_route_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_record_route_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_record_route_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_record_route(sip) \
  ((sip_record_route_t *)msg_header_access((msg_pub_t*)(sip), sip_record_route_class))

#define SIP_RECORD_ROUTE_INIT() SIP_HDR_INIT(record_route)

#if SU_HAVE_INLINE
su_inline sip_record_route_t *sip_record_route_init(sip_record_route_t x[1])
{
  return SIP_HEADER_INIT(x, sip_record_route_class, sizeof(sip_record_route_t));
}
#else
#define sip_record_route_init(x) \
  SIP_HEADER_INIT(x, sip_record_route_class, sizeof(sip_record_route_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_record_route(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_record_route_hash;
}
#else
int sip_is_record_route(sip_header_t const *header);
#endif

#define sip_record_route_p(h) sip_is_record_route((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_record_route_t *sip_record_route_dup(su_home_t *home, sip_record_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_record_route_t *sip_record_route_dup(su_home_t *home, sip_record_route_t const *hdr)
{
  return (sip_record_route_t *)
    msg_header_dup_as(home, sip_record_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_record_route_t *sip_record_route_copy(su_home_t *home, sip_record_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_record_route_t *sip_record_route_copy(su_home_t *home, sip_record_route_t const *hdr)
{
  return (sip_record_route_t *)
    msg_header_copy_as(home, sip_record_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_record_route_t *sip_record_route_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_record_route_t *sip_record_route_make(su_home_t *home, char const *s)
{
  return (sip_record_route_t *)sip_header_make(home, sip_record_route_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_record_route_t *sip_record_route_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_record_route_t *sip_record_route_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_record_route_class, fmt, ap);
  va_end(ap);

  return (sip_record_route_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_max_forwards_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_max_forwards_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_max_forwards(sip) \
  ((sip_max_forwards_t *)msg_header_access((msg_pub_t*)(sip), sip_max_forwards_class))

#define SIP_MAX_FORWARDS_INIT() SIP_HDR_INIT(max_forwards)

#if SU_HAVE_INLINE
su_inline sip_max_forwards_t *sip_max_forwards_init(sip_max_forwards_t x[1])
{
  return SIP_HEADER_INIT(x, sip_max_forwards_class, sizeof(sip_max_forwards_t));
}
#else
#define sip_max_forwards_init(x) \
  SIP_HEADER_INIT(x, sip_max_forwards_class, sizeof(sip_max_forwards_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_max_forwards(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_max_forwards_hash;
}
#else
int sip_is_max_forwards(sip_header_t const *header);
#endif

#define sip_max_forwards_p(h) sip_is_max_forwards((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_max_forwards_t *sip_max_forwards_dup(su_home_t *home, sip_max_forwards_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_max_forwards_t *sip_max_forwards_dup(su_home_t *home, sip_max_forwards_t const *hdr)
{
  return (sip_max_forwards_t *)
    msg_header_dup_as(home, sip_max_forwards_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_max_forwards_t *sip_max_forwards_copy(su_home_t *home, sip_max_forwards_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_max_forwards_t *sip_max_forwards_copy(su_home_t *home, sip_max_forwards_t const *hdr)
{
  return (sip_max_forwards_t *)
    msg_header_copy_as(home, sip_max_forwards_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_max_forwards_t *sip_max_forwards_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_max_forwards_t *sip_max_forwards_make(su_home_t *home, char const *s)
{
  return (sip_max_forwards_t *)sip_header_make(home, sip_max_forwards_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_max_forwards_t *sip_max_forwards_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_max_forwards_t *sip_max_forwards_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_max_forwards_class, fmt, ap);
  va_end(ap);

  return (sip_max_forwards_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_proxy_require_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_proxy_require_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_proxy_require(sip) \
  ((sip_proxy_require_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_require_class))

#define SIP_PROXY_REQUIRE_INIT() SIP_HDR_INIT(proxy_require)

#if SU_HAVE_INLINE
su_inline sip_proxy_require_t *sip_proxy_require_init(sip_proxy_require_t x[1])
{
  return SIP_HEADER_INIT(x, sip_proxy_require_class, sizeof(sip_proxy_require_t));
}
#else
#define sip_proxy_require_init(x) \
  SIP_HEADER_INIT(x, sip_proxy_require_class, sizeof(sip_proxy_require_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_proxy_require(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_proxy_require_hash;
}
#else
int sip_is_proxy_require(sip_header_t const *header);
#endif

#define sip_proxy_require_p(h) sip_is_proxy_require((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_require_t *sip_proxy_require_dup(su_home_t *home, sip_proxy_require_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_require_t *sip_proxy_require_dup(su_home_t *home, sip_proxy_require_t const *hdr)
{
  return (sip_proxy_require_t *)
    msg_header_dup_as(home, sip_proxy_require_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_require_t *sip_proxy_require_copy(su_home_t *home, sip_proxy_require_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_require_t *sip_proxy_require_copy(su_home_t *home, sip_proxy_require_t const *hdr)
{
  return (sip_proxy_require_t *)
    msg_header_copy_as(home, sip_proxy_require_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_require_t *sip_proxy_require_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_proxy_require_t *sip_proxy_require_make(su_home_t *home, char const *s)
{
  return (sip_proxy_require_t *)sip_header_make(home, sip_proxy_require_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_require_t *sip_proxy_require_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_proxy_require_t *sip_proxy_require_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_proxy_require_class, fmt, ap);
  va_end(ap);

  return (sip_proxy_require_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_from_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_from_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_from(sip) \
  ((sip_from_t *)msg_header_access((msg_pub_t*)(sip), sip_from_class))

#define SIP_FROM_INIT() SIP_HDR_INIT(from)

#if SU_HAVE_INLINE
su_inline sip_from_t *sip_from_init(sip_from_t x[1])
{
  return SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t));
}
#else
#define sip_from_init(x) \
  SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_from(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_from_hash;
}
#else
int sip_is_from(sip_header_t const *header);
#endif

#define sip_from_p(h) sip_is_from((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
{
  return (sip_from_t *)
    msg_header_dup_as(home, sip_from_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
{
  return (sip_from_t *)
    msg_header_copy_as(home, sip_from_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_from_t *sip_from_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_from_t *sip_from_make(su_home_t *home, char const *s)
{
  return (sip_from_t *)sip_header_make(home, sip_from_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_from_class, fmt, ap);
  va_end(ap);

  return (sip_from_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_to_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_to_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_to(sip) \
  ((sip_to_t *)msg_header_access((msg_pub_t*)(sip), sip_to_class))

#define SIP_TO_INIT() SIP_HDR_INIT(to)

#if SU_HAVE_INLINE
su_inline sip_to_t *sip_to_init(sip_to_t x[1])
{
  return SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t));
}
#else
#define sip_to_init(x) \
  SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_to(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_to_hash;
}
#else
int sip_is_to(sip_header_t const *header);
#endif

#define sip_to_p(h) sip_is_to((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
{
  return (sip_to_t *)
    msg_header_dup_as(home, sip_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
{
  return (sip_to_t *)
    msg_header_copy_as(home, sip_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_to_t *sip_to_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_to_t *sip_to_make(su_home_t *home, char const *s)
{
  return (sip_to_t *)sip_header_make(home, sip_to_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_to_class, fmt, ap);
  va_end(ap);

  return (sip_to_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_call_id_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_call_id_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_call_id(sip) \
  ((sip_call_id_t *)msg_header_access((msg_pub_t*)(sip), sip_call_id_class))

#define SIP_CALL_ID_INIT() SIP_HDR_INIT(call_id)

#if SU_HAVE_INLINE
su_inline sip_call_id_t *sip_call_id_init(sip_call_id_t x[1])
{
  return SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t));
}
#else
#define sip_call_id_init(x) \
  SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_call_id(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_call_id_hash;
}
#else
int sip_is_call_id(sip_header_t const *header);
#endif

#define sip_call_id_p(h) sip_is_call_id((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_call_id_t *sip_call_id_dup(su_home_t *home, sip_call_id_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_call_id_t *sip_call_id_dup(su_home_t *home, sip_call_id_t const *hdr)
{
  return (sip_call_id_t *)
    msg_header_dup_as(home, sip_call_id_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_id_t *sip_call_id_copy(su_home_t *home, sip_call_id_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_call_id_t *sip_call_id_copy(su_home_t *home, sip_call_id_t const *hdr)
{
  return (sip_call_id_t *)
    msg_header_copy_as(home, sip_call_id_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_id_t *sip_call_id_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_call_id_t *sip_call_id_make(su_home_t *home, char const *s)
{
  return (sip_call_id_t *)sip_header_make(home, sip_call_id_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_id_t *sip_call_id_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_call_id_t *sip_call_id_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_call_id_class, fmt, ap);
  va_end(ap);

  return (sip_call_id_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_cseq_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_cseq_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_cseq(sip) \
  ((sip_cseq_t *)msg_header_access((msg_pub_t*)(sip), sip_cseq_class))

#define SIP_CSEQ_INIT() SIP_HDR_INIT(cseq)

#if SU_HAVE_INLINE
su_inline sip_cseq_t *sip_cseq_init(sip_cseq_t x[1])
{
  return SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t));
}
#else
#define sip_cseq_init(x) \
  SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_cseq(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_cseq_hash;
}
#else
int sip_is_cseq(sip_header_t const *header);
#endif

#define sip_cseq_p(h) sip_is_cseq((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
{
  return (sip_cseq_t *)
    msg_header_dup_as(home, sip_cseq_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
{
  return (sip_cseq_t *)
    msg_header_copy_as(home, sip_cseq_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_cseq_t *sip_cseq_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_cseq_t *sip_cseq_make(su_home_t *home, char const *s)
{
  return (sip_cseq_t *)sip_header_make(home, sip_cseq_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_cseq_class, fmt, ap);
  va_end(ap);

  return (sip_cseq_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_contact_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_contact_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_contact(sip) \
  ((sip_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_contact_class))

#define SIP_CONTACT_INIT() SIP_HDR_INIT(contact)

#if SU_HAVE_INLINE
su_inline sip_contact_t *sip_contact_init(sip_contact_t x[1])
{
  return SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t));
}
#else
#define sip_contact_init(x) \
  SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_contact(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_contact_hash;
}
#else
int sip_is_contact(sip_header_t const *header);
#endif

#define sip_contact_p(h) sip_is_contact((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_contact_t *sip_contact_dup(su_home_t *home, sip_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_contact_t *sip_contact_dup(su_home_t *home, sip_contact_t const *hdr)
{
  return (sip_contact_t *)
    msg_header_dup_as(home, sip_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_contact_t *sip_contact_copy(su_home_t *home, sip_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_contact_t *sip_contact_copy(su_home_t *home, sip_contact_t const *hdr)
{
  return (sip_contact_t *)
    msg_header_copy_as(home, sip_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_contact_t *sip_contact_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_contact_t *sip_contact_make(su_home_t *home, char const *s)
{
  return (sip_contact_t *)sip_header_make(home, sip_contact_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_contact_t *sip_contact_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_contact_t *sip_contact_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_contact_class, fmt, ap);
  va_end(ap);

  return (sip_contact_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_rseq_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_rseq_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_rseq(sip) \
  ((sip_rseq_t *)msg_header_access((msg_pub_t*)(sip), sip_rseq_class))

#define SIP_RSEQ_INIT() SIP_HDR_INIT(rseq)

#if SU_HAVE_INLINE
su_inline sip_rseq_t *sip_rseq_init(sip_rseq_t x[1])
{
  return SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t));
}
#else
#define sip_rseq_init(x) \
  SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_rseq(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_rseq_hash;
}
#else
int sip_is_rseq(sip_header_t const *header);
#endif

#define sip_rseq_p(h) sip_is_rseq((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
{
  return (sip_rseq_t *)
    msg_header_dup_as(home, sip_rseq_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
{
  return (sip_rseq_t *)
    msg_header_copy_as(home, sip_rseq_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rseq_t *sip_rseq_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_rseq_t *sip_rseq_make(su_home_t *home, char const *s)
{
  return (sip_rseq_t *)sip_header_make(home, sip_rseq_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_rseq_class, fmt, ap);
  va_end(ap);

  return (sip_rseq_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_rack_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_rack_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_rack(sip) \
  ((sip_rack_t *)msg_header_access((msg_pub_t*)(sip), sip_rack_class))

#define SIP_RACK_INIT() SIP_HDR_INIT(rack)

#if SU_HAVE_INLINE
su_inline sip_rack_t *sip_rack_init(sip_rack_t x[1])
{
  return SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t));
}
#else
#define sip_rack_init(x) \
  SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_rack(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_rack_hash;
}
#else
int sip_is_rack(sip_header_t const *header);
#endif

#define sip_rack_p(h) sip_is_rack((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
{
  return (sip_rack_t *)
    msg_header_dup_as(home, sip_rack_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
{
  return (sip_rack_t *)
    msg_header_copy_as(home, sip_rack_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rack_t *sip_rack_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_rack_t *sip_rack_make(su_home_t *home, char const *s)
{
  return (sip_rack_t *)sip_header_make(home, sip_rack_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_rack_class, fmt, ap);
  va_end(ap);

  return (sip_rack_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_request_disposition_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_request_disposition_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_request_disposition(sip) \
  ((sip_request_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_request_disposition_class))

#define SIP_REQUEST_DISPOSITION_INIT() SIP_HDR_INIT(request_disposition)

#if SU_HAVE_INLINE
su_inline sip_request_disposition_t *sip_request_disposition_init(sip_request_disposition_t x[1])
{
  return SIP_HEADER_INIT(x, sip_request_disposition_class, sizeof(sip_request_disposition_t));
}
#else
#define sip_request_disposition_init(x) \
  SIP_HEADER_INIT(x, sip_request_disposition_class, sizeof(sip_request_disposition_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_request_disposition(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_request_disposition_hash;
}
#else
int sip_is_request_disposition(sip_header_t const *header);
#endif

#define sip_request_disposition_p(h) sip_is_request_disposition((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_request_disposition_t *sip_request_disposition_dup(su_home_t *home, sip_request_disposition_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_request_disposition_t *sip_request_disposition_dup(su_home_t *home, sip_request_disposition_t const *hdr)
{
  return (sip_request_disposition_t *)
    msg_header_dup_as(home, sip_request_disposition_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_disposition_t *sip_request_disposition_copy(su_home_t *home, sip_request_disposition_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_request_disposition_t *sip_request_disposition_copy(su_home_t *home, sip_request_disposition_t const *hdr)
{
  return (sip_request_disposition_t *)
    msg_header_copy_as(home, sip_request_disposition_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_disposition_t *sip_request_disposition_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_request_disposition_t *sip_request_disposition_make(su_home_t *home, char const *s)
{
  return (sip_request_disposition_t *)sip_header_make(home, sip_request_disposition_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_request_disposition_t *sip_request_disposition_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_request_disposition_t *sip_request_disposition_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_request_disposition_class, fmt, ap);
  va_end(ap);

  return (sip_request_disposition_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_accept_contact_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_accept_contact_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_accept_contact(sip) \
  ((sip_accept_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_contact_class))

#define SIP_ACCEPT_CONTACT_INIT() SIP_HDR_INIT(accept_contact)

#if SU_HAVE_INLINE
su_inline sip_accept_contact_t *sip_accept_contact_init(sip_accept_contact_t x[1])
{
  return SIP_HEADER_INIT(x, sip_accept_contact_class, sizeof(sip_accept_contact_t));
}
#else
#define sip_accept_contact_init(x) \
  SIP_HEADER_INIT(x, sip_accept_contact_class, sizeof(sip_accept_contact_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_accept_contact(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_accept_contact_hash;
}
#else
int sip_is_accept_contact(sip_header_t const *header);
#endif

#define sip_accept_contact_p(h) sip_is_accept_contact((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_contact_t *sip_accept_contact_dup(su_home_t *home, sip_accept_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_contact_t *sip_accept_contact_dup(su_home_t *home, sip_accept_contact_t const *hdr)
{
  return (sip_accept_contact_t *)
    msg_header_dup_as(home, sip_accept_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_contact_t *sip_accept_contact_copy(su_home_t *home, sip_accept_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_contact_t *sip_accept_contact_copy(su_home_t *home, sip_accept_contact_t const *hdr)
{
  return (sip_accept_contact_t *)
    msg_header_copy_as(home, sip_accept_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_contact_t *sip_accept_contact_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_accept_contact_t *sip_accept_contact_make(su_home_t *home, char const *s)
{
  return (sip_accept_contact_t *)sip_header_make(home, sip_accept_contact_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_contact_t *sip_accept_contact_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_accept_contact_t *sip_accept_contact_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_accept_contact_class, fmt, ap);
  va_end(ap);

  return (sip_accept_contact_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_reject_contact_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_reject_contact_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_reject_contact(sip) \
  ((sip_reject_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_reject_contact_class))

#define SIP_REJECT_CONTACT_INIT() SIP_HDR_INIT(reject_contact)

#if SU_HAVE_INLINE
su_inline sip_reject_contact_t *sip_reject_contact_init(sip_reject_contact_t x[1])
{
  return SIP_HEADER_INIT(x, sip_reject_contact_class, sizeof(sip_reject_contact_t));
}
#else
#define sip_reject_contact_init(x) \
  SIP_HEADER_INIT(x, sip_reject_contact_class, sizeof(sip_reject_contact_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_reject_contact(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_reject_contact_hash;
}
#else
int sip_is_reject_contact(sip_header_t const *header);
#endif

#define sip_reject_contact_p(h) sip_is_reject_contact((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_reject_contact_t *sip_reject_contact_dup(su_home_t *home, sip_reject_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_reject_contact_t *sip_reject_contact_dup(su_home_t *home, sip_reject_contact_t const *hdr)
{
  return (sip_reject_contact_t *)
    msg_header_dup_as(home, sip_reject_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reject_contact_t *sip_reject_contact_copy(su_home_t *home, sip_reject_contact_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_reject_contact_t *sip_reject_contact_copy(su_home_t *home, sip_reject_contact_t const *hdr)
{
  return (sip_reject_contact_t *)
    msg_header_copy_as(home, sip_reject_contact_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reject_contact_t *sip_reject_contact_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_reject_contact_t *sip_reject_contact_make(su_home_t *home, char const *s)
{
  return (sip_reject_contact_t *)sip_header_make(home, sip_reject_contact_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reject_contact_t *sip_reject_contact_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_reject_contact_t *sip_reject_contact_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_reject_contact_class, fmt, ap);
  va_end(ap);

  return (sip_reject_contact_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_expires_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_expires_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_expires(sip) \
  ((sip_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_expires_class))

#define SIP_EXPIRES_INIT() SIP_HDR_INIT(expires)

#if SU_HAVE_INLINE
su_inline sip_expires_t *sip_expires_init(sip_expires_t x[1])
{
  return SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t));
}
#else
#define sip_expires_init(x) \
  SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_expires(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_expires_hash;
}
#else
int sip_is_expires(sip_header_t const *header);
#endif

#define sip_expires_p(h) sip_is_expires((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_expires_t *sip_expires_dup(su_home_t *home, sip_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_expires_t *sip_expires_dup(su_home_t *home, sip_expires_t const *hdr)
{
  return (sip_expires_t *)
    msg_header_dup_as(home, sip_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_expires_t *sip_expires_copy(su_home_t *home, sip_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_expires_t *sip_expires_copy(su_home_t *home, sip_expires_t const *hdr)
{
  return (sip_expires_t *)
    msg_header_copy_as(home, sip_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_expires_t *sip_expires_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_expires_t *sip_expires_make(su_home_t *home, char const *s)
{
  return (sip_expires_t *)sip_header_make(home, sip_expires_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_expires_t *sip_expires_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_expires_t *sip_expires_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_expires_class, fmt, ap);
  va_end(ap);

  return (sip_expires_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_date_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_date_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_date(sip) \
  ((sip_date_t *)msg_header_access((msg_pub_t*)(sip), sip_date_class))

#define SIP_DATE_INIT() SIP_HDR_INIT(date)

#if SU_HAVE_INLINE
su_inline sip_date_t *sip_date_init(sip_date_t x[1])
{
  return SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t));
}
#else
#define sip_date_init(x) \
  SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_date(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_date_hash;
}
#else
int sip_is_date(sip_header_t const *header);
#endif

#define sip_date_p(h) sip_is_date((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
{
  return (sip_date_t *)
    msg_header_dup_as(home, sip_date_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
{
  return (sip_date_t *)
    msg_header_copy_as(home, sip_date_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_date_t *sip_date_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_date_t *sip_date_make(su_home_t *home, char const *s)
{
  return (sip_date_t *)sip_header_make(home, sip_date_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_date_class, fmt, ap);
  va_end(ap);

  return (sip_date_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_retry_after_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_retry_after_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_retry_after(sip) \
  ((sip_retry_after_t *)msg_header_access((msg_pub_t*)(sip), sip_retry_after_class))

#define SIP_RETRY_AFTER_INIT() SIP_HDR_INIT(retry_after)

#if SU_HAVE_INLINE
su_inline sip_retry_after_t *sip_retry_after_init(sip_retry_after_t x[1])
{
  return SIP_HEADER_INIT(x, sip_retry_after_class, sizeof(sip_retry_after_t));
}
#else
#define sip_retry_after_init(x) \
  SIP_HEADER_INIT(x, sip_retry_after_class, sizeof(sip_retry_after_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_retry_after(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_retry_after_hash;
}
#else
int sip_is_retry_after(sip_header_t const *header);
#endif

#define sip_retry_after_p(h) sip_is_retry_after((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_retry_after_t *sip_retry_after_dup(su_home_t *home, sip_retry_after_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_retry_after_t *sip_retry_after_dup(su_home_t *home, sip_retry_after_t const *hdr)
{
  return (sip_retry_after_t *)
    msg_header_dup_as(home, sip_retry_after_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_retry_after_t *sip_retry_after_copy(su_home_t *home, sip_retry_after_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_retry_after_t *sip_retry_after_copy(su_home_t *home, sip_retry_after_t const *hdr)
{
  return (sip_retry_after_t *)
    msg_header_copy_as(home, sip_retry_after_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_retry_after_t *sip_retry_after_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_retry_after_t *sip_retry_after_make(su_home_t *home, char const *s)
{
  return (sip_retry_after_t *)sip_header_make(home, sip_retry_after_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_retry_after_t *sip_retry_after_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_retry_after_t *sip_retry_after_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_retry_after_class, fmt, ap);
  va_end(ap);

  return (sip_retry_after_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_timestamp_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_timestamp_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_timestamp(sip) \
  ((sip_timestamp_t *)msg_header_access((msg_pub_t*)(sip), sip_timestamp_class))

#define SIP_TIMESTAMP_INIT() SIP_HDR_INIT(timestamp)

#if SU_HAVE_INLINE
su_inline sip_timestamp_t *sip_timestamp_init(sip_timestamp_t x[1])
{
  return SIP_HEADER_INIT(x, sip_timestamp_class, sizeof(sip_timestamp_t));
}
#else
#define sip_timestamp_init(x) \
  SIP_HEADER_INIT(x, sip_timestamp_class, sizeof(sip_timestamp_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_timestamp(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_timestamp_hash;
}
#else
int sip_is_timestamp(sip_header_t const *header);
#endif

#define sip_timestamp_p(h) sip_is_timestamp((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_timestamp_t *sip_timestamp_dup(su_home_t *home, sip_timestamp_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_timestamp_t *sip_timestamp_dup(su_home_t *home, sip_timestamp_t const *hdr)
{
  return (sip_timestamp_t *)
    msg_header_dup_as(home, sip_timestamp_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_timestamp_t *sip_timestamp_copy(su_home_t *home, sip_timestamp_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_timestamp_t *sip_timestamp_copy(su_home_t *home, sip_timestamp_t const *hdr)
{
  return (sip_timestamp_t *)
    msg_header_copy_as(home, sip_timestamp_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_timestamp_t *sip_timestamp_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_timestamp_t *sip_timestamp_make(su_home_t *home, char const *s)
{
  return (sip_timestamp_t *)sip_header_make(home, sip_timestamp_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_timestamp_t *sip_timestamp_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_timestamp_t *sip_timestamp_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_timestamp_class, fmt, ap);
  va_end(ap);

  return (sip_timestamp_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_min_expires_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_min_expires_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_min_expires(sip) \
  ((sip_min_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_min_expires_class))

#define SIP_MIN_EXPIRES_INIT() SIP_HDR_INIT(min_expires)

#if SU_HAVE_INLINE
su_inline sip_min_expires_t *sip_min_expires_init(sip_min_expires_t x[1])
{
  return SIP_HEADER_INIT(x, sip_min_expires_class, sizeof(sip_min_expires_t));
}
#else
#define sip_min_expires_init(x) \
  SIP_HEADER_INIT(x, sip_min_expires_class, sizeof(sip_min_expires_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_min_expires(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_min_expires_hash;
}
#else
int sip_is_min_expires(sip_header_t const *header);
#endif

#define sip_min_expires_p(h) sip_is_min_expires((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_min_expires_t *sip_min_expires_dup(su_home_t *home, sip_min_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_min_expires_t *sip_min_expires_dup(su_home_t *home, sip_min_expires_t const *hdr)
{
  return (sip_min_expires_t *)
    msg_header_dup_as(home, sip_min_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_expires_t *sip_min_expires_copy(su_home_t *home, sip_min_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_min_expires_t *sip_min_expires_copy(su_home_t *home, sip_min_expires_t const *hdr)
{
  return (sip_min_expires_t *)
    msg_header_copy_as(home, sip_min_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_expires_t *sip_min_expires_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_min_expires_t *sip_min_expires_make(su_home_t *home, char const *s)
{
  return (sip_min_expires_t *)sip_header_make(home, sip_min_expires_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_expires_t *sip_min_expires_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_min_expires_t *sip_min_expires_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_min_expires_class, fmt, ap);
  va_end(ap);

  return (sip_min_expires_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_subject_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_subject_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_subject(sip) \
  ((sip_subject_t *)msg_header_access((msg_pub_t*)(sip), sip_subject_class))

#define SIP_SUBJECT_INIT() SIP_HDR_INIT(subject)

#if SU_HAVE_INLINE
su_inline sip_subject_t *sip_subject_init(sip_subject_t x[1])
{
  return SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t));
}
#else
#define sip_subject_init(x) \
  SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_subject(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_subject_hash;
}
#else
int sip_is_subject(sip_header_t const *header);
#endif

#define sip_subject_p(h) sip_is_subject((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_subject_t *sip_subject_dup(su_home_t *home, sip_subject_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_subject_t *sip_subject_dup(su_home_t *home, sip_subject_t const *hdr)
{
  return (sip_subject_t *)
    msg_header_dup_as(home, sip_subject_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subject_t *sip_subject_copy(su_home_t *home, sip_subject_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_subject_t *sip_subject_copy(su_home_t *home, sip_subject_t const *hdr)
{
  return (sip_subject_t *)
    msg_header_copy_as(home, sip_subject_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subject_t *sip_subject_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_subject_t *sip_subject_make(su_home_t *home, char const *s)
{
  return (sip_subject_t *)sip_header_make(home, sip_subject_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subject_t *sip_subject_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_subject_t *sip_subject_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_subject_class, fmt, ap);
  va_end(ap);

  return (sip_subject_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_priority_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_priority_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_priority(sip) \
  ((sip_priority_t *)msg_header_access((msg_pub_t*)(sip), sip_priority_class))

#define SIP_PRIORITY_INIT() SIP_HDR_INIT(priority)

#if SU_HAVE_INLINE
su_inline sip_priority_t *sip_priority_init(sip_priority_t x[1])
{
  return SIP_HEADER_INIT(x, sip_priority_class, sizeof(sip_priority_t));
}
#else
#define sip_priority_init(x) \
  SIP_HEADER_INIT(x, sip_priority_class, sizeof(sip_priority_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_priority(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_priority_hash;
}
#else
int sip_is_priority(sip_header_t const *header);
#endif

#define sip_priority_p(h) sip_is_priority((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_priority_t *sip_priority_dup(su_home_t *home, sip_priority_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_priority_t *sip_priority_dup(su_home_t *home, sip_priority_t const *hdr)
{
  return (sip_priority_t *)
    msg_header_dup_as(home, sip_priority_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_priority_t *sip_priority_copy(su_home_t *home, sip_priority_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_priority_t *sip_priority_copy(su_home_t *home, sip_priority_t const *hdr)
{
  return (sip_priority_t *)
    msg_header_copy_as(home, sip_priority_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_priority_t *sip_priority_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_priority_t *sip_priority_make(su_home_t *home, char const *s)
{
  return (sip_priority_t *)sip_header_make(home, sip_priority_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_priority_t *sip_priority_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_priority_t *sip_priority_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_priority_class, fmt, ap);
  va_end(ap);

  return (sip_priority_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_call_info_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_call_info_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_call_info(sip) \
  ((sip_call_info_t *)msg_header_access((msg_pub_t*)(sip), sip_call_info_class))

#define SIP_CALL_INFO_INIT() SIP_HDR_INIT(call_info)

#if SU_HAVE_INLINE
su_inline sip_call_info_t *sip_call_info_init(sip_call_info_t x[1])
{
  return SIP_HEADER_INIT(x, sip_call_info_class, sizeof(sip_call_info_t));
}
#else
#define sip_call_info_init(x) \
  SIP_HEADER_INIT(x, sip_call_info_class, sizeof(sip_call_info_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_call_info(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_call_info_hash;
}
#else
int sip_is_call_info(sip_header_t const *header);
#endif

#define sip_call_info_p(h) sip_is_call_info((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_call_info_t *sip_call_info_dup(su_home_t *home, sip_call_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_call_info_t *sip_call_info_dup(su_home_t *home, sip_call_info_t const *hdr)
{
  return (sip_call_info_t *)
    msg_header_dup_as(home, sip_call_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_info_t *sip_call_info_copy(su_home_t *home, sip_call_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_call_info_t *sip_call_info_copy(su_home_t *home, sip_call_info_t const *hdr)
{
  return (sip_call_info_t *)
    msg_header_copy_as(home, sip_call_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_info_t *sip_call_info_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_call_info_t *sip_call_info_make(su_home_t *home, char const *s)
{
  return (sip_call_info_t *)sip_header_make(home, sip_call_info_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_call_info_t *sip_call_info_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_call_info_t *sip_call_info_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_call_info_class, fmt, ap);
  va_end(ap);

  return (sip_call_info_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_organization_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_organization_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_organization(sip) \
  ((sip_organization_t *)msg_header_access((msg_pub_t*)(sip), sip_organization_class))

#define SIP_ORGANIZATION_INIT() SIP_HDR_INIT(organization)

#if SU_HAVE_INLINE
su_inline sip_organization_t *sip_organization_init(sip_organization_t x[1])
{
  return SIP_HEADER_INIT(x, sip_organization_class, sizeof(sip_organization_t));
}
#else
#define sip_organization_init(x) \
  SIP_HEADER_INIT(x, sip_organization_class, sizeof(sip_organization_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_organization(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_organization_hash;
}
#else
int sip_is_organization(sip_header_t const *header);
#endif

#define sip_organization_p(h) sip_is_organization((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_organization_t *sip_organization_dup(su_home_t *home, sip_organization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_organization_t *sip_organization_dup(su_home_t *home, sip_organization_t const *hdr)
{
  return (sip_organization_t *)
    msg_header_dup_as(home, sip_organization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_organization_t *sip_organization_copy(su_home_t *home, sip_organization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_organization_t *sip_organization_copy(su_home_t *home, sip_organization_t const *hdr)
{
  return (sip_organization_t *)
    msg_header_copy_as(home, sip_organization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_organization_t *sip_organization_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_organization_t *sip_organization_make(su_home_t *home, char const *s)
{
  return (sip_organization_t *)sip_header_make(home, sip_organization_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_organization_t *sip_organization_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_organization_t *sip_organization_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_organization_class, fmt, ap);
  va_end(ap);

  return (sip_organization_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_server_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_server_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_server(sip) \
  ((sip_server_t *)msg_header_access((msg_pub_t*)(sip), sip_server_class))

#define SIP_SERVER_INIT() SIP_HDR_INIT(server)

#if SU_HAVE_INLINE
su_inline sip_server_t *sip_server_init(sip_server_t x[1])
{
  return SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t));
}
#else
#define sip_server_init(x) \
  SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_server(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_server_hash;
}
#else
int sip_is_server(sip_header_t const *header);
#endif

#define sip_server_p(h) sip_is_server((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_server_t *sip_server_dup(su_home_t *home, sip_server_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_server_t *sip_server_dup(su_home_t *home, sip_server_t const *hdr)
{
  return (sip_server_t *)
    msg_header_dup_as(home, sip_server_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_server_t *sip_server_copy(su_home_t *home, sip_server_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_server_t *sip_server_copy(su_home_t *home, sip_server_t const *hdr)
{
  return (sip_server_t *)
    msg_header_copy_as(home, sip_server_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_server_t *sip_server_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_server_t *sip_server_make(su_home_t *home, char const *s)
{
  return (sip_server_t *)sip_header_make(home, sip_server_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_server_class, fmt, ap);
  va_end(ap);

  return (sip_server_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_user_agent_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_user_agent_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_user_agent(sip) \
  ((sip_user_agent_t *)msg_header_access((msg_pub_t*)(sip), sip_user_agent_class))

#define SIP_USER_AGENT_INIT() SIP_HDR_INIT(user_agent)

#if SU_HAVE_INLINE
su_inline sip_user_agent_t *sip_user_agent_init(sip_user_agent_t x[1])
{
  return SIP_HEADER_INIT(x, sip_user_agent_class, sizeof(sip_user_agent_t));
}
#else
#define sip_user_agent_init(x) \
  SIP_HEADER_INIT(x, sip_user_agent_class, sizeof(sip_user_agent_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_user_agent(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_user_agent_hash;
}
#else
int sip_is_user_agent(sip_header_t const *header);
#endif

#define sip_user_agent_p(h) sip_is_user_agent((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_user_agent_t *sip_user_agent_dup(su_home_t *home, sip_user_agent_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_user_agent_t *sip_user_agent_dup(su_home_t *home, sip_user_agent_t const *hdr)
{
  return (sip_user_agent_t *)
    msg_header_dup_as(home, sip_user_agent_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_user_agent_t *sip_user_agent_copy(su_home_t *home, sip_user_agent_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_user_agent_t *sip_user_agent_copy(su_home_t *home, sip_user_agent_t const *hdr)
{
  return (sip_user_agent_t *)
    msg_header_copy_as(home, sip_user_agent_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_user_agent_t *sip_user_agent_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_user_agent_t *sip_user_agent_make(su_home_t *home, char const *s)
{
  return (sip_user_agent_t *)sip_header_make(home, sip_user_agent_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_user_agent_t *sip_user_agent_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_user_agent_t *sip_user_agent_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_user_agent_class, fmt, ap);
  va_end(ap);

  return (sip_user_agent_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_in_reply_to_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_in_reply_to_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_in_reply_to(sip) \
  ((sip_in_reply_to_t *)msg_header_access((msg_pub_t*)(sip), sip_in_reply_to_class))

#define SIP_IN_REPLY_TO_INIT() SIP_HDR_INIT(in_reply_to)

#if SU_HAVE_INLINE
su_inline sip_in_reply_to_t *sip_in_reply_to_init(sip_in_reply_to_t x[1])
{
  return SIP_HEADER_INIT(x, sip_in_reply_to_class, sizeof(sip_in_reply_to_t));
}
#else
#define sip_in_reply_to_init(x) \
  SIP_HEADER_INIT(x, sip_in_reply_to_class, sizeof(sip_in_reply_to_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_in_reply_to(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_in_reply_to_hash;
}
#else
int sip_is_in_reply_to(sip_header_t const *header);
#endif

#define sip_in_reply_to_p(h) sip_is_in_reply_to((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_in_reply_to_t *sip_in_reply_to_dup(su_home_t *home, sip_in_reply_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_in_reply_to_t *sip_in_reply_to_dup(su_home_t *home, sip_in_reply_to_t const *hdr)
{
  return (sip_in_reply_to_t *)
    msg_header_dup_as(home, sip_in_reply_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_in_reply_to_t *sip_in_reply_to_copy(su_home_t *home, sip_in_reply_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_in_reply_to_t *sip_in_reply_to_copy(su_home_t *home, sip_in_reply_to_t const *hdr)
{
  return (sip_in_reply_to_t *)
    msg_header_copy_as(home, sip_in_reply_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_in_reply_to_t *sip_in_reply_to_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_in_reply_to_t *sip_in_reply_to_make(su_home_t *home, char const *s)
{
  return (sip_in_reply_to_t *)sip_header_make(home, sip_in_reply_to_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_in_reply_to_t *sip_in_reply_to_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_in_reply_to_t *sip_in_reply_to_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_in_reply_to_class, fmt, ap);
  va_end(ap);

  return (sip_in_reply_to_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_accept_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_accept_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_accept(sip) \
  ((sip_accept_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_class))

#define SIP_ACCEPT_INIT() SIP_HDR_INIT(accept)

#if SU_HAVE_INLINE
su_inline sip_accept_t *sip_accept_init(sip_accept_t x[1])
{
  return SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t));
}
#else
#define sip_accept_init(x) \
  SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_accept(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_accept_hash;
}
#else
int sip_is_accept(sip_header_t const *header);
#endif

#define sip_accept_p(h) sip_is_accept((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_t *sip_accept_dup(su_home_t *home, sip_accept_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_t *sip_accept_dup(su_home_t *home, sip_accept_t const *hdr)
{
  return (sip_accept_t *)
    msg_header_dup_as(home, sip_accept_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_t *sip_accept_copy(su_home_t *home, sip_accept_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_t *sip_accept_copy(su_home_t *home, sip_accept_t const *hdr)
{
  return (sip_accept_t *)
    msg_header_copy_as(home, sip_accept_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_t *sip_accept_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_accept_t *sip_accept_make(su_home_t *home, char const *s)
{
  return (sip_accept_t *)sip_header_make(home, sip_accept_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_accept_class, fmt, ap);
  va_end(ap);

  return (sip_accept_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_accept_encoding_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_accept_encoding_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_accept_encoding(sip) \
  ((sip_accept_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_encoding_class))

#define SIP_ACCEPT_ENCODING_INIT() SIP_HDR_INIT(accept_encoding)

#if SU_HAVE_INLINE
su_inline sip_accept_encoding_t *sip_accept_encoding_init(sip_accept_encoding_t x[1])
{
  return SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t));
}
#else
#define sip_accept_encoding_init(x) \
  SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_accept_encoding(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_accept_encoding_hash;
}
#else
int sip_is_accept_encoding(sip_header_t const *header);
#endif

#define sip_accept_encoding_p(h) sip_is_accept_encoding((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
{
  return (sip_accept_encoding_t *)
    msg_header_dup_as(home, sip_accept_encoding_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
{
  return (sip_accept_encoding_t *)
    msg_header_copy_as(home, sip_accept_encoding_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
{
  return (sip_accept_encoding_t *)sip_header_make(home, sip_accept_encoding_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_accept_encoding_class, fmt, ap);
  va_end(ap);

  return (sip_accept_encoding_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_accept_language_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_accept_language_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_accept_language(sip) \
  ((sip_accept_language_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_language_class))

#define SIP_ACCEPT_LANGUAGE_INIT() SIP_HDR_INIT(accept_language)

#if SU_HAVE_INLINE
su_inline sip_accept_language_t *sip_accept_language_init(sip_accept_language_t x[1])
{
  return SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t));
}
#else
#define sip_accept_language_init(x) \
  SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_accept_language(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_accept_language_hash;
}
#else
int sip_is_accept_language(sip_header_t const *header);
#endif

#define sip_accept_language_p(h) sip_is_accept_language((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
{
  return (sip_accept_language_t *)
    msg_header_dup_as(home, sip_accept_language_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
{
  return (sip_accept_language_t *)
    msg_header_copy_as(home, sip_accept_language_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
{
  return (sip_accept_language_t *)sip_header_make(home, sip_accept_language_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_accept_language_class, fmt, ap);
  va_end(ap);

  return (sip_accept_language_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_allow_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_allow_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_allow(sip) \
  ((sip_allow_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_class))

#define SIP_ALLOW_INIT() SIP_HDR_INIT(allow)

#if SU_HAVE_INLINE
su_inline sip_allow_t *sip_allow_init(sip_allow_t x[1])
{
  return SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t));
}
#else
#define sip_allow_init(x) \
  SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_allow(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_allow_hash;
}
#else
int sip_is_allow(sip_header_t const *header);
#endif

#define sip_allow_p(h) sip_is_allow((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_t *sip_allow_dup(su_home_t *home, sip_allow_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_allow_t *sip_allow_dup(su_home_t *home, sip_allow_t const *hdr)
{
  return (sip_allow_t *)
    msg_header_dup_as(home, sip_allow_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_t *sip_allow_copy(su_home_t *home, sip_allow_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_allow_t *sip_allow_copy(su_home_t *home, sip_allow_t const *hdr)
{
  return (sip_allow_t *)
    msg_header_copy_as(home, sip_allow_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_t *sip_allow_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_allow_t *sip_allow_make(su_home_t *home, char const *s)
{
  return (sip_allow_t *)sip_header_make(home, sip_allow_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_allow_class, fmt, ap);
  va_end(ap);

  return (sip_allow_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_require_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_require_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_require(sip) \
  ((sip_require_t *)msg_header_access((msg_pub_t*)(sip), sip_require_class))

#define SIP_REQUIRE_INIT() SIP_HDR_INIT(require)

#if SU_HAVE_INLINE
su_inline sip_require_t *sip_require_init(sip_require_t x[1])
{
  return SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t));
}
#else
#define sip_require_init(x) \
  SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_require(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_require_hash;
}
#else
int sip_is_require(sip_header_t const *header);
#endif

#define sip_require_p(h) sip_is_require((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_require_t *sip_require_dup(su_home_t *home, sip_require_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_require_t *sip_require_dup(su_home_t *home, sip_require_t const *hdr)
{
  return (sip_require_t *)
    msg_header_dup_as(home, sip_require_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_require_t *sip_require_copy(su_home_t *home, sip_require_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_require_t *sip_require_copy(su_home_t *home, sip_require_t const *hdr)
{
  return (sip_require_t *)
    msg_header_copy_as(home, sip_require_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_require_t *sip_require_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_require_t *sip_require_make(su_home_t *home, char const *s)
{
  return (sip_require_t *)sip_header_make(home, sip_require_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_require_t *sip_require_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_require_t *sip_require_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_require_class, fmt, ap);
  va_end(ap);

  return (sip_require_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_supported_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_supported_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_supported(sip) \
  ((sip_supported_t *)msg_header_access((msg_pub_t*)(sip), sip_supported_class))

#define SIP_SUPPORTED_INIT() SIP_HDR_INIT(supported)

#if SU_HAVE_INLINE
su_inline sip_supported_t *sip_supported_init(sip_supported_t x[1])
{
  return SIP_HEADER_INIT(x, sip_supported_class, sizeof(sip_supported_t));
}
#else
#define sip_supported_init(x) \
  SIP_HEADER_INIT(x, sip_supported_class, sizeof(sip_supported_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_supported(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_supported_hash;
}
#else
int sip_is_supported(sip_header_t const *header);
#endif

#define sip_supported_p(h) sip_is_supported((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_supported_t *sip_supported_dup(su_home_t *home, sip_supported_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_supported_t *sip_supported_dup(su_home_t *home, sip_supported_t const *hdr)
{
  return (sip_supported_t *)
    msg_header_dup_as(home, sip_supported_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_supported_t *sip_supported_copy(su_home_t *home, sip_supported_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_supported_t *sip_supported_copy(su_home_t *home, sip_supported_t const *hdr)
{
  return (sip_supported_t *)
    msg_header_copy_as(home, sip_supported_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_supported_t *sip_supported_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_supported_t *sip_supported_make(su_home_t *home, char const *s)
{
  return (sip_supported_t *)sip_header_make(home, sip_supported_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_supported_t *sip_supported_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_supported_t *sip_supported_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_supported_class, fmt, ap);
  va_end(ap);

  return (sip_supported_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_unsupported_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_unsupported_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_unsupported(sip) \
  ((sip_unsupported_t *)msg_header_access((msg_pub_t*)(sip), sip_unsupported_class))

#define SIP_UNSUPPORTED_INIT() SIP_HDR_INIT(unsupported)

#if SU_HAVE_INLINE
su_inline sip_unsupported_t *sip_unsupported_init(sip_unsupported_t x[1])
{
  return SIP_HEADER_INIT(x, sip_unsupported_class, sizeof(sip_unsupported_t));
}
#else
#define sip_unsupported_init(x) \
  SIP_HEADER_INIT(x, sip_unsupported_class, sizeof(sip_unsupported_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_unsupported(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_unsupported_hash;
}
#else
int sip_is_unsupported(sip_header_t const *header);
#endif

#define sip_unsupported_p(h) sip_is_unsupported((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_unsupported_t *sip_unsupported_dup(su_home_t *home, sip_unsupported_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_unsupported_t *sip_unsupported_dup(su_home_t *home, sip_unsupported_t const *hdr)
{
  return (sip_unsupported_t *)
    msg_header_dup_as(home, sip_unsupported_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unsupported_t *sip_unsupported_copy(su_home_t *home, sip_unsupported_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_unsupported_t *sip_unsupported_copy(su_home_t *home, sip_unsupported_t const *hdr)
{
  return (sip_unsupported_t *)
    msg_header_copy_as(home, sip_unsupported_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unsupported_t *sip_unsupported_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_unsupported_t *sip_unsupported_make(su_home_t *home, char const *s)
{
  return (sip_unsupported_t *)sip_header_make(home, sip_unsupported_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unsupported_t *sip_unsupported_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_unsupported_t *sip_unsupported_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_unsupported_class, fmt, ap);
  va_end(ap);

  return (sip_unsupported_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_event_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_event_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_event(sip) \
  ((sip_event_t *)msg_header_access((msg_pub_t*)(sip), sip_event_class))

#define SIP_EVENT_INIT() SIP_HDR_INIT(event)

#if SU_HAVE_INLINE
su_inline sip_event_t *sip_event_init(sip_event_t x[1])
{
  return SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t));
}
#else
#define sip_event_init(x) \
  SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_event(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_event_hash;
}
#else
int sip_is_event(sip_header_t const *header);
#endif

#define sip_event_p(h) sip_is_event((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_event_t *sip_event_dup(su_home_t *home, sip_event_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_event_t *sip_event_dup(su_home_t *home, sip_event_t const *hdr)
{
  return (sip_event_t *)
    msg_header_dup_as(home, sip_event_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_event_t *sip_event_copy(su_home_t *home, sip_event_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_event_t *sip_event_copy(su_home_t *home, sip_event_t const *hdr)
{
  return (sip_event_t *)
    msg_header_copy_as(home, sip_event_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_event_t *sip_event_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_event_t *sip_event_make(su_home_t *home, char const *s)
{
  return (sip_event_t *)sip_header_make(home, sip_event_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_event_class, fmt, ap);
  va_end(ap);

  return (sip_event_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_allow_events_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_allow_events_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_allow_events(sip) \
  ((sip_allow_events_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_events_class))

#define SIP_ALLOW_EVENTS_INIT() SIP_HDR_INIT(allow_events)

#if SU_HAVE_INLINE
su_inline sip_allow_events_t *sip_allow_events_init(sip_allow_events_t x[1])
{
  return SIP_HEADER_INIT(x, sip_allow_events_class, sizeof(sip_allow_events_t));
}
#else
#define sip_allow_events_init(x) \
  SIP_HEADER_INIT(x, sip_allow_events_class, sizeof(sip_allow_events_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_allow_events(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_allow_events_hash;
}
#else
int sip_is_allow_events(sip_header_t const *header);
#endif

#define sip_allow_events_p(h) sip_is_allow_events((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_events_t *sip_allow_events_dup(su_home_t *home, sip_allow_events_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_allow_events_t *sip_allow_events_dup(su_home_t *home, sip_allow_events_t const *hdr)
{
  return (sip_allow_events_t *)
    msg_header_dup_as(home, sip_allow_events_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_events_t *sip_allow_events_copy(su_home_t *home, sip_allow_events_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_allow_events_t *sip_allow_events_copy(su_home_t *home, sip_allow_events_t const *hdr)
{
  return (sip_allow_events_t *)
    msg_header_copy_as(home, sip_allow_events_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_events_t *sip_allow_events_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_allow_events_t *sip_allow_events_make(su_home_t *home, char const *s)
{
  return (sip_allow_events_t *)sip_header_make(home, sip_allow_events_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_allow_events_t *sip_allow_events_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_allow_events_t *sip_allow_events_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_allow_events_class, fmt, ap);
  va_end(ap);

  return (sip_allow_events_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_subscription_state_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_subscription_state_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_subscription_state(sip) \
  ((sip_subscription_state_t *)msg_header_access((msg_pub_t*)(sip), sip_subscription_state_class))

#define SIP_SUBSCRIPTION_STATE_INIT() SIP_HDR_INIT(subscription_state)

#if SU_HAVE_INLINE
su_inline sip_subscription_state_t *sip_subscription_state_init(sip_subscription_state_t x[1])
{
  return SIP_HEADER_INIT(x, sip_subscription_state_class, sizeof(sip_subscription_state_t));
}
#else
#define sip_subscription_state_init(x) \
  SIP_HEADER_INIT(x, sip_subscription_state_class, sizeof(sip_subscription_state_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_subscription_state(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_subscription_state_hash;
}
#else
int sip_is_subscription_state(sip_header_t const *header);
#endif

#define sip_subscription_state_p(h) sip_is_subscription_state((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_subscription_state_t *sip_subscription_state_dup(su_home_t *home, sip_subscription_state_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_subscription_state_t *sip_subscription_state_dup(su_home_t *home, sip_subscription_state_t const *hdr)
{
  return (sip_subscription_state_t *)
    msg_header_dup_as(home, sip_subscription_state_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subscription_state_t *sip_subscription_state_copy(su_home_t *home, sip_subscription_state_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_subscription_state_t *sip_subscription_state_copy(su_home_t *home, sip_subscription_state_t const *hdr)
{
  return (sip_subscription_state_t *)
    msg_header_copy_as(home, sip_subscription_state_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subscription_state_t *sip_subscription_state_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_subscription_state_t *sip_subscription_state_make(su_home_t *home, char const *s)
{
  return (sip_subscription_state_t *)sip_header_make(home, sip_subscription_state_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_subscription_state_t *sip_subscription_state_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_subscription_state_t *sip_subscription_state_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_subscription_state_class, fmt, ap);
  va_end(ap);

  return (sip_subscription_state_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_proxy_authenticate_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_proxy_authenticate_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_proxy_authenticate(sip) \
  ((sip_proxy_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authenticate_class))

#define SIP_PROXY_AUTHENTICATE_INIT() SIP_HDR_INIT(proxy_authenticate)

#if SU_HAVE_INLINE
su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_init(sip_proxy_authenticate_t x[1])
{
  return SIP_HEADER_INIT(x, sip_proxy_authenticate_class, sizeof(sip_proxy_authenticate_t));
}
#else
#define sip_proxy_authenticate_init(x) \
  SIP_HEADER_INIT(x, sip_proxy_authenticate_class, sizeof(sip_proxy_authenticate_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_proxy_authenticate(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_proxy_authenticate_hash;
}
#else
int sip_is_proxy_authenticate(sip_header_t const *header);
#endif

#define sip_proxy_authenticate_p(h) sip_is_proxy_authenticate((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authenticate_t *sip_proxy_authenticate_dup(su_home_t *home, sip_proxy_authenticate_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authenticate_t *sip_proxy_authenticate_dup(su_home_t *home, sip_proxy_authenticate_t const *hdr)
{
  return (sip_proxy_authenticate_t *)
    msg_header_dup_as(home, sip_proxy_authenticate_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authenticate_t *sip_proxy_authenticate_copy(su_home_t *home, sip_proxy_authenticate_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authenticate_t *sip_proxy_authenticate_copy(su_home_t *home, sip_proxy_authenticate_t const *hdr)
{
  return (sip_proxy_authenticate_t *)
    msg_header_copy_as(home, sip_proxy_authenticate_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authenticate_t *sip_proxy_authenticate_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_make(su_home_t *home, char const *s)
{
  return (sip_proxy_authenticate_t *)sip_header_make(home, sip_proxy_authenticate_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authenticate_t *sip_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_proxy_authenticate_class, fmt, ap);
  va_end(ap);

  return (sip_proxy_authenticate_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_proxy_authentication_info_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_proxy_authentication_info_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_proxy_authentication_info(sip) \
  ((sip_proxy_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authentication_info_class))

#define SIP_PROXY_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(proxy_authentication_info)

#if SU_HAVE_INLINE
su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_init(sip_proxy_authentication_info_t x[1])
{
  return SIP_HEADER_INIT(x, sip_proxy_authentication_info_class, sizeof(sip_proxy_authentication_info_t));
}
#else
#define sip_proxy_authentication_info_init(x) \
  SIP_HEADER_INIT(x, sip_proxy_authentication_info_class, sizeof(sip_proxy_authentication_info_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_proxy_authentication_info(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_proxy_authentication_info_hash;
}
#else
int sip_is_proxy_authentication_info(sip_header_t const *header);
#endif

#define sip_proxy_authentication_info_p(h) sip_is_proxy_authentication_info((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authentication_info_t *sip_proxy_authentication_info_dup(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authentication_info_t *sip_proxy_authentication_info_dup(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
{
  return (sip_proxy_authentication_info_t *)
    msg_header_dup_as(home, sip_proxy_authentication_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authentication_info_t *sip_proxy_authentication_info_copy(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authentication_info_t *sip_proxy_authentication_info_copy(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
{
  return (sip_proxy_authentication_info_t *)
    msg_header_copy_as(home, sip_proxy_authentication_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authentication_info_t *sip_proxy_authentication_info_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_make(su_home_t *home, char const *s)
{
  return (sip_proxy_authentication_info_t *)sip_header_make(home, sip_proxy_authentication_info_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authentication_info_t *sip_proxy_authentication_info_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_proxy_authentication_info_class, fmt, ap);
  va_end(ap);

  return (sip_proxy_authentication_info_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_proxy_authorization_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_proxy_authorization_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_proxy_authorization(sip) \
  ((sip_proxy_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authorization_class))

#define SIP_PROXY_AUTHORIZATION_INIT() SIP_HDR_INIT(proxy_authorization)

#if SU_HAVE_INLINE
su_inline sip_proxy_authorization_t *sip_proxy_authorization_init(sip_proxy_authorization_t x[1])
{
  return SIP_HEADER_INIT(x, sip_proxy_authorization_class, sizeof(sip_proxy_authorization_t));
}
#else
#define sip_proxy_authorization_init(x) \
  SIP_HEADER_INIT(x, sip_proxy_authorization_class, sizeof(sip_proxy_authorization_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_proxy_authorization(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_proxy_authorization_hash;
}
#else
int sip_is_proxy_authorization(sip_header_t const *header);
#endif

#define sip_proxy_authorization_p(h) sip_is_proxy_authorization((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authorization_t *sip_proxy_authorization_dup(su_home_t *home, sip_proxy_authorization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authorization_t *sip_proxy_authorization_dup(su_home_t *home, sip_proxy_authorization_t const *hdr)
{
  return (sip_proxy_authorization_t *)
    msg_header_dup_as(home, sip_proxy_authorization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authorization_t *sip_proxy_authorization_copy(su_home_t *home, sip_proxy_authorization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_proxy_authorization_t *sip_proxy_authorization_copy(su_home_t *home, sip_proxy_authorization_t const *hdr)
{
  return (sip_proxy_authorization_t *)
    msg_header_copy_as(home, sip_proxy_authorization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authorization_t *sip_proxy_authorization_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_proxy_authorization_t *sip_proxy_authorization_make(su_home_t *home, char const *s)
{
  return (sip_proxy_authorization_t *)sip_header_make(home, sip_proxy_authorization_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_proxy_authorization_t *sip_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_proxy_authorization_t *sip_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_proxy_authorization_class, fmt, ap);
  va_end(ap);

  return (sip_proxy_authorization_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_authorization_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_authorization_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_authorization(sip) \
  ((sip_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_authorization_class))

#define SIP_AUTHORIZATION_INIT() SIP_HDR_INIT(authorization)

#if SU_HAVE_INLINE
su_inline sip_authorization_t *sip_authorization_init(sip_authorization_t x[1])
{
  return SIP_HEADER_INIT(x, sip_authorization_class, sizeof(sip_authorization_t));
}
#else
#define sip_authorization_init(x) \
  SIP_HEADER_INIT(x, sip_authorization_class, sizeof(sip_authorization_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_authorization(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_authorization_hash;
}
#else
int sip_is_authorization(sip_header_t const *header);
#endif

#define sip_authorization_p(h) sip_is_authorization((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_authorization_t *sip_authorization_dup(su_home_t *home, sip_authorization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_authorization_t *sip_authorization_dup(su_home_t *home, sip_authorization_t const *hdr)
{
  return (sip_authorization_t *)
    msg_header_dup_as(home, sip_authorization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authorization_t *sip_authorization_copy(su_home_t *home, sip_authorization_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_authorization_t *sip_authorization_copy(su_home_t *home, sip_authorization_t const *hdr)
{
  return (sip_authorization_t *)
    msg_header_copy_as(home, sip_authorization_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authorization_t *sip_authorization_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_authorization_t *sip_authorization_make(su_home_t *home, char const *s)
{
  return (sip_authorization_t *)sip_header_make(home, sip_authorization_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authorization_t *sip_authorization_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_authorization_t *sip_authorization_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_authorization_class, fmt, ap);
  va_end(ap);

  return (sip_authorization_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_www_authenticate_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_www_authenticate_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_www_authenticate(sip) \
  ((sip_www_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_www_authenticate_class))

#define SIP_WWW_AUTHENTICATE_INIT() SIP_HDR_INIT(www_authenticate)

#if SU_HAVE_INLINE
su_inline sip_www_authenticate_t *sip_www_authenticate_init(sip_www_authenticate_t x[1])
{
  return SIP_HEADER_INIT(x, sip_www_authenticate_class, sizeof(sip_www_authenticate_t));
}
#else
#define sip_www_authenticate_init(x) \
  SIP_HEADER_INIT(x, sip_www_authenticate_class, sizeof(sip_www_authenticate_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_www_authenticate(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_www_authenticate_hash;
}
#else
int sip_is_www_authenticate(sip_header_t const *header);
#endif

#define sip_www_authenticate_p(h) sip_is_www_authenticate((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_www_authenticate_t *sip_www_authenticate_dup(su_home_t *home, sip_www_authenticate_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_www_authenticate_t *sip_www_authenticate_dup(su_home_t *home, sip_www_authenticate_t const *hdr)
{
  return (sip_www_authenticate_t *)
    msg_header_dup_as(home, sip_www_authenticate_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_www_authenticate_t *sip_www_authenticate_copy(su_home_t *home, sip_www_authenticate_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_www_authenticate_t *sip_www_authenticate_copy(su_home_t *home, sip_www_authenticate_t const *hdr)
{
  return (sip_www_authenticate_t *)
    msg_header_copy_as(home, sip_www_authenticate_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_www_authenticate_t *sip_www_authenticate_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_www_authenticate_t *sip_www_authenticate_make(su_home_t *home, char const *s)
{
  return (sip_www_authenticate_t *)sip_header_make(home, sip_www_authenticate_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_www_authenticate_t *sip_www_authenticate_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_www_authenticate_t *sip_www_authenticate_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_www_authenticate_class, fmt, ap);
  va_end(ap);

  return (sip_www_authenticate_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_authentication_info_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_authentication_info_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_authentication_info(sip) \
  ((sip_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_authentication_info_class))

#define SIP_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(authentication_info)

#if SU_HAVE_INLINE
su_inline sip_authentication_info_t *sip_authentication_info_init(sip_authentication_info_t x[1])
{
  return SIP_HEADER_INIT(x, sip_authentication_info_class, sizeof(sip_authentication_info_t));
}
#else
#define sip_authentication_info_init(x) \
  SIP_HEADER_INIT(x, sip_authentication_info_class, sizeof(sip_authentication_info_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_authentication_info(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_authentication_info_hash;
}
#else
int sip_is_authentication_info(sip_header_t const *header);
#endif

#define sip_authentication_info_p(h) sip_is_authentication_info((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_authentication_info_t *sip_authentication_info_dup(su_home_t *home, sip_authentication_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_authentication_info_t *sip_authentication_info_dup(su_home_t *home, sip_authentication_info_t const *hdr)
{
  return (sip_authentication_info_t *)
    msg_header_dup_as(home, sip_authentication_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authentication_info_t *sip_authentication_info_copy(su_home_t *home, sip_authentication_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_authentication_info_t *sip_authentication_info_copy(su_home_t *home, sip_authentication_info_t const *hdr)
{
  return (sip_authentication_info_t *)
    msg_header_copy_as(home, sip_authentication_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authentication_info_t *sip_authentication_info_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_authentication_info_t *sip_authentication_info_make(su_home_t *home, char const *s)
{
  return (sip_authentication_info_t *)sip_header_make(home, sip_authentication_info_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_authentication_info_t *sip_authentication_info_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_authentication_info_t *sip_authentication_info_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_authentication_info_class, fmt, ap);
  va_end(ap);

  return (sip_authentication_info_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_error_info_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_error_info_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_error_info(sip) \
  ((sip_error_info_t *)msg_header_access((msg_pub_t*)(sip), sip_error_info_class))

#define SIP_ERROR_INFO_INIT() SIP_HDR_INIT(error_info)

#if SU_HAVE_INLINE
su_inline sip_error_info_t *sip_error_info_init(sip_error_info_t x[1])
{
  return SIP_HEADER_INIT(x, sip_error_info_class, sizeof(sip_error_info_t));
}
#else
#define sip_error_info_init(x) \
  SIP_HEADER_INIT(x, sip_error_info_class, sizeof(sip_error_info_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_error_info(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_error_info_hash;
}
#else
int sip_is_error_info(sip_header_t const *header);
#endif

#define sip_error_info_p(h) sip_is_error_info((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_error_info_t *sip_error_info_dup(su_home_t *home, sip_error_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_error_info_t *sip_error_info_dup(su_home_t *home, sip_error_info_t const *hdr)
{
  return (sip_error_info_t *)
    msg_header_dup_as(home, sip_error_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_info_t *sip_error_info_copy(su_home_t *home, sip_error_info_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_error_info_t *sip_error_info_copy(su_home_t *home, sip_error_info_t const *hdr)
{
  return (sip_error_info_t *)
    msg_header_copy_as(home, sip_error_info_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_info_t *sip_error_info_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_error_info_t *sip_error_info_make(su_home_t *home, char const *s)
{
  return (sip_error_info_t *)sip_header_make(home, sip_error_info_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_info_t *sip_error_info_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_error_info_t *sip_error_info_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_error_info_class, fmt, ap);
  va_end(ap);

  return (sip_error_info_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_warning_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_warning_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_warning(sip) \
  ((sip_warning_t *)msg_header_access((msg_pub_t*)(sip), sip_warning_class))

#define SIP_WARNING_INIT() SIP_HDR_INIT(warning)

#if SU_HAVE_INLINE
su_inline sip_warning_t *sip_warning_init(sip_warning_t x[1])
{
  return SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t));
}
#else
#define sip_warning_init(x) \
  SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_warning(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_warning_hash;
}
#else
int sip_is_warning(sip_header_t const *header);
#endif

#define sip_warning_p(h) sip_is_warning((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
{
  return (sip_warning_t *)
    msg_header_dup_as(home, sip_warning_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
{
  return (sip_warning_t *)
    msg_header_copy_as(home, sip_warning_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
{
  return (sip_warning_t *)sip_header_make(home, sip_warning_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_warning_class, fmt, ap);
  va_end(ap);

  return (sip_warning_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_refer_to_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_refer_to_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_refer_to(sip) \
  ((sip_refer_to_t *)msg_header_access((msg_pub_t*)(sip), sip_refer_to_class))

#define SIP_REFER_TO_INIT() SIP_HDR_INIT(refer_to)

#if SU_HAVE_INLINE
su_inline sip_refer_to_t *sip_refer_to_init(sip_refer_to_t x[1])
{
  return SIP_HEADER_INIT(x, sip_refer_to_class, sizeof(sip_refer_to_t));
}
#else
#define sip_refer_to_init(x) \
  SIP_HEADER_INIT(x, sip_refer_to_class, sizeof(sip_refer_to_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_refer_to(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_refer_to_hash;
}
#else
int sip_is_refer_to(sip_header_t const *header);
#endif

#define sip_refer_to_p(h) sip_is_refer_to((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_refer_to_t *sip_refer_to_dup(su_home_t *home, sip_refer_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_refer_to_t *sip_refer_to_dup(su_home_t *home, sip_refer_to_t const *hdr)
{
  return (sip_refer_to_t *)
    msg_header_dup_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_refer_to_t *sip_refer_to_copy(su_home_t *home, sip_refer_to_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_refer_to_t *sip_refer_to_copy(su_home_t *home, sip_refer_to_t const *hdr)
{
  return (sip_refer_to_t *)
    msg_header_copy_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_refer_to_t *sip_refer_to_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_refer_to_t *sip_refer_to_make(su_home_t *home, char const *s)
{
  return (sip_refer_to_t *)sip_header_make(home, sip_refer_to_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_refer_to_t *sip_refer_to_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_refer_to_t *sip_refer_to_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_refer_to_class, fmt, ap);
  va_end(ap);

  return (sip_refer_to_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_referred_by_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_referred_by_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_referred_by(sip) \
  ((sip_referred_by_t *)msg_header_access((msg_pub_t*)(sip), sip_referred_by_class))

#define SIP_REFERRED_BY_INIT() SIP_HDR_INIT(referred_by)

#if SU_HAVE_INLINE
su_inline sip_referred_by_t *sip_referred_by_init(sip_referred_by_t x[1])
{
  return SIP_HEADER_INIT(x, sip_referred_by_class, sizeof(sip_referred_by_t));
}
#else
#define sip_referred_by_init(x) \
  SIP_HEADER_INIT(x, sip_referred_by_class, sizeof(sip_referred_by_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_referred_by(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_referred_by_hash;
}
#else
int sip_is_referred_by(sip_header_t const *header);
#endif

#define sip_referred_by_p(h) sip_is_referred_by((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_referred_by_t *sip_referred_by_dup(su_home_t *home, sip_referred_by_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_referred_by_t *sip_referred_by_dup(su_home_t *home, sip_referred_by_t const *hdr)
{
  return (sip_referred_by_t *)
    msg_header_dup_as(home, sip_referred_by_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_referred_by_t *sip_referred_by_copy(su_home_t *home, sip_referred_by_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_referred_by_t *sip_referred_by_copy(su_home_t *home, sip_referred_by_t const *hdr)
{
  return (sip_referred_by_t *)
    msg_header_copy_as(home, sip_referred_by_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_referred_by_t *sip_referred_by_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_referred_by_t *sip_referred_by_make(su_home_t *home, char const *s)
{
  return (sip_referred_by_t *)sip_header_make(home, sip_referred_by_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_referred_by_t *sip_referred_by_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_referred_by_t *sip_referred_by_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_referred_by_class, fmt, ap);
  va_end(ap);

  return (sip_referred_by_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_replaces_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_replaces_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_replaces(sip) \
  ((sip_replaces_t *)msg_header_access((msg_pub_t*)(sip), sip_replaces_class))

#define SIP_REPLACES_INIT() SIP_HDR_INIT(replaces)

#if SU_HAVE_INLINE
su_inline sip_replaces_t *sip_replaces_init(sip_replaces_t x[1])
{
  return SIP_HEADER_INIT(x, sip_replaces_class, sizeof(sip_replaces_t));
}
#else
#define sip_replaces_init(x) \
  SIP_HEADER_INIT(x, sip_replaces_class, sizeof(sip_replaces_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_replaces(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_replaces_hash;
}
#else
int sip_is_replaces(sip_header_t const *header);
#endif

#define sip_replaces_p(h) sip_is_replaces((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_replaces_t *sip_replaces_dup(su_home_t *home, sip_replaces_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_replaces_t *sip_replaces_dup(su_home_t *home, sip_replaces_t const *hdr)
{
  return (sip_replaces_t *)
    msg_header_dup_as(home, sip_replaces_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_replaces_t *sip_replaces_copy(su_home_t *home, sip_replaces_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_replaces_t *sip_replaces_copy(su_home_t *home, sip_replaces_t const *hdr)
{
  return (sip_replaces_t *)
    msg_header_copy_as(home, sip_replaces_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_replaces_t *sip_replaces_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_replaces_t *sip_replaces_make(su_home_t *home, char const *s)
{
  return (sip_replaces_t *)sip_header_make(home, sip_replaces_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_replaces_t *sip_replaces_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_replaces_t *sip_replaces_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_replaces_class, fmt, ap);
  va_end(ap);

  return (sip_replaces_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_session_expires_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_session_expires_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_session_expires(sip) \
  ((sip_session_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_session_expires_class))

#define SIP_SESSION_EXPIRES_INIT() SIP_HDR_INIT(session_expires)

#if SU_HAVE_INLINE
su_inline sip_session_expires_t *sip_session_expires_init(sip_session_expires_t x[1])
{
  return SIP_HEADER_INIT(x, sip_session_expires_class, sizeof(sip_session_expires_t));
}
#else
#define sip_session_expires_init(x) \
  SIP_HEADER_INIT(x, sip_session_expires_class, sizeof(sip_session_expires_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_session_expires(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_session_expires_hash;
}
#else
int sip_is_session_expires(sip_header_t const *header);
#endif

#define sip_session_expires_p(h) sip_is_session_expires((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_session_expires_t *sip_session_expires_dup(su_home_t *home, sip_session_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_session_expires_t *sip_session_expires_dup(su_home_t *home, sip_session_expires_t const *hdr)
{
  return (sip_session_expires_t *)
    msg_header_dup_as(home, sip_session_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_session_expires_t *sip_session_expires_copy(su_home_t *home, sip_session_expires_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_session_expires_t *sip_session_expires_copy(su_home_t *home, sip_session_expires_t const *hdr)
{
  return (sip_session_expires_t *)
    msg_header_copy_as(home, sip_session_expires_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_session_expires_t *sip_session_expires_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_session_expires_t *sip_session_expires_make(su_home_t *home, char const *s)
{
  return (sip_session_expires_t *)sip_header_make(home, sip_session_expires_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_session_expires_t *sip_session_expires_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_session_expires_t *sip_session_expires_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_session_expires_class, fmt, ap);
  va_end(ap);

  return (sip_session_expires_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_min_se_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_min_se_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_min_se(sip) \
  ((sip_min_se_t *)msg_header_access((msg_pub_t*)(sip), sip_min_se_class))

#define SIP_MIN_SE_INIT() SIP_HDR_INIT(min_se)

#if SU_HAVE_INLINE
su_inline sip_min_se_t *sip_min_se_init(sip_min_se_t x[1])
{
  return SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t));
}
#else
#define sip_min_se_init(x) \
  SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_min_se(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_min_se_hash;
}
#else
int sip_is_min_se(sip_header_t const *header);
#endif

#define sip_min_se_p(h) sip_is_min_se((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_min_se_t *sip_min_se_dup(su_home_t *home, sip_min_se_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_min_se_t *sip_min_se_dup(su_home_t *home, sip_min_se_t const *hdr)
{
  return (sip_min_se_t *)
    msg_header_dup_as(home, sip_min_se_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_se_t *sip_min_se_copy(su_home_t *home, sip_min_se_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_min_se_t *sip_min_se_copy(su_home_t *home, sip_min_se_t const *hdr)
{
  return (sip_min_se_t *)
    msg_header_copy_as(home, sip_min_se_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_se_t *sip_min_se_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_min_se_t *sip_min_se_make(su_home_t *home, char const *s)
{
  return (sip_min_se_t *)sip_header_make(home, sip_min_se_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_min_se_class, fmt, ap);
  va_end(ap);

  return (sip_min_se_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_path_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_path_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_path(sip) \
  ((sip_path_t *)msg_header_access((msg_pub_t*)(sip), sip_path_class))

#define SIP_PATH_INIT() SIP_HDR_INIT(path)

#if SU_HAVE_INLINE
su_inline sip_path_t *sip_path_init(sip_path_t x[1])
{
  return SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t));
}
#else
#define sip_path_init(x) \
  SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_path(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_path_hash;
}
#else
int sip_is_path(sip_header_t const *header);
#endif

#define sip_path_p(h) sip_is_path((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
{
  return (sip_path_t *)
    msg_header_dup_as(home, sip_path_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
{
  return (sip_path_t *)
    msg_header_copy_as(home, sip_path_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_path_t *sip_path_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_path_t *sip_path_make(su_home_t *home, char const *s)
{
  return (sip_path_t *)sip_header_make(home, sip_path_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_path_class, fmt, ap);
  va_end(ap);

  return (sip_path_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_service_route_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_service_route_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_service_route(sip) \
  ((sip_service_route_t *)msg_header_access((msg_pub_t*)(sip), sip_service_route_class))

#define SIP_SERVICE_ROUTE_INIT() SIP_HDR_INIT(service_route)

#if SU_HAVE_INLINE
su_inline sip_service_route_t *sip_service_route_init(sip_service_route_t x[1])
{
  return SIP_HEADER_INIT(x, sip_service_route_class, sizeof(sip_service_route_t));
}
#else
#define sip_service_route_init(x) \
  SIP_HEADER_INIT(x, sip_service_route_class, sizeof(sip_service_route_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_service_route(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_service_route_hash;
}
#else
int sip_is_service_route(sip_header_t const *header);
#endif

#define sip_service_route_p(h) sip_is_service_route((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_service_route_t *sip_service_route_dup(su_home_t *home, sip_service_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_service_route_t *sip_service_route_dup(su_home_t *home, sip_service_route_t const *hdr)
{
  return (sip_service_route_t *)
    msg_header_dup_as(home, sip_service_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_service_route_t *sip_service_route_copy(su_home_t *home, sip_service_route_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_service_route_t *sip_service_route_copy(su_home_t *home, sip_service_route_t const *hdr)
{
  return (sip_service_route_t *)
    msg_header_copy_as(home, sip_service_route_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_service_route_t *sip_service_route_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_service_route_t *sip_service_route_make(su_home_t *home, char const *s)
{
  return (sip_service_route_t *)sip_header_make(home, sip_service_route_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_service_route_t *sip_service_route_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_service_route_t *sip_service_route_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_service_route_class, fmt, ap);
  va_end(ap);

  return (sip_service_route_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_reason_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_reason_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_reason(sip) \
  ((sip_reason_t *)msg_header_access((msg_pub_t*)(sip), sip_reason_class))

#define SIP_REASON_INIT() SIP_HDR_INIT(reason)

#if SU_HAVE_INLINE
su_inline sip_reason_t *sip_reason_init(sip_reason_t x[1])
{
  return SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t));
}
#else
#define sip_reason_init(x) \
  SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_reason(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_reason_hash;
}
#else
int sip_is_reason(sip_header_t const *header);
#endif

#define sip_reason_p(h) sip_is_reason((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_reason_t *sip_reason_dup(su_home_t *home, sip_reason_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_reason_t *sip_reason_dup(su_home_t *home, sip_reason_t const *hdr)
{
  return (sip_reason_t *)
    msg_header_dup_as(home, sip_reason_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reason_t *sip_reason_copy(su_home_t *home, sip_reason_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_reason_t *sip_reason_copy(su_home_t *home, sip_reason_t const *hdr)
{
  return (sip_reason_t *)
    msg_header_copy_as(home, sip_reason_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reason_t *sip_reason_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_reason_t *sip_reason_make(su_home_t *home, char const *s)
{
  return (sip_reason_t *)sip_header_make(home, sip_reason_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_reason_class, fmt, ap);
  va_end(ap);

  return (sip_reason_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_security_client_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_security_client_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_security_client(sip) \
  ((sip_security_client_t *)msg_header_access((msg_pub_t*)(sip), sip_security_client_class))

#define SIP_SECURITY_CLIENT_INIT() SIP_HDR_INIT(security_client)

#if SU_HAVE_INLINE
su_inline sip_security_client_t *sip_security_client_init(sip_security_client_t x[1])
{
  return SIP_HEADER_INIT(x, sip_security_client_class, sizeof(sip_security_client_t));
}
#else
#define sip_security_client_init(x) \
  SIP_HEADER_INIT(x, sip_security_client_class, sizeof(sip_security_client_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_security_client(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_security_client_hash;
}
#else
int sip_is_security_client(sip_header_t const *header);
#endif

#define sip_security_client_p(h) sip_is_security_client((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_security_client_t *sip_security_client_dup(su_home_t *home, sip_security_client_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_client_t *sip_security_client_dup(su_home_t *home, sip_security_client_t const *hdr)
{
  return (sip_security_client_t *)
    msg_header_dup_as(home, sip_security_client_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_client_t *sip_security_client_copy(su_home_t *home, sip_security_client_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_client_t *sip_security_client_copy(su_home_t *home, sip_security_client_t const *hdr)
{
  return (sip_security_client_t *)
    msg_header_copy_as(home, sip_security_client_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_client_t *sip_security_client_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_security_client_t *sip_security_client_make(su_home_t *home, char const *s)
{
  return (sip_security_client_t *)sip_header_make(home, sip_security_client_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_client_t *sip_security_client_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_security_client_t *sip_security_client_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_security_client_class, fmt, ap);
  va_end(ap);

  return (sip_security_client_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_security_server_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_security_server_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_security_server(sip) \
  ((sip_security_server_t *)msg_header_access((msg_pub_t*)(sip), sip_security_server_class))

#define SIP_SECURITY_SERVER_INIT() SIP_HDR_INIT(security_server)

#if SU_HAVE_INLINE
su_inline sip_security_server_t *sip_security_server_init(sip_security_server_t x[1])
{
  return SIP_HEADER_INIT(x, sip_security_server_class, sizeof(sip_security_server_t));
}
#else
#define sip_security_server_init(x) \
  SIP_HEADER_INIT(x, sip_security_server_class, sizeof(sip_security_server_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_security_server(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_security_server_hash;
}
#else
int sip_is_security_server(sip_header_t const *header);
#endif

#define sip_security_server_p(h) sip_is_security_server((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_security_server_t *sip_security_server_dup(su_home_t *home, sip_security_server_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_server_t *sip_security_server_dup(su_home_t *home, sip_security_server_t const *hdr)
{
  return (sip_security_server_t *)
    msg_header_dup_as(home, sip_security_server_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_server_t *sip_security_server_copy(su_home_t *home, sip_security_server_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_server_t *sip_security_server_copy(su_home_t *home, sip_security_server_t const *hdr)
{
  return (sip_security_server_t *)
    msg_header_copy_as(home, sip_security_server_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_server_t *sip_security_server_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_security_server_t *sip_security_server_make(su_home_t *home, char const *s)
{
  return (sip_security_server_t *)sip_header_make(home, sip_security_server_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_server_t *sip_security_server_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_security_server_t *sip_security_server_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_security_server_class, fmt, ap);
  va_end(ap);

  return (sip_security_server_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_security_verify_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_security_verify_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_security_verify(sip) \
  ((sip_security_verify_t *)msg_header_access((msg_pub_t*)(sip), sip_security_verify_class))

#define SIP_SECURITY_VERIFY_INIT() SIP_HDR_INIT(security_verify)

#if SU_HAVE_INLINE
su_inline sip_security_verify_t *sip_security_verify_init(sip_security_verify_t x[1])
{
  return SIP_HEADER_INIT(x, sip_security_verify_class, sizeof(sip_security_verify_t));
}
#else
#define sip_security_verify_init(x) \
  SIP_HEADER_INIT(x, sip_security_verify_class, sizeof(sip_security_verify_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_security_verify(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_security_verify_hash;
}
#else
int sip_is_security_verify(sip_header_t const *header);
#endif

#define sip_security_verify_p(h) sip_is_security_verify((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_security_verify_t *sip_security_verify_dup(su_home_t *home, sip_security_verify_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_verify_t *sip_security_verify_dup(su_home_t *home, sip_security_verify_t const *hdr)
{
  return (sip_security_verify_t *)
    msg_header_dup_as(home, sip_security_verify_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_verify_t *sip_security_verify_copy(su_home_t *home, sip_security_verify_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_security_verify_t *sip_security_verify_copy(su_home_t *home, sip_security_verify_t const *hdr)
{
  return (sip_security_verify_t *)
    msg_header_copy_as(home, sip_security_verify_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_verify_t *sip_security_verify_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_security_verify_t *sip_security_verify_make(su_home_t *home, char const *s)
{
  return (sip_security_verify_t *)sip_header_make(home, sip_security_verify_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_security_verify_t *sip_security_verify_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_security_verify_t *sip_security_verify_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_security_verify_class, fmt, ap);
  va_end(ap);

  return (sip_security_verify_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_privacy_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_privacy_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_privacy(sip) \
  ((sip_privacy_t *)msg_header_access((msg_pub_t*)(sip), sip_privacy_class))

#define SIP_PRIVACY_INIT() SIP_HDR_INIT(privacy)

#if SU_HAVE_INLINE
su_inline sip_privacy_t *sip_privacy_init(sip_privacy_t x[1])
{
  return SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t));
}
#else
#define sip_privacy_init(x) \
  SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_privacy(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_privacy_hash;
}
#else
int sip_is_privacy(sip_header_t const *header);
#endif

#define sip_privacy_p(h) sip_is_privacy((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_privacy_t *sip_privacy_dup(su_home_t *home, sip_privacy_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_privacy_t *sip_privacy_dup(su_home_t *home, sip_privacy_t const *hdr)
{
  return (sip_privacy_t *)
    msg_header_dup_as(home, sip_privacy_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_privacy_t *sip_privacy_copy(su_home_t *home, sip_privacy_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_privacy_t *sip_privacy_copy(su_home_t *home, sip_privacy_t const *hdr)
{
  return (sip_privacy_t *)
    msg_header_copy_as(home, sip_privacy_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_privacy_t *sip_privacy_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_privacy_t *sip_privacy_make(su_home_t *home, char const *s)
{
  return (sip_privacy_t *)sip_header_make(home, sip_privacy_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_privacy_t *sip_privacy_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_privacy_t *sip_privacy_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_privacy_class, fmt, ap);
  va_end(ap);

  return (sip_privacy_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_etag_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_etag_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_etag(sip) \
  ((sip_etag_t *)msg_header_access((msg_pub_t*)(sip), sip_etag_class))

#define SIP_ETAG_INIT() SIP_HDR_INIT(etag)

#if SU_HAVE_INLINE
su_inline sip_etag_t *sip_etag_init(sip_etag_t x[1])
{
  return SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t));
}
#else
#define sip_etag_init(x) \
  SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_etag(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_etag_hash;
}
#else
int sip_is_etag(sip_header_t const *header);
#endif

#define sip_etag_p(h) sip_is_etag((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
{
  return (sip_etag_t *)
    msg_header_dup_as(home, sip_etag_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
{
  return (sip_etag_t *)
    msg_header_copy_as(home, sip_etag_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_etag_t *sip_etag_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_etag_t *sip_etag_make(su_home_t *home, char const *s)
{
  return (sip_etag_t *)sip_header_make(home, sip_etag_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_etag_class, fmt, ap);
  va_end(ap);

  return (sip_etag_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_if_match_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_if_match_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_if_match(sip) \
  ((sip_if_match_t *)msg_header_access((msg_pub_t*)(sip), sip_if_match_class))

#define SIP_IF_MATCH_INIT() SIP_HDR_INIT(if_match)

#if SU_HAVE_INLINE
su_inline sip_if_match_t *sip_if_match_init(sip_if_match_t x[1])
{
  return SIP_HEADER_INIT(x, sip_if_match_class, sizeof(sip_if_match_t));
}
#else
#define sip_if_match_init(x) \
  SIP_HEADER_INIT(x, sip_if_match_class, sizeof(sip_if_match_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_if_match(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_if_match_hash;
}
#else
int sip_is_if_match(sip_header_t const *header);
#endif

#define sip_if_match_p(h) sip_is_if_match((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_if_match_t *sip_if_match_dup(su_home_t *home, sip_if_match_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_if_match_t *sip_if_match_dup(su_home_t *home, sip_if_match_t const *hdr)
{
  return (sip_if_match_t *)
    msg_header_dup_as(home, sip_if_match_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_if_match_t *sip_if_match_copy(su_home_t *home, sip_if_match_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_if_match_t *sip_if_match_copy(su_home_t *home, sip_if_match_t const *hdr)
{
  return (sip_if_match_t *)
    msg_header_copy_as(home, sip_if_match_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_if_match_t *sip_if_match_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_if_match_t *sip_if_match_make(su_home_t *home, char const *s)
{
  return (sip_if_match_t *)sip_header_make(home, sip_if_match_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_if_match_t *sip_if_match_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_if_match_t *sip_if_match_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_if_match_class, fmt, ap);
  va_end(ap);

  return (sip_if_match_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_mime_version_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_mime_version_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_mime_version(sip) \
  ((sip_mime_version_t *)msg_header_access((msg_pub_t*)(sip), sip_mime_version_class))

#define SIP_MIME_VERSION_INIT() SIP_HDR_INIT(mime_version)

#if SU_HAVE_INLINE
su_inline sip_mime_version_t *sip_mime_version_init(sip_mime_version_t x[1])
{
  return SIP_HEADER_INIT(x, sip_mime_version_class, sizeof(sip_mime_version_t));
}
#else
#define sip_mime_version_init(x) \
  SIP_HEADER_INIT(x, sip_mime_version_class, sizeof(sip_mime_version_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_mime_version(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_mime_version_hash;
}
#else
int sip_is_mime_version(sip_header_t const *header);
#endif

#define sip_mime_version_p(h) sip_is_mime_version((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_mime_version_t *sip_mime_version_dup(su_home_t *home, sip_mime_version_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_mime_version_t *sip_mime_version_dup(su_home_t *home, sip_mime_version_t const *hdr)
{
  return (sip_mime_version_t *)
    msg_header_dup_as(home, sip_mime_version_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_mime_version_t *sip_mime_version_copy(su_home_t *home, sip_mime_version_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_mime_version_t *sip_mime_version_copy(su_home_t *home, sip_mime_version_t const *hdr)
{
  return (sip_mime_version_t *)
    msg_header_copy_as(home, sip_mime_version_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_mime_version_t *sip_mime_version_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_mime_version_t *sip_mime_version_make(su_home_t *home, char const *s)
{
  return (sip_mime_version_t *)sip_header_make(home, sip_mime_version_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_mime_version_t *sip_mime_version_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_mime_version_t *sip_mime_version_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_mime_version_class, fmt, ap);
  va_end(ap);

  return (sip_mime_version_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_content_type_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_content_type_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_content_type(sip) \
  ((sip_content_type_t *)msg_header_access((msg_pub_t*)(sip), sip_content_type_class))

#define SIP_CONTENT_TYPE_INIT() SIP_HDR_INIT(content_type)

#if SU_HAVE_INLINE
su_inline sip_content_type_t *sip_content_type_init(sip_content_type_t x[1])
{
  return SIP_HEADER_INIT(x, sip_content_type_class, sizeof(sip_content_type_t));
}
#else
#define sip_content_type_init(x) \
  SIP_HEADER_INIT(x, sip_content_type_class, sizeof(sip_content_type_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_content_type(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_content_type_hash;
}
#else
int sip_is_content_type(sip_header_t const *header);
#endif

#define sip_content_type_p(h) sip_is_content_type((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_content_type_t *sip_content_type_dup(su_home_t *home, sip_content_type_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_type_t *sip_content_type_dup(su_home_t *home, sip_content_type_t const *hdr)
{
  return (sip_content_type_t *)
    msg_header_dup_as(home, sip_content_type_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_type_t *sip_content_type_copy(su_home_t *home, sip_content_type_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_type_t *sip_content_type_copy(su_home_t *home, sip_content_type_t const *hdr)
{
  return (sip_content_type_t *)
    msg_header_copy_as(home, sip_content_type_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_type_t *sip_content_type_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_content_type_t *sip_content_type_make(su_home_t *home, char const *s)
{
  return (sip_content_type_t *)sip_header_make(home, sip_content_type_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_type_t *sip_content_type_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_content_type_t *sip_content_type_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_content_type_class, fmt, ap);
  va_end(ap);

  return (sip_content_type_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_content_encoding_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_content_encoding_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_content_encoding(sip) \
  ((sip_content_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_content_encoding_class))

#define SIP_CONTENT_ENCODING_INIT() SIP_HDR_INIT(content_encoding)

#if SU_HAVE_INLINE
su_inline sip_content_encoding_t *sip_content_encoding_init(sip_content_encoding_t x[1])
{
  return SIP_HEADER_INIT(x, sip_content_encoding_class, sizeof(sip_content_encoding_t));
}
#else
#define sip_content_encoding_init(x) \
  SIP_HEADER_INIT(x, sip_content_encoding_class, sizeof(sip_content_encoding_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_content_encoding(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_content_encoding_hash;
}
#else
int sip_is_content_encoding(sip_header_t const *header);
#endif

#define sip_content_encoding_p(h) sip_is_content_encoding((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_content_encoding_t *sip_content_encoding_dup(su_home_t *home, sip_content_encoding_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_encoding_t *sip_content_encoding_dup(su_home_t *home, sip_content_encoding_t const *hdr)
{
  return (sip_content_encoding_t *)
    msg_header_dup_as(home, sip_content_encoding_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_encoding_t *sip_content_encoding_copy(su_home_t *home, sip_content_encoding_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_encoding_t *sip_content_encoding_copy(su_home_t *home, sip_content_encoding_t const *hdr)
{
  return (sip_content_encoding_t *)
    msg_header_copy_as(home, sip_content_encoding_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_encoding_t *sip_content_encoding_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_content_encoding_t *sip_content_encoding_make(su_home_t *home, char const *s)
{
  return (sip_content_encoding_t *)sip_header_make(home, sip_content_encoding_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_encoding_t *sip_content_encoding_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_content_encoding_t *sip_content_encoding_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_content_encoding_class, fmt, ap);
  va_end(ap);

  return (sip_content_encoding_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_content_language_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_content_language_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_content_language(sip) \
  ((sip_content_language_t *)msg_header_access((msg_pub_t*)(sip), sip_content_language_class))

#define SIP_CONTENT_LANGUAGE_INIT() SIP_HDR_INIT(content_language)

#if SU_HAVE_INLINE
su_inline sip_content_language_t *sip_content_language_init(sip_content_language_t x[1])
{
  return SIP_HEADER_INIT(x, sip_content_language_class, sizeof(sip_content_language_t));
}
#else
#define sip_content_language_init(x) \
  SIP_HEADER_INIT(x, sip_content_language_class, sizeof(sip_content_language_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_content_language(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_content_language_hash;
}
#else
int sip_is_content_language(sip_header_t const *header);
#endif

#define sip_content_language_p(h) sip_is_content_language((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_content_language_t *sip_content_language_dup(su_home_t *home, sip_content_language_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_language_t *sip_content_language_dup(su_home_t *home, sip_content_language_t const *hdr)
{
  return (sip_content_language_t *)
    msg_header_dup_as(home, sip_content_language_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_language_t *sip_content_language_copy(su_home_t *home, sip_content_language_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_language_t *sip_content_language_copy(su_home_t *home, sip_content_language_t const *hdr)
{
  return (sip_content_language_t *)
    msg_header_copy_as(home, sip_content_language_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_language_t *sip_content_language_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_content_language_t *sip_content_language_make(su_home_t *home, char const *s)
{
  return (sip_content_language_t *)sip_header_make(home, sip_content_language_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_language_t *sip_content_language_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_content_language_t *sip_content_language_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_content_language_class, fmt, ap);
  va_end(ap);

  return (sip_content_language_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_content_disposition_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_content_disposition_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_content_disposition(sip) \
  ((sip_content_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_content_disposition_class))

#define SIP_CONTENT_DISPOSITION_INIT() SIP_HDR_INIT(content_disposition)

#if SU_HAVE_INLINE
su_inline sip_content_disposition_t *sip_content_disposition_init(sip_content_disposition_t x[1])
{
  return SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t));
}
#else
#define sip_content_disposition_init(x) \
  SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_content_disposition(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_content_disposition_hash;
}
#else
int sip_is_content_disposition(sip_header_t const *header);
#endif

#define sip_content_disposition_p(h) sip_is_content_disposition((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
{
  return (sip_content_disposition_t *)
    msg_header_dup_as(home, sip_content_disposition_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
{
  return (sip_content_disposition_t *)
    msg_header_copy_as(home, sip_content_disposition_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
{
  return (sip_content_disposition_t *)sip_header_make(home, sip_content_disposition_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_content_disposition_class, fmt, ap);
  va_end(ap);

  return (sip_content_disposition_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_content_length_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_content_length_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_content_length(sip) \
  ((sip_content_length_t *)msg_header_access((msg_pub_t*)(sip), sip_content_length_class))

#define SIP_CONTENT_LENGTH_INIT() SIP_HDR_INIT(content_length)

#if SU_HAVE_INLINE
su_inline sip_content_length_t *sip_content_length_init(sip_content_length_t x[1])
{
  return SIP_HEADER_INIT(x, sip_content_length_class, sizeof(sip_content_length_t));
}
#else
#define sip_content_length_init(x) \
  SIP_HEADER_INIT(x, sip_content_length_class, sizeof(sip_content_length_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_content_length(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_content_length_hash;
}
#else
int sip_is_content_length(sip_header_t const *header);
#endif

#define sip_content_length_p(h) sip_is_content_length((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_content_length_t *sip_content_length_dup(su_home_t *home, sip_content_length_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_length_t *sip_content_length_dup(su_home_t *home, sip_content_length_t const *hdr)
{
  return (sip_content_length_t *)
    msg_header_dup_as(home, sip_content_length_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_length_t *sip_content_length_copy(su_home_t *home, sip_content_length_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_content_length_t *sip_content_length_copy(su_home_t *home, sip_content_length_t const *hdr)
{
  return (sip_content_length_t *)
    msg_header_copy_as(home, sip_content_length_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_length_t *sip_content_length_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_content_length_t *sip_content_length_make(su_home_t *home, char const *s)
{
  return (sip_content_length_t *)sip_header_make(home, sip_content_length_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_content_length_t *sip_content_length_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_content_length_t *sip_content_length_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_content_length_class, fmt, ap);
  va_end(ap);

  return (sip_content_length_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_unknown_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_unknown_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_unknown(sip) \
  ((sip_unknown_t *)msg_header_access((msg_pub_t*)(sip), sip_unknown_class))

#define SIP_UNKNOWN_INIT() SIP_HDR_INIT(unknown)

#if SU_HAVE_INLINE
su_inline sip_unknown_t *sip_unknown_init(sip_unknown_t x[1])
{
  return SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t));
}
#else
#define sip_unknown_init(x) \
  SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_unknown(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_unknown_hash;
}
#else
int sip_is_unknown(sip_header_t const *header);
#endif

#define sip_unknown_p(h) sip_is_unknown((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
{
  return (sip_unknown_t *)
    msg_header_dup_as(home, sip_unknown_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
{
  return (sip_unknown_t *)
    msg_header_copy_as(home, sip_unknown_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
{
  return (sip_unknown_t *)sip_header_make(home, sip_unknown_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_unknown_class, fmt, ap);
  va_end(ap);

  return (sip_unknown_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_error_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_error_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_error(sip) \
  ((sip_error_t *)msg_header_access((msg_pub_t*)(sip), sip_error_class))

#define SIP_ERROR_INIT() SIP_HDR_INIT(error)

#if SU_HAVE_INLINE
su_inline sip_error_t *sip_error_init(sip_error_t x[1])
{
  return SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t));
}
#else
#define sip_error_init(x) \
  SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_error(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_error_hash;
}
#else
int sip_is_error(sip_header_t const *header);
#endif

#define sip_error_p(h) sip_is_error((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
{
  return (sip_error_t *)
    msg_header_dup_as(home, sip_error_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
{
  return (sip_error_t *)
    msg_header_copy_as(home, sip_error_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_t *sip_error_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_error_t *sip_error_make(su_home_t *home, char const *s)
{
  return (sip_error_t *)sip_header_make(home, sip_error_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_error_class, fmt, ap);
  va_end(ap);

  return (sip_error_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_separator_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_separator_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_separator(sip) \
  ((sip_separator_t *)msg_header_access((msg_pub_t*)(sip), sip_separator_class))

#define SIP_SEPARATOR_INIT() SIP_HDR_INIT(separator)

#if SU_HAVE_INLINE
su_inline sip_separator_t *sip_separator_init(sip_separator_t x[1])
{
  return SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t));
}
#else
#define sip_separator_init(x) \
  SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_separator(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_separator_hash;
}
#else
int sip_is_separator(sip_header_t const *header);
#endif

#define sip_separator_p(h) sip_is_separator((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
{
  return (sip_separator_t *)
    msg_header_dup_as(home, sip_separator_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
{
  return (sip_separator_t *)
    msg_header_copy_as(home, sip_separator_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
{
  return (sip_separator_t *)sip_header_make(home, sip_separator_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_separator_class, fmt, ap);
  va_end(ap);

  return (sip_separator_t *)h;
}
#endif

SOFIAPUBFUN issize_t sip_payload_d(su_home_t *, msg_header_t *,
                                       char *s, isize_t slen);

SOFIAPUBFUN issize_t sip_payload_e(char b[], isize_t bsiz,
                                    msg_header_t const *h, int flags);

#define sip_payload(sip) \
  ((sip_payload_t *)msg_header_access((msg_pub_t*)(sip), sip_payload_class))

#define SIP_PAYLOAD_INIT() SIP_HDR_INIT(payload)

#if SU_HAVE_INLINE
su_inline sip_payload_t *sip_payload_init(sip_payload_t x[1])
{
  return SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t));
}
#else
#define sip_payload_init(x) \
  SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t))
#endif

#if SU_HAVE_INLINE
su_inline int sip_is_payload(sip_header_t const *header)
{
  return header && header->sh_class->hc_hash == sip_payload_hash;
}
#else
int sip_is_payload(sip_header_t const *header);
#endif

#define sip_payload_p(h) sip_is_payload((h))


#if SU_HAVE_INLINE
su_inline
#endif
sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
{
  return (sip_payload_t *)
    msg_header_dup_as(home, sip_payload_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline
sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
{
  return (sip_payload_t *)
    msg_header_copy_as(home, sip_payload_class, (msg_header_t const *)hdr);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
     __attribute__((__malloc__));

#if SU_HAVE_INLINE
su_inline sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
{
  return (sip_payload_t *)sip_header_make(home, sip_payload_class, s);
}
#endif

#if SU_HAVE_INLINE
su_inline
#endif
sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
     __attribute__((__malloc__, __format__ (printf, 2, 3)));

#if SU_HAVE_INLINE
su_inline sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
{
  sip_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = sip_header_vformat(home, sip_payload_class, fmt, ap);
  va_end(ap);

  return (sip_payload_t *)h;
}
#endif

SOFIA_END_DECLS
#endif /* !defined(SIP_PROTOS_H) */