sofia-sip/http_protos.h

Go to the documentation of this file.

/*
 * 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 HTTP_PROTOS_H

#define HTTP_PROTOS_H

#include <sofia-sip/su_config.h>

#ifndef HTTP_HEADER_H
#include <sofia-sip/http_header.h>
#endif
#ifndef HTTP_HCLASSES_H
#include <sofia-sip/http_hclasses.h>
#endif

#define http_header_make(h, c, s) \
  ((http_header_t *)msg_header_make((h), (c), (s)))
#define http_header_vformat(h, c, f, a) \
  ((http_header_t *)msg_header_vformat((h), (c), (f), (a)))

SOFIA_BEGIN_DECLS

/* Declare internal prototypes for request line */
 
enum {
  http_request_hash = -1
};

SOFIAPUBVAR msg_hclass_t http_request_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_request_d;

SOFIAPUBFUN msg_print_f http_request_e;

#define HTTP_REQUEST_INIT() HTTP_HDR_INIT(request)

#if SU_HAVE_INLINE
su_inline http_request_t *http_request_init(http_request_t x[1])
{
  return HTTP_HEADER_INIT(x, http_request_class, sizeof(http_request_t));
}
#else
#define http_request_init(x) \
  HTTP_HEADER_INIT(x, http_request_class, sizeof(http_request_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_request(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_request_hash;
}
#else
#define http_is_request(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_request_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_request_t *http_request_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_request_class, fmt, ap);
  va_end(ap);

  return (http_request_t *)h;
}

su_inline
http_request_t *http_request_dup(su_home_t *home, http_request_t const *o)
{
  return (http_request_t *)
    msg_header_dup_as(home, http_request_class, (msg_header_t const *)o);
}

su_inline
http_request_t *http_request_copy(su_home_t *home, http_request_t const *o)
{
  return (http_request_t *)
    msg_header_copy_as(home, http_request_class, (msg_header_t const *)o);
}

su_inline
http_request_t *http_request_make(su_home_t *home, char const *s)
{
  return (http_request_t *)http_header_make(home, http_request_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for status line */
 
enum {
  http_status_hash = -2
};

SOFIAPUBVAR msg_hclass_t http_status_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_status_d;

SOFIAPUBFUN msg_print_f http_status_e;

#define HTTP_STATUS_INIT() HTTP_HDR_INIT(status)

#if SU_HAVE_INLINE
su_inline http_status_t *http_status_init(http_status_t x[1])
{
  return HTTP_HEADER_INIT(x, http_status_class, sizeof(http_status_t));
}
#else
#define http_status_init(x) \
  HTTP_HEADER_INIT(x, http_status_class, sizeof(http_status_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_status(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_status_hash;
}
#else
#define http_is_status(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_status_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_status_t *http_status_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_status_class, fmt, ap);
  va_end(ap);

  return (http_status_t *)h;
}

su_inline
http_status_t *http_status_dup(su_home_t *home, http_status_t const *o)
{
  return (http_status_t *)
    msg_header_dup_as(home, http_status_class, (msg_header_t const *)o);
}

su_inline
http_status_t *http_status_copy(su_home_t *home, http_status_t const *o)
{
  return (http_status_t *)
    msg_header_copy_as(home, http_status_class, (msg_header_t const *)o);
}

su_inline
http_status_t *http_status_make(su_home_t *home, char const *s)
{
  return (http_status_t *)http_header_make(home, http_status_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Accept header */
 
enum {
  http_accept_hash = 29344
};

SOFIAPUBVAR msg_hclass_t http_accept_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_accept_d;

SOFIAPUBFUN msg_print_f http_accept_e;

#define HTTP_ACCEPT_INIT() HTTP_HDR_INIT(accept)

#if SU_HAVE_INLINE
su_inline http_accept_t *http_accept_init(http_accept_t x[1])
{
  return HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t));
}
#else
#define http_accept_init(x) \
  HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_accept(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_accept_hash;
}
#else
#define http_is_accept(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_accept_t *http_accept_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_accept_class, fmt, ap);
  va_end(ap);

  return (http_accept_t *)h;
}

su_inline
http_accept_t *http_accept_dup(su_home_t *home, http_accept_t const *o)
{
  return (http_accept_t *)
    msg_header_dup_as(home, http_accept_class, (msg_header_t const *)o);
}

su_inline
http_accept_t *http_accept_copy(su_home_t *home, http_accept_t const *o)
{
  return (http_accept_t *)
    msg_header_copy_as(home, http_accept_class, (msg_header_t const *)o);
}

su_inline
http_accept_t *http_accept_make(su_home_t *home, char const *s)
{
  return (http_accept_t *)http_header_make(home, http_accept_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Accept-Charset header */
 
enum {
  http_accept_charset_hash = 41803
};

SOFIAPUBVAR msg_hclass_t http_accept_charset_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_accept_charset_d;

SOFIAPUBFUN msg_print_f http_accept_charset_e;

#define HTTP_ACCEPT_CHARSET_INIT() HTTP_HDR_INIT(accept_charset)

#if SU_HAVE_INLINE
su_inline http_accept_charset_t *http_accept_charset_init(http_accept_charset_t x[1])
{
  return HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t));
}
#else
#define http_accept_charset_init(x) \
  HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_accept_charset(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_accept_charset_hash;
}
#else
#define http_is_accept_charset(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_charset_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_accept_charset_t *http_accept_charset_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_accept_charset_class, fmt, ap);
  va_end(ap);

  return (http_accept_charset_t *)h;
}

su_inline
http_accept_charset_t *http_accept_charset_dup(su_home_t *home, http_accept_charset_t const *o)
{
  return (http_accept_charset_t *)
    msg_header_dup_as(home, http_accept_charset_class, (msg_header_t const *)o);
}

su_inline
http_accept_charset_t *http_accept_charset_copy(su_home_t *home, http_accept_charset_t const *o)
{
  return (http_accept_charset_t *)
    msg_header_copy_as(home, http_accept_charset_class, (msg_header_t const *)o);
}

su_inline
http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
{
  return (http_accept_charset_t *)http_header_make(home, http_accept_charset_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Accept-Encoding header */
 
enum {
  http_accept_encoding_hash = 35932
};

SOFIAPUBVAR msg_hclass_t http_accept_encoding_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_accept_encoding_d;

SOFIAPUBFUN msg_print_f http_accept_encoding_e;

#define HTTP_ACCEPT_ENCODING_INIT() HTTP_HDR_INIT(accept_encoding)

#if SU_HAVE_INLINE
su_inline http_accept_encoding_t *http_accept_encoding_init(http_accept_encoding_t x[1])
{
  return HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t));
}
#else
#define http_accept_encoding_init(x) \
  HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_accept_encoding(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_accept_encoding_hash;
}
#else
#define http_is_accept_encoding(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_encoding_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_accept_encoding_t *http_accept_encoding_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_accept_encoding_class, fmt, ap);
  va_end(ap);

  return (http_accept_encoding_t *)h;
}

su_inline
http_accept_encoding_t *http_accept_encoding_dup(su_home_t *home, http_accept_encoding_t const *o)
{
  return (http_accept_encoding_t *)
    msg_header_dup_as(home, http_accept_encoding_class, (msg_header_t const *)o);
}

su_inline
http_accept_encoding_t *http_accept_encoding_copy(su_home_t *home, http_accept_encoding_t const *o)
{
  return (http_accept_encoding_t *)
    msg_header_copy_as(home, http_accept_encoding_class, (msg_header_t const *)o);
}

su_inline
http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
{
  return (http_accept_encoding_t *)http_header_make(home, http_accept_encoding_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Accept-Language header */
 
enum {
  http_accept_language_hash = 23797
};

SOFIAPUBVAR msg_hclass_t http_accept_language_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_accept_language_d;

SOFIAPUBFUN msg_print_f http_accept_language_e;

#define HTTP_ACCEPT_LANGUAGE_INIT() HTTP_HDR_INIT(accept_language)

#if SU_HAVE_INLINE
su_inline http_accept_language_t *http_accept_language_init(http_accept_language_t x[1])
{
  return HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t));
}
#else
#define http_accept_language_init(x) \
  HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_accept_language(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_accept_language_hash;
}
#else
#define http_is_accept_language(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_language_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_accept_language_t *http_accept_language_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_accept_language_class, fmt, ap);
  va_end(ap);

  return (http_accept_language_t *)h;
}

su_inline
http_accept_language_t *http_accept_language_dup(su_home_t *home, http_accept_language_t const *o)
{
  return (http_accept_language_t *)
    msg_header_dup_as(home, http_accept_language_class, (msg_header_t const *)o);
}

su_inline
http_accept_language_t *http_accept_language_copy(su_home_t *home, http_accept_language_t const *o)
{
  return (http_accept_language_t *)
    msg_header_copy_as(home, http_accept_language_class, (msg_header_t const *)o);
}

su_inline
http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
{
  return (http_accept_language_t *)http_header_make(home, http_accept_language_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Accept-Ranges header */
 
enum {
  http_accept_ranges_hash = 59733
};

SOFIAPUBVAR msg_hclass_t http_accept_ranges_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_accept_ranges_d;

SOFIAPUBFUN msg_print_f http_accept_ranges_e;

#define HTTP_ACCEPT_RANGES_INIT() HTTP_HDR_INIT(accept_ranges)

#if SU_HAVE_INLINE
su_inline http_accept_ranges_t *http_accept_ranges_init(http_accept_ranges_t x[1])
{
  return HTTP_HEADER_INIT(x, http_accept_ranges_class, sizeof(http_accept_ranges_t));
}
#else
#define http_accept_ranges_init(x) \
  HTTP_HEADER_INIT(x, http_accept_ranges_class, sizeof(http_accept_ranges_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_accept_ranges(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_accept_ranges_hash;
}
#else
#define http_is_accept_ranges(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_ranges_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_accept_ranges_t *http_accept_ranges_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_accept_ranges_class, fmt, ap);
  va_end(ap);

  return (http_accept_ranges_t *)h;
}

su_inline
http_accept_ranges_t *http_accept_ranges_dup(su_home_t *home, http_accept_ranges_t const *o)
{
  return (http_accept_ranges_t *)
    msg_header_dup_as(home, http_accept_ranges_class, (msg_header_t const *)o);
}

su_inline
http_accept_ranges_t *http_accept_ranges_copy(su_home_t *home, http_accept_ranges_t const *o)
{
  return (http_accept_ranges_t *)
    msg_header_copy_as(home, http_accept_ranges_class, (msg_header_t const *)o);
}

su_inline
http_accept_ranges_t *http_accept_ranges_make(su_home_t *home, char const *s)
{
  return (http_accept_ranges_t *)http_header_make(home, http_accept_ranges_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Allow header */
 
enum {
  http_allow_hash = 44519
};

SOFIAPUBVAR msg_hclass_t http_allow_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_allow_d;

SOFIAPUBFUN msg_print_f http_allow_e;

#define HTTP_ALLOW_INIT() HTTP_HDR_INIT(allow)

#if SU_HAVE_INLINE
su_inline http_allow_t *http_allow_init(http_allow_t x[1])
{
  return HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t));
}
#else
#define http_allow_init(x) \
  HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_allow(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_allow_hash;
}
#else
#define http_is_allow(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_allow_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_allow_t *http_allow_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_allow_class, fmt, ap);
  va_end(ap);

  return (http_allow_t *)h;
}

su_inline
http_allow_t *http_allow_dup(su_home_t *home, http_allow_t const *o)
{
  return (http_allow_t *)
    msg_header_dup_as(home, http_allow_class, (msg_header_t const *)o);
}

su_inline
http_allow_t *http_allow_copy(su_home_t *home, http_allow_t const *o)
{
  return (http_allow_t *)
    msg_header_copy_as(home, http_allow_class, (msg_header_t const *)o);
}

su_inline
http_allow_t *http_allow_make(su_home_t *home, char const *s)
{
  return (http_allow_t *)http_header_make(home, http_allow_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Authentication-Info header */
 
enum {
  http_authentication_info_hash = 20849
};

SOFIAPUBVAR msg_hclass_t http_authentication_info_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_authentication_info_d;

SOFIAPUBFUN msg_print_f http_authentication_info_e;

#define HTTP_AUTHENTICATION_INFO_INIT() HTTP_HDR_INIT(authentication_info)

#if SU_HAVE_INLINE
su_inline http_authentication_info_t *http_authentication_info_init(http_authentication_info_t x[1])
{
  return HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t));
}
#else
#define http_authentication_info_init(x) \
  HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_authentication_info(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_authentication_info_hash;
}
#else
#define http_is_authentication_info(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authentication_info_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_authentication_info_t *http_authentication_info_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_authentication_info_class, fmt, ap);
  va_end(ap);

  return (http_authentication_info_t *)h;
}

su_inline
http_authentication_info_t *http_authentication_info_dup(su_home_t *home, http_authentication_info_t const *o)
{
  return (http_authentication_info_t *)
    msg_header_dup_as(home, http_authentication_info_class, (msg_header_t const *)o);
}

su_inline
http_authentication_info_t *http_authentication_info_copy(su_home_t *home, http_authentication_info_t const *o)
{
  return (http_authentication_info_t *)
    msg_header_copy_as(home, http_authentication_info_class, (msg_header_t const *)o);
}

su_inline
http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
{
  return (http_authentication_info_t *)http_header_make(home, http_authentication_info_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Authorization header */
 
enum {
  http_authorization_hash = 36397
};

SOFIAPUBVAR msg_hclass_t http_authorization_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_authorization_d;

SOFIAPUBFUN msg_print_f http_authorization_e;

#define HTTP_AUTHORIZATION_INIT() HTTP_HDR_INIT(authorization)

#if SU_HAVE_INLINE
su_inline http_authorization_t *http_authorization_init(http_authorization_t x[1])
{
  return HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t));
}
#else
#define http_authorization_init(x) \
  HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_authorization(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_authorization_hash;
}
#else
#define http_is_authorization(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authorization_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_authorization_t *http_authorization_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_authorization_class, fmt, ap);
  va_end(ap);

  return (http_authorization_t *)h;
}

su_inline
http_authorization_t *http_authorization_dup(su_home_t *home, http_authorization_t const *o)
{
  return (http_authorization_t *)
    msg_header_dup_as(home, http_authorization_class, (msg_header_t const *)o);
}

su_inline
http_authorization_t *http_authorization_copy(su_home_t *home, http_authorization_t const *o)
{
  return (http_authorization_t *)
    msg_header_copy_as(home, http_authorization_class, (msg_header_t const *)o);
}

su_inline
http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
{
  return (http_authorization_t *)http_header_make(home, http_authorization_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Age header */
 
enum {
  http_age_hash = 34725
};

SOFIAPUBVAR msg_hclass_t http_age_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_age_d;

SOFIAPUBFUN msg_print_f http_age_e;

#define HTTP_AGE_INIT() HTTP_HDR_INIT(age)

#if SU_HAVE_INLINE
su_inline http_age_t *http_age_init(http_age_t x[1])
{
  return HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t));
}
#else
#define http_age_init(x) \
  HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_age(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_age_hash;
}
#else
#define http_is_age(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_age_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_age_t *http_age_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_age_class, fmt, ap);
  va_end(ap);

  return (http_age_t *)h;
}

su_inline
http_age_t *http_age_dup(su_home_t *home, http_age_t const *o)
{
  return (http_age_t *)
    msg_header_dup_as(home, http_age_class, (msg_header_t const *)o);
}

su_inline
http_age_t *http_age_copy(su_home_t *home, http_age_t const *o)
{
  return (http_age_t *)
    msg_header_copy_as(home, http_age_class, (msg_header_t const *)o);
}

su_inline
http_age_t *http_age_make(su_home_t *home, char const *s)
{
  return (http_age_t *)http_header_make(home, http_age_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Cache-Control header */
 
enum {
  http_cache_control_hash = 48250
};

SOFIAPUBVAR msg_hclass_t http_cache_control_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_cache_control_d;

SOFIAPUBFUN msg_print_f http_cache_control_e;

#define HTTP_CACHE_CONTROL_INIT() HTTP_HDR_INIT(cache_control)

#if SU_HAVE_INLINE
su_inline http_cache_control_t *http_cache_control_init(http_cache_control_t x[1])
{
  return HTTP_HEADER_INIT(x, http_cache_control_class, sizeof(http_cache_control_t));
}
#else
#define http_cache_control_init(x) \
  HTTP_HEADER_INIT(x, http_cache_control_class, sizeof(http_cache_control_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_cache_control(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_cache_control_hash;
}
#else
#define http_is_cache_control(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cache_control_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_cache_control_t *http_cache_control_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_cache_control_class, fmt, ap);
  va_end(ap);

  return (http_cache_control_t *)h;
}

su_inline
http_cache_control_t *http_cache_control_dup(su_home_t *home, http_cache_control_t const *o)
{
  return (http_cache_control_t *)
    msg_header_dup_as(home, http_cache_control_class, (msg_header_t const *)o);
}

su_inline
http_cache_control_t *http_cache_control_copy(su_home_t *home, http_cache_control_t const *o)
{
  return (http_cache_control_t *)
    msg_header_copy_as(home, http_cache_control_class, (msg_header_t const *)o);
}

su_inline
http_cache_control_t *http_cache_control_make(su_home_t *home, char const *s)
{
  return (http_cache_control_t *)http_header_make(home, http_cache_control_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Connection header */
 
enum {
  http_connection_hash = 32700
};

SOFIAPUBVAR msg_hclass_t http_connection_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_connection_d;

SOFIAPUBFUN msg_print_f http_connection_e;

#define HTTP_CONNECTION_INIT() HTTP_HDR_INIT(connection)

#if SU_HAVE_INLINE
su_inline http_connection_t *http_connection_init(http_connection_t x[1])
{
  return HTTP_HEADER_INIT(x, http_connection_class, sizeof(http_connection_t));
}
#else
#define http_connection_init(x) \
  HTTP_HEADER_INIT(x, http_connection_class, sizeof(http_connection_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_connection(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_connection_hash;
}
#else
#define http_is_connection(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_connection_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_connection_t *http_connection_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_connection_class, fmt, ap);
  va_end(ap);

  return (http_connection_t *)h;
}

su_inline
http_connection_t *http_connection_dup(su_home_t *home, http_connection_t const *o)
{
  return (http_connection_t *)
    msg_header_dup_as(home, http_connection_class, (msg_header_t const *)o);
}

su_inline
http_connection_t *http_connection_copy(su_home_t *home, http_connection_t const *o)
{
  return (http_connection_t *)
    msg_header_copy_as(home, http_connection_class, (msg_header_t const *)o);
}

su_inline
http_connection_t *http_connection_make(su_home_t *home, char const *s)
{
  return (http_connection_t *)http_header_make(home, http_connection_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Date header */
 
enum {
  http_date_hash = 43982
};

SOFIAPUBVAR msg_hclass_t http_date_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_date_d;

SOFIAPUBFUN msg_print_f http_date_e;

#define HTTP_DATE_INIT() HTTP_HDR_INIT(date)

#if SU_HAVE_INLINE
su_inline http_date_t *http_date_init(http_date_t x[1])
{
  return HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t));
}
#else
#define http_date_init(x) \
  HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_date(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_date_hash;
}
#else
#define http_is_date(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_date_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_date_t *http_date_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_date_class, fmt, ap);
  va_end(ap);

  return (http_date_t *)h;
}

su_inline
http_date_t *http_date_dup(su_home_t *home, http_date_t const *o)
{
  return (http_date_t *)
    msg_header_dup_as(home, http_date_class, (msg_header_t const *)o);
}

su_inline
http_date_t *http_date_copy(su_home_t *home, http_date_t const *o)
{
  return (http_date_t *)
    msg_header_copy_as(home, http_date_class, (msg_header_t const *)o);
}

su_inline
http_date_t *http_date_make(su_home_t *home, char const *s)
{
  return (http_date_t *)http_header_make(home, http_date_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for ETag header */
 
enum {
  http_etag_hash = 1813
};

SOFIAPUBVAR msg_hclass_t http_etag_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_etag_d;

SOFIAPUBFUN msg_print_f http_etag_e;

#define HTTP_ETAG_INIT() HTTP_HDR_INIT(etag)

#if SU_HAVE_INLINE
su_inline http_etag_t *http_etag_init(http_etag_t x[1])
{
  return HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t));
}
#else
#define http_etag_init(x) \
  HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_etag(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_etag_hash;
}
#else
#define http_is_etag(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_etag_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_etag_t *http_etag_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_etag_class, fmt, ap);
  va_end(ap);

  return (http_etag_t *)h;
}

su_inline
http_etag_t *http_etag_dup(su_home_t *home, http_etag_t const *o)
{
  return (http_etag_t *)
    msg_header_dup_as(home, http_etag_class, (msg_header_t const *)o);
}

su_inline
http_etag_t *http_etag_copy(su_home_t *home, http_etag_t const *o)
{
  return (http_etag_t *)
    msg_header_copy_as(home, http_etag_class, (msg_header_t const *)o);
}

su_inline
http_etag_t *http_etag_make(su_home_t *home, char const *s)
{
  return (http_etag_t *)http_header_make(home, http_etag_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Expect header */
 
enum {
  http_expect_hash = 30389
};

SOFIAPUBVAR msg_hclass_t http_expect_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_expect_d;

SOFIAPUBFUN msg_print_f http_expect_e;

#define HTTP_EXPECT_INIT() HTTP_HDR_INIT(expect)

#if SU_HAVE_INLINE
su_inline http_expect_t *http_expect_init(http_expect_t x[1])
{
  return HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t));
}
#else
#define http_expect_init(x) \
  HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_expect(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_expect_hash;
}
#else
#define http_is_expect(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expect_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_expect_t *http_expect_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_expect_class, fmt, ap);
  va_end(ap);

  return (http_expect_t *)h;
}

su_inline
http_expect_t *http_expect_dup(su_home_t *home, http_expect_t const *o)
{
  return (http_expect_t *)
    msg_header_dup_as(home, http_expect_class, (msg_header_t const *)o);
}

su_inline
http_expect_t *http_expect_copy(su_home_t *home, http_expect_t const *o)
{
  return (http_expect_t *)
    msg_header_copy_as(home, http_expect_class, (msg_header_t const *)o);
}

su_inline
http_expect_t *http_expect_make(su_home_t *home, char const *s)
{
  return (http_expect_t *)http_header_make(home, http_expect_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Expires header */
 
enum {
  http_expires_hash = 28680
};

SOFIAPUBVAR msg_hclass_t http_expires_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_expires_d;

SOFIAPUBFUN msg_print_f http_expires_e;

#define HTTP_EXPIRES_INIT() HTTP_HDR_INIT(expires)

#if SU_HAVE_INLINE
su_inline http_expires_t *http_expires_init(http_expires_t x[1])
{
  return HTTP_HEADER_INIT(x, http_expires_class, sizeof(http_expires_t));
}
#else
#define http_expires_init(x) \
  HTTP_HEADER_INIT(x, http_expires_class, sizeof(http_expires_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_expires(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_expires_hash;
}
#else
#define http_is_expires(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expires_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_expires_t *http_expires_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_expires_class, fmt, ap);
  va_end(ap);

  return (http_expires_t *)h;
}

su_inline
http_expires_t *http_expires_dup(su_home_t *home, http_expires_t const *o)
{
  return (http_expires_t *)
    msg_header_dup_as(home, http_expires_class, (msg_header_t const *)o);
}

su_inline
http_expires_t *http_expires_copy(su_home_t *home, http_expires_t const *o)
{
  return (http_expires_t *)
    msg_header_copy_as(home, http_expires_class, (msg_header_t const *)o);
}

su_inline
http_expires_t *http_expires_make(su_home_t *home, char const *s)
{
  return (http_expires_t *)http_header_make(home, http_expires_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for From header */
 
enum {
  http_from_hash = 15368
};

SOFIAPUBVAR msg_hclass_t http_from_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_from_d;

SOFIAPUBFUN msg_print_f http_from_e;

#define HTTP_FROM_INIT() HTTP_HDR_INIT(from)

#if SU_HAVE_INLINE
su_inline http_from_t *http_from_init(http_from_t x[1])
{
  return HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t));
}
#else
#define http_from_init(x) \
  HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_from(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_from_hash;
}
#else
#define http_is_from(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_from_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_from_t *http_from_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_from_class, fmt, ap);
  va_end(ap);

  return (http_from_t *)h;
}

su_inline
http_from_t *http_from_dup(su_home_t *home, http_from_t const *o)
{
  return (http_from_t *)
    msg_header_dup_as(home, http_from_class, (msg_header_t const *)o);
}

su_inline
http_from_t *http_from_copy(su_home_t *home, http_from_t const *o)
{
  return (http_from_t *)
    msg_header_copy_as(home, http_from_class, (msg_header_t const *)o);
}

su_inline
http_from_t *http_from_make(su_home_t *home, char const *s)
{
  return (http_from_t *)http_header_make(home, http_from_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Host header */
 
enum {
  http_host_hash = 33850
};

SOFIAPUBVAR msg_hclass_t http_host_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_host_d;

SOFIAPUBFUN msg_print_f http_host_e;

#define HTTP_HOST_INIT() HTTP_HDR_INIT(host)

#if SU_HAVE_INLINE
su_inline http_host_t *http_host_init(http_host_t x[1])
{
  return HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t));
}
#else
#define http_host_init(x) \
  HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_host(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_host_hash;
}
#else
#define http_is_host(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_host_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_host_t *http_host_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_host_class, fmt, ap);
  va_end(ap);

  return (http_host_t *)h;
}

su_inline
http_host_t *http_host_dup(su_home_t *home, http_host_t const *o)
{
  return (http_host_t *)
    msg_header_dup_as(home, http_host_class, (msg_header_t const *)o);
}

su_inline
http_host_t *http_host_copy(su_home_t *home, http_host_t const *o)
{
  return (http_host_t *)
    msg_header_copy_as(home, http_host_class, (msg_header_t const *)o);
}

su_inline
http_host_t *http_host_make(su_home_t *home, char const *s)
{
  return (http_host_t *)http_header_make(home, http_host_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for If-Match header */
 
enum {
  http_if_match_hash = 805
};

SOFIAPUBVAR msg_hclass_t http_if_match_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_if_match_d;

SOFIAPUBFUN msg_print_f http_if_match_e;

#define HTTP_IF_MATCH_INIT() HTTP_HDR_INIT(if_match)

#if SU_HAVE_INLINE
su_inline http_if_match_t *http_if_match_init(http_if_match_t x[1])
{
  return HTTP_HEADER_INIT(x, http_if_match_class, sizeof(http_if_match_t));
}
#else
#define http_if_match_init(x) \
  HTTP_HEADER_INIT(x, http_if_match_class, sizeof(http_if_match_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_if_match(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_if_match_hash;
}
#else
#define http_is_if_match(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_match_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_if_match_t *http_if_match_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_if_match_class, fmt, ap);
  va_end(ap);

  return (http_if_match_t *)h;
}

su_inline
http_if_match_t *http_if_match_dup(su_home_t *home, http_if_match_t const *o)
{
  return (http_if_match_t *)
    msg_header_dup_as(home, http_if_match_class, (msg_header_t const *)o);
}

su_inline
http_if_match_t *http_if_match_copy(su_home_t *home, http_if_match_t const *o)
{
  return (http_if_match_t *)
    msg_header_copy_as(home, http_if_match_class, (msg_header_t const *)o);
}

su_inline
http_if_match_t *http_if_match_make(su_home_t *home, char const *s)
{
  return (http_if_match_t *)http_header_make(home, http_if_match_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for If-Modified-Since header */
 
enum {
  http_if_modified_since_hash = 4424
};

SOFIAPUBVAR msg_hclass_t http_if_modified_since_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_if_modified_since_d;

SOFIAPUBFUN msg_print_f http_if_modified_since_e;

#define HTTP_IF_MODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_modified_since)

#if SU_HAVE_INLINE
su_inline http_if_modified_since_t *http_if_modified_since_init(http_if_modified_since_t x[1])
{
  return HTTP_HEADER_INIT(x, http_if_modified_since_class, sizeof(http_if_modified_since_t));
}
#else
#define http_if_modified_since_init(x) \
  HTTP_HEADER_INIT(x, http_if_modified_since_class, sizeof(http_if_modified_since_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_if_modified_since(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_if_modified_since_hash;
}
#else
#define http_is_if_modified_since(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_modified_since_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_if_modified_since_t *http_if_modified_since_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_if_modified_since_class, fmt, ap);
  va_end(ap);

  return (http_if_modified_since_t *)h;
}

su_inline
http_if_modified_since_t *http_if_modified_since_dup(su_home_t *home, http_if_modified_since_t const *o)
{
  return (http_if_modified_since_t *)
    msg_header_dup_as(home, http_if_modified_since_class, (msg_header_t const *)o);
}

su_inline
http_if_modified_since_t *http_if_modified_since_copy(su_home_t *home, http_if_modified_since_t const *o)
{
  return (http_if_modified_since_t *)
    msg_header_copy_as(home, http_if_modified_since_class, (msg_header_t const *)o);
}

su_inline
http_if_modified_since_t *http_if_modified_since_make(su_home_t *home, char const *s)
{
  return (http_if_modified_since_t *)http_header_make(home, http_if_modified_since_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for If-None-Match header */
 
enum {
  http_if_none_match_hash = 64610
};

SOFIAPUBVAR msg_hclass_t http_if_none_match_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_if_none_match_d;

SOFIAPUBFUN msg_print_f http_if_none_match_e;

#define HTTP_IF_NONE_MATCH_INIT() HTTP_HDR_INIT(if_none_match)

#if SU_HAVE_INLINE
su_inline http_if_none_match_t *http_if_none_match_init(http_if_none_match_t x[1])
{
  return HTTP_HEADER_INIT(x, http_if_none_match_class, sizeof(http_if_none_match_t));
}
#else
#define http_if_none_match_init(x) \
  HTTP_HEADER_INIT(x, http_if_none_match_class, sizeof(http_if_none_match_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_if_none_match(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_if_none_match_hash;
}
#else
#define http_is_if_none_match(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_none_match_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_if_none_match_t *http_if_none_match_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_if_none_match_class, fmt, ap);
  va_end(ap);

  return (http_if_none_match_t *)h;
}

su_inline
http_if_none_match_t *http_if_none_match_dup(su_home_t *home, http_if_none_match_t const *o)
{
  return (http_if_none_match_t *)
    msg_header_dup_as(home, http_if_none_match_class, (msg_header_t const *)o);
}

su_inline
http_if_none_match_t *http_if_none_match_copy(su_home_t *home, http_if_none_match_t const *o)
{
  return (http_if_none_match_t *)
    msg_header_copy_as(home, http_if_none_match_class, (msg_header_t const *)o);
}

su_inline
http_if_none_match_t *http_if_none_match_make(su_home_t *home, char const *s)
{
  return (http_if_none_match_t *)http_header_make(home, http_if_none_match_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for If-Range header */
 
enum {
  http_if_range_hash = 40469
};

SOFIAPUBVAR msg_hclass_t http_if_range_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_if_range_d;

SOFIAPUBFUN msg_print_f http_if_range_e;

#define HTTP_IF_RANGE_INIT() HTTP_HDR_INIT(if_range)

#if SU_HAVE_INLINE
su_inline http_if_range_t *http_if_range_init(http_if_range_t x[1])
{
  return HTTP_HEADER_INIT(x, http_if_range_class, sizeof(http_if_range_t));
}
#else
#define http_if_range_init(x) \
  HTTP_HEADER_INIT(x, http_if_range_class, sizeof(http_if_range_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_if_range(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_if_range_hash;
}
#else
#define http_is_if_range(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_range_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_if_range_t *http_if_range_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_if_range_class, fmt, ap);
  va_end(ap);

  return (http_if_range_t *)h;
}

su_inline
http_if_range_t *http_if_range_dup(su_home_t *home, http_if_range_t const *o)
{
  return (http_if_range_t *)
    msg_header_dup_as(home, http_if_range_class, (msg_header_t const *)o);
}

su_inline
http_if_range_t *http_if_range_copy(su_home_t *home, http_if_range_t const *o)
{
  return (http_if_range_t *)
    msg_header_copy_as(home, http_if_range_class, (msg_header_t const *)o);
}

su_inline
http_if_range_t *http_if_range_make(su_home_t *home, char const *s)
{
  return (http_if_range_t *)http_header_make(home, http_if_range_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for If-Unmodified-Since header */
 
enum {
  http_if_unmodified_since_hash = 2675
};

SOFIAPUBVAR msg_hclass_t http_if_unmodified_since_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_if_unmodified_since_d;

SOFIAPUBFUN msg_print_f http_if_unmodified_since_e;

#define HTTP_IF_UNMODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_unmodified_since)

#if SU_HAVE_INLINE
su_inline http_if_unmodified_since_t *http_if_unmodified_since_init(http_if_unmodified_since_t x[1])
{
  return HTTP_HEADER_INIT(x, http_if_unmodified_since_class, sizeof(http_if_unmodified_since_t));
}
#else
#define http_if_unmodified_since_init(x) \
  HTTP_HEADER_INIT(x, http_if_unmodified_since_class, sizeof(http_if_unmodified_since_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_if_unmodified_since(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_if_unmodified_since_hash;
}
#else
#define http_is_if_unmodified_since(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_unmodified_since_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_if_unmodified_since_t *http_if_unmodified_since_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_if_unmodified_since_class, fmt, ap);
  va_end(ap);

  return (http_if_unmodified_since_t *)h;
}

su_inline
http_if_unmodified_since_t *http_if_unmodified_since_dup(su_home_t *home, http_if_unmodified_since_t const *o)
{
  return (http_if_unmodified_since_t *)
    msg_header_dup_as(home, http_if_unmodified_since_class, (msg_header_t const *)o);
}

su_inline
http_if_unmodified_since_t *http_if_unmodified_since_copy(su_home_t *home, http_if_unmodified_since_t const *o)
{
  return (http_if_unmodified_since_t *)
    msg_header_copy_as(home, http_if_unmodified_since_class, (msg_header_t const *)o);
}

su_inline
http_if_unmodified_since_t *http_if_unmodified_since_make(su_home_t *home, char const *s)
{
  return (http_if_unmodified_since_t *)http_header_make(home, http_if_unmodified_since_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Last-Modified header */
 
enum {
  http_last_modified_hash = 19958
};

SOFIAPUBVAR msg_hclass_t http_last_modified_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_last_modified_d;

SOFIAPUBFUN msg_print_f http_last_modified_e;

#define HTTP_LAST_MODIFIED_INIT() HTTP_HDR_INIT(last_modified)

#if SU_HAVE_INLINE
su_inline http_last_modified_t *http_last_modified_init(http_last_modified_t x[1])
{
  return HTTP_HEADER_INIT(x, http_last_modified_class, sizeof(http_last_modified_t));
}
#else
#define http_last_modified_init(x) \
  HTTP_HEADER_INIT(x, http_last_modified_class, sizeof(http_last_modified_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_last_modified(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_last_modified_hash;
}
#else
#define http_is_last_modified(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_last_modified_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_last_modified_t *http_last_modified_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_last_modified_class, fmt, ap);
  va_end(ap);

  return (http_last_modified_t *)h;
}

su_inline
http_last_modified_t *http_last_modified_dup(su_home_t *home, http_last_modified_t const *o)
{
  return (http_last_modified_t *)
    msg_header_dup_as(home, http_last_modified_class, (msg_header_t const *)o);
}

su_inline
http_last_modified_t *http_last_modified_copy(su_home_t *home, http_last_modified_t const *o)
{
  return (http_last_modified_t *)
    msg_header_copy_as(home, http_last_modified_class, (msg_header_t const *)o);
}

su_inline
http_last_modified_t *http_last_modified_make(su_home_t *home, char const *s)
{
  return (http_last_modified_t *)http_header_make(home, http_last_modified_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Location header */
 
enum {
  http_location_hash = 60949
};

SOFIAPUBVAR msg_hclass_t http_location_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_location_d;

SOFIAPUBFUN msg_print_f http_location_e;

#define HTTP_LOCATION_INIT() HTTP_HDR_INIT(location)

#if SU_HAVE_INLINE
su_inline http_location_t *http_location_init(http_location_t x[1])
{
  return HTTP_HEADER_INIT(x, http_location_class, sizeof(http_location_t));
}
#else
#define http_location_init(x) \
  HTTP_HEADER_INIT(x, http_location_class, sizeof(http_location_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_location(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_location_hash;
}
#else
#define http_is_location(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_location_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_location_t *http_location_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_location_class, fmt, ap);
  va_end(ap);

  return (http_location_t *)h;
}

su_inline
http_location_t *http_location_dup(su_home_t *home, http_location_t const *o)
{
  return (http_location_t *)
    msg_header_dup_as(home, http_location_class, (msg_header_t const *)o);
}

su_inline
http_location_t *http_location_copy(su_home_t *home, http_location_t const *o)
{
  return (http_location_t *)
    msg_header_copy_as(home, http_location_class, (msg_header_t const *)o);
}

su_inline
http_location_t *http_location_make(su_home_t *home, char const *s)
{
  return (http_location_t *)http_header_make(home, http_location_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Max-Forwards header */
 
enum {
  http_max_forwards_hash = 27231
};

SOFIAPUBVAR msg_hclass_t http_max_forwards_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_max_forwards_d;

SOFIAPUBFUN msg_print_f http_max_forwards_e;

#define HTTP_MAX_FORWARDS_INIT() HTTP_HDR_INIT(max_forwards)

#if SU_HAVE_INLINE
su_inline http_max_forwards_t *http_max_forwards_init(http_max_forwards_t x[1])
{
  return HTTP_HEADER_INIT(x, http_max_forwards_class, sizeof(http_max_forwards_t));
}
#else
#define http_max_forwards_init(x) \
  HTTP_HEADER_INIT(x, http_max_forwards_class, sizeof(http_max_forwards_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_max_forwards(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_max_forwards_hash;
}
#else
#define http_is_max_forwards(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_max_forwards_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_max_forwards_t *http_max_forwards_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_max_forwards_class, fmt, ap);
  va_end(ap);

  return (http_max_forwards_t *)h;
}

su_inline
http_max_forwards_t *http_max_forwards_dup(su_home_t *home, http_max_forwards_t const *o)
{
  return (http_max_forwards_t *)
    msg_header_dup_as(home, http_max_forwards_class, (msg_header_t const *)o);
}

su_inline
http_max_forwards_t *http_max_forwards_copy(su_home_t *home, http_max_forwards_t const *o)
{
  return (http_max_forwards_t *)
    msg_header_copy_as(home, http_max_forwards_class, (msg_header_t const *)o);
}

su_inline
http_max_forwards_t *http_max_forwards_make(su_home_t *home, char const *s)
{
  return (http_max_forwards_t *)http_header_make(home, http_max_forwards_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Pragma header */
 
enum {
  http_pragma_hash = 49776
};

SOFIAPUBVAR msg_hclass_t http_pragma_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_pragma_d;

SOFIAPUBFUN msg_print_f http_pragma_e;

#define HTTP_PRAGMA_INIT() HTTP_HDR_INIT(pragma)

#if SU_HAVE_INLINE
su_inline http_pragma_t *http_pragma_init(http_pragma_t x[1])
{
  return HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t));
}
#else
#define http_pragma_init(x) \
  HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_pragma(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_pragma_hash;
}
#else
#define http_is_pragma(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_pragma_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_pragma_t *http_pragma_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_pragma_class, fmt, ap);
  va_end(ap);

  return (http_pragma_t *)h;
}

su_inline
http_pragma_t *http_pragma_dup(su_home_t *home, http_pragma_t const *o)
{
  return (http_pragma_t *)
    msg_header_dup_as(home, http_pragma_class, (msg_header_t const *)o);
}

su_inline
http_pragma_t *http_pragma_copy(su_home_t *home, http_pragma_t const *o)
{
  return (http_pragma_t *)
    msg_header_copy_as(home, http_pragma_class, (msg_header_t const *)o);
}

su_inline
http_pragma_t *http_pragma_make(su_home_t *home, char const *s)
{
  return (http_pragma_t *)http_header_make(home, http_pragma_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Proxy-Authenticate header */
 
enum {
  http_proxy_authenticate_hash = 57658
};

SOFIAPUBVAR msg_hclass_t http_proxy_authenticate_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_proxy_authenticate_d;

SOFIAPUBFUN msg_print_f http_proxy_authenticate_e;

#define HTTP_PROXY_AUTHENTICATE_INIT() HTTP_HDR_INIT(proxy_authenticate)

#if SU_HAVE_INLINE
su_inline http_proxy_authenticate_t *http_proxy_authenticate_init(http_proxy_authenticate_t x[1])
{
  return HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t));
}
#else
#define http_proxy_authenticate_init(x) \
  HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_proxy_authenticate(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_proxy_authenticate_hash;
}
#else
#define http_is_proxy_authenticate(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authenticate_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_proxy_authenticate_t *http_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_proxy_authenticate_class, fmt, ap);
  va_end(ap);

  return (http_proxy_authenticate_t *)h;
}

su_inline
http_proxy_authenticate_t *http_proxy_authenticate_dup(su_home_t *home, http_proxy_authenticate_t const *o)
{
  return (http_proxy_authenticate_t *)
    msg_header_dup_as(home, http_proxy_authenticate_class, (msg_header_t const *)o);
}

su_inline
http_proxy_authenticate_t *http_proxy_authenticate_copy(su_home_t *home, http_proxy_authenticate_t const *o)
{
  return (http_proxy_authenticate_t *)
    msg_header_copy_as(home, http_proxy_authenticate_class, (msg_header_t const *)o);
}

su_inline
http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
{
  return (http_proxy_authenticate_t *)http_header_make(home, http_proxy_authenticate_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Proxy-Authorization header */
 
enum {
  http_proxy_authorization_hash = 21244
};

SOFIAPUBVAR msg_hclass_t http_proxy_authorization_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_proxy_authorization_d;

SOFIAPUBFUN msg_print_f http_proxy_authorization_e;

#define HTTP_PROXY_AUTHORIZATION_INIT() HTTP_HDR_INIT(proxy_authorization)

#if SU_HAVE_INLINE
su_inline http_proxy_authorization_t *http_proxy_authorization_init(http_proxy_authorization_t x[1])
{
  return HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t));
}
#else
#define http_proxy_authorization_init(x) \
  HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_proxy_authorization(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_proxy_authorization_hash;
}
#else
#define http_is_proxy_authorization(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authorization_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_proxy_authorization_t *http_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_proxy_authorization_class, fmt, ap);
  va_end(ap);

  return (http_proxy_authorization_t *)h;
}

su_inline
http_proxy_authorization_t *http_proxy_authorization_dup(su_home_t *home, http_proxy_authorization_t const *o)
{
  return (http_proxy_authorization_t *)
    msg_header_dup_as(home, http_proxy_authorization_class, (msg_header_t const *)o);
}

su_inline
http_proxy_authorization_t *http_proxy_authorization_copy(su_home_t *home, http_proxy_authorization_t const *o)
{
  return (http_proxy_authorization_t *)
    msg_header_copy_as(home, http_proxy_authorization_class, (msg_header_t const *)o);
}

su_inline
http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
{
  return (http_proxy_authorization_t *)http_header_make(home, http_proxy_authorization_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Range header */
 
enum {
  http_range_hash = 20297
};

SOFIAPUBVAR msg_hclass_t http_range_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_range_d;

SOFIAPUBFUN msg_print_f http_range_e;

#define HTTP_RANGE_INIT() HTTP_HDR_INIT(range)

#if SU_HAVE_INLINE
su_inline http_range_t *http_range_init(http_range_t x[1])
{
  return HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t));
}
#else
#define http_range_init(x) \
  HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_range(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_range_hash;
}
#else
#define http_is_range(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_range_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_range_t *http_range_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_range_class, fmt, ap);
  va_end(ap);

  return (http_range_t *)h;
}

su_inline
http_range_t *http_range_dup(su_home_t *home, http_range_t const *o)
{
  return (http_range_t *)
    msg_header_dup_as(home, http_range_class, (msg_header_t const *)o);
}

su_inline
http_range_t *http_range_copy(su_home_t *home, http_range_t const *o)
{
  return (http_range_t *)
    msg_header_copy_as(home, http_range_class, (msg_header_t const *)o);
}

su_inline
http_range_t *http_range_make(su_home_t *home, char const *s)
{
  return (http_range_t *)http_header_make(home, http_range_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Referer header */
 
enum {
  http_referer_hash = 64523
};

SOFIAPUBVAR msg_hclass_t http_referer_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_referer_d;

SOFIAPUBFUN msg_print_f http_referer_e;

#define HTTP_REFERER_INIT() HTTP_HDR_INIT(referer)

#if SU_HAVE_INLINE
su_inline http_referer_t *http_referer_init(http_referer_t x[1])
{
  return HTTP_HEADER_INIT(x, http_referer_class, sizeof(http_referer_t));
}
#else
#define http_referer_init(x) \
  HTTP_HEADER_INIT(x, http_referer_class, sizeof(http_referer_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_referer(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_referer_hash;
}
#else
#define http_is_referer(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_referer_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_referer_t *http_referer_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_referer_class, fmt, ap);
  va_end(ap);

  return (http_referer_t *)h;
}

su_inline
http_referer_t *http_referer_dup(su_home_t *home, http_referer_t const *o)
{
  return (http_referer_t *)
    msg_header_dup_as(home, http_referer_class, (msg_header_t const *)o);
}

su_inline
http_referer_t *http_referer_copy(su_home_t *home, http_referer_t const *o)
{
  return (http_referer_t *)
    msg_header_copy_as(home, http_referer_class, (msg_header_t const *)o);
}

su_inline
http_referer_t *http_referer_make(su_home_t *home, char const *s)
{
  return (http_referer_t *)http_header_make(home, http_referer_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Retry-After header */
 
enum {
  http_retry_after_hash = 30349
};

SOFIAPUBVAR msg_hclass_t http_retry_after_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_retry_after_d;

SOFIAPUBFUN msg_print_f http_retry_after_e;

#define HTTP_RETRY_AFTER_INIT() HTTP_HDR_INIT(retry_after)

#if SU_HAVE_INLINE
su_inline http_retry_after_t *http_retry_after_init(http_retry_after_t x[1])
{
  return HTTP_HEADER_INIT(x, http_retry_after_class, sizeof(http_retry_after_t));
}
#else
#define http_retry_after_init(x) \
  HTTP_HEADER_INIT(x, http_retry_after_class, sizeof(http_retry_after_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_retry_after(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_retry_after_hash;
}
#else
#define http_is_retry_after(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_retry_after_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_retry_after_t *http_retry_after_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_retry_after_class, fmt, ap);
  va_end(ap);

  return (http_retry_after_t *)h;
}

su_inline
http_retry_after_t *http_retry_after_dup(su_home_t *home, http_retry_after_t const *o)
{
  return (http_retry_after_t *)
    msg_header_dup_as(home, http_retry_after_class, (msg_header_t const *)o);
}

su_inline
http_retry_after_t *http_retry_after_copy(su_home_t *home, http_retry_after_t const *o)
{
  return (http_retry_after_t *)
    msg_header_copy_as(home, http_retry_after_class, (msg_header_t const *)o);
}

su_inline
http_retry_after_t *http_retry_after_make(su_home_t *home, char const *s)
{
  return (http_retry_after_t *)http_header_make(home, http_retry_after_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Server header */
 
enum {
  http_server_hash = 31323
};

SOFIAPUBVAR msg_hclass_t http_server_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_server_d;

SOFIAPUBFUN msg_print_f http_server_e;

#define HTTP_SERVER_INIT() HTTP_HDR_INIT(server)

#if SU_HAVE_INLINE
su_inline http_server_t *http_server_init(http_server_t x[1])
{
  return HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t));
}
#else
#define http_server_init(x) \
  HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_server(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_server_hash;
}
#else
#define http_is_server(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_server_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_server_t *http_server_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_server_class, fmt, ap);
  va_end(ap);

  return (http_server_t *)h;
}

su_inline
http_server_t *http_server_dup(su_home_t *home, http_server_t const *o)
{
  return (http_server_t *)
    msg_header_dup_as(home, http_server_class, (msg_header_t const *)o);
}

su_inline
http_server_t *http_server_copy(su_home_t *home, http_server_t const *o)
{
  return (http_server_t *)
    msg_header_copy_as(home, http_server_class, (msg_header_t const *)o);
}

su_inline
http_server_t *http_server_make(su_home_t *home, char const *s)
{
  return (http_server_t *)http_header_make(home, http_server_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for TE header */
 
enum {
  http_te_hash = 5165
};

SOFIAPUBVAR msg_hclass_t http_te_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_te_d;

SOFIAPUBFUN msg_print_f http_te_e;

#define HTTP_TE_INIT() HTTP_HDR_INIT(te)

#if SU_HAVE_INLINE
su_inline http_te_t *http_te_init(http_te_t x[1])
{
  return HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t));
}
#else
#define http_te_init(x) \
  HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_te(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_te_hash;
}
#else
#define http_is_te(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_te_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_te_t *http_te_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_te_class, fmt, ap);
  va_end(ap);

  return (http_te_t *)h;
}

su_inline
http_te_t *http_te_dup(su_home_t *home, http_te_t const *o)
{
  return (http_te_t *)
    msg_header_dup_as(home, http_te_class, (msg_header_t const *)o);
}

su_inline
http_te_t *http_te_copy(su_home_t *home, http_te_t const *o)
{
  return (http_te_t *)
    msg_header_copy_as(home, http_te_class, (msg_header_t const *)o);
}

su_inline
http_te_t *http_te_make(su_home_t *home, char const *s)
{
  return (http_te_t *)http_header_make(home, http_te_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Trailer header */
 
enum {
  http_trailer_hash = 11015
};

SOFIAPUBVAR msg_hclass_t http_trailer_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_trailer_d;

SOFIAPUBFUN msg_print_f http_trailer_e;

#define HTTP_TRAILER_INIT() HTTP_HDR_INIT(trailer)

#if SU_HAVE_INLINE
su_inline http_trailer_t *http_trailer_init(http_trailer_t x[1])
{
  return HTTP_HEADER_INIT(x, http_trailer_class, sizeof(http_trailer_t));
}
#else
#define http_trailer_init(x) \
  HTTP_HEADER_INIT(x, http_trailer_class, sizeof(http_trailer_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_trailer(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_trailer_hash;
}
#else
#define http_is_trailer(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_trailer_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_trailer_t *http_trailer_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_trailer_class, fmt, ap);
  va_end(ap);

  return (http_trailer_t *)h;
}

su_inline
http_trailer_t *http_trailer_dup(su_home_t *home, http_trailer_t const *o)
{
  return (http_trailer_t *)
    msg_header_dup_as(home, http_trailer_class, (msg_header_t const *)o);
}

su_inline
http_trailer_t *http_trailer_copy(su_home_t *home, http_trailer_t const *o)
{
  return (http_trailer_t *)
    msg_header_copy_as(home, http_trailer_class, (msg_header_t const *)o);
}

su_inline
http_trailer_t *http_trailer_make(su_home_t *home, char const *s)
{
  return (http_trailer_t *)http_header_make(home, http_trailer_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Transfer-Encoding header */
 
enum {
  http_transfer_encoding_hash = 25509
};

SOFIAPUBVAR msg_hclass_t http_transfer_encoding_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_transfer_encoding_d;

SOFIAPUBFUN msg_print_f http_transfer_encoding_e;

#define HTTP_TRANSFER_ENCODING_INIT() HTTP_HDR_INIT(transfer_encoding)

#if SU_HAVE_INLINE
su_inline http_transfer_encoding_t *http_transfer_encoding_init(http_transfer_encoding_t x[1])
{
  return HTTP_HEADER_INIT(x, http_transfer_encoding_class, sizeof(http_transfer_encoding_t));
}
#else
#define http_transfer_encoding_init(x) \
  HTTP_HEADER_INIT(x, http_transfer_encoding_class, sizeof(http_transfer_encoding_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_transfer_encoding(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_transfer_encoding_hash;
}
#else
#define http_is_transfer_encoding(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_transfer_encoding_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_transfer_encoding_t *http_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_transfer_encoding_class, fmt, ap);
  va_end(ap);

  return (http_transfer_encoding_t *)h;
}

su_inline
http_transfer_encoding_t *http_transfer_encoding_dup(su_home_t *home, http_transfer_encoding_t const *o)
{
  return (http_transfer_encoding_t *)
    msg_header_dup_as(home, http_transfer_encoding_class, (msg_header_t const *)o);
}

su_inline
http_transfer_encoding_t *http_transfer_encoding_copy(su_home_t *home, http_transfer_encoding_t const *o)
{
  return (http_transfer_encoding_t *)
    msg_header_copy_as(home, http_transfer_encoding_class, (msg_header_t const *)o);
}

su_inline
http_transfer_encoding_t *http_transfer_encoding_make(su_home_t *home, char const *s)
{
  return (http_transfer_encoding_t *)http_header_make(home, http_transfer_encoding_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Upgrade header */
 
enum {
  http_upgrade_hash = 16256
};

SOFIAPUBVAR msg_hclass_t http_upgrade_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_upgrade_d;

SOFIAPUBFUN msg_print_f http_upgrade_e;

#define HTTP_UPGRADE_INIT() HTTP_HDR_INIT(upgrade)

#if SU_HAVE_INLINE
su_inline http_upgrade_t *http_upgrade_init(http_upgrade_t x[1])
{
  return HTTP_HEADER_INIT(x, http_upgrade_class, sizeof(http_upgrade_t));
}
#else
#define http_upgrade_init(x) \
  HTTP_HEADER_INIT(x, http_upgrade_class, sizeof(http_upgrade_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_upgrade(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_upgrade_hash;
}
#else
#define http_is_upgrade(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_upgrade_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_upgrade_t *http_upgrade_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_upgrade_class, fmt, ap);
  va_end(ap);

  return (http_upgrade_t *)h;
}

su_inline
http_upgrade_t *http_upgrade_dup(su_home_t *home, http_upgrade_t const *o)
{
  return (http_upgrade_t *)
    msg_header_dup_as(home, http_upgrade_class, (msg_header_t const *)o);
}

su_inline
http_upgrade_t *http_upgrade_copy(su_home_t *home, http_upgrade_t const *o)
{
  return (http_upgrade_t *)
    msg_header_copy_as(home, http_upgrade_class, (msg_header_t const *)o);
}

su_inline
http_upgrade_t *http_upgrade_make(su_home_t *home, char const *s)
{
  return (http_upgrade_t *)http_header_make(home, http_upgrade_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for User-Agent header */
 
enum {
  http_user_agent_hash = 40911
};

SOFIAPUBVAR msg_hclass_t http_user_agent_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_user_agent_d;

SOFIAPUBFUN msg_print_f http_user_agent_e;

#define HTTP_USER_AGENT_INIT() HTTP_HDR_INIT(user_agent)

#if SU_HAVE_INLINE
su_inline http_user_agent_t *http_user_agent_init(http_user_agent_t x[1])
{
  return HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t));
}
#else
#define http_user_agent_init(x) \
  HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_user_agent(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_user_agent_hash;
}
#else
#define http_is_user_agent(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_user_agent_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_user_agent_t *http_user_agent_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_user_agent_class, fmt, ap);
  va_end(ap);

  return (http_user_agent_t *)h;
}

su_inline
http_user_agent_t *http_user_agent_dup(su_home_t *home, http_user_agent_t const *o)
{
  return (http_user_agent_t *)
    msg_header_dup_as(home, http_user_agent_class, (msg_header_t const *)o);
}

su_inline
http_user_agent_t *http_user_agent_copy(su_home_t *home, http_user_agent_t const *o)
{
  return (http_user_agent_t *)
    msg_header_copy_as(home, http_user_agent_class, (msg_header_t const *)o);
}

su_inline
http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
{
  return (http_user_agent_t *)http_header_make(home, http_user_agent_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Vary header */
 
enum {
  http_vary_hash = 57074
};

SOFIAPUBVAR msg_hclass_t http_vary_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_vary_d;

SOFIAPUBFUN msg_print_f http_vary_e;

#define HTTP_VARY_INIT() HTTP_HDR_INIT(vary)

#if SU_HAVE_INLINE
su_inline http_vary_t *http_vary_init(http_vary_t x[1])
{
  return HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t));
}
#else
#define http_vary_init(x) \
  HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_vary(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_vary_hash;
}
#else
#define http_is_vary(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_vary_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_vary_t *http_vary_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_vary_class, fmt, ap);
  va_end(ap);

  return (http_vary_t *)h;
}

su_inline
http_vary_t *http_vary_dup(su_home_t *home, http_vary_t const *o)
{
  return (http_vary_t *)
    msg_header_dup_as(home, http_vary_class, (msg_header_t const *)o);
}

su_inline
http_vary_t *http_vary_copy(su_home_t *home, http_vary_t const *o)
{
  return (http_vary_t *)
    msg_header_copy_as(home, http_vary_class, (msg_header_t const *)o);
}

su_inline
http_vary_t *http_vary_make(su_home_t *home, char const *s)
{
  return (http_vary_t *)http_header_make(home, http_vary_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Via header */
 
enum {
  http_via_hash = 46244
};

SOFIAPUBVAR msg_hclass_t http_via_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_via_d;

SOFIAPUBFUN msg_print_f http_via_e;

#define HTTP_VIA_INIT() HTTP_HDR_INIT(via)

#if SU_HAVE_INLINE
su_inline http_via_t *http_via_init(http_via_t x[1])
{
  return HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t));
}
#else
#define http_via_init(x) \
  HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_via(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_via_hash;
}
#else
#define http_is_via(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_via_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_via_t *http_via_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_via_class, fmt, ap);
  va_end(ap);

  return (http_via_t *)h;
}

su_inline
http_via_t *http_via_dup(su_home_t *home, http_via_t const *o)
{
  return (http_via_t *)
    msg_header_dup_as(home, http_via_class, (msg_header_t const *)o);
}

su_inline
http_via_t *http_via_copy(su_home_t *home, http_via_t const *o)
{
  return (http_via_t *)
    msg_header_copy_as(home, http_via_class, (msg_header_t const *)o);
}

su_inline
http_via_t *http_via_make(su_home_t *home, char const *s)
{
  return (http_via_t *)http_header_make(home, http_via_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Warning header */
 
enum {
  http_warning_hash = 4130
};

SOFIAPUBVAR msg_hclass_t http_warning_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_warning_d;

SOFIAPUBFUN msg_print_f http_warning_e;

#define HTTP_WARNING_INIT() HTTP_HDR_INIT(warning)

#if SU_HAVE_INLINE
su_inline http_warning_t *http_warning_init(http_warning_t x[1])
{
  return HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t));
}
#else
#define http_warning_init(x) \
  HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_warning(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_warning_hash;
}
#else
#define http_is_warning(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_warning_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_warning_t *http_warning_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_warning_class, fmt, ap);
  va_end(ap);

  return (http_warning_t *)h;
}

su_inline
http_warning_t *http_warning_dup(su_home_t *home, http_warning_t const *o)
{
  return (http_warning_t *)
    msg_header_dup_as(home, http_warning_class, (msg_header_t const *)o);
}

su_inline
http_warning_t *http_warning_copy(su_home_t *home, http_warning_t const *o)
{
  return (http_warning_t *)
    msg_header_copy_as(home, http_warning_class, (msg_header_t const *)o);
}

su_inline
http_warning_t *http_warning_make(su_home_t *home, char const *s)
{
  return (http_warning_t *)http_header_make(home, http_warning_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for WWW-Authenticate header */
 
enum {
  http_www_authenticate_hash = 16217
};

SOFIAPUBVAR msg_hclass_t http_www_authenticate_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_www_authenticate_d;

SOFIAPUBFUN msg_print_f http_www_authenticate_e;

#define HTTP_WWW_AUTHENTICATE_INIT() HTTP_HDR_INIT(www_authenticate)

#if SU_HAVE_INLINE
su_inline http_www_authenticate_t *http_www_authenticate_init(http_www_authenticate_t x[1])
{
  return HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t));
}
#else
#define http_www_authenticate_init(x) \
  HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_www_authenticate(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_www_authenticate_hash;
}
#else
#define http_is_www_authenticate(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_www_authenticate_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_www_authenticate_t *http_www_authenticate_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_www_authenticate_class, fmt, ap);
  va_end(ap);

  return (http_www_authenticate_t *)h;
}

su_inline
http_www_authenticate_t *http_www_authenticate_dup(su_home_t *home, http_www_authenticate_t const *o)
{
  return (http_www_authenticate_t *)
    msg_header_dup_as(home, http_www_authenticate_class, (msg_header_t const *)o);
}

su_inline
http_www_authenticate_t *http_www_authenticate_copy(su_home_t *home, http_www_authenticate_t const *o)
{
  return (http_www_authenticate_t *)
    msg_header_copy_as(home, http_www_authenticate_class, (msg_header_t const *)o);
}

su_inline
http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
{
  return (http_www_authenticate_t *)http_header_make(home, http_www_authenticate_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Proxy-Connection header */
 
enum {
  http_proxy_connection_hash = 60183
};

SOFIAPUBVAR msg_hclass_t http_proxy_connection_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_proxy_connection_d;

SOFIAPUBFUN msg_print_f http_proxy_connection_e;

#define HTTP_PROXY_CONNECTION_INIT() HTTP_HDR_INIT(proxy_connection)

#if SU_HAVE_INLINE
su_inline http_proxy_connection_t *http_proxy_connection_init(http_proxy_connection_t x[1])
{
  return HTTP_HEADER_INIT(x, http_proxy_connection_class, sizeof(http_proxy_connection_t));
}
#else
#define http_proxy_connection_init(x) \
  HTTP_HEADER_INIT(x, http_proxy_connection_class, sizeof(http_proxy_connection_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_proxy_connection(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_proxy_connection_hash;
}
#else
#define http_is_proxy_connection(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_connection_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_proxy_connection_t *http_proxy_connection_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_proxy_connection_class, fmt, ap);
  va_end(ap);

  return (http_proxy_connection_t *)h;
}

su_inline
http_proxy_connection_t *http_proxy_connection_dup(su_home_t *home, http_proxy_connection_t const *o)
{
  return (http_proxy_connection_t *)
    msg_header_dup_as(home, http_proxy_connection_class, (msg_header_t const *)o);
}

su_inline
http_proxy_connection_t *http_proxy_connection_copy(su_home_t *home, http_proxy_connection_t const *o)
{
  return (http_proxy_connection_t *)
    msg_header_copy_as(home, http_proxy_connection_class, (msg_header_t const *)o);
}

su_inline
http_proxy_connection_t *http_proxy_connection_make(su_home_t *home, char const *s)
{
  return (http_proxy_connection_t *)http_header_make(home, http_proxy_connection_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Set-Cookie header */
 
enum {
  http_set_cookie_hash = 57887
};

SOFIAPUBVAR msg_hclass_t http_set_cookie_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_set_cookie_d;

SOFIAPUBFUN msg_print_f http_set_cookie_e;

#define HTTP_SET_COOKIE_INIT() HTTP_HDR_INIT(set_cookie)

#if SU_HAVE_INLINE
su_inline http_set_cookie_t *http_set_cookie_init(http_set_cookie_t x[1])
{
  return HTTP_HEADER_INIT(x, http_set_cookie_class, sizeof(http_set_cookie_t));
}
#else
#define http_set_cookie_init(x) \
  HTTP_HEADER_INIT(x, http_set_cookie_class, sizeof(http_set_cookie_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_set_cookie(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_set_cookie_hash;
}
#else
#define http_is_set_cookie(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_set_cookie_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_set_cookie_t *http_set_cookie_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_set_cookie_class, fmt, ap);
  va_end(ap);

  return (http_set_cookie_t *)h;
}

su_inline
http_set_cookie_t *http_set_cookie_dup(su_home_t *home, http_set_cookie_t const *o)
{
  return (http_set_cookie_t *)
    msg_header_dup_as(home, http_set_cookie_class, (msg_header_t const *)o);
}

su_inline
http_set_cookie_t *http_set_cookie_copy(su_home_t *home, http_set_cookie_t const *o)
{
  return (http_set_cookie_t *)
    msg_header_copy_as(home, http_set_cookie_class, (msg_header_t const *)o);
}

su_inline
http_set_cookie_t *http_set_cookie_make(su_home_t *home, char const *s)
{
  return (http_set_cookie_t *)http_header_make(home, http_set_cookie_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Cookie header */
 
enum {
  http_cookie_hash = 78
};

SOFIAPUBVAR msg_hclass_t http_cookie_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_cookie_d;

SOFIAPUBFUN msg_print_f http_cookie_e;

#define HTTP_COOKIE_INIT() HTTP_HDR_INIT(cookie)

#if SU_HAVE_INLINE
su_inline http_cookie_t *http_cookie_init(http_cookie_t x[1])
{
  return HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t));
}
#else
#define http_cookie_init(x) \
  HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_cookie(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_cookie_hash;
}
#else
#define http_is_cookie(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cookie_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_cookie_t *http_cookie_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_cookie_class, fmt, ap);
  va_end(ap);

  return (http_cookie_t *)h;
}

su_inline
http_cookie_t *http_cookie_dup(su_home_t *home, http_cookie_t const *o)
{
  return (http_cookie_t *)
    msg_header_dup_as(home, http_cookie_class, (msg_header_t const *)o);
}

su_inline
http_cookie_t *http_cookie_copy(su_home_t *home, http_cookie_t const *o)
{
  return (http_cookie_t *)
    msg_header_copy_as(home, http_cookie_class, (msg_header_t const *)o);
}

su_inline
http_cookie_t *http_cookie_make(su_home_t *home, char const *s)
{
  return (http_cookie_t *)http_header_make(home, http_cookie_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for MIME-Version header */
 
enum {
  http_mime_version_hash = 49047
};

SOFIAPUBVAR msg_hclass_t http_mime_version_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_mime_version_d;

SOFIAPUBFUN msg_print_f http_mime_version_e;

#define HTTP_MIME_VERSION_INIT() HTTP_HDR_INIT(mime_version)

#if SU_HAVE_INLINE
su_inline http_mime_version_t *http_mime_version_init(http_mime_version_t x[1])
{
  return HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t));
}
#else
#define http_mime_version_init(x) \
  HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_mime_version(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_mime_version_hash;
}
#else
#define http_is_mime_version(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_mime_version_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_mime_version_t *http_mime_version_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_mime_version_class, fmt, ap);
  va_end(ap);

  return (http_mime_version_t *)h;
}

su_inline
http_mime_version_t *http_mime_version_dup(su_home_t *home, http_mime_version_t const *o)
{
  return (http_mime_version_t *)
    msg_header_dup_as(home, http_mime_version_class, (msg_header_t const *)o);
}

su_inline
http_mime_version_t *http_mime_version_copy(su_home_t *home, http_mime_version_t const *o)
{
  return (http_mime_version_t *)
    msg_header_copy_as(home, http_mime_version_class, (msg_header_t const *)o);
}

su_inline
http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
{
  return (http_mime_version_t *)http_header_make(home, http_mime_version_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Encoding header */
 
enum {
  http_content_encoding_hash = 8707
};

SOFIAPUBVAR msg_hclass_t http_content_encoding_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_encoding_d;

SOFIAPUBFUN msg_print_f http_content_encoding_e;

#define HTTP_CONTENT_ENCODING_INIT() HTTP_HDR_INIT(content_encoding)

#if SU_HAVE_INLINE
su_inline http_content_encoding_t *http_content_encoding_init(http_content_encoding_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t));
}
#else
#define http_content_encoding_init(x) \
  HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_encoding(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_encoding_hash;
}
#else
#define http_is_content_encoding(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_encoding_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_encoding_t *http_content_encoding_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_encoding_class, fmt, ap);
  va_end(ap);

  return (http_content_encoding_t *)h;
}

su_inline
http_content_encoding_t *http_content_encoding_dup(su_home_t *home, http_content_encoding_t const *o)
{
  return (http_content_encoding_t *)
    msg_header_dup_as(home, http_content_encoding_class, (msg_header_t const *)o);
}

su_inline
http_content_encoding_t *http_content_encoding_copy(su_home_t *home, http_content_encoding_t const *o)
{
  return (http_content_encoding_t *)
    msg_header_copy_as(home, http_content_encoding_class, (msg_header_t const *)o);
}

su_inline
http_content_encoding_t *http_content_encoding_make(su_home_t *home, char const *s)
{
  return (http_content_encoding_t *)http_header_make(home, http_content_encoding_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Language header */
 
enum {
  http_content_language_hash = 62108
};

SOFIAPUBVAR msg_hclass_t http_content_language_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_language_d;

SOFIAPUBFUN msg_print_f http_content_language_e;

#define HTTP_CONTENT_LANGUAGE_INIT() HTTP_HDR_INIT(content_language)

#if SU_HAVE_INLINE
su_inline http_content_language_t *http_content_language_init(http_content_language_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t));
}
#else
#define http_content_language_init(x) \
  HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_language(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_language_hash;
}
#else
#define http_is_content_language(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_language_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_language_t *http_content_language_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_language_class, fmt, ap);
  va_end(ap);

  return (http_content_language_t *)h;
}

su_inline
http_content_language_t *http_content_language_dup(su_home_t *home, http_content_language_t const *o)
{
  return (http_content_language_t *)
    msg_header_dup_as(home, http_content_language_class, (msg_header_t const *)o);
}

su_inline
http_content_language_t *http_content_language_copy(su_home_t *home, http_content_language_t const *o)
{
  return (http_content_language_t *)
    msg_header_copy_as(home, http_content_language_class, (msg_header_t const *)o);
}

su_inline
http_content_language_t *http_content_language_make(su_home_t *home, char const *s)
{
  return (http_content_language_t *)http_header_make(home, http_content_language_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Length header */
 
enum {
  http_content_length_hash = 8402
};

SOFIAPUBVAR msg_hclass_t http_content_length_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_length_d;

SOFIAPUBFUN msg_print_f http_content_length_e;

#define HTTP_CONTENT_LENGTH_INIT() HTTP_HDR_INIT(content_length)

#if SU_HAVE_INLINE
su_inline http_content_length_t *http_content_length_init(http_content_length_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t));
}
#else
#define http_content_length_init(x) \
  HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_length(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_length_hash;
}
#else
#define http_is_content_length(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_length_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_length_t *http_content_length_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_length_class, fmt, ap);
  va_end(ap);

  return (http_content_length_t *)h;
}

su_inline
http_content_length_t *http_content_length_dup(su_home_t *home, http_content_length_t const *o)
{
  return (http_content_length_t *)
    msg_header_dup_as(home, http_content_length_class, (msg_header_t const *)o);
}

su_inline
http_content_length_t *http_content_length_copy(su_home_t *home, http_content_length_t const *o)
{
  return (http_content_length_t *)
    msg_header_copy_as(home, http_content_length_class, (msg_header_t const *)o);
}

su_inline
http_content_length_t *http_content_length_make(su_home_t *home, char const *s)
{
  return (http_content_length_t *)http_header_make(home, http_content_length_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Location header */
 
enum {
  http_content_location_hash = 3453
};

SOFIAPUBVAR msg_hclass_t http_content_location_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_location_d;

SOFIAPUBFUN msg_print_f http_content_location_e;

#define HTTP_CONTENT_LOCATION_INIT() HTTP_HDR_INIT(content_location)

#if SU_HAVE_INLINE
su_inline http_content_location_t *http_content_location_init(http_content_location_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t));
}
#else
#define http_content_location_init(x) \
  HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_location(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_location_hash;
}
#else
#define http_is_content_location(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_location_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_location_t *http_content_location_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_location_class, fmt, ap);
  va_end(ap);

  return (http_content_location_t *)h;
}

su_inline
http_content_location_t *http_content_location_dup(su_home_t *home, http_content_location_t const *o)
{
  return (http_content_location_t *)
    msg_header_dup_as(home, http_content_location_class, (msg_header_t const *)o);
}

su_inline
http_content_location_t *http_content_location_copy(su_home_t *home, http_content_location_t const *o)
{
  return (http_content_location_t *)
    msg_header_copy_as(home, http_content_location_class, (msg_header_t const *)o);
}

su_inline
http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
{
  return (http_content_location_t *)http_header_make(home, http_content_location_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-MD5 header */
 
enum {
  http_content_md5_hash = 60494
};

SOFIAPUBVAR msg_hclass_t http_content_md5_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_md5_d;

SOFIAPUBFUN msg_print_f http_content_md5_e;

#define HTTP_CONTENT_MD5_INIT() HTTP_HDR_INIT(content_md5)

#if SU_HAVE_INLINE
su_inline http_content_md5_t *http_content_md5_init(http_content_md5_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t));
}
#else
#define http_content_md5_init(x) \
  HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_md5(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_md5_hash;
}
#else
#define http_is_content_md5(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_md5_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_md5_t *http_content_md5_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_md5_class, fmt, ap);
  va_end(ap);

  return (http_content_md5_t *)h;
}

su_inline
http_content_md5_t *http_content_md5_dup(su_home_t *home, http_content_md5_t const *o)
{
  return (http_content_md5_t *)
    msg_header_dup_as(home, http_content_md5_class, (msg_header_t const *)o);
}

su_inline
http_content_md5_t *http_content_md5_copy(su_home_t *home, http_content_md5_t const *o)
{
  return (http_content_md5_t *)
    msg_header_copy_as(home, http_content_md5_class, (msg_header_t const *)o);
}

su_inline
http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
{
  return (http_content_md5_t *)http_header_make(home, http_content_md5_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Range header */
 
enum {
  http_content_range_hash = 64465
};

SOFIAPUBVAR msg_hclass_t http_content_range_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_range_d;

SOFIAPUBFUN msg_print_f http_content_range_e;

#define HTTP_CONTENT_RANGE_INIT() HTTP_HDR_INIT(content_range)

#if SU_HAVE_INLINE
su_inline http_content_range_t *http_content_range_init(http_content_range_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_range_class, sizeof(http_content_range_t));
}
#else
#define http_content_range_init(x) \
  HTTP_HEADER_INIT(x, http_content_range_class, sizeof(http_content_range_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_range(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_range_hash;
}
#else
#define http_is_content_range(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_range_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_range_t *http_content_range_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_range_class, fmt, ap);
  va_end(ap);

  return (http_content_range_t *)h;
}

su_inline
http_content_range_t *http_content_range_dup(su_home_t *home, http_content_range_t const *o)
{
  return (http_content_range_t *)
    msg_header_dup_as(home, http_content_range_class, (msg_header_t const *)o);
}

su_inline
http_content_range_t *http_content_range_copy(su_home_t *home, http_content_range_t const *o)
{
  return (http_content_range_t *)
    msg_header_copy_as(home, http_content_range_class, (msg_header_t const *)o);
}

su_inline
http_content_range_t *http_content_range_make(su_home_t *home, char const *s)
{
  return (http_content_range_t *)http_header_make(home, http_content_range_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for Content-Type header */
 
enum {
  http_content_type_hash = 51226
};

SOFIAPUBVAR msg_hclass_t http_content_type_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_content_type_d;

SOFIAPUBFUN msg_print_f http_content_type_e;

#define HTTP_CONTENT_TYPE_INIT() HTTP_HDR_INIT(content_type)

#if SU_HAVE_INLINE
su_inline http_content_type_t *http_content_type_init(http_content_type_t x[1])
{
  return HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t));
}
#else
#define http_content_type_init(x) \
  HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_content_type(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_content_type_hash;
}
#else
#define http_is_content_type(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_type_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_content_type_t *http_content_type_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_content_type_class, fmt, ap);
  va_end(ap);

  return (http_content_type_t *)h;
}

su_inline
http_content_type_t *http_content_type_dup(su_home_t *home, http_content_type_t const *o)
{
  return (http_content_type_t *)
    msg_header_dup_as(home, http_content_type_class, (msg_header_t const *)o);
}

su_inline
http_content_type_t *http_content_type_copy(su_home_t *home, http_content_type_t const *o)
{
  return (http_content_type_t *)
    msg_header_copy_as(home, http_content_type_class, (msg_header_t const *)o);
}

su_inline
http_content_type_t *http_content_type_make(su_home_t *home, char const *s)
{
  return (http_content_type_t *)http_header_make(home, http_content_type_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for unknown headers */
 
enum {
  http_unknown_hash = -3
};

SOFIAPUBVAR msg_hclass_t http_unknown_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_unknown_d;

SOFIAPUBFUN msg_print_f http_unknown_e;

#define HTTP_UNKNOWN_INIT() HTTP_HDR_INIT(unknown)

#if SU_HAVE_INLINE
su_inline http_unknown_t *http_unknown_init(http_unknown_t x[1])
{
  return HTTP_HEADER_INIT(x, http_unknown_class, sizeof(http_unknown_t));
}
#else
#define http_unknown_init(x) \
  HTTP_HEADER_INIT(x, http_unknown_class, sizeof(http_unknown_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_unknown(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_unknown_hash;
}
#else
#define http_is_unknown(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_unknown_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_unknown_t *http_unknown_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_unknown_class, fmt, ap);
  va_end(ap);

  return (http_unknown_t *)h;
}

su_inline
http_unknown_t *http_unknown_dup(su_home_t *home, http_unknown_t const *o)
{
  return (http_unknown_t *)
    msg_header_dup_as(home, http_unknown_class, (msg_header_t const *)o);
}

su_inline
http_unknown_t *http_unknown_copy(su_home_t *home, http_unknown_t const *o)
{
  return (http_unknown_t *)
    msg_header_copy_as(home, http_unknown_class, (msg_header_t const *)o);
}

su_inline
http_unknown_t *http_unknown_make(su_home_t *home, char const *s)
{
  return (http_unknown_t *)http_header_make(home, http_unknown_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for erroneous headers */
 
enum {
  http_error_hash = -4
};

SOFIAPUBVAR msg_hclass_t http_error_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_error_d;

SOFIAPUBFUN msg_print_f http_error_e;

#define HTTP_ERROR_INIT() HTTP_HDR_INIT(error)

#if SU_HAVE_INLINE
su_inline http_error_t *http_error_init(http_error_t x[1])
{
  return HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t));
}
#else
#define http_error_init(x) \
  HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_error(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_error_hash;
}
#else
#define http_is_error(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_error_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_error_t *http_error_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_error_class, fmt, ap);
  va_end(ap);

  return (http_error_t *)h;
}

su_inline
http_error_t *http_error_dup(su_home_t *home, http_error_t const *o)
{
  return (http_error_t *)
    msg_header_dup_as(home, http_error_class, (msg_header_t const *)o);
}

su_inline
http_error_t *http_error_copy(su_home_t *home, http_error_t const *o)
{
  return (http_error_t *)
    msg_header_copy_as(home, http_error_class, (msg_header_t const *)o);
}

su_inline
http_error_t *http_error_make(su_home_t *home, char const *s)
{
  return (http_error_t *)http_header_make(home, http_error_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for separator line between headers and body */
 
enum {
  http_separator_hash = -5
};

SOFIAPUBVAR msg_hclass_t http_separator_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_separator_d;

SOFIAPUBFUN msg_print_f http_separator_e;

#define HTTP_SEPARATOR_INIT() HTTP_HDR_INIT(separator)

#if SU_HAVE_INLINE
su_inline http_separator_t *http_separator_init(http_separator_t x[1])
{
  return HTTP_HEADER_INIT(x, http_separator_class, sizeof(http_separator_t));
}
#else
#define http_separator_init(x) \
  HTTP_HEADER_INIT(x, http_separator_class, sizeof(http_separator_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_separator(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_separator_hash;
}
#else
#define http_is_separator(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_separator_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_separator_t *http_separator_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_separator_class, fmt, ap);
  va_end(ap);

  return (http_separator_t *)h;
}

su_inline
http_separator_t *http_separator_dup(su_home_t *home, http_separator_t const *o)
{
  return (http_separator_t *)
    msg_header_dup_as(home, http_separator_class, (msg_header_t const *)o);
}

su_inline
http_separator_t *http_separator_copy(su_home_t *home, http_separator_t const *o)
{
  return (http_separator_t *)
    msg_header_copy_as(home, http_separator_class, (msg_header_t const *)o);
}

su_inline
http_separator_t *http_separator_make(su_home_t *home, char const *s)
{
  return (http_separator_t *)http_header_make(home, http_separator_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

/* Declare internal prototypes for message payload */
 
enum {
  http_payload_hash = -6
};

SOFIAPUBVAR msg_hclass_t http_payload_class[];

#ifndef HTTP_HCLASSES_ONLY

SOFIAPUBFUN msg_parse_f http_payload_d;

SOFIAPUBFUN msg_print_f http_payload_e;

#define HTTP_PAYLOAD_INIT() HTTP_HDR_INIT(payload)

#if SU_HAVE_INLINE
su_inline http_payload_t *http_payload_init(http_payload_t x[1])
{
  return HTTP_HEADER_INIT(x, http_payload_class, sizeof(http_payload_t));
}
#else
#define http_payload_init(x) \
  HTTP_HEADER_INIT(x, http_payload_class, sizeof(http_payload_t))
#endif

#if SU_HAVE_INLINE
su_inline
int http_is_payload(http_header_t const *header)
{
  return header && header->sh_class->hc_hash == http_payload_hash;
}
#else
#define http_is_payload(h) \
 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_payload_hash)
#endif

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

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

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

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


/* Inlined functions */
#if SU_HAVE_INLINE
su_inline
http_payload_t *http_payload_format(su_home_t *home, char const *fmt, ...)
{
  http_header_t *h;
  va_list ap;

  va_start(ap, fmt);
  h = http_header_vformat(home, http_payload_class, fmt, ap);
  va_end(ap);

  return (http_payload_t *)h;
}

su_inline
http_payload_t *http_payload_dup(su_home_t *home, http_payload_t const *o)
{
  return (http_payload_t *)
    msg_header_dup_as(home, http_payload_class, (msg_header_t const *)o);
}

su_inline
http_payload_t *http_payload_copy(su_home_t *home, http_payload_t const *o)
{
  return (http_payload_t *)
    msg_header_copy_as(home, http_payload_class, (msg_header_t const *)o);
}

su_inline
http_payload_t *http_payload_make(su_home_t *home, char const *s)
{
  return (http_payload_t *)http_header_make(home, http_payload_class, s);
}
#endif

#endif /* !define HTTP_HCLASSES_ONLY */

SOFIA_END_DECLS
#endif /* !defined(HTTP_PROTOS_H) */