Loading...
Searching...
No Matches
msg_mime_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 MSG_MIME_PROTOS_H
#define MSG_MIME_PROTOS_H
#ifndef MSG_PARSER_H
#include <sofia-sip/msg_parser.h>
#endif
#ifndef MSG_MIME_H
#include <sofia-sip/msg_mime.h>
#endif
#ifndef MSG_MCLASS_H
#include <sofia-sip/msg_mclass.h>
#endif
#ifndef MSG_MCLASS_H
#include <sofia-sip/msg_mclass.h>
#endif
SOFIA_BEGIN_DECLS
MSG_DLL extern msg_mclass_t const msg_multipart_mclass[1];
#define msg_multipart_class ((msg_hclass_t *)msg_multipart_mclass)
/* Declare internal prototypes for Content-Type header */
enum {
msg_content_type_hash = 51226
};
MSG_DLL msg_parse_f msg_content_type_d;
MSG_DLL msg_print_f msg_content_type_e;
MSG_DLL msg_xtra_f msg_content_type_dup_xtra;
MSG_DLL msg_dup_f msg_content_type_dup_one;
#ifndef msg_content_type_class
MSG_DLL extern msg_hclass_t msg_content_type_class[];
#endif
#define MSG_CONTENT_TYPE_INIT() MSG_HDR_INIT(content_type)
#if SU_HAVE_INLINE
su_inline msg_content_type_t *msg_content_type_init(msg_content_type_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_type_class, sizeof(msg_content_type_t));
}
#else
#define msg_content_type_init(x) \
MSG_HEADER_INIT(x, msg_content_type_class, sizeof(msg_content_type_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_type(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_type_hash;
}
#else
int msg_is_content_type(msg_header_t const *header);
#endif
#define msg_content_type_p(h) msg_is_content_type((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_type_t *msg_content_type_dup(su_home_t *home,
msg_content_type_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_type_t *msg_content_type_dup(su_home_t *home,
msg_content_type_t const *header)
{
return (msg_content_type_t *)
msg_header_dup_as(home, msg_content_type_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_type_t *msg_content_type_copy(su_home_t *home,
msg_content_type_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_type_t *msg_content_type_copy(su_home_t *home,
msg_content_type_t const *header)
{
return (msg_content_type_t *)
msg_header_copy_as(home, msg_content_type_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_type_t *msg_content_type_make(su_home_t *home, char const *s)
{
return (msg_content_type_t*)msg_header_make(home, msg_content_type_class, s);
}
#else
msg_content_type_t *msg_content_type_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_type_t *msg_content_type_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_type_t *msg_content_type_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_type_class, fmt, ap);
va_end(ap);
return (msg_content_type_t*)h;
}
#endif
/* Declare internal prototypes for Content-Disposition header */
enum {
msg_content_disposition_hash = 16333
};
MSG_DLL msg_parse_f msg_content_disposition_d;
MSG_DLL msg_print_f msg_content_disposition_e;
MSG_DLL msg_xtra_f msg_content_disposition_dup_xtra;
MSG_DLL msg_dup_f msg_content_disposition_dup_one;
#ifndef msg_content_disposition_class
MSG_DLL extern msg_hclass_t msg_content_disposition_class[];
#endif
#define MSG_CONTENT_DISPOSITION_INIT() MSG_HDR_INIT(content_disposition)
#if SU_HAVE_INLINE
su_inline msg_content_disposition_t *msg_content_disposition_init(msg_content_disposition_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_disposition_class, sizeof(msg_content_disposition_t));
}
#else
#define msg_content_disposition_init(x) \
MSG_HEADER_INIT(x, msg_content_disposition_class, sizeof(msg_content_disposition_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_disposition(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_disposition_hash;
}
#else
int msg_is_content_disposition(msg_header_t const *header);
#endif
#define msg_content_disposition_p(h) msg_is_content_disposition((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_disposition_t *msg_content_disposition_dup(su_home_t *home,
msg_content_disposition_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_disposition_t *msg_content_disposition_dup(su_home_t *home,
msg_content_disposition_t const *header)
{
return (msg_content_disposition_t *)
msg_header_dup_as(home, msg_content_disposition_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_disposition_t *msg_content_disposition_copy(su_home_t *home,
msg_content_disposition_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_disposition_t *msg_content_disposition_copy(su_home_t *home,
msg_content_disposition_t const *header)
{
return (msg_content_disposition_t *)
msg_header_copy_as(home, msg_content_disposition_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_disposition_t *msg_content_disposition_make(su_home_t *home, char const *s)
{
return (msg_content_disposition_t*)msg_header_make(home, msg_content_disposition_class, s);
}
#else
msg_content_disposition_t *msg_content_disposition_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_disposition_t *msg_content_disposition_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_disposition_t *msg_content_disposition_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_disposition_class, fmt, ap);
va_end(ap);
return (msg_content_disposition_t*)h;
}
#endif
/* Declare internal prototypes for Content-Location header */
enum {
msg_content_location_hash = 3453
};
MSG_DLL msg_parse_f msg_content_location_d;
MSG_DLL msg_print_f msg_content_location_e;
MSG_DLL msg_xtra_f msg_content_location_dup_xtra;
MSG_DLL msg_dup_f msg_content_location_dup_one;
#ifndef msg_content_location_class
MSG_DLL extern msg_hclass_t msg_content_location_class[];
#endif
#define MSG_CONTENT_LOCATION_INIT() MSG_HDR_INIT(content_location)
#if SU_HAVE_INLINE
su_inline msg_content_location_t *msg_content_location_init(msg_content_location_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_location_class, sizeof(msg_content_location_t));
}
#else
#define msg_content_location_init(x) \
MSG_HEADER_INIT(x, msg_content_location_class, sizeof(msg_content_location_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_location(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_location_hash;
}
#else
int msg_is_content_location(msg_header_t const *header);
#endif
#define msg_content_location_p(h) msg_is_content_location((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_location_t *msg_content_location_dup(su_home_t *home,
msg_content_location_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_location_t *msg_content_location_dup(su_home_t *home,
msg_content_location_t const *header)
{
return (msg_content_location_t *)
msg_header_dup_as(home, msg_content_location_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_location_t *msg_content_location_copy(su_home_t *home,
msg_content_location_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_location_t *msg_content_location_copy(su_home_t *home,
msg_content_location_t const *header)
{
return (msg_content_location_t *)
msg_header_copy_as(home, msg_content_location_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_location_t *msg_content_location_make(su_home_t *home, char const *s)
{
return (msg_content_location_t*)msg_header_make(home, msg_content_location_class, s);
}
#else
msg_content_location_t *msg_content_location_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_location_t *msg_content_location_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_location_t *msg_content_location_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_location_class, fmt, ap);
va_end(ap);
return (msg_content_location_t*)h;
}
#endif
/* Declare internal prototypes for Content-ID header */
enum {
msg_content_id_hash = 42909
};
MSG_DLL msg_parse_f msg_content_id_d;
MSG_DLL msg_print_f msg_content_id_e;
MSG_DLL msg_xtra_f msg_content_id_dup_xtra;
MSG_DLL msg_dup_f msg_content_id_dup_one;
#ifndef msg_content_id_class
MSG_DLL extern msg_hclass_t msg_content_id_class[];
#endif
#define MSG_CONTENT_ID_INIT() MSG_HDR_INIT(content_id)
#if SU_HAVE_INLINE
su_inline msg_content_id_t *msg_content_id_init(msg_content_id_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_id_class, sizeof(msg_content_id_t));
}
#else
#define msg_content_id_init(x) \
MSG_HEADER_INIT(x, msg_content_id_class, sizeof(msg_content_id_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_id(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_id_hash;
}
#else
int msg_is_content_id(msg_header_t const *header);
#endif
#define msg_content_id_p(h) msg_is_content_id((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_id_t *msg_content_id_dup(su_home_t *home,
msg_content_id_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_id_t *msg_content_id_dup(su_home_t *home,
msg_content_id_t const *header)
{
return (msg_content_id_t *)
msg_header_dup_as(home, msg_content_id_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_id_t *msg_content_id_copy(su_home_t *home,
msg_content_id_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_id_t *msg_content_id_copy(su_home_t *home,
msg_content_id_t const *header)
{
return (msg_content_id_t *)
msg_header_copy_as(home, msg_content_id_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s)
{
return (msg_content_id_t*)msg_header_make(home, msg_content_id_class, s);
}
#else
msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_id_t *msg_content_id_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_id_t *msg_content_id_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_id_class, fmt, ap);
va_end(ap);
return (msg_content_id_t*)h;
}
#endif
/* Declare internal prototypes for Content-Language header */
enum {
msg_content_language_hash = 62108
};
MSG_DLL msg_parse_f msg_content_language_d;
MSG_DLL msg_print_f msg_content_language_e;
MSG_DLL msg_xtra_f msg_content_language_dup_xtra;
MSG_DLL msg_dup_f msg_content_language_dup_one;
#ifndef msg_content_language_class
MSG_DLL extern msg_hclass_t msg_content_language_class[];
#endif
#define MSG_CONTENT_LANGUAGE_INIT() MSG_HDR_INIT(content_language)
#if SU_HAVE_INLINE
su_inline msg_content_language_t *msg_content_language_init(msg_content_language_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_language_class, sizeof(msg_content_language_t));
}
#else
#define msg_content_language_init(x) \
MSG_HEADER_INIT(x, msg_content_language_class, sizeof(msg_content_language_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_language(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_language_hash;
}
#else
int msg_is_content_language(msg_header_t const *header);
#endif
#define msg_content_language_p(h) msg_is_content_language((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_language_t *msg_content_language_dup(su_home_t *home,
msg_content_language_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_language_t *msg_content_language_dup(su_home_t *home,
msg_content_language_t const *header)
{
return (msg_content_language_t *)
msg_header_dup_as(home, msg_content_language_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_language_t *msg_content_language_copy(su_home_t *home,
msg_content_language_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_language_t *msg_content_language_copy(su_home_t *home,
msg_content_language_t const *header)
{
return (msg_content_language_t *)
msg_header_copy_as(home, msg_content_language_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_language_t *msg_content_language_make(su_home_t *home, char const *s)
{
return (msg_content_language_t*)msg_header_make(home, msg_content_language_class, s);
}
#else
msg_content_language_t *msg_content_language_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_language_t *msg_content_language_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_language_t *msg_content_language_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_language_class, fmt, ap);
va_end(ap);
return (msg_content_language_t*)h;
}
#endif
/* Declare internal prototypes for Content-Encoding header */
enum {
msg_content_encoding_hash = 8707
};
MSG_DLL msg_parse_f msg_content_encoding_d;
MSG_DLL msg_print_f msg_content_encoding_e;
MSG_DLL msg_xtra_f msg_content_encoding_dup_xtra;
MSG_DLL msg_dup_f msg_content_encoding_dup_one;
#ifndef msg_content_encoding_class
MSG_DLL extern msg_hclass_t msg_content_encoding_class[];
#endif
#define MSG_CONTENT_ENCODING_INIT() MSG_HDR_INIT(content_encoding)
#if SU_HAVE_INLINE
su_inline msg_content_encoding_t *msg_content_encoding_init(msg_content_encoding_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_encoding_class, sizeof(msg_content_encoding_t));
}
#else
#define msg_content_encoding_init(x) \
MSG_HEADER_INIT(x, msg_content_encoding_class, sizeof(msg_content_encoding_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_encoding(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_encoding_hash;
}
#else
int msg_is_content_encoding(msg_header_t const *header);
#endif
#define msg_content_encoding_p(h) msg_is_content_encoding((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_encoding_t *msg_content_encoding_dup(su_home_t *home,
msg_content_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_encoding_t *msg_content_encoding_dup(su_home_t *home,
msg_content_encoding_t const *header)
{
return (msg_content_encoding_t *)
msg_header_dup_as(home, msg_content_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_encoding_t *msg_content_encoding_copy(su_home_t *home,
msg_content_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_encoding_t *msg_content_encoding_copy(su_home_t *home,
msg_content_encoding_t const *header)
{
return (msg_content_encoding_t *)
msg_header_copy_as(home, msg_content_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_encoding_t *msg_content_encoding_make(su_home_t *home, char const *s)
{
return (msg_content_encoding_t*)msg_header_make(home, msg_content_encoding_class, s);
}
#else
msg_content_encoding_t *msg_content_encoding_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_encoding_t *msg_content_encoding_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_encoding_t *msg_content_encoding_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_encoding_class, fmt, ap);
va_end(ap);
return (msg_content_encoding_t*)h;
}
#endif
/* Declare internal prototypes for Content-Transfer-Encoding header */
enum {
msg_content_transfer_encoding_hash = 7853
};
MSG_DLL msg_parse_f msg_content_transfer_encoding_d;
MSG_DLL msg_print_f msg_content_transfer_encoding_e;
MSG_DLL msg_xtra_f msg_content_transfer_encoding_dup_xtra;
MSG_DLL msg_dup_f msg_content_transfer_encoding_dup_one;
#ifndef msg_content_transfer_encoding_class
MSG_DLL extern msg_hclass_t msg_content_transfer_encoding_class[];
#endif
#define MSG_CONTENT_TRANSFER_ENCODING_INIT() MSG_HDR_INIT(content_transfer_encoding)
#if SU_HAVE_INLINE
su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_init(msg_content_transfer_encoding_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_transfer_encoding_class, sizeof(msg_content_transfer_encoding_t));
}
#else
#define msg_content_transfer_encoding_init(x) \
MSG_HEADER_INIT(x, msg_content_transfer_encoding_class, sizeof(msg_content_transfer_encoding_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_transfer_encoding(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_transfer_encoding_hash;
}
#else
int msg_is_content_transfer_encoding(msg_header_t const *header);
#endif
#define msg_content_transfer_encoding_p(h) msg_is_content_transfer_encoding((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_transfer_encoding_t *msg_content_transfer_encoding_dup(su_home_t *home,
msg_content_transfer_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_transfer_encoding_t *msg_content_transfer_encoding_dup(su_home_t *home,
msg_content_transfer_encoding_t const *header)
{
return (msg_content_transfer_encoding_t *)
msg_header_dup_as(home, msg_content_transfer_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_transfer_encoding_t *msg_content_transfer_encoding_copy(su_home_t *home,
msg_content_transfer_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_transfer_encoding_t *msg_content_transfer_encoding_copy(su_home_t *home,
msg_content_transfer_encoding_t const *header)
{
return (msg_content_transfer_encoding_t *)
msg_header_copy_as(home, msg_content_transfer_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_make(su_home_t *home, char const *s)
{
return (msg_content_transfer_encoding_t*)msg_header_make(home, msg_content_transfer_encoding_class, s);
}
#else
msg_content_transfer_encoding_t *msg_content_transfer_encoding_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_transfer_encoding_t *msg_content_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_transfer_encoding_class, fmt, ap);
va_end(ap);
return (msg_content_transfer_encoding_t*)h;
}
#endif
/* Declare internal prototypes for Accept header */
enum {
msg_accept_hash = 29344
};
MSG_DLL msg_parse_f msg_accept_d;
MSG_DLL msg_print_f msg_accept_e;
MSG_DLL msg_xtra_f msg_accept_dup_xtra;
MSG_DLL msg_dup_f msg_accept_dup_one;
#ifndef msg_accept_class
MSG_DLL extern msg_hclass_t msg_accept_class[];
#endif
#define MSG_ACCEPT_INIT() MSG_HDR_INIT(accept)
#if SU_HAVE_INLINE
su_inline msg_accept_t *msg_accept_init(msg_accept_t x[1])
{
return MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t));
}
#else
#define msg_accept_init(x) \
MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_accept(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_accept_hash;
}
#else
int msg_is_accept(msg_header_t const *header);
#endif
#define msg_accept_p(h) msg_is_accept((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_t *msg_accept_dup(su_home_t *home,
msg_accept_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_t *msg_accept_dup(su_home_t *home,
msg_accept_t const *header)
{
return (msg_accept_t *)
msg_header_dup_as(home, msg_accept_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_t *msg_accept_copy(su_home_t *home,
msg_accept_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_t *msg_accept_copy(su_home_t *home,
msg_accept_t const *header)
{
return (msg_accept_t *)
msg_header_copy_as(home, msg_accept_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_accept_t *msg_accept_make(su_home_t *home, char const *s)
{
return (msg_accept_t*)msg_header_make(home, msg_accept_class, s);
}
#else
msg_accept_t *msg_accept_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_accept_class, fmt, ap);
va_end(ap);
return (msg_accept_t*)h;
}
#endif
/* Declare internal prototypes for Accept-Charset header */
enum {
msg_accept_charset_hash = 41803
};
MSG_DLL msg_parse_f msg_accept_charset_d;
MSG_DLL msg_print_f msg_accept_charset_e;
MSG_DLL msg_xtra_f msg_accept_charset_dup_xtra;
MSG_DLL msg_dup_f msg_accept_charset_dup_one;
#ifndef msg_accept_charset_class
MSG_DLL extern msg_hclass_t msg_accept_charset_class[];
#endif
#define MSG_ACCEPT_CHARSET_INIT() MSG_HDR_INIT(accept_charset)
#if SU_HAVE_INLINE
su_inline msg_accept_charset_t *msg_accept_charset_init(msg_accept_charset_t x[1])
{
return MSG_HEADER_INIT(x, msg_accept_charset_class, sizeof(msg_accept_charset_t));
}
#else
#define msg_accept_charset_init(x) \
MSG_HEADER_INIT(x, msg_accept_charset_class, sizeof(msg_accept_charset_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_accept_charset(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_accept_charset_hash;
}
#else
int msg_is_accept_charset(msg_header_t const *header);
#endif
#define msg_accept_charset_p(h) msg_is_accept_charset((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_charset_t *msg_accept_charset_dup(su_home_t *home,
msg_accept_charset_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_charset_t *msg_accept_charset_dup(su_home_t *home,
msg_accept_charset_t const *header)
{
return (msg_accept_charset_t *)
msg_header_dup_as(home, msg_accept_charset_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_charset_t *msg_accept_charset_copy(su_home_t *home,
msg_accept_charset_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_charset_t *msg_accept_charset_copy(su_home_t *home,
msg_accept_charset_t const *header)
{
return (msg_accept_charset_t *)
msg_header_copy_as(home, msg_accept_charset_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_accept_charset_t *msg_accept_charset_make(su_home_t *home, char const *s)
{
return (msg_accept_charset_t*)msg_header_make(home, msg_accept_charset_class, s);
}
#else
msg_accept_charset_t *msg_accept_charset_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_charset_t *msg_accept_charset_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_accept_charset_t *msg_accept_charset_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_accept_charset_class, fmt, ap);
va_end(ap);
return (msg_accept_charset_t*)h;
}
#endif
/* Declare internal prototypes for Accept-Encoding header */
enum {
msg_accept_encoding_hash = 35932
};
MSG_DLL msg_parse_f msg_accept_encoding_d;
MSG_DLL msg_print_f msg_accept_encoding_e;
MSG_DLL msg_xtra_f msg_accept_encoding_dup_xtra;
MSG_DLL msg_dup_f msg_accept_encoding_dup_one;
#ifndef msg_accept_encoding_class
MSG_DLL extern msg_hclass_t msg_accept_encoding_class[];
#endif
#define MSG_ACCEPT_ENCODING_INIT() MSG_HDR_INIT(accept_encoding)
#if SU_HAVE_INLINE
su_inline msg_accept_encoding_t *msg_accept_encoding_init(msg_accept_encoding_t x[1])
{
return MSG_HEADER_INIT(x, msg_accept_encoding_class, sizeof(msg_accept_encoding_t));
}
#else
#define msg_accept_encoding_init(x) \
MSG_HEADER_INIT(x, msg_accept_encoding_class, sizeof(msg_accept_encoding_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_accept_encoding(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_accept_encoding_hash;
}
#else
int msg_is_accept_encoding(msg_header_t const *header);
#endif
#define msg_accept_encoding_p(h) msg_is_accept_encoding((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_encoding_t *msg_accept_encoding_dup(su_home_t *home,
msg_accept_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_encoding_t *msg_accept_encoding_dup(su_home_t *home,
msg_accept_encoding_t const *header)
{
return (msg_accept_encoding_t *)
msg_header_dup_as(home, msg_accept_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_encoding_t *msg_accept_encoding_copy(su_home_t *home,
msg_accept_encoding_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_encoding_t *msg_accept_encoding_copy(su_home_t *home,
msg_accept_encoding_t const *header)
{
return (msg_accept_encoding_t *)
msg_header_copy_as(home, msg_accept_encoding_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_accept_encoding_t *msg_accept_encoding_make(su_home_t *home, char const *s)
{
return (msg_accept_encoding_t*)msg_header_make(home, msg_accept_encoding_class, s);
}
#else
msg_accept_encoding_t *msg_accept_encoding_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_encoding_t *msg_accept_encoding_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_accept_encoding_t *msg_accept_encoding_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_accept_encoding_class, fmt, ap);
va_end(ap);
return (msg_accept_encoding_t*)h;
}
#endif
/* Declare internal prototypes for Accept-Language header */
enum {
msg_accept_language_hash = 23797
};
MSG_DLL msg_parse_f msg_accept_language_d;
MSG_DLL msg_print_f msg_accept_language_e;
MSG_DLL msg_xtra_f msg_accept_language_dup_xtra;
MSG_DLL msg_dup_f msg_accept_language_dup_one;
#ifndef msg_accept_language_class
MSG_DLL extern msg_hclass_t msg_accept_language_class[];
#endif
#define MSG_ACCEPT_LANGUAGE_INIT() MSG_HDR_INIT(accept_language)
#if SU_HAVE_INLINE
su_inline msg_accept_language_t *msg_accept_language_init(msg_accept_language_t x[1])
{
return MSG_HEADER_INIT(x, msg_accept_language_class, sizeof(msg_accept_language_t));
}
#else
#define msg_accept_language_init(x) \
MSG_HEADER_INIT(x, msg_accept_language_class, sizeof(msg_accept_language_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_accept_language(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_accept_language_hash;
}
#else
int msg_is_accept_language(msg_header_t const *header);
#endif
#define msg_accept_language_p(h) msg_is_accept_language((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_language_t *msg_accept_language_dup(su_home_t *home,
msg_accept_language_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_language_t *msg_accept_language_dup(su_home_t *home,
msg_accept_language_t const *header)
{
return (msg_accept_language_t *)
msg_header_dup_as(home, msg_accept_language_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_language_t *msg_accept_language_copy(su_home_t *home,
msg_accept_language_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_accept_language_t *msg_accept_language_copy(su_home_t *home,
msg_accept_language_t const *header)
{
return (msg_accept_language_t *)
msg_header_copy_as(home, msg_accept_language_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_accept_language_t *msg_accept_language_make(su_home_t *home, char const *s)
{
return (msg_accept_language_t*)msg_header_make(home, msg_accept_language_class, s);
}
#else
msg_accept_language_t *msg_accept_language_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_accept_language_t *msg_accept_language_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_accept_language_t *msg_accept_language_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_accept_language_class, fmt, ap);
va_end(ap);
return (msg_accept_language_t*)h;
}
#endif
/* Declare internal prototypes for MIME-Version header */
enum {
msg_mime_version_hash = 49047
};
MSG_DLL msg_parse_f msg_mime_version_d;
MSG_DLL msg_print_f msg_mime_version_e;
MSG_DLL msg_xtra_f msg_mime_version_dup_xtra;
MSG_DLL msg_dup_f msg_mime_version_dup_one;
#ifndef msg_mime_version_class
MSG_DLL extern msg_hclass_t msg_mime_version_class[];
#endif
#define MSG_MIME_VERSION_INIT() MSG_HDR_INIT(mime_version)
#if SU_HAVE_INLINE
su_inline msg_mime_version_t *msg_mime_version_init(msg_mime_version_t x[1])
{
return MSG_HEADER_INIT(x, msg_mime_version_class, sizeof(msg_mime_version_t));
}
#else
#define msg_mime_version_init(x) \
MSG_HEADER_INIT(x, msg_mime_version_class, sizeof(msg_mime_version_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_mime_version(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_mime_version_hash;
}
#else
int msg_is_mime_version(msg_header_t const *header);
#endif
#define msg_mime_version_p(h) msg_is_mime_version((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_mime_version_t *msg_mime_version_dup(su_home_t *home,
msg_mime_version_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_mime_version_t *msg_mime_version_dup(su_home_t *home,
msg_mime_version_t const *header)
{
return (msg_mime_version_t *)
msg_header_dup_as(home, msg_mime_version_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_mime_version_t *msg_mime_version_copy(su_home_t *home,
msg_mime_version_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_mime_version_t *msg_mime_version_copy(su_home_t *home,
msg_mime_version_t const *header)
{
return (msg_mime_version_t *)
msg_header_copy_as(home, msg_mime_version_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_mime_version_t *msg_mime_version_make(su_home_t *home, char const *s)
{
return (msg_mime_version_t*)msg_header_make(home, msg_mime_version_class, s);
}
#else
msg_mime_version_t *msg_mime_version_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_mime_version_t *msg_mime_version_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_mime_version_t *msg_mime_version_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_mime_version_class, fmt, ap);
va_end(ap);
return (msg_mime_version_t*)h;
}
#endif
/* Declare internal prototypes for Content-MD5 header */
enum {
msg_content_md5_hash = 60494
};
MSG_DLL msg_parse_f msg_content_md5_d;
MSG_DLL msg_print_f msg_content_md5_e;
MSG_DLL msg_xtra_f msg_content_md5_dup_xtra;
MSG_DLL msg_dup_f msg_content_md5_dup_one;
#ifndef msg_content_md5_class
MSG_DLL extern msg_hclass_t msg_content_md5_class[];
#endif
#define MSG_CONTENT_MD5_INIT() MSG_HDR_INIT(content_md5)
#if SU_HAVE_INLINE
su_inline msg_content_md5_t *msg_content_md5_init(msg_content_md5_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_md5_class, sizeof(msg_content_md5_t));
}
#else
#define msg_content_md5_init(x) \
MSG_HEADER_INIT(x, msg_content_md5_class, sizeof(msg_content_md5_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_md5(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_md5_hash;
}
#else
int msg_is_content_md5(msg_header_t const *header);
#endif
#define msg_content_md5_p(h) msg_is_content_md5((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_md5_t *msg_content_md5_dup(su_home_t *home,
msg_content_md5_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_md5_t *msg_content_md5_dup(su_home_t *home,
msg_content_md5_t const *header)
{
return (msg_content_md5_t *)
msg_header_dup_as(home, msg_content_md5_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_md5_t *msg_content_md5_copy(su_home_t *home,
msg_content_md5_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_md5_t *msg_content_md5_copy(su_home_t *home,
msg_content_md5_t const *header)
{
return (msg_content_md5_t *)
msg_header_copy_as(home, msg_content_md5_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s)
{
return (msg_content_md5_t*)msg_header_make(home, msg_content_md5_class, s);
}
#else
msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_md5_t *msg_content_md5_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_md5_t *msg_content_md5_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_md5_class, fmt, ap);
va_end(ap);
return (msg_content_md5_t*)h;
}
#endif
/* Declare internal prototypes for Content-Length header */
enum {
msg_content_length_hash = 8402
};
MSG_DLL msg_parse_f msg_content_length_d;
MSG_DLL msg_print_f msg_content_length_e;
MSG_DLL msg_xtra_f msg_content_length_dup_xtra;
MSG_DLL msg_dup_f msg_content_length_dup_one;
#ifndef msg_content_length_class
MSG_DLL extern msg_hclass_t msg_content_length_class[];
#endif
#define MSG_CONTENT_LENGTH_INIT() MSG_HDR_INIT(content_length)
#if SU_HAVE_INLINE
su_inline msg_content_length_t *msg_content_length_init(msg_content_length_t x[1])
{
return MSG_HEADER_INIT(x, msg_content_length_class, sizeof(msg_content_length_t));
}
#else
#define msg_content_length_init(x) \
MSG_HEADER_INIT(x, msg_content_length_class, sizeof(msg_content_length_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_content_length(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_content_length_hash;
}
#else
int msg_is_content_length(msg_header_t const *header);
#endif
#define msg_content_length_p(h) msg_is_content_length((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_length_t *msg_content_length_dup(su_home_t *home,
msg_content_length_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_length_t *msg_content_length_dup(su_home_t *home,
msg_content_length_t const *header)
{
return (msg_content_length_t *)
msg_header_dup_as(home, msg_content_length_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_length_t *msg_content_length_copy(su_home_t *home,
msg_content_length_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_content_length_t *msg_content_length_copy(su_home_t *home,
msg_content_length_t const *header)
{
return (msg_content_length_t *)
msg_header_copy_as(home, msg_content_length_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_content_length_t *msg_content_length_make(su_home_t *home, char const *s)
{
return (msg_content_length_t*)msg_header_make(home, msg_content_length_class, s);
}
#else
msg_content_length_t *msg_content_length_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_content_length_t *msg_content_length_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_content_length_t *msg_content_length_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_content_length_class, fmt, ap);
va_end(ap);
return (msg_content_length_t*)h;
}
#endif
/* Declare internal prototypes for Recursive multipart header */
enum {
msg_multipart_hash = 58884
};
MSG_DLL msg_parse_f msg_multipart_d;
MSG_DLL msg_print_f msg_multipart_e;
MSG_DLL msg_xtra_f msg_multipart_dup_xtra;
MSG_DLL msg_dup_f msg_multipart_dup_one;
#ifndef msg_multipart_class
MSG_DLL extern msg_hclass_t msg_multipart_class[];
#endif
#define MSG_MULTIPART_INIT() MSG_HDR_INIT(multipart)
#if SU_HAVE_INLINE
su_inline msg_multipart_t *msg_multipart_init(msg_multipart_t x[1])
{
return MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t));
}
#else
#define msg_multipart_init(x) \
MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_multipart(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_multipart_hash;
}
#else
int msg_is_multipart(msg_header_t const *header);
#endif
#define msg_multipart_p(h) msg_is_multipart((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_multipart_t *msg_multipart_dup(su_home_t *home,
msg_multipart_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_multipart_t *msg_multipart_dup(su_home_t *home,
msg_multipart_t const *header)
{
return (msg_multipart_t *)
msg_header_dup_as(home, msg_multipart_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_multipart_t *msg_multipart_copy(su_home_t *home,
msg_multipart_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_multipart_t *msg_multipart_copy(su_home_t *home,
msg_multipart_t const *header)
{
return (msg_multipart_t *)
msg_header_copy_as(home, msg_multipart_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s)
{
return (msg_multipart_t*)msg_header_make(home, msg_multipart_class, s);
}
#else
msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_multipart_t *msg_multipart_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_multipart_t *msg_multipart_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_multipart_class, fmt, ap);
va_end(ap);
return (msg_multipart_t*)h;
}
#endif
/* Declare internal prototypes for Warning header */
enum {
msg_warning_hash = 4130
};
MSG_DLL msg_parse_f msg_warning_d;
MSG_DLL msg_print_f msg_warning_e;
MSG_DLL msg_xtra_f msg_warning_dup_xtra;
MSG_DLL msg_dup_f msg_warning_dup_one;
#ifndef msg_warning_class
MSG_DLL extern msg_hclass_t msg_warning_class[];
#endif
#define MSG_WARNING_INIT() MSG_HDR_INIT(warning)
#if SU_HAVE_INLINE
su_inline msg_warning_t *msg_warning_init(msg_warning_t x[1])
{
return MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t));
}
#else
#define msg_warning_init(x) \
MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t))
#endif
#if SU_HAVE_INLINE
su_inline int msg_is_warning(msg_header_t const *header)
{
return header && header->sh_class->hc_hash == msg_warning_hash;
}
#else
int msg_is_warning(msg_header_t const *header);
#endif
#define msg_warning_p(h) msg_is_warning((h))
#if SU_HAVE_INLINE
su_inline
#endif
msg_warning_t *msg_warning_dup(su_home_t *home,
msg_warning_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_warning_t *msg_warning_dup(su_home_t *home,
msg_warning_t const *header)
{
return (msg_warning_t *)
msg_header_dup_as(home, msg_warning_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_warning_t *msg_warning_copy(su_home_t *home,
msg_warning_t const *header);
#if SU_HAVE_INLINE
su_inline
msg_warning_t *msg_warning_copy(su_home_t *home,
msg_warning_t const *header)
{
return (msg_warning_t *)
msg_header_copy_as(home, msg_warning_class, (msg_header_t const *)header);
}
#endif
#if SU_HAVE_INLINE
su_inline msg_warning_t *msg_warning_make(su_home_t *home, char const *s)
{
return (msg_warning_t*)msg_header_make(home, msg_warning_class, s);
}
#else
msg_warning_t *msg_warning_make(su_home_t *home, char const *s);
#endif
#if SU_HAVE_INLINE
su_inline
#endif
msg_warning_t *msg_warning_format(su_home_t *home, char const *fmt, ...)
__attribute__((__format__ (printf, 2, 3)));
#if SU_HAVE_INLINE
su_inline msg_warning_t *msg_warning_format(su_home_t *home, char const *fmt, ...)
{
msg_header_t *h;
va_list ap;
va_start(ap, fmt);
h = msg_header_vformat(home, msg_warning_class, fmt, ap);
va_end(ap);
return (msg_warning_t*)h;
}
#endif
/* Internal prototypes */
MSG_DLL msg_update_f msg_accept_update;
MSG_DLL msg_update_f msg_accept_any_update;
MSG_DLL msg_update_f msg_content_disposition_update;
SOFIA_END_DECLS
#endif
msg_accept_charset_init
msg_accept_charset_t * msg_accept_charset_init(msg_accept_charset_t x[1])
Initialize an msg_accept_charset_t structure.
Definition msg_mime_protos.h:2119
msg_accept_charset_t
msg_accept_any_t msg_accept_charset_t
The structure msg_accept_encoding_t contains representation of Accept-Charset header.
Definition msg_mime.h:56
msg_accept_charset_dup
msg_accept_charset_t * msg_accept_charset_dup(su_home_t *home, msg_accept_charset_t const *header)
Duplicate (deep copy) msg_accept_charset_t.
Definition msg_mime_protos.h:2186
msg_accept_charset_copy
msg_accept_charset_t * msg_accept_charset_copy(su_home_t *home, msg_accept_charset_t const *header)
Copy an msg_accept_charset_t header structure.
Definition msg_mime_protos.h:2231
msg_accept_charset_make
msg_accept_charset_t * msg_accept_charset_make(su_home_t *home, char const *s)
Make a header structure msg_accept_charset_t.
Definition msg_mime_protos.h:2257
msg_accept_charset_format
msg_accept_charset_t * msg_accept_charset_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Charset header from formatting result.
Definition msg_mime_protos.h:2294
msg_accept_charset_d
msg_parse_f msg_accept_charset_d
Parse a Accept-Charset header.
Definition msg_mime_protos.h:2071
msg_is_accept_charset
int msg_is_accept_charset(msg_header_t const *header)
Test if header object is an instance of msg_accept_charset_t.
Definition msg_mime_protos.h:2141
msg_accept_charset_e
msg_print_f msg_accept_charset_e
Print a Accept-Charset header.
Definition msg_mime_protos.h:2074
msg_accept_charset_class
msg_hclass_t msg_accept_charset_class[]
Header class for Accept-Charset header.
Definition msg_mime.c:1333
msg_accept_charset_hash
@ msg_accept_charset_hash
Hash of Accept-Charset header.
Definition msg_mime_protos.h:2067
msg_accept_encoding_dup
msg_accept_encoding_t * msg_accept_encoding_dup(su_home_t *home, msg_accept_encoding_t const *header)
Duplicate (deep copy) msg_accept_encoding_t.
Definition msg_mime_protos.h:2436
msg_accept_encoding_d
msg_parse_f msg_accept_encoding_d
Parse a Accept-Encoding header.
Definition msg_mime_protos.h:2321
msg_accept_encoding_e
msg_print_f msg_accept_encoding_e
Print a Accept-Encoding header.
Definition msg_mime_protos.h:2324
msg_accept_encoding_init
msg_accept_encoding_t * msg_accept_encoding_init(msg_accept_encoding_t x[1])
Initialize an msg_accept_encoding_t structure.
Definition msg_mime_protos.h:2369
msg_accept_encoding_make
msg_accept_encoding_t * msg_accept_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_accept_encoding_t.
Definition msg_mime_protos.h:2507
msg_accept_encoding_class
msg_hclass_t msg_accept_encoding_class[]
Header class for Accept-Encoding header.
Definition msg_mime.c:1384
msg_accept_encoding_format
msg_accept_encoding_t * msg_accept_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Encoding header from formatting result.
Definition msg_mime_protos.h:2544
msg_accept_encoding_copy
msg_accept_encoding_t * msg_accept_encoding_copy(su_home_t *home, msg_accept_encoding_t const *header)
Copy an msg_accept_encoding_t header structure.
Definition msg_mime_protos.h:2481
msg_is_accept_encoding
int msg_is_accept_encoding(msg_header_t const *header)
Test if header object is an instance of msg_accept_encoding_t.
Definition msg_mime_protos.h:2391
msg_accept_encoding_t
msg_accept_any_t msg_accept_encoding_t
The structure msg_accept_encoding_t contains representation of Accept-Encoding header.
Definition msg_mime.h:57
msg_accept_encoding_hash
@ msg_accept_encoding_hash
Hash of Accept-Encoding header.
Definition msg_mime_protos.h:2317
msg_accept_language_t
msg_accept_any_t msg_accept_language_t
The structure msg_accept_language_t contains representation of Accept-Language header.
Definition msg_mime.h:58
msg_accept_language_e
msg_print_f msg_accept_language_e
Print a Accept-Language header.
Definition msg_mime_protos.h:2574
msg_accept_language_dup
msg_accept_language_t * msg_accept_language_dup(su_home_t *home, msg_accept_language_t const *header)
Duplicate (deep copy) msg_accept_language_t.
Definition msg_mime_protos.h:2686
msg_accept_language_class
msg_hclass_t msg_accept_language_class[]
Header class for Accept-Language header.
Definition msg_mime.c:1435
msg_accept_language_init
msg_accept_language_t * msg_accept_language_init(msg_accept_language_t x[1])
Initialize an msg_accept_language_t structure.
Definition msg_mime_protos.h:2619
msg_is_accept_language
int msg_is_accept_language(msg_header_t const *header)
Test if header object is an instance of msg_accept_language_t.
Definition msg_mime_protos.h:2641
msg_accept_language_d
msg_parse_f msg_accept_language_d
Parse a Accept-Language header.
Definition msg_mime_protos.h:2571
msg_accept_language_copy
msg_accept_language_t * msg_accept_language_copy(su_home_t *home, msg_accept_language_t const *header)
Copy an msg_accept_language_t header structure.
Definition msg_mime_protos.h:2731
msg_accept_language_make
msg_accept_language_t * msg_accept_language_make(su_home_t *home, char const *s)
Make a header structure msg_accept_language_t.
Definition msg_mime_protos.h:2757
msg_accept_language_format
msg_accept_language_t * msg_accept_language_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Language header from formatting result.
Definition msg_mime_protos.h:2794
msg_accept_language_hash
@ msg_accept_language_hash
Hash of Accept-Language header.
Definition msg_mime_protos.h:2567
msg_accept_copy
msg_accept_t * msg_accept_copy(su_home_t *home, msg_accept_t const *header)
Copy an msg_accept_t header structure.
Definition msg_mime_protos.h:1981
msg_is_accept
int msg_is_accept(msg_header_t const *header)
Test if header object is an instance of msg_accept_t.
Definition msg_mime_protos.h:1891
msg_accept_init
msg_accept_t * msg_accept_init(msg_accept_t x[1])
Initialize an msg_accept_t structure.
Definition msg_mime_protos.h:1869
msg_accept_d
msg_parse_f msg_accept_d
Parse a Accept header.
Definition msg_mime_protos.h:1821
msg_accept_e
msg_print_f msg_accept_e
Print a Accept header.
Definition msg_mime_protos.h:1824
msg_accept_make
msg_accept_t * msg_accept_make(su_home_t *home, char const *s)
Make a header structure msg_accept_t.
Definition msg_mime_protos.h:2007
msg_accept_format
msg_accept_t * msg_accept_format(su_home_t *home, char const *fmt,...)))
Make a Accept header from formatting result.
Definition msg_mime_protos.h:2044
msg_accept_t
struct msg_accept_s msg_accept_t
The structure msg_accept_t contains representation of an Accept header.
Definition msg_mime.h:54
msg_accept_dup
msg_accept_t * msg_accept_dup(su_home_t *home, msg_accept_t const *header)
Duplicate (deep copy) msg_accept_t.
Definition msg_mime_protos.h:1936
msg_accept_class
msg_hclass_t msg_accept_class[]
Header class for Accept header.
Definition msg_mime.c:1070
msg_accept_hash
@ msg_accept_hash
Hash of Accept header.
Definition msg_mime_protos.h:1817
msg_content_disposition_e
msg_print_f msg_content_disposition_e
Print a Content-Disposition header.
Definition msg_mime_protos.h:324
msg_content_disposition_init
msg_content_disposition_t * msg_content_disposition_init(msg_content_disposition_t x[1])
Initialize an msg_content_disposition_t structure.
Definition msg_mime_protos.h:369
msg_content_disposition_dup
msg_content_disposition_t * msg_content_disposition_dup(su_home_t *home, msg_content_disposition_t const *header)
Duplicate (deep copy) msg_content_disposition_t.
Definition msg_mime_protos.h:436
msg_content_disposition_t
struct msg_content_disposition_s msg_content_disposition_t
The structure msg_content_disposition_t contains representation of an Content-Disposition header.
Definition msg_mime.h:60
msg_content_disposition_format
msg_content_disposition_t * msg_content_disposition_format(su_home_t *home, char const *fmt,...)))
Make a Content-Disposition header from formatting result.
Definition msg_mime_protos.h:544
msg_content_disposition_d
msg_parse_f msg_content_disposition_d
Parse a Content-Disposition header.
Definition msg_mime_protos.h:321
msg_content_disposition_class
msg_hclass_t msg_content_disposition_class[]
Header class for Content-Disposition header.
Definition msg_mime.c:1510
msg_content_disposition_copy
msg_content_disposition_t * msg_content_disposition_copy(su_home_t *home, msg_content_disposition_t const *header)
Copy an msg_content_disposition_t header structure.
Definition msg_mime_protos.h:481
msg_is_content_disposition
int msg_is_content_disposition(msg_header_t const *header)
Test if header object is an instance of msg_content_disposition_t.
Definition msg_mime_protos.h:391
msg_content_disposition_make
msg_content_disposition_t * msg_content_disposition_make(su_home_t *home, char const *s)
Make a header structure msg_content_disposition_t.
Definition msg_mime_protos.h:507
msg_content_disposition_hash
@ msg_content_disposition_hash
Hash of Content-Disposition header.
Definition msg_mime_protos.h:317
msg_content_encoding_init
msg_content_encoding_t * msg_content_encoding_init(msg_content_encoding_t x[1])
Initialize an msg_content_encoding_t structure.
Definition msg_mime_protos.h:1369
msg_content_encoding_t
msg_list_t msg_content_encoding_t
The structure msg_content_encoding_t contains representation of an Content-Encoding header.
Definition msg_mime.h:62
msg_content_encoding_copy
msg_content_encoding_t * msg_content_encoding_copy(su_home_t *home, msg_content_encoding_t const *header)
Copy an msg_content_encoding_t header structure.
Definition msg_mime_protos.h:1481
msg_content_encoding_make
msg_content_encoding_t * msg_content_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_encoding_t.
Definition msg_mime_protos.h:1507
msg_content_encoding_format
msg_content_encoding_t * msg_content_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Encoding header from formatting result.
Definition msg_mime_protos.h:1544
msg_content_encoding_dup
msg_content_encoding_t * msg_content_encoding_dup(su_home_t *home, msg_content_encoding_t const *header)
Duplicate (deep copy) msg_content_encoding_t.
Definition msg_mime_protos.h:1436
msg_is_content_encoding
int msg_is_content_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_encoding_t.
Definition msg_mime_protos.h:1391
msg_content_encoding_e
msg_print_f msg_content_encoding_e
Print a Content-Encoding header.
Definition msg_mime_protos.h:1324
msg_content_encoding_d
msg_parse_f msg_content_encoding_d
Parse a Content-Encoding header.
Definition msg_mime_protos.h:1321
msg_content_encoding_class
msg_hclass_t msg_content_encoding_class[]
Header class for Content-Encoding header.
Definition msg_mime.c:1623
msg_content_encoding_hash
@ msg_content_encoding_hash
Hash of Content-Encoding header.
Definition msg_mime_protos.h:1317
msg_content_id_copy
msg_content_id_t * msg_content_id_copy(su_home_t *home, msg_content_id_t const *header)
Copy an msg_content_id_t header structure.
Definition msg_mime_protos.h:981
msg_content_id_init
msg_content_id_t * msg_content_id_init(msg_content_id_t x[1])
Initialize an msg_content_id_t structure.
Definition msg_mime_protos.h:869
msg_content_id_make
msg_content_id_t * msg_content_id_make(su_home_t *home, char const *s)
Make a header structure msg_content_id_t.
Definition msg_mime_protos.h:1007
msg_content_id_dup
msg_content_id_t * msg_content_id_dup(su_home_t *home, msg_content_id_t const *header)
Duplicate (deep copy) msg_content_id_t.
Definition msg_mime_protos.h:936
msg_is_content_id
int msg_is_content_id(msg_header_t const *header)
Test if header object is an instance of msg_content_id_t.
Definition msg_mime_protos.h:891
msg_content_id_format
msg_content_id_t * msg_content_id_format(su_home_t *home, char const *fmt,...)))
Make a Content-ID header from formatting result.
Definition msg_mime_protos.h:1044
msg_content_id_t
msg_generic_t msg_content_id_t
Content-ID Header Structure.
Definition msg_mime.h:63
msg_content_id_class
msg_hclass_t msg_content_id_class[]
Header class for Content-ID header.
Definition msg_mime.c:1829
msg_content_id_hash
@ msg_content_id_hash
Hash of Content-ID header.
Definition msg_mime_protos.h:817
msg_is_content_language
int msg_is_content_language(msg_header_t const *header)
Test if header object is an instance of msg_content_language_t.
Definition msg_mime_protos.h:1141
msg_content_language_make
msg_content_language_t * msg_content_language_make(su_home_t *home, char const *s)
Make a header structure msg_content_language_t.
Definition msg_mime_protos.h:1257
msg_content_language_class
msg_hclass_t msg_content_language_class[]
Header class for Content-Language header.
Definition msg_mime.c:1678
msg_content_language_d
msg_parse_f msg_content_language_d
Parse a Content-Language header.
Definition msg_mime_protos.h:1071
msg_content_language_format
msg_content_language_t * msg_content_language_format(su_home_t *home, char const *fmt,...)))
Make a Content-Language header from formatting result.
Definition msg_mime_protos.h:1294
msg_content_language_dup
msg_content_language_t * msg_content_language_dup(su_home_t *home, msg_content_language_t const *header)
Duplicate (deep copy) msg_content_language_t.
Definition msg_mime_protos.h:1186
msg_content_language_copy
msg_content_language_t * msg_content_language_copy(su_home_t *home, msg_content_language_t const *header)
Copy an msg_content_language_t header structure.
Definition msg_mime_protos.h:1231
msg_content_language_e
msg_print_f msg_content_language_e
Print a Content-Language header.
Definition msg_mime_protos.h:1074
msg_content_language_t
msg_list_t msg_content_language_t
The structure msg_content_language_t contains representation of Content-Language header.
Definition msg_mime.h:66
msg_content_language_init
msg_content_language_t * msg_content_language_init(msg_content_language_t x[1])
Initialize an msg_content_language_t structure.
Definition msg_mime_protos.h:1119
msg_content_language_hash
@ msg_content_language_hash
Hash of Content-Language header.
Definition msg_mime_protos.h:1067
msg_content_length_make
msg_content_length_t * msg_content_length_make(su_home_t *home, char const *s)
Make a header structure msg_content_length_t.
Definition msg_mime_protos.h:3507
msg_content_length_init
msg_content_length_t * msg_content_length_init(msg_content_length_t x[1])
Initialize an msg_content_length_t structure.
Definition msg_mime_protos.h:3369
msg_content_length_t
struct msg_content_length_s msg_content_length_t
The structure msg_content_length_t contains representation of a Content-Length header.
Definition msg_mime.h:64
msg_is_content_length
int msg_is_content_length(msg_header_t const *header)
Test if header object is an instance of msg_content_length_t.
Definition msg_mime_protos.h:3391
msg_content_length_format
msg_content_length_t * msg_content_length_format(su_home_t *home, char const *fmt,...)))
Make a Content-Length header from formatting result.
Definition msg_mime_protos.h:3544
msg_content_length_class
msg_hclass_t msg_content_length_class[]
Header class for Content-Length header.
Definition msg_mime.c:1727
msg_content_length_copy
msg_content_length_t * msg_content_length_copy(su_home_t *home, msg_content_length_t const *header)
Copy an msg_content_length_t header structure.
Definition msg_mime_protos.h:3481
msg_content_length_dup
msg_content_length_t * msg_content_length_dup(su_home_t *home, msg_content_length_t const *header)
Duplicate (deep copy) msg_content_length_t.
Definition msg_mime_protos.h:3436
msg_content_length_hash
@ msg_content_length_hash
Hash of Content-Length header.
Definition msg_mime_protos.h:3317
msg_content_location_format
msg_content_location_t * msg_content_location_format(su_home_t *home, char const *fmt,...)))
Make a Content-Location header from formatting result.
Definition msg_mime_protos.h:794
msg_content_location_make
msg_content_location_t * msg_content_location_make(su_home_t *home, char const *s)
Make a header structure msg_content_location_t.
Definition msg_mime_protos.h:757
msg_is_content_location
int msg_is_content_location(msg_header_t const *header)
Test if header object is an instance of msg_content_location_t.
Definition msg_mime_protos.h:641
msg_content_location_class
msg_hclass_t msg_content_location_class[]
Header class for Content-Location header.
Definition msg_mime.c:2012
msg_content_location_copy
msg_content_location_t * msg_content_location_copy(su_home_t *home, msg_content_location_t const *header)
Copy an msg_content_location_t header structure.
Definition msg_mime_protos.h:731
msg_content_location_t
msg_generic_t msg_content_location_t
The structure msg_content_location_t contains representation of an Content-Location header.
Definition msg_mime.h:65
msg_content_location_init
msg_content_location_t * msg_content_location_init(msg_content_location_t x[1])
Initialize an msg_content_location_t structure.
Definition msg_mime_protos.h:619
msg_content_location_dup
msg_content_location_t * msg_content_location_dup(su_home_t *home, msg_content_location_t const *header)
Duplicate (deep copy) msg_content_location_t.
Definition msg_mime_protos.h:686
msg_content_location_hash
@ msg_content_location_hash
Hash of Content-Location header.
Definition msg_mime_protos.h:567
msg_is_content_md5
int msg_is_content_md5(msg_header_t const *header)
Test if header object is an instance of msg_content_md5_t.
Definition msg_mime_protos.h:3141
msg_content_md5_copy
msg_content_md5_t * msg_content_md5_copy(su_home_t *home, msg_content_md5_t const *header)
Copy an msg_content_md5_t header structure.
Definition msg_mime_protos.h:3231
msg_content_md5_dup
msg_content_md5_t * msg_content_md5_dup(su_home_t *home, msg_content_md5_t const *header)
Duplicate (deep copy) msg_content_md5_t.
Definition msg_mime_protos.h:3186
msg_content_md5_class
msg_hclass_t msg_content_md5_class[]
Header class for Content-MD5 header.
Definition msg_mime.c:1792
msg_content_md5_t
msg_generic_t msg_content_md5_t
The structure msg_content_md5_t contains representation of an Content-MD5 header.
Definition msg_mime.h:67
msg_content_md5_init
msg_content_md5_t * msg_content_md5_init(msg_content_md5_t x[1])
Initialize an msg_content_md5_t structure.
Definition msg_mime_protos.h:3119
msg_content_md5_format
msg_content_md5_t * msg_content_md5_format(su_home_t *home, char const *fmt,...)))
Make a Content-MD5 header from formatting result.
Definition msg_mime_protos.h:3294
msg_content_md5_make
msg_content_md5_t * msg_content_md5_make(su_home_t *home, char const *s)
Make a header structure msg_content_md5_t.
Definition msg_mime_protos.h:3257
msg_content_md5_hash
@ msg_content_md5_hash
Hash of Content-MD5 header.
Definition msg_mime_protos.h:3067
msg_is_content_transfer_encoding
int msg_is_content_transfer_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_transfer_encoding_t.
Definition msg_mime_protos.h:1641
msg_content_transfer_encoding_t
msg_generic_t msg_content_transfer_encoding_t
The structure msg_content_transfer_encoding_t contains representation of an Content-Transfer-Encoding...
Definition msg_mime.h:68
msg_content_transfer_encoding_dup
msg_content_transfer_encoding_t * msg_content_transfer_encoding_dup(su_home_t *home, msg_content_transfer_encoding_t const *header)
Duplicate (deep copy) msg_content_transfer_encoding_t.
Definition msg_mime_protos.h:1686
msg_content_transfer_encoding_make
msg_content_transfer_encoding_t * msg_content_transfer_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_transfer_encoding_t.
Definition msg_mime_protos.h:1757
msg_content_transfer_encoding_init
msg_content_transfer_encoding_t * msg_content_transfer_encoding_init(msg_content_transfer_encoding_t x[1])
Initialize an msg_content_transfer_encoding_t structure.
Definition msg_mime_protos.h:1619
msg_content_transfer_encoding_format
msg_content_transfer_encoding_t * msg_content_transfer_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Transfer-Encoding header from formatting result.
Definition msg_mime_protos.h:1794
msg_content_transfer_encoding_copy
msg_content_transfer_encoding_t * msg_content_transfer_encoding_copy(su_home_t *home, msg_content_transfer_encoding_t const *header)
Copy an msg_content_transfer_encoding_t header structure.
Definition msg_mime_protos.h:1731
msg_content_transfer_encoding_class
msg_hclass_t msg_content_transfer_encoding_class[]
Header class for Content-Transfer-Encoding header.
Definition msg_mime.c:2078
msg_content_transfer_encoding_hash
@ msg_content_transfer_encoding_hash
Hash of Content-Transfer-Encoding header.
Definition msg_mime_protos.h:1567
msg_content_type_d
msg_parse_f msg_content_type_d
Parse a Content-Type header.
Definition msg_mime_protos.h:71
msg_content_type_dup
msg_content_type_t * msg_content_type_dup(su_home_t *home, msg_content_type_t const *header)
Duplicate (deep copy) msg_content_type_t.
Definition msg_mime_protos.h:186
msg_content_type_copy
msg_content_type_t * msg_content_type_copy(su_home_t *home, msg_content_type_t const *header)
Copy an msg_content_type_t header structure.
Definition msg_mime_protos.h:231
msg_content_type_t
struct msg_content_type_s msg_content_type_t
The structure msg_content_type_t contains representation of Content-Type header.
Definition msg_mime.h:69
msg_content_type_init
msg_content_type_t * msg_content_type_init(msg_content_type_t x[1])
Initialize an msg_content_type_t structure.
Definition msg_mime_protos.h:119
msg_content_type_format
msg_content_type_t * msg_content_type_format(su_home_t *home, char const *fmt,...)))
Make a Content-Type header from formatting result.
Definition msg_mime_protos.h:294
msg_content_type_e
msg_print_f msg_content_type_e
Print a Content-Type header.
Definition msg_mime_protos.h:74
msg_content_type_make
msg_content_type_t * msg_content_type_make(su_home_t *home, char const *s)
Make a header structure msg_content_type_t.
Definition msg_mime_protos.h:257
msg_content_type_class
msg_hclass_t msg_content_type_class[]
Header class for Content-Type header.
Definition msg_mime.c:1872
msg_is_content_type
int msg_is_content_type(msg_header_t const *header)
Test if header object is an instance of msg_content_type_t.
Definition msg_mime_protos.h:141
msg_content_type_hash
@ msg_content_type_hash
Hash of Content-Type header.
Definition msg_mime_protos.h:67
msg_mime_version_copy
msg_mime_version_t * msg_mime_version_copy(su_home_t *home, msg_mime_version_t const *header)
Copy an msg_mime_version_t header structure.
Definition msg_mime_protos.h:2981
msg_mime_version_init
msg_mime_version_t * msg_mime_version_init(msg_mime_version_t x[1])
Initialize an msg_mime_version_t structure.
Definition msg_mime_protos.h:2869
msg_is_mime_version
int msg_is_mime_version(msg_header_t const *header)
Test if header object is an instance of msg_mime_version_t.
Definition msg_mime_protos.h:2891
msg_mime_version_e
msg_print_f msg_mime_version_e
Print a MIME-Version header.
Definition msg_mime_protos.h:2824
msg_mime_version_class
msg_hclass_t msg_mime_version_class[]
Header class for MIME-Version header.
Definition msg_mime.c:1971
msg_mime_version_dup
msg_mime_version_t * msg_mime_version_dup(su_home_t *home, msg_mime_version_t const *header)
Duplicate (deep copy) msg_mime_version_t.
Definition msg_mime_protos.h:2936
msg_mime_version_d
msg_parse_f msg_mime_version_d
Parse a MIME-Version header.
Definition msg_mime_protos.h:2821
msg_mime_version_t
msg_generic_t msg_mime_version_t
The structure msg_mime_version_t contains representation of an MIME-Version header.
Definition msg_mime.h:70
msg_mime_version_format
msg_mime_version_t * msg_mime_version_format(su_home_t *home, char const *fmt,...)))
Make a MIME-Version header from formatting result.
Definition msg_mime_protos.h:3044
msg_mime_version_make
msg_mime_version_t * msg_mime_version_make(su_home_t *home, char const *s)
Make a header structure msg_mime_version_t.
Definition msg_mime_protos.h:3007
msg_mime_version_hash
@ msg_mime_version_hash
Hash of MIME-Version header.
Definition msg_mime_protos.h:2817
msg_multipart_d
msg_parse_f msg_multipart_d
Parse a Recursive multipart header.
Definition msg_mime_protos.h:3571
msg_multipart_init
msg_multipart_t * msg_multipart_init(msg_multipart_t x[1])
Initialize an msg_multipart_t structure.
Definition msg_mime_protos.h:3619
msg_multipart_make
msg_multipart_t * msg_multipart_make(su_home_t *home, char const *s)
Make a header structure msg_multipart_t.
Definition msg_mime_protos.h:3757
msg_multipart_copy
msg_multipart_t * msg_multipart_copy(su_home_t *home, msg_multipart_t const *header)
Copy an msg_multipart_t header structure.
Definition msg_mime_protos.h:3731
msg_multipart_dup
msg_multipart_t * msg_multipart_dup(su_home_t *home, msg_multipart_t const *header)
Duplicate (deep copy) msg_multipart_t.
Definition msg_mime_protos.h:3686
msg_multipart_format
msg_multipart_t * msg_multipart_format(su_home_t *home, char const *fmt,...)))
Make a Recursive multipart header from formatting result.
Definition msg_mime_protos.h:3794
msg_is_multipart
int msg_is_multipart(msg_header_t const *header)
Test if header object is an instance of msg_multipart_t.
Definition msg_mime_protos.h:3641
msg_multipart_e
msg_print_f msg_multipart_e
Print a Recursive multipart header.
Definition msg_mime_protos.h:3574
msg_multipart_hash
@ msg_multipart_hash
Hash of Recursive multipart header.
Definition msg_mime_protos.h:3567
msg_is_warning
int msg_is_warning(msg_header_t const *header)
Test if header object is an instance of msg_warning_t.
Definition msg_mime_protos.h:3891
msg_warning_class
msg_hclass_t msg_warning_class[]
Header class for Warning header.
Definition msg_mime.c:2202
msg_warning_copy
msg_warning_t * msg_warning_copy(su_home_t *home, msg_warning_t const *header)
Copy an msg_warning_t header structure.
Definition msg_mime_protos.h:3981
msg_warning_dup
msg_warning_t * msg_warning_dup(su_home_t *home, msg_warning_t const *header)
Duplicate (deep copy) msg_warning_t.
Definition msg_mime_protos.h:3936
msg_warning_e
msg_print_f msg_warning_e
Print a Warning header.
Definition msg_mime_protos.h:3824
msg_warning_format
msg_warning_t * msg_warning_format(su_home_t *home, char const *fmt,...)))
Make a Warning header from formatting result.
Definition msg_mime_protos.h:4044
msg_warning_make
msg_warning_t * msg_warning_make(su_home_t *home, char const *s)
Make a header structure msg_warning_t.
Definition msg_mime_protos.h:4007
msg_warning_t
struct msg_warning_s msg_warning_t
The structure msg_warning_t contains representation of an Warning header.
Definition msg_mime.h:71
msg_warning_init
msg_warning_t * msg_warning_init(msg_warning_t x[1])
Initialize an msg_warning_t structure.
Definition msg_mime_protos.h:3869
msg_warning_d
msg_parse_f msg_warning_d
Parse a Warning header.
Definition msg_mime_protos.h:3821
msg_warning_hash
@ msg_warning_hash
Hash of Warning header.
Definition msg_mime_protos.h:3817
msg_header_make
msg_header_t * msg_header_make(su_home_t *home, msg_hclass_t *hc, char const *s))
Make a header from a value string.
Definition msg_header_make.c:64
msg_header_vformat
msg_header_t * msg_header_vformat(su_home_t *home, msg_hclass_t *hc, char const *fmt, va_list ap))
Make a MSG header with formatting provided.
Definition msg_header_make.c:105
msg_header_copy_as
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
Copy a list of header objects.
Definition msg_header_copy.c:148
msg_header_dup_as
msg_header_t * msg_header_dup_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
Duplicate a header as class hc.
Definition msg_header_copy.c:259
MSG_HEADER_INIT
#define MSG_HEADER_INIT(h, msg_class, size)
Initialize a header structure.
Definition msg_header.h:298
msg_mclass.h
Parser table and message factory object.
msg_mime.h
MIME headers and multipart messages (RFC 2045).
msg_multipart_t
struct msg_multipart_s msg_multipart_t
Multipart body object.
Definition msg_mime.h:74
msg_parser.h
Message parser interface.
msg_hclass_t
struct msg_hclass_s const msg_hclass_t
Header class.
Definition msg_types.h:48
msg_header_t
MSG_HDR_T msg_header_t
Any protocol-specific header object.
Definition msg_types.h:87
msg_mclass_t
struct msg_mclass_s msg_mclass_t
Message class.
Definition msg_types.h:45
su_home_t
SU_HOME_T su_home_t
su_inline
#define su_inline

Sofia-SIP 1.12.11devel - Copyright (C) 2006 Nokia Corporation. All rights reserved. Licensed under the terms of the GNU Lesser General Public License.