http 1.12.11devel
Loading...
Searching...
No Matches
http_protos.h
Go to the documentation of this file.
1/*
2 * This file is part of the Sofia-SIP package
3 *
4 * Copyright (C) 2005 Nokia Corporation.
5 *
6 * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public License
10 * as published by the Free Software Foundation; either version 2.1 of
11 * the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful, but
14 * WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
21 * 02110-1301 USA
22 *
23 */
24
25#ifndef HTTP_PROTOS_H
27#define HTTP_PROTOS_H
28
38#include <sofia-sip/su_config.h>
39
40#ifndef HTTP_HEADER_H
42#endif
43#ifndef HTTP_HCLASSES_H
45#endif
46
47#define http_header_make(h, c, s) \
48 ((http_header_t *)msg_header_make((h), (c), (s)))
49#define http_header_vformat(h, c, f, a) \
50 ((http_header_t *)msg_header_vformat((h), (c), (f), (a)))
51
52SOFIA_BEGIN_DECLS
53
54/* Declare internal prototypes for request line */
55
58enum {
61};
62
72
73#ifndef HTTP_HCLASSES_ONLY
74
77
80
92#define HTTP_REQUEST_INIT() HTTP_HDR_INIT(request)
93
107#if SU_HAVE_INLINE
112#else
113#define http_request_init(x) \
114 HTTP_HEADER_INIT(x, http_request_class, sizeof(http_request_t))
115#endif
116
130#if SU_HAVE_INLINE
133{
134 return header && header->sh_class->hc_hash == http_request_hash;
135}
136#else
137#define http_is_request(h) \
138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_request_hash)
139#endif
140
168#if SU_HAVE_INLINE
170#endif
172 http_request_t const *hdr)
173 __attribute__((__malloc__));
174
203#if SU_HAVE_INLINE
205#endif
207 http_request_t const *hdr)
208 __attribute__((__malloc__));
209
228#if SU_HAVE_INLINE
230#endif
231http_request_t *http_request_make(su_home_t *home, char const *s)
232 __attribute__((__malloc__));
233
256#if SU_HAVE_INLINE
258#endif
259http_request_t *http_request_format(su_home_t *home, char const *fmt, ...)
260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
261
262
263/* Inlined functions */
264#if SU_HAVE_INLINE
266http_request_t *http_request_format(su_home_t *home, char const *fmt, ...)
267{
268 http_header_t *h;
269 va_list ap;
270
271 va_start(ap, fmt);
272 h = http_header_vformat(home, http_request_class, fmt, ap);
273 va_end(ap);
274
275 return (http_request_t *)h;
276}
277
284
291
294{
295 return (http_request_t *)http_header_make(home, http_request_class, s);
296}
297#endif
298
299#endif /* !define HTTP_HCLASSES_ONLY */
300
304/* Declare internal prototypes for status line */
305
308enum {
312
322
323#ifndef HTTP_HCLASSES_ONLY
324
327
330
342#define HTTP_STATUS_INIT() HTTP_HDR_INIT(status)
343
357#if SU_HAVE_INLINE
362#else
363#define http_status_init(x) \
364 HTTP_HEADER_INIT(x, http_status_class, sizeof(http_status_t))
365#endif
366
380#if SU_HAVE_INLINE
383{
384 return header && header->sh_class->hc_hash == http_status_hash;
385}
386#else
387#define http_is_status(h) \
388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_status_hash)
389#endif
390
418#if SU_HAVE_INLINE
420#endif
422 http_status_t const *hdr)
423 __attribute__((__malloc__));
424
453#if SU_HAVE_INLINE
455#endif
457 http_status_t const *hdr)
458 __attribute__((__malloc__));
459
478#if SU_HAVE_INLINE
480#endif
481http_status_t *http_status_make(su_home_t *home, char const *s)
482 __attribute__((__malloc__));
483
506#if SU_HAVE_INLINE
508#endif
509http_status_t *http_status_format(su_home_t *home, char const *fmt, ...)
510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
511
512
513/* Inlined functions */
514#if SU_HAVE_INLINE
516http_status_t *http_status_format(su_home_t *home, char const *fmt, ...)
517{
518 http_header_t *h;
519 va_list ap;
520
521 va_start(ap, fmt);
522 h = http_header_vformat(home, http_status_class, fmt, ap);
523 va_end(ap);
524
525 return (http_status_t *)h;
526}
527
534
541
544{
545 return (http_status_t *)http_header_make(home, http_status_class, s);
546}
547#endif
548
549#endif /* !define HTTP_HCLASSES_ONLY */
550
554/* Declare internal prototypes for Accept header */
555
558enum {
560 http_accept_hash = 29344
562
572
573#ifndef HTTP_HCLASSES_ONLY
574
577
580
592#define HTTP_ACCEPT_INIT() HTTP_HDR_INIT(accept)
593
607#if SU_HAVE_INLINE
608su_inline http_accept_t *http_accept_init(http_accept_t x[1])
609{
610 return HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t));
611}
612#else
613#define http_accept_init(x) \
614 HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t))
615#endif
616
630#if SU_HAVE_INLINE
633{
634 return header && header->sh_class->hc_hash == http_accept_hash;
635}
636#else
637#define http_is_accept(h) \
638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_hash)
639#endif
640
668#if SU_HAVE_INLINE
670#endif
671http_accept_t *http_accept_dup(su_home_t *home,
672 http_accept_t const *hdr)
673 __attribute__((__malloc__));
674
703#if SU_HAVE_INLINE
705#endif
706http_accept_t *http_accept_copy(su_home_t *home,
707 http_accept_t const *hdr)
708 __attribute__((__malloc__));
709
728#if SU_HAVE_INLINE
730#endif
731http_accept_t *http_accept_make(su_home_t *home, char const *s)
732 __attribute__((__malloc__));
733
756#if SU_HAVE_INLINE
758#endif
759http_accept_t *http_accept_format(su_home_t *home, char const *fmt, ...)
760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
761
762
763/* Inlined functions */
764#if SU_HAVE_INLINE
766http_accept_t *http_accept_format(su_home_t *home, char const *fmt, ...)
767{
768 http_header_t *h;
769 va_list ap;
770
771 va_start(ap, fmt);
772 h = http_header_vformat(home, http_accept_class, fmt, ap);
773 va_end(ap);
774
775 return (http_accept_t *)h;
776}
777
779http_accept_t *http_accept_dup(su_home_t *home, http_accept_t const *o)
780{
781 return (http_accept_t *)
783}
784
786http_accept_t *http_accept_copy(su_home_t *home, http_accept_t const *o)
787{
788 return (http_accept_t *)
790}
791
793http_accept_t *http_accept_make(su_home_t *home, char const *s)
794{
795 return (http_accept_t *)http_header_make(home, http_accept_class, s);
796}
797#endif
798
799#endif /* !define HTTP_HCLASSES_ONLY */
800
804/* Declare internal prototypes for Accept-Charset header */
805
808enum {
812
822
823#ifndef HTTP_HCLASSES_ONLY
824
827
830
842#define HTTP_ACCEPT_CHARSET_INIT() HTTP_HDR_INIT(accept_charset)
843
857#if SU_HAVE_INLINE
858su_inline http_accept_charset_t *http_accept_charset_init(http_accept_charset_t x[1])
859{
860 return HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t));
861}
862#else
863#define http_accept_charset_init(x) \
864 HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t))
865#endif
866
880#if SU_HAVE_INLINE
883{
884 return header && header->sh_class->hc_hash == http_accept_charset_hash;
885}
886#else
887#define http_is_accept_charset(h) \
888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_charset_hash)
889#endif
890
918#if SU_HAVE_INLINE
920#endif
921http_accept_charset_t *http_accept_charset_dup(su_home_t *home,
922 http_accept_charset_t const *hdr)
923 __attribute__((__malloc__));
924
953#if SU_HAVE_INLINE
955#endif
956http_accept_charset_t *http_accept_charset_copy(su_home_t *home,
957 http_accept_charset_t const *hdr)
958 __attribute__((__malloc__));
959
978#if SU_HAVE_INLINE
980#endif
981http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
982 __attribute__((__malloc__));
983
1006#if SU_HAVE_INLINE
1008#endif
1009http_accept_charset_t *http_accept_charset_format(su_home_t *home, char const *fmt, ...)
1010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1011
1012
1013/* Inlined functions */
1014#if SU_HAVE_INLINE
1016http_accept_charset_t *http_accept_charset_format(su_home_t *home, char const *fmt, ...)
1017{
1018 http_header_t *h;
1019 va_list ap;
1020
1021 va_start(ap, fmt);
1022 h = http_header_vformat(home, http_accept_charset_class, fmt, ap);
1023 va_end(ap);
1024
1025 return (http_accept_charset_t *)h;
1026}
1027
1029http_accept_charset_t *http_accept_charset_dup(su_home_t *home, http_accept_charset_t const *o)
1030{
1031 return (http_accept_charset_t *)
1033}
1034
1036http_accept_charset_t *http_accept_charset_copy(su_home_t *home, http_accept_charset_t const *o)
1037{
1038 return (http_accept_charset_t *)
1040}
1041
1043http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
1044{
1045 return (http_accept_charset_t *)http_header_make(home, http_accept_charset_class, s);
1046}
1047#endif
1048
1049#endif /* !define HTTP_HCLASSES_ONLY */
1050
1054/* Declare internal prototypes for Accept-Encoding header */
1055
1058enum {
1062
1072
1073#ifndef HTTP_HCLASSES_ONLY
1074
1077
1080
1092#define HTTP_ACCEPT_ENCODING_INIT() HTTP_HDR_INIT(accept_encoding)
1093
1107#if SU_HAVE_INLINE
1108su_inline http_accept_encoding_t *http_accept_encoding_init(http_accept_encoding_t x[1])
1109{
1110 return HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t));
1111}
1112#else
1113#define http_accept_encoding_init(x) \
1114 HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t))
1115#endif
1116
1130#if SU_HAVE_INLINE
1133{
1134 return header && header->sh_class->hc_hash == http_accept_encoding_hash;
1135}
1136#else
1137#define http_is_accept_encoding(h) \
1138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_encoding_hash)
1139#endif
1140
1168#if SU_HAVE_INLINE
1170#endif
1171http_accept_encoding_t *http_accept_encoding_dup(su_home_t *home,
1172 http_accept_encoding_t const *hdr)
1173 __attribute__((__malloc__));
1174
1203#if SU_HAVE_INLINE
1205#endif
1206http_accept_encoding_t *http_accept_encoding_copy(su_home_t *home,
1207 http_accept_encoding_t const *hdr)
1208 __attribute__((__malloc__));
1209
1228#if SU_HAVE_INLINE
1230#endif
1231http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
1232 __attribute__((__malloc__));
1233
1256#if SU_HAVE_INLINE
1258#endif
1259http_accept_encoding_t *http_accept_encoding_format(su_home_t *home, char const *fmt, ...)
1260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1261
1262
1263/* Inlined functions */
1264#if SU_HAVE_INLINE
1266http_accept_encoding_t *http_accept_encoding_format(su_home_t *home, char const *fmt, ...)
1267{
1268 http_header_t *h;
1269 va_list ap;
1270
1271 va_start(ap, fmt);
1272 h = http_header_vformat(home, http_accept_encoding_class, fmt, ap);
1273 va_end(ap);
1274
1275 return (http_accept_encoding_t *)h;
1276}
1277
1279http_accept_encoding_t *http_accept_encoding_dup(su_home_t *home, http_accept_encoding_t const *o)
1280{
1281 return (http_accept_encoding_t *)
1283}
1284
1286http_accept_encoding_t *http_accept_encoding_copy(su_home_t *home, http_accept_encoding_t const *o)
1287{
1288 return (http_accept_encoding_t *)
1290}
1291
1293http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
1294{
1295 return (http_accept_encoding_t *)http_header_make(home, http_accept_encoding_class, s);
1296}
1297#endif
1298
1299#endif /* !define HTTP_HCLASSES_ONLY */
1300
1304/* Declare internal prototypes for Accept-Language header */
1305
1308enum {
1312
1322
1323#ifndef HTTP_HCLASSES_ONLY
1324
1327
1330
1342#define HTTP_ACCEPT_LANGUAGE_INIT() HTTP_HDR_INIT(accept_language)
1343
1357#if SU_HAVE_INLINE
1358su_inline http_accept_language_t *http_accept_language_init(http_accept_language_t x[1])
1359{
1360 return HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t));
1361}
1362#else
1363#define http_accept_language_init(x) \
1364 HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t))
1365#endif
1366
1380#if SU_HAVE_INLINE
1383{
1384 return header && header->sh_class->hc_hash == http_accept_language_hash;
1385}
1386#else
1387#define http_is_accept_language(h) \
1388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_language_hash)
1389#endif
1390
1418#if SU_HAVE_INLINE
1420#endif
1421http_accept_language_t *http_accept_language_dup(su_home_t *home,
1422 http_accept_language_t const *hdr)
1423 __attribute__((__malloc__));
1424
1453#if SU_HAVE_INLINE
1455#endif
1456http_accept_language_t *http_accept_language_copy(su_home_t *home,
1457 http_accept_language_t const *hdr)
1458 __attribute__((__malloc__));
1459
1478#if SU_HAVE_INLINE
1480#endif
1481http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
1482 __attribute__((__malloc__));
1483
1506#if SU_HAVE_INLINE
1508#endif
1509http_accept_language_t *http_accept_language_format(su_home_t *home, char const *fmt, ...)
1510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1511
1512
1513/* Inlined functions */
1514#if SU_HAVE_INLINE
1516http_accept_language_t *http_accept_language_format(su_home_t *home, char const *fmt, ...)
1517{
1518 http_header_t *h;
1519 va_list ap;
1520
1521 va_start(ap, fmt);
1522 h = http_header_vformat(home, http_accept_language_class, fmt, ap);
1523 va_end(ap);
1524
1525 return (http_accept_language_t *)h;
1526}
1527
1529http_accept_language_t *http_accept_language_dup(su_home_t *home, http_accept_language_t const *o)
1530{
1531 return (http_accept_language_t *)
1533}
1534
1536http_accept_language_t *http_accept_language_copy(su_home_t *home, http_accept_language_t const *o)
1537{
1538 return (http_accept_language_t *)
1540}
1541
1543http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
1544{
1545 return (http_accept_language_t *)http_header_make(home, http_accept_language_class, s);
1546}
1547#endif
1548
1549#endif /* !define HTTP_HCLASSES_ONLY */
1550
1554/* Declare internal prototypes for Accept-Ranges header */
1555
1558enum {
1562
1572
1573#ifndef HTTP_HCLASSES_ONLY
1574
1577
1580
1592#define HTTP_ACCEPT_RANGES_INIT() HTTP_HDR_INIT(accept_ranges)
1593
1607#if SU_HAVE_INLINE
1612#else
1613#define http_accept_ranges_init(x) \
1614 HTTP_HEADER_INIT(x, http_accept_ranges_class, sizeof(http_accept_ranges_t))
1615#endif
1616
1630#if SU_HAVE_INLINE
1633{
1634 return header && header->sh_class->hc_hash == http_accept_ranges_hash;
1635}
1636#else
1637#define http_is_accept_ranges(h) \
1638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_ranges_hash)
1639#endif
1640
1668#if SU_HAVE_INLINE
1670#endif
1672 http_accept_ranges_t const *hdr)
1673 __attribute__((__malloc__));
1674
1703#if SU_HAVE_INLINE
1705#endif
1707 http_accept_ranges_t const *hdr)
1708 __attribute__((__malloc__));
1709
1728#if SU_HAVE_INLINE
1730#endif
1732 __attribute__((__malloc__));
1733
1756#if SU_HAVE_INLINE
1758#endif
1759http_accept_ranges_t *http_accept_ranges_format(su_home_t *home, char const *fmt, ...)
1760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1761
1762
1763/* Inlined functions */
1764#if SU_HAVE_INLINE
1767{
1768 http_header_t *h;
1769 va_list ap;
1770
1771 va_start(ap, fmt);
1772 h = http_header_vformat(home, http_accept_ranges_class, fmt, ap);
1773 va_end(ap);
1774
1775 return (http_accept_ranges_t *)h;
1776}
1777
1784
1791
1794{
1795 return (http_accept_ranges_t *)http_header_make(home, http_accept_ranges_class, s);
1796}
1797#endif
1798
1799#endif /* !define HTTP_HCLASSES_ONLY */
1800
1804/* Declare internal prototypes for Allow header */
1805
1808enum {
1810 http_allow_hash = 44519
1812
1822
1823#ifndef HTTP_HCLASSES_ONLY
1824
1827
1830
1842#define HTTP_ALLOW_INIT() HTTP_HDR_INIT(allow)
1843
1857#if SU_HAVE_INLINE
1862#else
1863#define http_allow_init(x) \
1864 HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t))
1865#endif
1866
1880#if SU_HAVE_INLINE
1883{
1884 return header && header->sh_class->hc_hash == http_allow_hash;
1885}
1886#else
1887#define http_is_allow(h) \
1888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_allow_hash)
1889#endif
1890
1918#if SU_HAVE_INLINE
1920#endif
1922 http_allow_t const *hdr)
1923 __attribute__((__malloc__));
1924
1953#if SU_HAVE_INLINE
1955#endif
1957 http_allow_t const *hdr)
1958 __attribute__((__malloc__));
1959
1978#if SU_HAVE_INLINE
1980#endif
1981http_allow_t *http_allow_make(su_home_t *home, char const *s)
1982 __attribute__((__malloc__));
1983
2006#if SU_HAVE_INLINE
2008#endif
2009http_allow_t *http_allow_format(su_home_t *home, char const *fmt, ...)
2010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2011
2012
2013/* Inlined functions */
2014#if SU_HAVE_INLINE
2016http_allow_t *http_allow_format(su_home_t *home, char const *fmt, ...)
2017{
2018 http_header_t *h;
2019 va_list ap;
2020
2021 va_start(ap, fmt);
2022 h = http_header_vformat(home, http_allow_class, fmt, ap);
2023 va_end(ap);
2024
2025 return (http_allow_t *)h;
2026}
2027
2030{
2031 return (http_allow_t *)
2033}
2034
2037{
2038 return (http_allow_t *)
2040}
2041
2044{
2045 return (http_allow_t *)http_header_make(home, http_allow_class, s);
2046}
2047#endif
2048
2049#endif /* !define HTTP_HCLASSES_ONLY */
2050
2054/* Declare internal prototypes for Authentication-Info header */
2055
2058enum {
2062
2072
2073#ifndef HTTP_HCLASSES_ONLY
2074
2077
2080
2092#define HTTP_AUTHENTICATION_INFO_INIT() HTTP_HDR_INIT(authentication_info)
2093
2107#if SU_HAVE_INLINE
2108su_inline http_authentication_info_t *http_authentication_info_init(http_authentication_info_t x[1])
2109{
2110 return HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t));
2111}
2112#else
2113#define http_authentication_info_init(x) \
2114 HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t))
2115#endif
2116
2130#if SU_HAVE_INLINE
2133{
2134 return header && header->sh_class->hc_hash == http_authentication_info_hash;
2135}
2136#else
2137#define http_is_authentication_info(h) \
2138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authentication_info_hash)
2139#endif
2140
2168#if SU_HAVE_INLINE
2170#endif
2171http_authentication_info_t *http_authentication_info_dup(su_home_t *home,
2172 http_authentication_info_t const *hdr)
2173 __attribute__((__malloc__));
2174
2203#if SU_HAVE_INLINE
2205#endif
2206http_authentication_info_t *http_authentication_info_copy(su_home_t *home,
2207 http_authentication_info_t const *hdr)
2208 __attribute__((__malloc__));
2209
2228#if SU_HAVE_INLINE
2230#endif
2231http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
2232 __attribute__((__malloc__));
2233
2256#if SU_HAVE_INLINE
2258#endif
2259http_authentication_info_t *http_authentication_info_format(su_home_t *home, char const *fmt, ...)
2260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2261
2262
2263/* Inlined functions */
2264#if SU_HAVE_INLINE
2266http_authentication_info_t *http_authentication_info_format(su_home_t *home, char const *fmt, ...)
2267{
2268 http_header_t *h;
2269 va_list ap;
2270
2271 va_start(ap, fmt);
2272 h = http_header_vformat(home, http_authentication_info_class, fmt, ap);
2273 va_end(ap);
2274
2275 return (http_authentication_info_t *)h;
2276}
2277
2279http_authentication_info_t *http_authentication_info_dup(su_home_t *home, http_authentication_info_t const *o)
2280{
2281 return (http_authentication_info_t *)
2283}
2284
2286http_authentication_info_t *http_authentication_info_copy(su_home_t *home, http_authentication_info_t const *o)
2287{
2288 return (http_authentication_info_t *)
2290}
2291
2293http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
2294{
2295 return (http_authentication_info_t *)http_header_make(home, http_authentication_info_class, s);
2296}
2297#endif
2298
2299#endif /* !define HTTP_HCLASSES_ONLY */
2300
2304/* Declare internal prototypes for Authorization header */
2305
2308enum {
2312
2322
2323#ifndef HTTP_HCLASSES_ONLY
2324
2327
2330
2342#define HTTP_AUTHORIZATION_INIT() HTTP_HDR_INIT(authorization)
2343
2357#if SU_HAVE_INLINE
2358su_inline http_authorization_t *http_authorization_init(http_authorization_t x[1])
2359{
2360 return HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t));
2361}
2362#else
2363#define http_authorization_init(x) \
2364 HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t))
2365#endif
2366
2380#if SU_HAVE_INLINE
2383{
2384 return header && header->sh_class->hc_hash == http_authorization_hash;
2385}
2386#else
2387#define http_is_authorization(h) \
2388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authorization_hash)
2389#endif
2390
2418#if SU_HAVE_INLINE
2420#endif
2421http_authorization_t *http_authorization_dup(su_home_t *home,
2422 http_authorization_t const *hdr)
2423 __attribute__((__malloc__));
2424
2453#if SU_HAVE_INLINE
2455#endif
2456http_authorization_t *http_authorization_copy(su_home_t *home,
2457 http_authorization_t const *hdr)
2458 __attribute__((__malloc__));
2459
2478#if SU_HAVE_INLINE
2480#endif
2481http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
2482 __attribute__((__malloc__));
2483
2506#if SU_HAVE_INLINE
2508#endif
2509http_authorization_t *http_authorization_format(su_home_t *home, char const *fmt, ...)
2510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2511
2512
2513/* Inlined functions */
2514#if SU_HAVE_INLINE
2516http_authorization_t *http_authorization_format(su_home_t *home, char const *fmt, ...)
2517{
2518 http_header_t *h;
2519 va_list ap;
2520
2521 va_start(ap, fmt);
2522 h = http_header_vformat(home, http_authorization_class, fmt, ap);
2523 va_end(ap);
2524
2525 return (http_authorization_t *)h;
2526}
2527
2529http_authorization_t *http_authorization_dup(su_home_t *home, http_authorization_t const *o)
2530{
2531 return (http_authorization_t *)
2533}
2534
2536http_authorization_t *http_authorization_copy(su_home_t *home, http_authorization_t const *o)
2537{
2538 return (http_authorization_t *)
2540}
2541
2543http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
2544{
2545 return (http_authorization_t *)http_header_make(home, http_authorization_class, s);
2546}
2547#endif
2548
2549#endif /* !define HTTP_HCLASSES_ONLY */
2550
2554/* Declare internal prototypes for Age header */
2555
2558enum {
2560 http_age_hash = 34725
2562
2572
2573#ifndef HTTP_HCLASSES_ONLY
2574
2577
2580
2592#define HTTP_AGE_INIT() HTTP_HDR_INIT(age)
2593
2607#if SU_HAVE_INLINE
2608su_inline http_age_t *http_age_init(http_age_t x[1])
2609{
2610 return HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t));
2611}
2612#else
2613#define http_age_init(x) \
2614 HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t))
2615#endif
2616
2630#if SU_HAVE_INLINE
2632int http_is_age(http_header_t const *header)
2633{
2634 return header && header->sh_class->hc_hash == http_age_hash;
2635}
2636#else
2637#define http_is_age(h) \
2638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_age_hash)
2639#endif
2640
2668#if SU_HAVE_INLINE
2670#endif
2671http_age_t *http_age_dup(su_home_t *home,
2672 http_age_t const *hdr)
2673 __attribute__((__malloc__));
2674
2703#if SU_HAVE_INLINE
2705#endif
2706http_age_t *http_age_copy(su_home_t *home,
2707 http_age_t const *hdr)
2708 __attribute__((__malloc__));
2709
2728#if SU_HAVE_INLINE
2730#endif
2731http_age_t *http_age_make(su_home_t *home, char const *s)
2732 __attribute__((__malloc__));
2733
2756#if SU_HAVE_INLINE
2758#endif
2759http_age_t *http_age_format(su_home_t *home, char const *fmt, ...)
2760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2761
2762
2763/* Inlined functions */
2764#if SU_HAVE_INLINE
2766http_age_t *http_age_format(su_home_t *home, char const *fmt, ...)
2767{
2768 http_header_t *h;
2769 va_list ap;
2770
2771 va_start(ap, fmt);
2772 h = http_header_vformat(home, http_age_class, fmt, ap);
2773 va_end(ap);
2774
2775 return (http_age_t *)h;
2776}
2777
2779http_age_t *http_age_dup(su_home_t *home, http_age_t const *o)
2780{
2781 return (http_age_t *)
2783}
2784
2786http_age_t *http_age_copy(su_home_t *home, http_age_t const *o)
2787{
2788 return (http_age_t *)
2790}
2791
2793http_age_t *http_age_make(su_home_t *home, char const *s)
2794{
2795 return (http_age_t *)http_header_make(home, http_age_class, s);
2796}
2797#endif
2798
2799#endif /* !define HTTP_HCLASSES_ONLY */
2800
2804/* Declare internal prototypes for Cache-Control header */
2805
2808enum {
2812
2822
2823#ifndef HTTP_HCLASSES_ONLY
2824
2827
2830
2842#define HTTP_CACHE_CONTROL_INIT() HTTP_HDR_INIT(cache_control)
2843
2857#if SU_HAVE_INLINE
2862#else
2863#define http_cache_control_init(x) \
2864 HTTP_HEADER_INIT(x, http_cache_control_class, sizeof(http_cache_control_t))
2865#endif
2866
2880#if SU_HAVE_INLINE
2883{
2884 return header && header->sh_class->hc_hash == http_cache_control_hash;
2885}
2886#else
2887#define http_is_cache_control(h) \
2888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cache_control_hash)
2889#endif
2890
2918#if SU_HAVE_INLINE
2920#endif
2922 http_cache_control_t const *hdr)
2923 __attribute__((__malloc__));
2924
2953#if SU_HAVE_INLINE
2955#endif
2957 http_cache_control_t const *hdr)
2958 __attribute__((__malloc__));
2959
2978#if SU_HAVE_INLINE
2980#endif
2982 __attribute__((__malloc__));
2983
3006#if SU_HAVE_INLINE
3008#endif
3009http_cache_control_t *http_cache_control_format(su_home_t *home, char const *fmt, ...)
3010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3011
3012
3013/* Inlined functions */
3014#if SU_HAVE_INLINE
3017{
3018 http_header_t *h;
3019 va_list ap;
3020
3021 va_start(ap, fmt);
3022 h = http_header_vformat(home, http_cache_control_class, fmt, ap);
3023 va_end(ap);
3024
3025 return (http_cache_control_t *)h;
3026}
3027
3034
3041
3044{
3045 return (http_cache_control_t *)http_header_make(home, http_cache_control_class, s);
3046}
3047#endif
3048
3049#endif /* !define HTTP_HCLASSES_ONLY */
3050
3054/* Declare internal prototypes for Connection header */
3055
3058enum {
3060 http_connection_hash = 32700
3062
3072
3073#ifndef HTTP_HCLASSES_ONLY
3074
3077
3080
3092#define HTTP_CONNECTION_INIT() HTTP_HDR_INIT(connection)
3093
3107#if SU_HAVE_INLINE
3112#else
3113#define http_connection_init(x) \
3114 HTTP_HEADER_INIT(x, http_connection_class, sizeof(http_connection_t))
3115#endif
3116
3130#if SU_HAVE_INLINE
3133{
3134 return header && header->sh_class->hc_hash == http_connection_hash;
3135}
3136#else
3137#define http_is_connection(h) \
3138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_connection_hash)
3139#endif
3140
3168#if SU_HAVE_INLINE
3170#endif
3172 http_connection_t const *hdr)
3173 __attribute__((__malloc__));
3174
3203#if SU_HAVE_INLINE
3205#endif
3207 http_connection_t const *hdr)
3208 __attribute__((__malloc__));
3209
3228#if SU_HAVE_INLINE
3230#endif
3232 __attribute__((__malloc__));
3233
3256#if SU_HAVE_INLINE
3258#endif
3259http_connection_t *http_connection_format(su_home_t *home, char const *fmt, ...)
3260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3261
3262
3263/* Inlined functions */
3264#if SU_HAVE_INLINE
3267{
3268 http_header_t *h;
3269 va_list ap;
3270
3271 va_start(ap, fmt);
3272 h = http_header_vformat(home, http_connection_class, fmt, ap);
3273 va_end(ap);
3274
3275 return (http_connection_t *)h;
3276}
3277
3284
3291
3294{
3295 return (http_connection_t *)http_header_make(home, http_connection_class, s);
3296}
3297#endif
3298
3299#endif /* !define HTTP_HCLASSES_ONLY */
3300
3304/* Declare internal prototypes for Date header */
3305
3308enum {
3310 http_date_hash = 43982
3312
3322
3323#ifndef HTTP_HCLASSES_ONLY
3324
3327
3330
3342#define HTTP_DATE_INIT() HTTP_HDR_INIT(date)
3343
3357#if SU_HAVE_INLINE
3362#else
3363#define http_date_init(x) \
3364 HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t))
3365#endif
3366
3380#if SU_HAVE_INLINE
3382int http_is_date(http_header_t const *header)
3383{
3384 return header && header->sh_class->hc_hash == http_date_hash;
3385}
3386#else
3387#define http_is_date(h) \
3388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_date_hash)
3389#endif
3390
3418#if SU_HAVE_INLINE
3420#endif
3422 http_date_t const *hdr)
3423 __attribute__((__malloc__));
3424
3453#if SU_HAVE_INLINE
3455#endif
3457 http_date_t const *hdr)
3458 __attribute__((__malloc__));
3459
3478#if SU_HAVE_INLINE
3480#endif
3481http_date_t *http_date_make(su_home_t *home, char const *s)
3482 __attribute__((__malloc__));
3483
3506#if SU_HAVE_INLINE
3508#endif
3509http_date_t *http_date_format(su_home_t *home, char const *fmt, ...)
3510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3511
3512
3513/* Inlined functions */
3514#if SU_HAVE_INLINE
3516http_date_t *http_date_format(su_home_t *home, char const *fmt, ...)
3517{
3518 http_header_t *h;
3519 va_list ap;
3520
3521 va_start(ap, fmt);
3522 h = http_header_vformat(home, http_date_class, fmt, ap);
3523 va_end(ap);
3524
3525 return (http_date_t *)h;
3526}
3527
3530{
3531 return (http_date_t *)
3533}
3534
3537{
3538 return (http_date_t *)
3540}
3541
3544{
3545 return (http_date_t *)http_header_make(home, http_date_class, s);
3546}
3547#endif
3548
3549#endif /* !define HTTP_HCLASSES_ONLY */
3550
3554/* Declare internal prototypes for ETag header */
3555
3558enum {
3560 http_etag_hash = 1813
3562
3572
3573#ifndef HTTP_HCLASSES_ONLY
3574
3577
3580
3592#define HTTP_ETAG_INIT() HTTP_HDR_INIT(etag)
3593
3607#if SU_HAVE_INLINE
3608su_inline http_etag_t *http_etag_init(http_etag_t x[1])
3609{
3610 return HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t));
3611}
3612#else
3613#define http_etag_init(x) \
3614 HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t))
3615#endif
3616
3630#if SU_HAVE_INLINE
3632int http_is_etag(http_header_t const *header)
3633{
3634 return header && header->sh_class->hc_hash == http_etag_hash;
3635}
3636#else
3637#define http_is_etag(h) \
3638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_etag_hash)
3639#endif
3640
3668#if SU_HAVE_INLINE
3670#endif
3671http_etag_t *http_etag_dup(su_home_t *home,
3672 http_etag_t const *hdr)
3673 __attribute__((__malloc__));
3674
3703#if SU_HAVE_INLINE
3705#endif
3706http_etag_t *http_etag_copy(su_home_t *home,
3707 http_etag_t const *hdr)
3708 __attribute__((__malloc__));
3709
3728#if SU_HAVE_INLINE
3730#endif
3731http_etag_t *http_etag_make(su_home_t *home, char const *s)
3732 __attribute__((__malloc__));
3733
3756#if SU_HAVE_INLINE
3758#endif
3759http_etag_t *http_etag_format(su_home_t *home, char const *fmt, ...)
3760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3761
3762
3763/* Inlined functions */
3764#if SU_HAVE_INLINE
3766http_etag_t *http_etag_format(su_home_t *home, char const *fmt, ...)
3767{
3768 http_header_t *h;
3769 va_list ap;
3770
3771 va_start(ap, fmt);
3772 h = http_header_vformat(home, http_etag_class, fmt, ap);
3773 va_end(ap);
3774
3775 return (http_etag_t *)h;
3776}
3777
3779http_etag_t *http_etag_dup(su_home_t *home, http_etag_t const *o)
3780{
3781 return (http_etag_t *)
3783}
3784
3786http_etag_t *http_etag_copy(su_home_t *home, http_etag_t const *o)
3787{
3788 return (http_etag_t *)
3790}
3791
3793http_etag_t *http_etag_make(su_home_t *home, char const *s)
3794{
3795 return (http_etag_t *)http_header_make(home, http_etag_class, s);
3796}
3797#endif
3798
3799#endif /* !define HTTP_HCLASSES_ONLY */
3800
3804/* Declare internal prototypes for Expect header */
3805
3808enum {
3810 http_expect_hash = 30389
3812
3822
3823#ifndef HTTP_HCLASSES_ONLY
3824
3827
3830
3842#define HTTP_EXPECT_INIT() HTTP_HDR_INIT(expect)
3843
3857#if SU_HAVE_INLINE
3858su_inline http_expect_t *http_expect_init(http_expect_t x[1])
3859{
3860 return HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t));
3861}
3862#else
3863#define http_expect_init(x) \
3864 HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t))
3865#endif
3866
3880#if SU_HAVE_INLINE
3883{
3884 return header && header->sh_class->hc_hash == http_expect_hash;
3885}
3886#else
3887#define http_is_expect(h) \
3888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expect_hash)
3889#endif
3890
3918#if SU_HAVE_INLINE
3920#endif
3921http_expect_t *http_expect_dup(su_home_t *home,
3922 http_expect_t const *hdr)
3923 __attribute__((__malloc__));
3924
3953#if SU_HAVE_INLINE
3955#endif
3956http_expect_t *http_expect_copy(su_home_t *home,
3957 http_expect_t const *hdr)
3958 __attribute__((__malloc__));
3959
3978#if SU_HAVE_INLINE
3980#endif
3981http_expect_t *http_expect_make(su_home_t *home, char const *s)
3982 __attribute__((__malloc__));
3983
4006#if SU_HAVE_INLINE
4008#endif
4009http_expect_t *http_expect_format(su_home_t *home, char const *fmt, ...)
4010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4011
4012
4013/* Inlined functions */
4014#if SU_HAVE_INLINE
4016http_expect_t *http_expect_format(su_home_t *home, char const *fmt, ...)
4017{
4018 http_header_t *h;
4019 va_list ap;
4020
4021 va_start(ap, fmt);
4022 h = http_header_vformat(home, http_expect_class, fmt, ap);
4023 va_end(ap);
4024
4025 return (http_expect_t *)h;
4026}
4027
4029http_expect_t *http_expect_dup(su_home_t *home, http_expect_t const *o)
4030{
4031 return (http_expect_t *)
4033}
4034
4036http_expect_t *http_expect_copy(su_home_t *home, http_expect_t const *o)
4037{
4038 return (http_expect_t *)
4040}
4041
4043http_expect_t *http_expect_make(su_home_t *home, char const *s)
4044{
4045 return (http_expect_t *)http_header_make(home, http_expect_class, s);
4046}
4047#endif
4048
4049#endif /* !define HTTP_HCLASSES_ONLY */
4050
4054/* Declare internal prototypes for Expires header */
4055
4058enum {
4060 http_expires_hash = 28680
4062
4072
4073#ifndef HTTP_HCLASSES_ONLY
4074
4077
4080
4092#define HTTP_EXPIRES_INIT() HTTP_HDR_INIT(expires)
4093
4107#if SU_HAVE_INLINE
4112#else
4113#define http_expires_init(x) \
4114 HTTP_HEADER_INIT(x, http_expires_class, sizeof(http_expires_t))
4115#endif
4116
4130#if SU_HAVE_INLINE
4133{
4134 return header && header->sh_class->hc_hash == http_expires_hash;
4135}
4136#else
4137#define http_is_expires(h) \
4138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expires_hash)
4139#endif
4140
4168#if SU_HAVE_INLINE
4170#endif
4172 http_expires_t const *hdr)
4173 __attribute__((__malloc__));
4174
4203#if SU_HAVE_INLINE
4205#endif
4207 http_expires_t const *hdr)
4208 __attribute__((__malloc__));
4209
4228#if SU_HAVE_INLINE
4230#endif
4231http_expires_t *http_expires_make(su_home_t *home, char const *s)
4232 __attribute__((__malloc__));
4233
4256#if SU_HAVE_INLINE
4258#endif
4259http_expires_t *http_expires_format(su_home_t *home, char const *fmt, ...)
4260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4261
4262
4263/* Inlined functions */
4264#if SU_HAVE_INLINE
4266http_expires_t *http_expires_format(su_home_t *home, char const *fmt, ...)
4267{
4268 http_header_t *h;
4269 va_list ap;
4270
4271 va_start(ap, fmt);
4272 h = http_header_vformat(home, http_expires_class, fmt, ap);
4273 va_end(ap);
4274
4275 return (http_expires_t *)h;
4276}
4277
4284
4291
4294{
4295 return (http_expires_t *)http_header_make(home, http_expires_class, s);
4296}
4297#endif
4298
4299#endif /* !define HTTP_HCLASSES_ONLY */
4300
4304/* Declare internal prototypes for From header */
4305
4308enum {
4310 http_from_hash = 15368
4312
4322
4323#ifndef HTTP_HCLASSES_ONLY
4324
4327
4330
4342#define HTTP_FROM_INIT() HTTP_HDR_INIT(from)
4343
4357#if SU_HAVE_INLINE
4358su_inline http_from_t *http_from_init(http_from_t x[1])
4359{
4360 return HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t));
4361}
4362#else
4363#define http_from_init(x) \
4364 HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t))
4365#endif
4366
4380#if SU_HAVE_INLINE
4382int http_is_from(http_header_t const *header)
4383{
4384 return header && header->sh_class->hc_hash == http_from_hash;
4385}
4386#else
4387#define http_is_from(h) \
4388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_from_hash)
4389#endif
4390
4418#if SU_HAVE_INLINE
4420#endif
4421http_from_t *http_from_dup(su_home_t *home,
4422 http_from_t const *hdr)
4423 __attribute__((__malloc__));
4424
4453#if SU_HAVE_INLINE
4455#endif
4456http_from_t *http_from_copy(su_home_t *home,
4457 http_from_t const *hdr)
4458 __attribute__((__malloc__));
4459
4478#if SU_HAVE_INLINE
4480#endif
4481http_from_t *http_from_make(su_home_t *home, char const *s)
4482 __attribute__((__malloc__));
4483
4506#if SU_HAVE_INLINE
4508#endif
4509http_from_t *http_from_format(su_home_t *home, char const *fmt, ...)
4510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4511
4512
4513/* Inlined functions */
4514#if SU_HAVE_INLINE
4516http_from_t *http_from_format(su_home_t *home, char const *fmt, ...)
4517{
4518 http_header_t *h;
4519 va_list ap;
4520
4521 va_start(ap, fmt);
4522 h = http_header_vformat(home, http_from_class, fmt, ap);
4523 va_end(ap);
4524
4525 return (http_from_t *)h;
4526}
4527
4529http_from_t *http_from_dup(su_home_t *home, http_from_t const *o)
4530{
4531 return (http_from_t *)
4533}
4534
4536http_from_t *http_from_copy(su_home_t *home, http_from_t const *o)
4537{
4538 return (http_from_t *)
4540}
4541
4543http_from_t *http_from_make(su_home_t *home, char const *s)
4544{
4545 return (http_from_t *)http_header_make(home, http_from_class, s);
4546}
4547#endif
4548
4549#endif /* !define HTTP_HCLASSES_ONLY */
4550
4554/* Declare internal prototypes for Host header */
4555
4558enum {
4560 http_host_hash = 33850
4562
4572
4573#ifndef HTTP_HCLASSES_ONLY
4574
4577
4580
4592#define HTTP_HOST_INIT() HTTP_HDR_INIT(host)
4593
4607#if SU_HAVE_INLINE
4612#else
4613#define http_host_init(x) \
4614 HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t))
4615#endif
4616
4630#if SU_HAVE_INLINE
4632int http_is_host(http_header_t const *header)
4633{
4634 return header && header->sh_class->hc_hash == http_host_hash;
4635}
4636#else
4637#define http_is_host(h) \
4638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_host_hash)
4639#endif
4640
4668#if SU_HAVE_INLINE
4670#endif
4672 http_host_t const *hdr)
4673 __attribute__((__malloc__));
4674
4703#if SU_HAVE_INLINE
4705#endif
4707 http_host_t const *hdr)
4708 __attribute__((__malloc__));
4709
4728#if SU_HAVE_INLINE
4730#endif
4731http_host_t *http_host_make(su_home_t *home, char const *s)
4732 __attribute__((__malloc__));
4733
4756#if SU_HAVE_INLINE
4758#endif
4759http_host_t *http_host_format(su_home_t *home, char const *fmt, ...)
4760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4761
4762
4763/* Inlined functions */
4764#if SU_HAVE_INLINE
4766http_host_t *http_host_format(su_home_t *home, char const *fmt, ...)
4767{
4768 http_header_t *h;
4769 va_list ap;
4770
4771 va_start(ap, fmt);
4772 h = http_header_vformat(home, http_host_class, fmt, ap);
4773 va_end(ap);
4774
4775 return (http_host_t *)h;
4776}
4777
4780{
4781 return (http_host_t *)
4783}
4784
4787{
4788 return (http_host_t *)
4790}
4791
4794{
4795 return (http_host_t *)http_header_make(home, http_host_class, s);
4796}
4797#endif
4798
4799#endif /* !define HTTP_HCLASSES_ONLY */
4800
4804/* Declare internal prototypes for If-Match header */
4805
4808enum {
4810 http_if_match_hash = 805
4812
4822
4823#ifndef HTTP_HCLASSES_ONLY
4824
4827
4830
4842#define HTTP_IF_MATCH_INIT() HTTP_HDR_INIT(if_match)
4843
4857#if SU_HAVE_INLINE
4862#else
4863#define http_if_match_init(x) \
4864 HTTP_HEADER_INIT(x, http_if_match_class, sizeof(http_if_match_t))
4865#endif
4866
4880#if SU_HAVE_INLINE
4883{
4884 return header && header->sh_class->hc_hash == http_if_match_hash;
4885}
4886#else
4887#define http_is_if_match(h) \
4888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_match_hash)
4889#endif
4890
4918#if SU_HAVE_INLINE
4920#endif
4922 http_if_match_t const *hdr)
4923 __attribute__((__malloc__));
4924
4953#if SU_HAVE_INLINE
4955#endif
4957 http_if_match_t const *hdr)
4958 __attribute__((__malloc__));
4959
4978#if SU_HAVE_INLINE
4980#endif
4981http_if_match_t *http_if_match_make(su_home_t *home, char const *s)
4982 __attribute__((__malloc__));
4983
5006#if SU_HAVE_INLINE
5008#endif
5009http_if_match_t *http_if_match_format(su_home_t *home, char const *fmt, ...)
5010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5011
5012
5013/* Inlined functions */
5014#if SU_HAVE_INLINE
5017{
5018 http_header_t *h;
5019 va_list ap;
5020
5021 va_start(ap, fmt);
5022 h = http_header_vformat(home, http_if_match_class, fmt, ap);
5023 va_end(ap);
5024
5025 return (http_if_match_t *)h;
5026}
5027
5034
5041
5044{
5045 return (http_if_match_t *)http_header_make(home, http_if_match_class, s);
5046}
5047#endif
5048
5049#endif /* !define HTTP_HCLASSES_ONLY */
5050
5054/* Declare internal prototypes for If-Modified-Since header */
5055
5058enum {
5062
5072
5073#ifndef HTTP_HCLASSES_ONLY
5074
5077
5080
5092#define HTTP_IF_MODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_modified_since)
5093
5107#if SU_HAVE_INLINE
5112#else
5113#define http_if_modified_since_init(x) \
5114 HTTP_HEADER_INIT(x, http_if_modified_since_class, sizeof(http_if_modified_since_t))
5115#endif
5116
5130#if SU_HAVE_INLINE
5133{
5134 return header && header->sh_class->hc_hash == http_if_modified_since_hash;
5135}
5136#else
5137#define http_is_if_modified_since(h) \
5138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_modified_since_hash)
5139#endif
5140
5168#if SU_HAVE_INLINE
5170#endif
5172 http_if_modified_since_t const *hdr)
5173 __attribute__((__malloc__));
5174
5203#if SU_HAVE_INLINE
5205#endif
5207 http_if_modified_since_t const *hdr)
5208 __attribute__((__malloc__));
5209
5228#if SU_HAVE_INLINE
5230#endif
5232 __attribute__((__malloc__));
5233
5256#if SU_HAVE_INLINE
5258#endif
5260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5261
5262
5263/* Inlined functions */
5264#if SU_HAVE_INLINE
5267{
5268 http_header_t *h;
5269 va_list ap;
5270
5271 va_start(ap, fmt);
5272 h = http_header_vformat(home, http_if_modified_since_class, fmt, ap);
5273 va_end(ap);
5274
5275 return (http_if_modified_since_t *)h;
5276}
5277
5284
5291
5294{
5295 return (http_if_modified_since_t *)http_header_make(home, http_if_modified_since_class, s);
5296}
5297#endif
5298
5299#endif /* !define HTTP_HCLASSES_ONLY */
5300
5304/* Declare internal prototypes for If-None-Match header */
5305
5308enum {
5312
5322
5323#ifndef HTTP_HCLASSES_ONLY
5324
5327
5330
5342#define HTTP_IF_NONE_MATCH_INIT() HTTP_HDR_INIT(if_none_match)
5343
5357#if SU_HAVE_INLINE
5362#else
5363#define http_if_none_match_init(x) \
5364 HTTP_HEADER_INIT(x, http_if_none_match_class, sizeof(http_if_none_match_t))
5365#endif
5366
5380#if SU_HAVE_INLINE
5383{
5384 return header && header->sh_class->hc_hash == http_if_none_match_hash;
5385}
5386#else
5387#define http_is_if_none_match(h) \
5388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_none_match_hash)
5389#endif
5390
5418#if SU_HAVE_INLINE
5420#endif
5422 http_if_none_match_t const *hdr)
5423 __attribute__((__malloc__));
5424
5453#if SU_HAVE_INLINE
5455#endif
5457 http_if_none_match_t const *hdr)
5458 __attribute__((__malloc__));
5459
5478#if SU_HAVE_INLINE
5480#endif
5482 __attribute__((__malloc__));
5483
5506#if SU_HAVE_INLINE
5508#endif
5509http_if_none_match_t *http_if_none_match_format(su_home_t *home, char const *fmt, ...)
5510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5511
5512
5513/* Inlined functions */
5514#if SU_HAVE_INLINE
5517{
5518 http_header_t *h;
5519 va_list ap;
5520
5521 va_start(ap, fmt);
5522 h = http_header_vformat(home, http_if_none_match_class, fmt, ap);
5523 va_end(ap);
5524
5525 return (http_if_none_match_t *)h;
5526}
5527
5534
5541
5544{
5545 return (http_if_none_match_t *)http_header_make(home, http_if_none_match_class, s);
5546}
5547#endif
5548
5549#endif /* !define HTTP_HCLASSES_ONLY */
5550
5554/* Declare internal prototypes for If-Range header */
5555
5558enum {
5560 http_if_range_hash = 40469
5562
5572
5573#ifndef HTTP_HCLASSES_ONLY
5574
5577
5580
5592#define HTTP_IF_RANGE_INIT() HTTP_HDR_INIT(if_range)
5593
5607#if SU_HAVE_INLINE
5612#else
5613#define http_if_range_init(x) \
5614 HTTP_HEADER_INIT(x, http_if_range_class, sizeof(http_if_range_t))
5615#endif
5616
5630#if SU_HAVE_INLINE
5633{
5634 return header && header->sh_class->hc_hash == http_if_range_hash;
5635}
5636#else
5637#define http_is_if_range(h) \
5638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_range_hash)
5639#endif
5640
5668#if SU_HAVE_INLINE
5670#endif
5672 http_if_range_t const *hdr)
5673 __attribute__((__malloc__));
5674
5703#if SU_HAVE_INLINE
5705#endif
5707 http_if_range_t const *hdr)
5708 __attribute__((__malloc__));
5709
5728#if SU_HAVE_INLINE
5730#endif
5731http_if_range_t *http_if_range_make(su_home_t *home, char const *s)
5732 __attribute__((__malloc__));
5733
5756#if SU_HAVE_INLINE
5758#endif
5759http_if_range_t *http_if_range_format(su_home_t *home, char const *fmt, ...)
5760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5761
5762
5763/* Inlined functions */
5764#if SU_HAVE_INLINE
5767{
5768 http_header_t *h;
5769 va_list ap;
5770
5771 va_start(ap, fmt);
5772 h = http_header_vformat(home, http_if_range_class, fmt, ap);
5773 va_end(ap);
5774
5775 return (http_if_range_t *)h;
5776}
5777
5784
5791
5794{
5795 return (http_if_range_t *)http_header_make(home, http_if_range_class, s);
5796}
5797#endif
5798
5799#endif /* !define HTTP_HCLASSES_ONLY */
5800
5804/* Declare internal prototypes for If-Unmodified-Since header */
5805
5808enum {
5812
5822
5823#ifndef HTTP_HCLASSES_ONLY
5824
5827
5830
5842#define HTTP_IF_UNMODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_unmodified_since)
5843
5857#if SU_HAVE_INLINE
5862#else
5863#define http_if_unmodified_since_init(x) \
5864 HTTP_HEADER_INIT(x, http_if_unmodified_since_class, sizeof(http_if_unmodified_since_t))
5865#endif
5866
5880#if SU_HAVE_INLINE
5883{
5884 return header && header->sh_class->hc_hash == http_if_unmodified_since_hash;
5885}
5886#else
5887#define http_is_if_unmodified_since(h) \
5888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_unmodified_since_hash)
5889#endif
5890
5918#if SU_HAVE_INLINE
5920#endif
5922 http_if_unmodified_since_t const *hdr)
5923 __attribute__((__malloc__));
5924
5953#if SU_HAVE_INLINE
5955#endif
5957 http_if_unmodified_since_t const *hdr)
5958 __attribute__((__malloc__));
5959
5978#if SU_HAVE_INLINE
5980#endif
5982 __attribute__((__malloc__));
5983
6006#if SU_HAVE_INLINE
6008#endif
6010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6011
6012
6013/* Inlined functions */
6014#if SU_HAVE_INLINE
6017{
6018 http_header_t *h;
6019 va_list ap;
6020
6021 va_start(ap, fmt);
6022 h = http_header_vformat(home, http_if_unmodified_since_class, fmt, ap);
6023 va_end(ap);
6024
6025 return (http_if_unmodified_since_t *)h;
6026}
6027
6034
6041
6047#endif
6048
6049#endif /* !define HTTP_HCLASSES_ONLY */
6050
6054/* Declare internal prototypes for Last-Modified header */
6055
6058enum {
6062
6072
6073#ifndef HTTP_HCLASSES_ONLY
6074
6077
6080
6092#define HTTP_LAST_MODIFIED_INIT() HTTP_HDR_INIT(last_modified)
6093
6107#if SU_HAVE_INLINE
6112#else
6113#define http_last_modified_init(x) \
6114 HTTP_HEADER_INIT(x, http_last_modified_class, sizeof(http_last_modified_t))
6115#endif
6116
6130#if SU_HAVE_INLINE
6133{
6134 return header && header->sh_class->hc_hash == http_last_modified_hash;
6135}
6136#else
6137#define http_is_last_modified(h) \
6138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_last_modified_hash)
6139#endif
6140
6168#if SU_HAVE_INLINE
6170#endif
6172 http_last_modified_t const *hdr)
6173 __attribute__((__malloc__));
6174
6203#if SU_HAVE_INLINE
6205#endif
6207 http_last_modified_t const *hdr)
6208 __attribute__((__malloc__));
6209
6228#if SU_HAVE_INLINE
6230#endif
6232 __attribute__((__malloc__));
6233
6256#if SU_HAVE_INLINE
6258#endif
6259http_last_modified_t *http_last_modified_format(su_home_t *home, char const *fmt, ...)
6260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6261
6262
6263/* Inlined functions */
6264#if SU_HAVE_INLINE
6267{
6268 http_header_t *h;
6269 va_list ap;
6270
6271 va_start(ap, fmt);
6272 h = http_header_vformat(home, http_last_modified_class, fmt, ap);
6273 va_end(ap);
6274
6275 return (http_last_modified_t *)h;
6276}
6277
6284
6291
6294{
6295 return (http_last_modified_t *)http_header_make(home, http_last_modified_class, s);
6296}
6297#endif
6298
6299#endif /* !define HTTP_HCLASSES_ONLY */
6300
6304/* Declare internal prototypes for Location header */
6305
6308enum {
6310 http_location_hash = 60949
6312
6322
6323#ifndef HTTP_HCLASSES_ONLY
6324
6327
6330
6342#define HTTP_LOCATION_INIT() HTTP_HDR_INIT(location)
6343
6357#if SU_HAVE_INLINE
6362#else
6363#define http_location_init(x) \
6364 HTTP_HEADER_INIT(x, http_location_class, sizeof(http_location_t))
6365#endif
6366
6380#if SU_HAVE_INLINE
6383{
6384 return header && header->sh_class->hc_hash == http_location_hash;
6385}
6386#else
6387#define http_is_location(h) \
6388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_location_hash)
6389#endif
6390
6418#if SU_HAVE_INLINE
6420#endif
6422 http_location_t const *hdr)
6423 __attribute__((__malloc__));
6424
6453#if SU_HAVE_INLINE
6455#endif
6457 http_location_t const *hdr)
6458 __attribute__((__malloc__));
6459
6478#if SU_HAVE_INLINE
6480#endif
6481http_location_t *http_location_make(su_home_t *home, char const *s)
6482 __attribute__((__malloc__));
6483
6506#if SU_HAVE_INLINE
6508#endif
6509http_location_t *http_location_format(su_home_t *home, char const *fmt, ...)
6510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6511
6512
6513/* Inlined functions */
6514#if SU_HAVE_INLINE
6517{
6518 http_header_t *h;
6519 va_list ap;
6520
6521 va_start(ap, fmt);
6522 h = http_header_vformat(home, http_location_class, fmt, ap);
6523 va_end(ap);
6524
6525 return (http_location_t *)h;
6526}
6527
6534
6541
6544{
6545 return (http_location_t *)http_header_make(home, http_location_class, s);
6546}
6547#endif
6548
6549#endif /* !define HTTP_HCLASSES_ONLY */
6550
6554/* Declare internal prototypes for Max-Forwards header */
6555
6558enum {
6562
6572
6573#ifndef HTTP_HCLASSES_ONLY
6574
6577
6580
6592#define HTTP_MAX_FORWARDS_INIT() HTTP_HDR_INIT(max_forwards)
6593
6607#if SU_HAVE_INLINE
6612#else
6613#define http_max_forwards_init(x) \
6614 HTTP_HEADER_INIT(x, http_max_forwards_class, sizeof(http_max_forwards_t))
6615#endif
6616
6630#if SU_HAVE_INLINE
6633{
6634 return header && header->sh_class->hc_hash == http_max_forwards_hash;
6635}
6636#else
6637#define http_is_max_forwards(h) \
6638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_max_forwards_hash)
6639#endif
6640
6668#if SU_HAVE_INLINE
6670#endif
6672 http_max_forwards_t const *hdr)
6673 __attribute__((__malloc__));
6674
6703#if SU_HAVE_INLINE
6705#endif
6707 http_max_forwards_t const *hdr)
6708 __attribute__((__malloc__));
6709
6728#if SU_HAVE_INLINE
6730#endif
6732 __attribute__((__malloc__));
6733
6756#if SU_HAVE_INLINE
6758#endif
6759http_max_forwards_t *http_max_forwards_format(su_home_t *home, char const *fmt, ...)
6760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6761
6762
6763/* Inlined functions */
6764#if SU_HAVE_INLINE
6767{
6768 http_header_t *h;
6769 va_list ap;
6770
6771 va_start(ap, fmt);
6772 h = http_header_vformat(home, http_max_forwards_class, fmt, ap);
6773 va_end(ap);
6774
6775 return (http_max_forwards_t *)h;
6776}
6777
6784
6791
6794{
6795 return (http_max_forwards_t *)http_header_make(home, http_max_forwards_class, s);
6796}
6797#endif
6798
6799#endif /* !define HTTP_HCLASSES_ONLY */
6800
6804/* Declare internal prototypes for Pragma header */
6805
6808enum {
6810 http_pragma_hash = 49776
6812
6822
6823#ifndef HTTP_HCLASSES_ONLY
6824
6827
6830
6842#define HTTP_PRAGMA_INIT() HTTP_HDR_INIT(pragma)
6843
6857#if SU_HAVE_INLINE
6862#else
6863#define http_pragma_init(x) \
6864 HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t))
6865#endif
6866
6880#if SU_HAVE_INLINE
6883{
6884 return header && header->sh_class->hc_hash == http_pragma_hash;
6885}
6886#else
6887#define http_is_pragma(h) \
6888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_pragma_hash)
6889#endif
6890
6918#if SU_HAVE_INLINE
6920#endif
6922 http_pragma_t const *hdr)
6923 __attribute__((__malloc__));
6924
6953#if SU_HAVE_INLINE
6955#endif
6957 http_pragma_t const *hdr)
6958 __attribute__((__malloc__));
6959
6978#if SU_HAVE_INLINE
6980#endif
6981http_pragma_t *http_pragma_make(su_home_t *home, char const *s)
6982 __attribute__((__malloc__));
6983
7006#if SU_HAVE_INLINE
7008#endif
7009http_pragma_t *http_pragma_format(su_home_t *home, char const *fmt, ...)
7010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7011
7012
7013/* Inlined functions */
7014#if SU_HAVE_INLINE
7016http_pragma_t *http_pragma_format(su_home_t *home, char const *fmt, ...)
7017{
7018 http_header_t *h;
7019 va_list ap;
7020
7021 va_start(ap, fmt);
7022 h = http_header_vformat(home, http_pragma_class, fmt, ap);
7023 va_end(ap);
7024
7025 return (http_pragma_t *)h;
7026}
7027
7030{
7031 return (http_pragma_t *)
7033}
7034
7037{
7038 return (http_pragma_t *)
7040}
7041
7044{
7045 return (http_pragma_t *)http_header_make(home, http_pragma_class, s);
7046}
7047#endif
7048
7049#endif /* !define HTTP_HCLASSES_ONLY */
7050
7054/* Declare internal prototypes for Proxy-Authenticate header */
7055
7058enum {
7062
7072
7073#ifndef HTTP_HCLASSES_ONLY
7074
7077
7080
7092#define HTTP_PROXY_AUTHENTICATE_INIT() HTTP_HDR_INIT(proxy_authenticate)
7093
7107#if SU_HAVE_INLINE
7108su_inline http_proxy_authenticate_t *http_proxy_authenticate_init(http_proxy_authenticate_t x[1])
7109{
7110 return HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t));
7111}
7112#else
7113#define http_proxy_authenticate_init(x) \
7114 HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t))
7115#endif
7116
7130#if SU_HAVE_INLINE
7133{
7134 return header && header->sh_class->hc_hash == http_proxy_authenticate_hash;
7135}
7136#else
7137#define http_is_proxy_authenticate(h) \
7138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authenticate_hash)
7139#endif
7140
7168#if SU_HAVE_INLINE
7170#endif
7171http_proxy_authenticate_t *http_proxy_authenticate_dup(su_home_t *home,
7172 http_proxy_authenticate_t const *hdr)
7173 __attribute__((__malloc__));
7174
7203#if SU_HAVE_INLINE
7205#endif
7206http_proxy_authenticate_t *http_proxy_authenticate_copy(su_home_t *home,
7207 http_proxy_authenticate_t const *hdr)
7208 __attribute__((__malloc__));
7209
7228#if SU_HAVE_INLINE
7230#endif
7231http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
7232 __attribute__((__malloc__));
7233
7256#if SU_HAVE_INLINE
7258#endif
7259http_proxy_authenticate_t *http_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
7260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7261
7262
7263/* Inlined functions */
7264#if SU_HAVE_INLINE
7266http_proxy_authenticate_t *http_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
7267{
7268 http_header_t *h;
7269 va_list ap;
7270
7271 va_start(ap, fmt);
7272 h = http_header_vformat(home, http_proxy_authenticate_class, fmt, ap);
7273 va_end(ap);
7274
7275 return (http_proxy_authenticate_t *)h;
7276}
7277
7279http_proxy_authenticate_t *http_proxy_authenticate_dup(su_home_t *home, http_proxy_authenticate_t const *o)
7280{
7281 return (http_proxy_authenticate_t *)
7283}
7284
7286http_proxy_authenticate_t *http_proxy_authenticate_copy(su_home_t *home, http_proxy_authenticate_t const *o)
7287{
7288 return (http_proxy_authenticate_t *)
7290}
7291
7293http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
7294{
7295 return (http_proxy_authenticate_t *)http_header_make(home, http_proxy_authenticate_class, s);
7296}
7297#endif
7298
7299#endif /* !define HTTP_HCLASSES_ONLY */
7300
7304/* Declare internal prototypes for Proxy-Authorization header */
7305
7308enum {
7312
7322
7323#ifndef HTTP_HCLASSES_ONLY
7324
7327
7330
7342#define HTTP_PROXY_AUTHORIZATION_INIT() HTTP_HDR_INIT(proxy_authorization)
7343
7357#if SU_HAVE_INLINE
7358su_inline http_proxy_authorization_t *http_proxy_authorization_init(http_proxy_authorization_t x[1])
7359{
7360 return HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t));
7361}
7362#else
7363#define http_proxy_authorization_init(x) \
7364 HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t))
7365#endif
7366
7380#if SU_HAVE_INLINE
7383{
7384 return header && header->sh_class->hc_hash == http_proxy_authorization_hash;
7385}
7386#else
7387#define http_is_proxy_authorization(h) \
7388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authorization_hash)
7389#endif
7390
7418#if SU_HAVE_INLINE
7420#endif
7421http_proxy_authorization_t *http_proxy_authorization_dup(su_home_t *home,
7422 http_proxy_authorization_t const *hdr)
7423 __attribute__((__malloc__));
7424
7453#if SU_HAVE_INLINE
7455#endif
7456http_proxy_authorization_t *http_proxy_authorization_copy(su_home_t *home,
7457 http_proxy_authorization_t const *hdr)
7458 __attribute__((__malloc__));
7459
7478#if SU_HAVE_INLINE
7480#endif
7481http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
7482 __attribute__((__malloc__));
7483
7506#if SU_HAVE_INLINE
7508#endif
7509http_proxy_authorization_t *http_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
7510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7511
7512
7513/* Inlined functions */
7514#if SU_HAVE_INLINE
7516http_proxy_authorization_t *http_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
7517{
7518 http_header_t *h;
7519 va_list ap;
7520
7521 va_start(ap, fmt);
7522 h = http_header_vformat(home, http_proxy_authorization_class, fmt, ap);
7523 va_end(ap);
7524
7525 return (http_proxy_authorization_t *)h;
7526}
7527
7529http_proxy_authorization_t *http_proxy_authorization_dup(su_home_t *home, http_proxy_authorization_t const *o)
7530{
7531 return (http_proxy_authorization_t *)
7533}
7534
7536http_proxy_authorization_t *http_proxy_authorization_copy(su_home_t *home, http_proxy_authorization_t const *o)
7537{
7538 return (http_proxy_authorization_t *)
7540}
7541
7543http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
7544{
7545 return (http_proxy_authorization_t *)http_header_make(home, http_proxy_authorization_class, s);
7546}
7547#endif
7548
7549#endif /* !define HTTP_HCLASSES_ONLY */
7550
7554/* Declare internal prototypes for Range header */
7555
7558enum {
7560 http_range_hash = 20297
7562
7572
7573#ifndef HTTP_HCLASSES_ONLY
7574
7577
7580
7592#define HTTP_RANGE_INIT() HTTP_HDR_INIT(range)
7593
7607#if SU_HAVE_INLINE
7612#else
7613#define http_range_init(x) \
7614 HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t))
7615#endif
7616
7630#if SU_HAVE_INLINE
7633{
7634 return header && header->sh_class->hc_hash == http_range_hash;
7635}
7636#else
7637#define http_is_range(h) \
7638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_range_hash)
7639#endif
7640
7668#if SU_HAVE_INLINE
7670#endif
7672 http_range_t const *hdr)
7673 __attribute__((__malloc__));
7674
7703#if SU_HAVE_INLINE
7705#endif
7707 http_range_t const *hdr)
7708 __attribute__((__malloc__));
7709
7728#if SU_HAVE_INLINE
7730#endif
7731http_range_t *http_range_make(su_home_t *home, char const *s)
7732 __attribute__((__malloc__));
7733
7756#if SU_HAVE_INLINE
7758#endif
7759http_range_t *http_range_format(su_home_t *home, char const *fmt, ...)
7760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7761
7762
7763/* Inlined functions */
7764#if SU_HAVE_INLINE
7766http_range_t *http_range_format(su_home_t *home, char const *fmt, ...)
7767{
7768 http_header_t *h;
7769 va_list ap;
7770
7771 va_start(ap, fmt);
7772 h = http_header_vformat(home, http_range_class, fmt, ap);
7773 va_end(ap);
7774
7775 return (http_range_t *)h;
7776}
7777
7780{
7781 return (http_range_t *)
7783}
7784
7787{
7788 return (http_range_t *)
7790}
7791
7794{
7795 return (http_range_t *)http_header_make(home, http_range_class, s);
7796}
7797#endif
7798
7799#endif /* !define HTTP_HCLASSES_ONLY */
7800
7804/* Declare internal prototypes for Referer header */
7805
7808enum {
7810 http_referer_hash = 64523
7812
7822
7823#ifndef HTTP_HCLASSES_ONLY
7824
7827
7830
7842#define HTTP_REFERER_INIT() HTTP_HDR_INIT(referer)
7843
7857#if SU_HAVE_INLINE
7862#else
7863#define http_referer_init(x) \
7864 HTTP_HEADER_INIT(x, http_referer_class, sizeof(http_referer_t))
7865#endif
7866
7880#if SU_HAVE_INLINE
7883{
7884 return header && header->sh_class->hc_hash == http_referer_hash;
7885}
7886#else
7887#define http_is_referer(h) \
7888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_referer_hash)
7889#endif
7890
7918#if SU_HAVE_INLINE
7920#endif
7922 http_referer_t const *hdr)
7923 __attribute__((__malloc__));
7924
7953#if SU_HAVE_INLINE
7955#endif
7957 http_referer_t const *hdr)
7958 __attribute__((__malloc__));
7959
7978#if SU_HAVE_INLINE
7980#endif
7981http_referer_t *http_referer_make(su_home_t *home, char const *s)
7982 __attribute__((__malloc__));
7983
8006#if SU_HAVE_INLINE
8008#endif
8009http_referer_t *http_referer_format(su_home_t *home, char const *fmt, ...)
8010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8011
8012
8013/* Inlined functions */
8014#if SU_HAVE_INLINE
8016http_referer_t *http_referer_format(su_home_t *home, char const *fmt, ...)
8017{
8018 http_header_t *h;
8019 va_list ap;
8020
8021 va_start(ap, fmt);
8022 h = http_header_vformat(home, http_referer_class, fmt, ap);
8023 va_end(ap);
8024
8025 return (http_referer_t *)h;
8026}
8027
8034
8041
8044{
8045 return (http_referer_t *)http_header_make(home, http_referer_class, s);
8046}
8047#endif
8048
8049#endif /* !define HTTP_HCLASSES_ONLY */
8050
8054/* Declare internal prototypes for Retry-After header */
8055
8058enum {
8060 http_retry_after_hash = 30349
8062
8072
8073#ifndef HTTP_HCLASSES_ONLY
8074
8077
8080
8092#define HTTP_RETRY_AFTER_INIT() HTTP_HDR_INIT(retry_after)
8093
8107#if SU_HAVE_INLINE
8112#else
8113#define http_retry_after_init(x) \
8114 HTTP_HEADER_INIT(x, http_retry_after_class, sizeof(http_retry_after_t))
8115#endif
8116
8130#if SU_HAVE_INLINE
8133{
8134 return header && header->sh_class->hc_hash == http_retry_after_hash;
8135}
8136#else
8137#define http_is_retry_after(h) \
8138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_retry_after_hash)
8139#endif
8140
8168#if SU_HAVE_INLINE
8170#endif
8172 http_retry_after_t const *hdr)
8173 __attribute__((__malloc__));
8174
8203#if SU_HAVE_INLINE
8205#endif
8207 http_retry_after_t const *hdr)
8208 __attribute__((__malloc__));
8209
8228#if SU_HAVE_INLINE
8230#endif
8232 __attribute__((__malloc__));
8233
8256#if SU_HAVE_INLINE
8258#endif
8259http_retry_after_t *http_retry_after_format(su_home_t *home, char const *fmt, ...)
8260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8261
8262
8263/* Inlined functions */
8264#if SU_HAVE_INLINE
8267{
8268 http_header_t *h;
8269 va_list ap;
8270
8271 va_start(ap, fmt);
8272 h = http_header_vformat(home, http_retry_after_class, fmt, ap);
8273 va_end(ap);
8274
8275 return (http_retry_after_t *)h;
8276}
8277
8284
8291
8294{
8295 return (http_retry_after_t *)http_header_make(home, http_retry_after_class, s);
8296}
8297#endif
8298
8299#endif /* !define HTTP_HCLASSES_ONLY */
8300
8304/* Declare internal prototypes for Server header */
8305
8308enum {
8310 http_server_hash = 31323
8312
8322
8323#ifndef HTTP_HCLASSES_ONLY
8324
8327
8330
8342#define HTTP_SERVER_INIT() HTTP_HDR_INIT(server)
8343
8357#if SU_HAVE_INLINE
8358su_inline http_server_t *http_server_init(http_server_t x[1])
8359{
8360 return HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t));
8361}
8362#else
8363#define http_server_init(x) \
8364 HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t))
8365#endif
8366
8380#if SU_HAVE_INLINE
8383{
8384 return header && header->sh_class->hc_hash == http_server_hash;
8385}
8386#else
8387#define http_is_server(h) \
8388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_server_hash)
8389#endif
8390
8418#if SU_HAVE_INLINE
8420#endif
8421http_server_t *http_server_dup(su_home_t *home,
8422 http_server_t const *hdr)
8423 __attribute__((__malloc__));
8424
8453#if SU_HAVE_INLINE
8455#endif
8456http_server_t *http_server_copy(su_home_t *home,
8457 http_server_t const *hdr)
8458 __attribute__((__malloc__));
8459
8478#if SU_HAVE_INLINE
8480#endif
8481http_server_t *http_server_make(su_home_t *home, char const *s)
8482 __attribute__((__malloc__));
8483
8506#if SU_HAVE_INLINE
8508#endif
8509http_server_t *http_server_format(su_home_t *home, char const *fmt, ...)
8510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8511
8512
8513/* Inlined functions */
8514#if SU_HAVE_INLINE
8516http_server_t *http_server_format(su_home_t *home, char const *fmt, ...)
8517{
8518 http_header_t *h;
8519 va_list ap;
8520
8521 va_start(ap, fmt);
8522 h = http_header_vformat(home, http_server_class, fmt, ap);
8523 va_end(ap);
8524
8525 return (http_server_t *)h;
8526}
8527
8529http_server_t *http_server_dup(su_home_t *home, http_server_t const *o)
8530{
8531 return (http_server_t *)
8533}
8534
8536http_server_t *http_server_copy(su_home_t *home, http_server_t const *o)
8537{
8538 return (http_server_t *)
8540}
8541
8543http_server_t *http_server_make(su_home_t *home, char const *s)
8544{
8545 return (http_server_t *)http_header_make(home, http_server_class, s);
8546}
8547#endif
8548
8549#endif /* !define HTTP_HCLASSES_ONLY */
8550
8554/* Declare internal prototypes for TE header */
8555
8558enum {
8560 http_te_hash = 5165
8562
8572
8573#ifndef HTTP_HCLASSES_ONLY
8574
8577
8580
8592#define HTTP_TE_INIT() HTTP_HDR_INIT(te)
8593
8607#if SU_HAVE_INLINE
8612#else
8613#define http_te_init(x) \
8614 HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t))
8615#endif
8616
8630#if SU_HAVE_INLINE
8632int http_is_te(http_header_t const *header)
8633{
8634 return header && header->sh_class->hc_hash == http_te_hash;
8635}
8636#else
8637#define http_is_te(h) \
8638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_te_hash)
8639#endif
8640
8668#if SU_HAVE_INLINE
8670#endif
8672 http_te_t const *hdr)
8673 __attribute__((__malloc__));
8674
8703#if SU_HAVE_INLINE
8705#endif
8707 http_te_t const *hdr)
8708 __attribute__((__malloc__));
8709
8728#if SU_HAVE_INLINE
8730#endif
8731http_te_t *http_te_make(su_home_t *home, char const *s)
8732 __attribute__((__malloc__));
8733
8756#if SU_HAVE_INLINE
8758#endif
8759http_te_t *http_te_format(su_home_t *home, char const *fmt, ...)
8760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8761
8762
8763/* Inlined functions */
8764#if SU_HAVE_INLINE
8766http_te_t *http_te_format(su_home_t *home, char const *fmt, ...)
8767{
8768 http_header_t *h;
8769 va_list ap;
8770
8771 va_start(ap, fmt);
8772 h = http_header_vformat(home, http_te_class, fmt, ap);
8773 va_end(ap);
8774
8775 return (http_te_t *)h;
8776}
8777
8780{
8781 return (http_te_t *)
8782 msg_header_dup_as(home, http_te_class, (msg_header_t const *)o);
8783}
8784
8787{
8788 return (http_te_t *)
8790}
8791
8793http_te_t *http_te_make(su_home_t *home, char const *s)
8794{
8795 return (http_te_t *)http_header_make(home, http_te_class, s);
8796}
8797#endif
8798
8799#endif /* !define HTTP_HCLASSES_ONLY */
8800
8804/* Declare internal prototypes for Trailer header */
8805
8808enum {
8810 http_trailer_hash = 11015
8812
8822
8823#ifndef HTTP_HCLASSES_ONLY
8824
8827
8830
8842#define HTTP_TRAILER_INIT() HTTP_HDR_INIT(trailer)
8843
8857#if SU_HAVE_INLINE
8862#else
8863#define http_trailer_init(x) \
8864 HTTP_HEADER_INIT(x, http_trailer_class, sizeof(http_trailer_t))
8865#endif
8866
8880#if SU_HAVE_INLINE
8883{
8884 return header && header->sh_class->hc_hash == http_trailer_hash;
8885}
8886#else
8887#define http_is_trailer(h) \
8888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_trailer_hash)
8889#endif
8890
8918#if SU_HAVE_INLINE
8920#endif
8922 http_trailer_t const *hdr)
8923 __attribute__((__malloc__));
8924
8953#if SU_HAVE_INLINE
8955#endif
8957 http_trailer_t const *hdr)
8958 __attribute__((__malloc__));
8959
8978#if SU_HAVE_INLINE
8980#endif
8981http_trailer_t *http_trailer_make(su_home_t *home, char const *s)
8982 __attribute__((__malloc__));
8983
9006#if SU_HAVE_INLINE
9008#endif
9009http_trailer_t *http_trailer_format(su_home_t *home, char const *fmt, ...)
9010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9011
9012
9013/* Inlined functions */
9014#if SU_HAVE_INLINE
9016http_trailer_t *http_trailer_format(su_home_t *home, char const *fmt, ...)
9017{
9018 http_header_t *h;
9019 va_list ap;
9020
9021 va_start(ap, fmt);
9022 h = http_header_vformat(home, http_trailer_class, fmt, ap);
9023 va_end(ap);
9024
9025 return (http_trailer_t *)h;
9026}
9027
9034
9041
9044{
9045 return (http_trailer_t *)http_header_make(home, http_trailer_class, s);
9046}
9047#endif
9048
9049#endif /* !define HTTP_HCLASSES_ONLY */
9050
9054/* Declare internal prototypes for Transfer-Encoding header */
9055
9058enum {
9062
9072
9073#ifndef HTTP_HCLASSES_ONLY
9074
9077
9080
9092#define HTTP_TRANSFER_ENCODING_INIT() HTTP_HDR_INIT(transfer_encoding)
9093
9107#if SU_HAVE_INLINE
9112#else
9113#define http_transfer_encoding_init(x) \
9114 HTTP_HEADER_INIT(x, http_transfer_encoding_class, sizeof(http_transfer_encoding_t))
9115#endif
9116
9130#if SU_HAVE_INLINE
9133{
9134 return header && header->sh_class->hc_hash == http_transfer_encoding_hash;
9135}
9136#else
9137#define http_is_transfer_encoding(h) \
9138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_transfer_encoding_hash)
9139#endif
9140
9168#if SU_HAVE_INLINE
9170#endif
9172 http_transfer_encoding_t const *hdr)
9173 __attribute__((__malloc__));
9174
9203#if SU_HAVE_INLINE
9205#endif
9207 http_transfer_encoding_t const *hdr)
9208 __attribute__((__malloc__));
9209
9228#if SU_HAVE_INLINE
9230#endif
9232 __attribute__((__malloc__));
9233
9256#if SU_HAVE_INLINE
9258#endif
9260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9261
9262
9263/* Inlined functions */
9264#if SU_HAVE_INLINE
9267{
9268 http_header_t *h;
9269 va_list ap;
9270
9271 va_start(ap, fmt);
9272 h = http_header_vformat(home, http_transfer_encoding_class, fmt, ap);
9273 va_end(ap);
9274
9275 return (http_transfer_encoding_t *)h;
9276}
9277
9284
9291
9294{
9295 return (http_transfer_encoding_t *)http_header_make(home, http_transfer_encoding_class, s);
9296}
9297#endif
9298
9299#endif /* !define HTTP_HCLASSES_ONLY */
9300
9304/* Declare internal prototypes for Upgrade header */
9305
9308enum {
9310 http_upgrade_hash = 16256
9312
9322
9323#ifndef HTTP_HCLASSES_ONLY
9324
9327
9330
9342#define HTTP_UPGRADE_INIT() HTTP_HDR_INIT(upgrade)
9343
9357#if SU_HAVE_INLINE
9362#else
9363#define http_upgrade_init(x) \
9364 HTTP_HEADER_INIT(x, http_upgrade_class, sizeof(http_upgrade_t))
9365#endif
9366
9380#if SU_HAVE_INLINE
9383{
9384 return header && header->sh_class->hc_hash == http_upgrade_hash;
9385}
9386#else
9387#define http_is_upgrade(h) \
9388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_upgrade_hash)
9389#endif
9390
9418#if SU_HAVE_INLINE
9420#endif
9422 http_upgrade_t const *hdr)
9423 __attribute__((__malloc__));
9424
9453#if SU_HAVE_INLINE
9455#endif
9457 http_upgrade_t const *hdr)
9458 __attribute__((__malloc__));
9459
9478#if SU_HAVE_INLINE
9480#endif
9481http_upgrade_t *http_upgrade_make(su_home_t *home, char const *s)
9482 __attribute__((__malloc__));
9483
9506#if SU_HAVE_INLINE
9508#endif
9509http_upgrade_t *http_upgrade_format(su_home_t *home, char const *fmt, ...)
9510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9511
9512
9513/* Inlined functions */
9514#if SU_HAVE_INLINE
9516http_upgrade_t *http_upgrade_format(su_home_t *home, char const *fmt, ...)
9517{
9518 http_header_t *h;
9519 va_list ap;
9520
9521 va_start(ap, fmt);
9522 h = http_header_vformat(home, http_upgrade_class, fmt, ap);
9523 va_end(ap);
9524
9525 return (http_upgrade_t *)h;
9526}
9527
9534
9541
9544{
9545 return (http_upgrade_t *)http_header_make(home, http_upgrade_class, s);
9546}
9547#endif
9548
9549#endif /* !define HTTP_HCLASSES_ONLY */
9550
9554/* Declare internal prototypes for User-Agent header */
9555
9558enum {
9560 http_user_agent_hash = 40911
9562
9572
9573#ifndef HTTP_HCLASSES_ONLY
9574
9577
9580
9592#define HTTP_USER_AGENT_INIT() HTTP_HDR_INIT(user_agent)
9593
9607#if SU_HAVE_INLINE
9608su_inline http_user_agent_t *http_user_agent_init(http_user_agent_t x[1])
9609{
9610 return HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t));
9611}
9612#else
9613#define http_user_agent_init(x) \
9614 HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t))
9615#endif
9616
9630#if SU_HAVE_INLINE
9633{
9634 return header && header->sh_class->hc_hash == http_user_agent_hash;
9635}
9636#else
9637#define http_is_user_agent(h) \
9638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_user_agent_hash)
9639#endif
9640
9668#if SU_HAVE_INLINE
9670#endif
9671http_user_agent_t *http_user_agent_dup(su_home_t *home,
9672 http_user_agent_t const *hdr)
9673 __attribute__((__malloc__));
9674
9703#if SU_HAVE_INLINE
9705#endif
9706http_user_agent_t *http_user_agent_copy(su_home_t *home,
9707 http_user_agent_t const *hdr)
9708 __attribute__((__malloc__));
9709
9728#if SU_HAVE_INLINE
9730#endif
9731http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
9732 __attribute__((__malloc__));
9733
9756#if SU_HAVE_INLINE
9758#endif
9759http_user_agent_t *http_user_agent_format(su_home_t *home, char const *fmt, ...)
9760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9761
9762
9763/* Inlined functions */
9764#if SU_HAVE_INLINE
9766http_user_agent_t *http_user_agent_format(su_home_t *home, char const *fmt, ...)
9767{
9768 http_header_t *h;
9769 va_list ap;
9770
9771 va_start(ap, fmt);
9772 h = http_header_vformat(home, http_user_agent_class, fmt, ap);
9773 va_end(ap);
9774
9775 return (http_user_agent_t *)h;
9776}
9777
9779http_user_agent_t *http_user_agent_dup(su_home_t *home, http_user_agent_t const *o)
9780{
9781 return (http_user_agent_t *)
9783}
9784
9786http_user_agent_t *http_user_agent_copy(su_home_t *home, http_user_agent_t const *o)
9787{
9788 return (http_user_agent_t *)
9790}
9791
9793http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
9794{
9795 return (http_user_agent_t *)http_header_make(home, http_user_agent_class, s);
9796}
9797#endif
9798
9799#endif /* !define HTTP_HCLASSES_ONLY */
9800
9804/* Declare internal prototypes for Vary header */
9805
9808enum {
9810 http_vary_hash = 57074
9812
9822
9823#ifndef HTTP_HCLASSES_ONLY
9824
9827
9830
9842#define HTTP_VARY_INIT() HTTP_HDR_INIT(vary)
9843
9857#if SU_HAVE_INLINE
9862#else
9863#define http_vary_init(x) \
9864 HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t))
9865#endif
9866
9880#if SU_HAVE_INLINE
9882int http_is_vary(http_header_t const *header)
9883{
9884 return header && header->sh_class->hc_hash == http_vary_hash;
9885}
9886#else
9887#define http_is_vary(h) \
9888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_vary_hash)
9889#endif
9890
9918#if SU_HAVE_INLINE
9920#endif
9922 http_vary_t const *hdr)
9923 __attribute__((__malloc__));
9924
9953#if SU_HAVE_INLINE
9955#endif
9957 http_vary_t const *hdr)
9958 __attribute__((__malloc__));
9959
9978#if SU_HAVE_INLINE
9980#endif
9981http_vary_t *http_vary_make(su_home_t *home, char const *s)
9982 __attribute__((__malloc__));
9983
10006#if SU_HAVE_INLINE
10008#endif
10009http_vary_t *http_vary_format(su_home_t *home, char const *fmt, ...)
10010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10011
10012
10013/* Inlined functions */
10014#if SU_HAVE_INLINE
10016http_vary_t *http_vary_format(su_home_t *home, char const *fmt, ...)
10017{
10018 http_header_t *h;
10019 va_list ap;
10020
10021 va_start(ap, fmt);
10022 h = http_header_vformat(home, http_vary_class, fmt, ap);
10023 va_end(ap);
10024
10025 return (http_vary_t *)h;
10026}
10027
10030{
10031 return (http_vary_t *)
10033}
10034
10037{
10038 return (http_vary_t *)
10040}
10041
10044{
10045 return (http_vary_t *)http_header_make(home, http_vary_class, s);
10046}
10047#endif
10048
10049#endif /* !define HTTP_HCLASSES_ONLY */
10050
10054/* Declare internal prototypes for Via header */
10055
10058enum {
10060 http_via_hash = 46244
10062
10072
10073#ifndef HTTP_HCLASSES_ONLY
10074
10077
10080
10092#define HTTP_VIA_INIT() HTTP_HDR_INIT(via)
10093
10107#if SU_HAVE_INLINE
10112#else
10113#define http_via_init(x) \
10114 HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t))
10115#endif
10116
10130#if SU_HAVE_INLINE
10132int http_is_via(http_header_t const *header)
10133{
10134 return header && header->sh_class->hc_hash == http_via_hash;
10135}
10136#else
10137#define http_is_via(h) \
10138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_via_hash)
10139#endif
10140
10168#if SU_HAVE_INLINE
10170#endif
10172 http_via_t const *hdr)
10173 __attribute__((__malloc__));
10174
10203#if SU_HAVE_INLINE
10205#endif
10207 http_via_t const *hdr)
10208 __attribute__((__malloc__));
10209
10228#if SU_HAVE_INLINE
10230#endif
10231http_via_t *http_via_make(su_home_t *home, char const *s)
10232 __attribute__((__malloc__));
10233
10256#if SU_HAVE_INLINE
10258#endif
10259http_via_t *http_via_format(su_home_t *home, char const *fmt, ...)
10260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10261
10262
10263/* Inlined functions */
10264#if SU_HAVE_INLINE
10266http_via_t *http_via_format(su_home_t *home, char const *fmt, ...)
10267{
10268 http_header_t *h;
10269 va_list ap;
10270
10271 va_start(ap, fmt);
10272 h = http_header_vformat(home, http_via_class, fmt, ap);
10273 va_end(ap);
10274
10275 return (http_via_t *)h;
10276}
10277
10280{
10281 return (http_via_t *)
10283}
10284
10287{
10288 return (http_via_t *)
10290}
10291
10293http_via_t *http_via_make(su_home_t *home, char const *s)
10294{
10295 return (http_via_t *)http_header_make(home, http_via_class, s);
10296}
10297#endif
10298
10299#endif /* !define HTTP_HCLASSES_ONLY */
10300
10304/* Declare internal prototypes for Warning header */
10305
10308enum {
10310 http_warning_hash = 4130
10312
10322
10323#ifndef HTTP_HCLASSES_ONLY
10324
10327
10330
10342#define HTTP_WARNING_INIT() HTTP_HDR_INIT(warning)
10343
10357#if SU_HAVE_INLINE
10358su_inline http_warning_t *http_warning_init(http_warning_t x[1])
10359{
10360 return HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t));
10361}
10362#else
10363#define http_warning_init(x) \
10364 HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t))
10365#endif
10366
10380#if SU_HAVE_INLINE
10383{
10384 return header && header->sh_class->hc_hash == http_warning_hash;
10385}
10386#else
10387#define http_is_warning(h) \
10388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_warning_hash)
10389#endif
10390
10418#if SU_HAVE_INLINE
10420#endif
10421http_warning_t *http_warning_dup(su_home_t *home,
10422 http_warning_t const *hdr)
10423 __attribute__((__malloc__));
10424
10453#if SU_HAVE_INLINE
10455#endif
10456http_warning_t *http_warning_copy(su_home_t *home,
10457 http_warning_t const *hdr)
10458 __attribute__((__malloc__));
10459
10478#if SU_HAVE_INLINE
10480#endif
10481http_warning_t *http_warning_make(su_home_t *home, char const *s)
10482 __attribute__((__malloc__));
10483
10506#if SU_HAVE_INLINE
10508#endif
10509http_warning_t *http_warning_format(su_home_t *home, char const *fmt, ...)
10510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10511
10512
10513/* Inlined functions */
10514#if SU_HAVE_INLINE
10516http_warning_t *http_warning_format(su_home_t *home, char const *fmt, ...)
10517{
10518 http_header_t *h;
10519 va_list ap;
10520
10521 va_start(ap, fmt);
10522 h = http_header_vformat(home, http_warning_class, fmt, ap);
10523 va_end(ap);
10524
10525 return (http_warning_t *)h;
10526}
10527
10529http_warning_t *http_warning_dup(su_home_t *home, http_warning_t const *o)
10530{
10531 return (http_warning_t *)
10533}
10534
10536http_warning_t *http_warning_copy(su_home_t *home, http_warning_t const *o)
10537{
10538 return (http_warning_t *)
10540}
10541
10543http_warning_t *http_warning_make(su_home_t *home, char const *s)
10544{
10545 return (http_warning_t *)http_header_make(home, http_warning_class, s);
10546}
10547#endif
10548
10549#endif /* !define HTTP_HCLASSES_ONLY */
10550
10554/* Declare internal prototypes for WWW-Authenticate header */
10555
10558enum {
10562
10572
10573#ifndef HTTP_HCLASSES_ONLY
10574
10577
10580
10592#define HTTP_WWW_AUTHENTICATE_INIT() HTTP_HDR_INIT(www_authenticate)
10593
10607#if SU_HAVE_INLINE
10608su_inline http_www_authenticate_t *http_www_authenticate_init(http_www_authenticate_t x[1])
10609{
10610 return HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t));
10611}
10612#else
10613#define http_www_authenticate_init(x) \
10614 HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t))
10615#endif
10616
10630#if SU_HAVE_INLINE
10633{
10634 return header && header->sh_class->hc_hash == http_www_authenticate_hash;
10635}
10636#else
10637#define http_is_www_authenticate(h) \
10638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_www_authenticate_hash)
10639#endif
10640
10668#if SU_HAVE_INLINE
10670#endif
10671http_www_authenticate_t *http_www_authenticate_dup(su_home_t *home,
10672 http_www_authenticate_t const *hdr)
10673 __attribute__((__malloc__));
10674
10703#if SU_HAVE_INLINE
10705#endif
10706http_www_authenticate_t *http_www_authenticate_copy(su_home_t *home,
10707 http_www_authenticate_t const *hdr)
10708 __attribute__((__malloc__));
10709
10728#if SU_HAVE_INLINE
10730#endif
10731http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
10732 __attribute__((__malloc__));
10733
10756#if SU_HAVE_INLINE
10758#endif
10759http_www_authenticate_t *http_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10761
10762
10763/* Inlined functions */
10764#if SU_HAVE_INLINE
10766http_www_authenticate_t *http_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10767{
10768 http_header_t *h;
10769 va_list ap;
10770
10771 va_start(ap, fmt);
10772 h = http_header_vformat(home, http_www_authenticate_class, fmt, ap);
10773 va_end(ap);
10774
10775 return (http_www_authenticate_t *)h;
10776}
10777
10779http_www_authenticate_t *http_www_authenticate_dup(su_home_t *home, http_www_authenticate_t const *o)
10780{
10781 return (http_www_authenticate_t *)
10783}
10784
10786http_www_authenticate_t *http_www_authenticate_copy(su_home_t *home, http_www_authenticate_t const *o)
10787{
10788 return (http_www_authenticate_t *)
10790}
10791
10793http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
10794{
10795 return (http_www_authenticate_t *)http_header_make(home, http_www_authenticate_class, s);
10796}
10797#endif
10798
10799#endif /* !define HTTP_HCLASSES_ONLY */
10800
10804/* Declare internal prototypes for Proxy-Connection header */
10805
10808enum {
10812
10822
10823#ifndef HTTP_HCLASSES_ONLY
10824
10827
10830
10842#define HTTP_PROXY_CONNECTION_INIT() HTTP_HDR_INIT(proxy_connection)
10843
10857#if SU_HAVE_INLINE
10862#else
10863#define http_proxy_connection_init(x) \
10864 HTTP_HEADER_INIT(x, http_proxy_connection_class, sizeof(http_proxy_connection_t))
10865#endif
10866
10880#if SU_HAVE_INLINE
10883{
10884 return header && header->sh_class->hc_hash == http_proxy_connection_hash;
10885}
10886#else
10887#define http_is_proxy_connection(h) \
10888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_connection_hash)
10889#endif
10890
10918#if SU_HAVE_INLINE
10920#endif
10922 http_proxy_connection_t const *hdr)
10923 __attribute__((__malloc__));
10924
10953#if SU_HAVE_INLINE
10955#endif
10957 http_proxy_connection_t const *hdr)
10958 __attribute__((__malloc__));
10959
10978#if SU_HAVE_INLINE
10980#endif
10982 __attribute__((__malloc__));
10983
11006#if SU_HAVE_INLINE
11008#endif
11010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11011
11012
11013/* Inlined functions */
11014#if SU_HAVE_INLINE
11017{
11018 http_header_t *h;
11019 va_list ap;
11020
11021 va_start(ap, fmt);
11022 h = http_header_vformat(home, http_proxy_connection_class, fmt, ap);
11023 va_end(ap);
11024
11025 return (http_proxy_connection_t *)h;
11026}
11027
11034
11041
11044{
11045 return (http_proxy_connection_t *)http_header_make(home, http_proxy_connection_class, s);
11046}
11047#endif
11048
11049#endif /* !define HTTP_HCLASSES_ONLY */
11050
11054/* Declare internal prototypes for Set-Cookie header */
11055
11058enum {
11060 http_set_cookie_hash = 57887
11062
11072
11073#ifndef HTTP_HCLASSES_ONLY
11074
11077
11080
11092#define HTTP_SET_COOKIE_INIT() HTTP_HDR_INIT(set_cookie)
11093
11107#if SU_HAVE_INLINE
11112#else
11113#define http_set_cookie_init(x) \
11114 HTTP_HEADER_INIT(x, http_set_cookie_class, sizeof(http_set_cookie_t))
11115#endif
11116
11130#if SU_HAVE_INLINE
11133{
11134 return header && header->sh_class->hc_hash == http_set_cookie_hash;
11135}
11136#else
11137#define http_is_set_cookie(h) \
11138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_set_cookie_hash)
11139#endif
11140
11168#if SU_HAVE_INLINE
11170#endif
11172 http_set_cookie_t const *hdr)
11173 __attribute__((__malloc__));
11174
11203#if SU_HAVE_INLINE
11205#endif
11207 http_set_cookie_t const *hdr)
11208 __attribute__((__malloc__));
11209
11228#if SU_HAVE_INLINE
11230#endif
11232 __attribute__((__malloc__));
11233
11256#if SU_HAVE_INLINE
11258#endif
11259http_set_cookie_t *http_set_cookie_format(su_home_t *home, char const *fmt, ...)
11260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11261
11262
11263/* Inlined functions */
11264#if SU_HAVE_INLINE
11267{
11268 http_header_t *h;
11269 va_list ap;
11270
11271 va_start(ap, fmt);
11272 h = http_header_vformat(home, http_set_cookie_class, fmt, ap);
11273 va_end(ap);
11274
11275 return (http_set_cookie_t *)h;
11276}
11277
11284
11291
11294{
11295 return (http_set_cookie_t *)http_header_make(home, http_set_cookie_class, s);
11296}
11297#endif
11298
11299#endif /* !define HTTP_HCLASSES_ONLY */
11300
11304/* Declare internal prototypes for Cookie header */
11305
11308enum {
11310 http_cookie_hash = 78
11312
11322
11323#ifndef HTTP_HCLASSES_ONLY
11324
11327
11330
11342#define HTTP_COOKIE_INIT() HTTP_HDR_INIT(cookie)
11343
11357#if SU_HAVE_INLINE
11362#else
11363#define http_cookie_init(x) \
11364 HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t))
11365#endif
11366
11380#if SU_HAVE_INLINE
11383{
11384 return header && header->sh_class->hc_hash == http_cookie_hash;
11385}
11386#else
11387#define http_is_cookie(h) \
11388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cookie_hash)
11389#endif
11390
11418#if SU_HAVE_INLINE
11420#endif
11422 http_cookie_t const *hdr)
11423 __attribute__((__malloc__));
11424
11453#if SU_HAVE_INLINE
11455#endif
11457 http_cookie_t const *hdr)
11458 __attribute__((__malloc__));
11459
11478#if SU_HAVE_INLINE
11480#endif
11481http_cookie_t *http_cookie_make(su_home_t *home, char const *s)
11482 __attribute__((__malloc__));
11483
11506#if SU_HAVE_INLINE
11508#endif
11509http_cookie_t *http_cookie_format(su_home_t *home, char const *fmt, ...)
11510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11511
11512
11513/* Inlined functions */
11514#if SU_HAVE_INLINE
11516http_cookie_t *http_cookie_format(su_home_t *home, char const *fmt, ...)
11517{
11518 http_header_t *h;
11519 va_list ap;
11520
11521 va_start(ap, fmt);
11522 h = http_header_vformat(home, http_cookie_class, fmt, ap);
11523 va_end(ap);
11524
11525 return (http_cookie_t *)h;
11526}
11527
11530{
11531 return (http_cookie_t *)
11533}
11534
11537{
11538 return (http_cookie_t *)
11540}
11541
11544{
11545 return (http_cookie_t *)http_header_make(home, http_cookie_class, s);
11546}
11547#endif
11548
11549#endif /* !define HTTP_HCLASSES_ONLY */
11550
11554/* Declare internal prototypes for MIME-Version header */
11555
11558enum {
11562
11572
11573#ifndef HTTP_HCLASSES_ONLY
11574
11577
11580
11592#define HTTP_MIME_VERSION_INIT() HTTP_HDR_INIT(mime_version)
11593
11607#if SU_HAVE_INLINE
11608su_inline http_mime_version_t *http_mime_version_init(http_mime_version_t x[1])
11609{
11610 return HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t));
11611}
11612#else
11613#define http_mime_version_init(x) \
11614 HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t))
11615#endif
11616
11630#if SU_HAVE_INLINE
11633{
11634 return header && header->sh_class->hc_hash == http_mime_version_hash;
11635}
11636#else
11637#define http_is_mime_version(h) \
11638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_mime_version_hash)
11639#endif
11640
11668#if SU_HAVE_INLINE
11670#endif
11671http_mime_version_t *http_mime_version_dup(su_home_t *home,
11672 http_mime_version_t const *hdr)
11673 __attribute__((__malloc__));
11674
11703#if SU_HAVE_INLINE
11705#endif
11706http_mime_version_t *http_mime_version_copy(su_home_t *home,
11707 http_mime_version_t const *hdr)
11708 __attribute__((__malloc__));
11709
11728#if SU_HAVE_INLINE
11730#endif
11731http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
11732 __attribute__((__malloc__));
11733
11756#if SU_HAVE_INLINE
11758#endif
11759http_mime_version_t *http_mime_version_format(su_home_t *home, char const *fmt, ...)
11760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11761
11762
11763/* Inlined functions */
11764#if SU_HAVE_INLINE
11766http_mime_version_t *http_mime_version_format(su_home_t *home, char const *fmt, ...)
11767{
11768 http_header_t *h;
11769 va_list ap;
11770
11771 va_start(ap, fmt);
11772 h = http_header_vformat(home, http_mime_version_class, fmt, ap);
11773 va_end(ap);
11774
11775 return (http_mime_version_t *)h;
11776}
11777
11779http_mime_version_t *http_mime_version_dup(su_home_t *home, http_mime_version_t const *o)
11780{
11781 return (http_mime_version_t *)
11783}
11784
11786http_mime_version_t *http_mime_version_copy(su_home_t *home, http_mime_version_t const *o)
11787{
11788 return (http_mime_version_t *)
11790}
11791
11793http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
11794{
11795 return (http_mime_version_t *)http_header_make(home, http_mime_version_class, s);
11796}
11797#endif
11798
11799#endif /* !define HTTP_HCLASSES_ONLY */
11800
11804/* Declare internal prototypes for Content-Encoding header */
11805
11808enum {
11812
11822
11823#ifndef HTTP_HCLASSES_ONLY
11824
11827
11830
11842#define HTTP_CONTENT_ENCODING_INIT() HTTP_HDR_INIT(content_encoding)
11843
11857#if SU_HAVE_INLINE
11858su_inline http_content_encoding_t *http_content_encoding_init(http_content_encoding_t x[1])
11859{
11860 return HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t));
11861}
11862#else
11863#define http_content_encoding_init(x) \
11864 HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t))
11865#endif
11866
11880#if SU_HAVE_INLINE
11883{
11884 return header && header->sh_class->hc_hash == http_content_encoding_hash;
11885}
11886#else
11887#define http_is_content_encoding(h) \
11888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_encoding_hash)
11889#endif
11890
11918#if SU_HAVE_INLINE
11920#endif
11921http_content_encoding_t *http_content_encoding_dup(su_home_t *home,
11922 http_content_encoding_t const *hdr)
11923 __attribute__((__malloc__));
11924
11953#if SU_HAVE_INLINE
11955#endif
11956http_content_encoding_t *http_content_encoding_copy(su_home_t *home,
11957 http_content_encoding_t const *hdr)
11958 __attribute__((__malloc__));
11959
11978#if SU_HAVE_INLINE
11980#endif
11981http_content_encoding_t *http_content_encoding_make(su_home_t *home, char const *s)
11982 __attribute__((__malloc__));
11983
12006#if SU_HAVE_INLINE
12008#endif
12009http_content_encoding_t *http_content_encoding_format(su_home_t *home, char const *fmt, ...)
12010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12011
12012
12013/* Inlined functions */
12014#if SU_HAVE_INLINE
12016http_content_encoding_t *http_content_encoding_format(su_home_t *home, char const *fmt, ...)
12017{
12018 http_header_t *h;
12019 va_list ap;
12020
12021 va_start(ap, fmt);
12022 h = http_header_vformat(home, http_content_encoding_class, fmt, ap);
12023 va_end(ap);
12024
12025 return (http_content_encoding_t *)h;
12026}
12027
12029http_content_encoding_t *http_content_encoding_dup(su_home_t *home, http_content_encoding_t const *o)
12030{
12031 return (http_content_encoding_t *)
12033}
12034
12036http_content_encoding_t *http_content_encoding_copy(su_home_t *home, http_content_encoding_t const *o)
12037{
12038 return (http_content_encoding_t *)
12040}
12041
12043http_content_encoding_t *http_content_encoding_make(su_home_t *home, char const *s)
12044{
12045 return (http_content_encoding_t *)http_header_make(home, http_content_encoding_class, s);
12046}
12047#endif
12048
12049#endif /* !define HTTP_HCLASSES_ONLY */
12050
12054/* Declare internal prototypes for Content-Language header */
12055
12058enum {
12062
12072
12073#ifndef HTTP_HCLASSES_ONLY
12074
12077
12080
12092#define HTTP_CONTENT_LANGUAGE_INIT() HTTP_HDR_INIT(content_language)
12093
12107#if SU_HAVE_INLINE
12108su_inline http_content_language_t *http_content_language_init(http_content_language_t x[1])
12109{
12110 return HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t));
12111}
12112#else
12113#define http_content_language_init(x) \
12114 HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t))
12115#endif
12116
12130#if SU_HAVE_INLINE
12133{
12134 return header && header->sh_class->hc_hash == http_content_language_hash;
12135}
12136#else
12137#define http_is_content_language(h) \
12138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_language_hash)
12139#endif
12140
12168#if SU_HAVE_INLINE
12170#endif
12171http_content_language_t *http_content_language_dup(su_home_t *home,
12172 http_content_language_t const *hdr)
12173 __attribute__((__malloc__));
12174
12203#if SU_HAVE_INLINE
12205#endif
12206http_content_language_t *http_content_language_copy(su_home_t *home,
12207 http_content_language_t const *hdr)
12208 __attribute__((__malloc__));
12209
12228#if SU_HAVE_INLINE
12230#endif
12231http_content_language_t *http_content_language_make(su_home_t *home, char const *s)
12232 __attribute__((__malloc__));
12233
12256#if SU_HAVE_INLINE
12258#endif
12259http_content_language_t *http_content_language_format(su_home_t *home, char const *fmt, ...)
12260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12261
12262
12263/* Inlined functions */
12264#if SU_HAVE_INLINE
12266http_content_language_t *http_content_language_format(su_home_t *home, char const *fmt, ...)
12267{
12268 http_header_t *h;
12269 va_list ap;
12270
12271 va_start(ap, fmt);
12272 h = http_header_vformat(home, http_content_language_class, fmt, ap);
12273 va_end(ap);
12274
12275 return (http_content_language_t *)h;
12276}
12277
12279http_content_language_t *http_content_language_dup(su_home_t *home, http_content_language_t const *o)
12280{
12281 return (http_content_language_t *)
12283}
12284
12286http_content_language_t *http_content_language_copy(su_home_t *home, http_content_language_t const *o)
12287{
12288 return (http_content_language_t *)
12290}
12291
12293http_content_language_t *http_content_language_make(su_home_t *home, char const *s)
12294{
12295 return (http_content_language_t *)http_header_make(home, http_content_language_class, s);
12296}
12297#endif
12298
12299#endif /* !define HTTP_HCLASSES_ONLY */
12300
12304/* Declare internal prototypes for Content-Length header */
12305
12308enum {
12312
12322
12323#ifndef HTTP_HCLASSES_ONLY
12324
12327
12330
12342#define HTTP_CONTENT_LENGTH_INIT() HTTP_HDR_INIT(content_length)
12343
12357#if SU_HAVE_INLINE
12358su_inline http_content_length_t *http_content_length_init(http_content_length_t x[1])
12359{
12360 return HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t));
12361}
12362#else
12363#define http_content_length_init(x) \
12364 HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t))
12365#endif
12366
12380#if SU_HAVE_INLINE
12383{
12384 return header && header->sh_class->hc_hash == http_content_length_hash;
12385}
12386#else
12387#define http_is_content_length(h) \
12388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_length_hash)
12389#endif
12390
12418#if SU_HAVE_INLINE
12420#endif
12421http_content_length_t *http_content_length_dup(su_home_t *home,
12422 http_content_length_t const *hdr)
12423 __attribute__((__malloc__));
12424
12453#if SU_HAVE_INLINE
12455#endif
12456http_content_length_t *http_content_length_copy(su_home_t *home,
12457 http_content_length_t const *hdr)
12458 __attribute__((__malloc__));
12459
12478#if SU_HAVE_INLINE
12480#endif
12481http_content_length_t *http_content_length_make(su_home_t *home, char const *s)
12482 __attribute__((__malloc__));
12483
12506#if SU_HAVE_INLINE
12508#endif
12509http_content_length_t *http_content_length_format(su_home_t *home, char const *fmt, ...)
12510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12511
12512
12513/* Inlined functions */
12514#if SU_HAVE_INLINE
12516http_content_length_t *http_content_length_format(su_home_t *home, char const *fmt, ...)
12517{
12518 http_header_t *h;
12519 va_list ap;
12520
12521 va_start(ap, fmt);
12522 h = http_header_vformat(home, http_content_length_class, fmt, ap);
12523 va_end(ap);
12524
12525 return (http_content_length_t *)h;
12526}
12527
12529http_content_length_t *http_content_length_dup(su_home_t *home, http_content_length_t const *o)
12530{
12531 return (http_content_length_t *)
12533}
12534
12536http_content_length_t *http_content_length_copy(su_home_t *home, http_content_length_t const *o)
12537{
12538 return (http_content_length_t *)
12540}
12541
12543http_content_length_t *http_content_length_make(su_home_t *home, char const *s)
12544{
12545 return (http_content_length_t *)http_header_make(home, http_content_length_class, s);
12546}
12547#endif
12548
12549#endif /* !define HTTP_HCLASSES_ONLY */
12550
12554/* Declare internal prototypes for Content-Location header */
12555
12558enum {
12562
12572
12573#ifndef HTTP_HCLASSES_ONLY
12574
12577
12580
12592#define HTTP_CONTENT_LOCATION_INIT() HTTP_HDR_INIT(content_location)
12593
12607#if SU_HAVE_INLINE
12608su_inline http_content_location_t *http_content_location_init(http_content_location_t x[1])
12609{
12610 return HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t));
12611}
12612#else
12613#define http_content_location_init(x) \
12614 HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t))
12615#endif
12616
12630#if SU_HAVE_INLINE
12633{
12634 return header && header->sh_class->hc_hash == http_content_location_hash;
12635}
12636#else
12637#define http_is_content_location(h) \
12638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_location_hash)
12639#endif
12640
12668#if SU_HAVE_INLINE
12670#endif
12671http_content_location_t *http_content_location_dup(su_home_t *home,
12672 http_content_location_t const *hdr)
12673 __attribute__((__malloc__));
12674
12703#if SU_HAVE_INLINE
12705#endif
12706http_content_location_t *http_content_location_copy(su_home_t *home,
12707 http_content_location_t const *hdr)
12708 __attribute__((__malloc__));
12709
12728#if SU_HAVE_INLINE
12730#endif
12731http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
12732 __attribute__((__malloc__));
12733
12756#if SU_HAVE_INLINE
12758#endif
12759http_content_location_t *http_content_location_format(su_home_t *home, char const *fmt, ...)
12760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12761
12762
12763/* Inlined functions */
12764#if SU_HAVE_INLINE
12766http_content_location_t *http_content_location_format(su_home_t *home, char const *fmt, ...)
12767{
12768 http_header_t *h;
12769 va_list ap;
12770
12771 va_start(ap, fmt);
12772 h = http_header_vformat(home, http_content_location_class, fmt, ap);
12773 va_end(ap);
12774
12775 return (http_content_location_t *)h;
12776}
12777
12779http_content_location_t *http_content_location_dup(su_home_t *home, http_content_location_t const *o)
12780{
12781 return (http_content_location_t *)
12783}
12784
12786http_content_location_t *http_content_location_copy(su_home_t *home, http_content_location_t const *o)
12787{
12788 return (http_content_location_t *)
12790}
12791
12793http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
12794{
12795 return (http_content_location_t *)http_header_make(home, http_content_location_class, s);
12796}
12797#endif
12798
12799#endif /* !define HTTP_HCLASSES_ONLY */
12800
12804/* Declare internal prototypes for Content-MD5 header */
12805
12808enum {
12810 http_content_md5_hash = 60494
12812
12822
12823#ifndef HTTP_HCLASSES_ONLY
12824
12827
12830
12842#define HTTP_CONTENT_MD5_INIT() HTTP_HDR_INIT(content_md5)
12843
12857#if SU_HAVE_INLINE
12858su_inline http_content_md5_t *http_content_md5_init(http_content_md5_t x[1])
12859{
12860 return HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t));
12861}
12862#else
12863#define http_content_md5_init(x) \
12864 HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t))
12865#endif
12866
12880#if SU_HAVE_INLINE
12883{
12884 return header && header->sh_class->hc_hash == http_content_md5_hash;
12885}
12886#else
12887#define http_is_content_md5(h) \
12888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_md5_hash)
12889#endif
12890
12918#if SU_HAVE_INLINE
12920#endif
12921http_content_md5_t *http_content_md5_dup(su_home_t *home,
12922 http_content_md5_t const *hdr)
12923 __attribute__((__malloc__));
12924
12953#if SU_HAVE_INLINE
12955#endif
12956http_content_md5_t *http_content_md5_copy(su_home_t *home,
12957 http_content_md5_t const *hdr)
12958 __attribute__((__malloc__));
12959
12978#if SU_HAVE_INLINE
12980#endif
12981http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
12982 __attribute__((__malloc__));
12983
13006#if SU_HAVE_INLINE
13008#endif
13009http_content_md5_t *http_content_md5_format(su_home_t *home, char const *fmt, ...)
13010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13011
13012
13013/* Inlined functions */
13014#if SU_HAVE_INLINE
13016http_content_md5_t *http_content_md5_format(su_home_t *home, char const *fmt, ...)
13017{
13018 http_header_t *h;
13019 va_list ap;
13020
13021 va_start(ap, fmt);
13022 h = http_header_vformat(home, http_content_md5_class, fmt, ap);
13023 va_end(ap);
13024
13025 return (http_content_md5_t *)h;
13026}
13027
13029http_content_md5_t *http_content_md5_dup(su_home_t *home, http_content_md5_t const *o)
13030{
13031 return (http_content_md5_t *)
13033}
13034
13036http_content_md5_t *http_content_md5_copy(su_home_t *home, http_content_md5_t const *o)
13037{
13038 return (http_content_md5_t *)
13040}
13041
13043http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
13044{
13045 return (http_content_md5_t *)http_header_make(home, http_content_md5_class, s);
13046}
13047#endif
13048
13049#endif /* !define HTTP_HCLASSES_ONLY */
13050
13054/* Declare internal prototypes for Content-Range header */
13055
13058enum {
13062
13072
13073#ifndef HTTP_HCLASSES_ONLY
13074
13077
13080
13092#define HTTP_CONTENT_RANGE_INIT() HTTP_HDR_INIT(content_range)
13093
13107#if SU_HAVE_INLINE
13112#else
13113#define http_content_range_init(x) \
13114 HTTP_HEADER_INIT(x, http_content_range_class, sizeof(http_content_range_t))
13115#endif
13116
13130#if SU_HAVE_INLINE
13133{
13134 return header && header->sh_class->hc_hash == http_content_range_hash;
13135}
13136#else
13137#define http_is_content_range(h) \
13138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_range_hash)
13139#endif
13140
13168#if SU_HAVE_INLINE
13170#endif
13172 http_content_range_t const *hdr)
13173 __attribute__((__malloc__));
13174
13203#if SU_HAVE_INLINE
13205#endif
13207 http_content_range_t const *hdr)
13208 __attribute__((__malloc__));
13209
13228#if SU_HAVE_INLINE
13230#endif
13232 __attribute__((__malloc__));
13233
13256#if SU_HAVE_INLINE
13258#endif
13259http_content_range_t *http_content_range_format(su_home_t *home, char const *fmt, ...)
13260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13261
13262
13263/* Inlined functions */
13264#if SU_HAVE_INLINE
13267{
13268 http_header_t *h;
13269 va_list ap;
13270
13271 va_start(ap, fmt);
13272 h = http_header_vformat(home, http_content_range_class, fmt, ap);
13273 va_end(ap);
13274
13275 return (http_content_range_t *)h;
13276}
13277
13284
13291
13294{
13295 return (http_content_range_t *)http_header_make(home, http_content_range_class, s);
13296}
13297#endif
13298
13299#endif /* !define HTTP_HCLASSES_ONLY */
13300
13304/* Declare internal prototypes for Content-Type header */
13305
13308enum {
13312
13322
13323#ifndef HTTP_HCLASSES_ONLY
13324
13327
13330
13342#define HTTP_CONTENT_TYPE_INIT() HTTP_HDR_INIT(content_type)
13343
13357#if SU_HAVE_INLINE
13358su_inline http_content_type_t *http_content_type_init(http_content_type_t x[1])
13359{
13360 return HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t));
13361}
13362#else
13363#define http_content_type_init(x) \
13364 HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t))
13365#endif
13366
13380#if SU_HAVE_INLINE
13383{
13384 return header && header->sh_class->hc_hash == http_content_type_hash;
13385}
13386#else
13387#define http_is_content_type(h) \
13388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_type_hash)
13389#endif
13390
13418#if SU_HAVE_INLINE
13420#endif
13421http_content_type_t *http_content_type_dup(su_home_t *home,
13422 http_content_type_t const *hdr)
13423 __attribute__((__malloc__));
13424
13453#if SU_HAVE_INLINE
13455#endif
13456http_content_type_t *http_content_type_copy(su_home_t *home,
13457 http_content_type_t const *hdr)
13458 __attribute__((__malloc__));
13459
13478#if SU_HAVE_INLINE
13480#endif
13481http_content_type_t *http_content_type_make(su_home_t *home, char const *s)
13482 __attribute__((__malloc__));
13483
13506#if SU_HAVE_INLINE
13508#endif
13509http_content_type_t *http_content_type_format(su_home_t *home, char const *fmt, ...)
13510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13511
13512
13513/* Inlined functions */
13514#if SU_HAVE_INLINE
13516http_content_type_t *http_content_type_format(su_home_t *home, char const *fmt, ...)
13517{
13518 http_header_t *h;
13519 va_list ap;
13520
13521 va_start(ap, fmt);
13522 h = http_header_vformat(home, http_content_type_class, fmt, ap);
13523 va_end(ap);
13524
13525 return (http_content_type_t *)h;
13526}
13527
13529http_content_type_t *http_content_type_dup(su_home_t *home, http_content_type_t const *o)
13530{
13531 return (http_content_type_t *)
13533}
13534
13536http_content_type_t *http_content_type_copy(su_home_t *home, http_content_type_t const *o)
13537{
13538 return (http_content_type_t *)
13540}
13541
13543http_content_type_t *http_content_type_make(su_home_t *home, char const *s)
13544{
13545 return (http_content_type_t *)http_header_make(home, http_content_type_class, s);
13546}
13547#endif
13548
13549#endif /* !define HTTP_HCLASSES_ONLY */
13550
13554/* Declare internal prototypes for unknown headers */
13555
13558enum {
13562
13572
13573#ifndef HTTP_HCLASSES_ONLY
13574
13577
13580
13592#define HTTP_UNKNOWN_INIT() HTTP_HDR_INIT(unknown)
13593
13607#if SU_HAVE_INLINE
13612#else
13613#define http_unknown_init(x) \
13614 HTTP_HEADER_INIT(x, http_unknown_class, sizeof(http_unknown_t))
13615#endif
13616
13630#if SU_HAVE_INLINE
13633{
13634 return header && header->sh_class->hc_hash == http_unknown_hash;
13635}
13636#else
13637#define http_is_unknown(h) \
13638 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_unknown_hash)
13639#endif
13640
13668#if SU_HAVE_INLINE
13670#endif
13672 http_unknown_t const *hdr)
13673 __attribute__((__malloc__));
13674
13703#if SU_HAVE_INLINE
13705#endif
13707 http_unknown_t const *hdr)
13708 __attribute__((__malloc__));
13709
13728#if SU_HAVE_INLINE
13730#endif
13731http_unknown_t *http_unknown_make(su_home_t *home, char const *s)
13732 __attribute__((__malloc__));
13733
13756#if SU_HAVE_INLINE
13758#endif
13759http_unknown_t *http_unknown_format(su_home_t *home, char const *fmt, ...)
13760 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13761
13762
13763/* Inlined functions */
13764#if SU_HAVE_INLINE
13766http_unknown_t *http_unknown_format(su_home_t *home, char const *fmt, ...)
13767{
13768 http_header_t *h;
13769 va_list ap;
13770
13771 va_start(ap, fmt);
13772 h = http_header_vformat(home, http_unknown_class, fmt, ap);
13773 va_end(ap);
13774
13775 return (http_unknown_t *)h;
13776}
13777
13780{
13781 return (http_unknown_t *)
13783}
13784
13787{
13788 return (http_unknown_t *)
13790}
13791
13794{
13795 return (http_unknown_t *)http_header_make(home, http_unknown_class, s);
13796}
13797#endif
13798
13799#endif /* !define HTTP_HCLASSES_ONLY */
13800
13804/* Declare internal prototypes for erroneous headers */
13805
13808enum {
13810 http_error_hash = -4
13812
13822
13823#ifndef HTTP_HCLASSES_ONLY
13824
13827
13830
13842#define HTTP_ERROR_INIT() HTTP_HDR_INIT(error)
13843
13857#if SU_HAVE_INLINE
13862#else
13863#define http_error_init(x) \
13864 HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t))
13865#endif
13866
13880#if SU_HAVE_INLINE
13883{
13884 return header && header->sh_class->hc_hash == http_error_hash;
13885}
13886#else
13887#define http_is_error(h) \
13888 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_error_hash)
13889#endif
13890
13918#if SU_HAVE_INLINE
13920#endif
13922 http_error_t const *hdr)
13923 __attribute__((__malloc__));
13924
13953#if SU_HAVE_INLINE
13955#endif
13957 http_error_t const *hdr)
13958 __attribute__((__malloc__));
13959
13978#if SU_HAVE_INLINE
13980#endif
13981http_error_t *http_error_make(su_home_t *home, char const *s)
13982 __attribute__((__malloc__));
13983
14006#if SU_HAVE_INLINE
14008#endif
14009http_error_t *http_error_format(su_home_t *home, char const *fmt, ...)
14010 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14011
14012
14013/* Inlined functions */
14014#if SU_HAVE_INLINE
14016http_error_t *http_error_format(su_home_t *home, char const *fmt, ...)
14017{
14018 http_header_t *h;
14019 va_list ap;
14020
14021 va_start(ap, fmt);
14022 h = http_header_vformat(home, http_error_class, fmt, ap);
14023 va_end(ap);
14024
14025 return (http_error_t *)h;
14026}
14027
14030{
14031 return (http_error_t *)
14033}
14034
14037{
14038 return (http_error_t *)
14040}
14041
14044{
14045 return (http_error_t *)http_header_make(home, http_error_class, s);
14046}
14047#endif
14048
14049#endif /* !define HTTP_HCLASSES_ONLY */
14050
14054/* Declare internal prototypes for separator line between headers and body */
14055
14058enum {
14062
14072
14073#ifndef HTTP_HCLASSES_ONLY
14074
14077
14080
14092#define HTTP_SEPARATOR_INIT() HTTP_HDR_INIT(separator)
14093
14107#if SU_HAVE_INLINE
14112#else
14113#define http_separator_init(x) \
14114 HTTP_HEADER_INIT(x, http_separator_class, sizeof(http_separator_t))
14115#endif
14116
14130#if SU_HAVE_INLINE
14133{
14134 return header && header->sh_class->hc_hash == http_separator_hash;
14135}
14136#else
14137#define http_is_separator(h) \
14138 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_separator_hash)
14139#endif
14140
14168#if SU_HAVE_INLINE
14170#endif
14172 http_separator_t const *hdr)
14173 __attribute__((__malloc__));
14174
14203#if SU_HAVE_INLINE
14205#endif
14207 http_separator_t const *hdr)
14208 __attribute__((__malloc__));
14209
14228#if SU_HAVE_INLINE
14230#endif
14231http_separator_t *http_separator_make(su_home_t *home, char const *s)
14232 __attribute__((__malloc__));
14233
14256#if SU_HAVE_INLINE
14258#endif
14259http_separator_t *http_separator_format(su_home_t *home, char const *fmt, ...)
14260 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14261
14262
14263/* Inlined functions */
14264#if SU_HAVE_INLINE
14267{
14268 http_header_t *h;
14269 va_list ap;
14270
14271 va_start(ap, fmt);
14272 h = http_header_vformat(home, http_separator_class, fmt, ap);
14273 va_end(ap);
14274
14275 return (http_separator_t *)h;
14276}
14277
14284
14291
14294{
14295 return (http_separator_t *)http_header_make(home, http_separator_class, s);
14296}
14297#endif
14298
14299#endif /* !define HTTP_HCLASSES_ONLY */
14300
14304/* Declare internal prototypes for message payload */
14305
14308enum {
14312
14322
14323#ifndef HTTP_HCLASSES_ONLY
14324
14327
14330
14342#define HTTP_PAYLOAD_INIT() HTTP_HDR_INIT(payload)
14343
14357#if SU_HAVE_INLINE
14362#else
14363#define http_payload_init(x) \
14364 HTTP_HEADER_INIT(x, http_payload_class, sizeof(http_payload_t))
14365#endif
14366
14380#if SU_HAVE_INLINE
14383{
14384 return header && header->sh_class->hc_hash == http_payload_hash;
14385}
14386#else
14387#define http_is_payload(h) \
14388 ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_payload_hash)
14389#endif
14390
14418#if SU_HAVE_INLINE
14420#endif
14422 http_payload_t const *hdr)
14423 __attribute__((__malloc__));
14424
14453#if SU_HAVE_INLINE
14455#endif
14457 http_payload_t const *hdr)
14458 __attribute__((__malloc__));
14459
14478#if SU_HAVE_INLINE
14480#endif
14481http_payload_t *http_payload_make(su_home_t *home, char const *s)
14482 __attribute__((__malloc__));
14483
14506#if SU_HAVE_INLINE
14508#endif
14509http_payload_t *http_payload_format(su_home_t *home, char const *fmt, ...)
14510 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14511
14512
14513/* Inlined functions */
14514#if SU_HAVE_INLINE
14516http_payload_t *http_payload_format(su_home_t *home, char const *fmt, ...)
14517{
14518 http_header_t *h;
14519 va_list ap;
14520
14521 va_start(ap, fmt);
14522 h = http_header_vformat(home, http_payload_class, fmt, ap);
14523 va_end(ap);
14524
14525 return (http_payload_t *)h;
14526}
14527
14530{
14531 return (http_payload_t *)
14533}
14534
14537{
14538 return (http_payload_t *)
14540}
14541
14544{
14545 return (http_payload_t *)http_header_make(home, http_payload_class, s);
14546}
14547#endif
14548
14549#endif /* !define HTTP_HCLASSES_ONLY */
14550
14554SOFIA_END_DECLS
14555#endif /* !defined(HTTP_PROTOS_H) */
http_accept_charset_t * http_accept_charset_init(http_accept_charset_t x[1])
Initialize a structure http_accept_charset_t.
Definition http_protos.h:858
http_accept_charset_t * http_accept_charset_dup(su_home_t *home, http_accept_charset_t const *hdr))
Duplicate (deep copy) http_accept_charset_t.
Definition http_protos.h:1029
http_accept_charset_t * http_accept_charset_copy(su_home_t *home, http_accept_charset_t const *hdr))
Copy a http_accept_charset_t header structure.
Definition http_protos.h:1036
msg_hclass_t http_accept_charset_class[]
Header class for HTTP Accept-Charset header.
msg_parse_f http_accept_charset_d
Decode (parse) a Accept-Charset header.
Definition http_protos.h:826
int http_is_accept_charset(http_header_t const *header)
Test if header object is instance of http_accept_charset_t.
Definition http_protos.h:882
http_accept_charset_t * http_accept_charset_make(su_home_t *home, char const *s))
Make a header structure http_accept_charset_t.
Definition http_protos.h:1043
msg_print_f http_accept_charset_e
Encode (print) a Accept-Charset header.
Definition http_protos.h:829
http_accept_charset_t * http_accept_charset_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Charset header from formatting result.
Definition http_protos.h:1016
@ http_accept_charset_hash
Hash of Accept-Charset header.
Definition http_protos.h:810
int http_is_accept_encoding(http_header_t const *header)
Test if header object is instance of http_accept_encoding_t.
Definition http_protos.h:1132
msg_print_f http_accept_encoding_e
Encode (print) a Accept-Encoding header.
Definition http_protos.h:1079
msg_hclass_t http_accept_encoding_class[]
Header class for HTTP Accept-Encoding header.
http_accept_encoding_t * http_accept_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Encoding header from formatting result.
Definition http_protos.h:1266
http_accept_encoding_t * http_accept_encoding_make(su_home_t *home, char const *s))
Make a header structure http_accept_encoding_t.
Definition http_protos.h:1293
http_accept_encoding_t * http_accept_encoding_copy(su_home_t *home, http_accept_encoding_t const *hdr))
Copy a http_accept_encoding_t header structure.
Definition http_protos.h:1286
msg_parse_f http_accept_encoding_d
Decode (parse) a Accept-Encoding header.
Definition http_protos.h:1076
http_accept_encoding_t * http_accept_encoding_dup(su_home_t *home, http_accept_encoding_t const *hdr))
Duplicate (deep copy) http_accept_encoding_t.
Definition http_protos.h:1279
http_accept_encoding_t * http_accept_encoding_init(http_accept_encoding_t x[1])
Initialize a structure http_accept_encoding_t.
Definition http_protos.h:1108
@ http_accept_encoding_hash
Hash of Accept-Encoding header.
Definition http_protos.h:1060
msg_print_f http_accept_language_e
Encode (print) a Accept-Language header.
Definition http_protos.h:1329
http_accept_language_t * http_accept_language_dup(su_home_t *home, http_accept_language_t const *hdr))
Duplicate (deep copy) http_accept_language_t.
Definition http_protos.h:1529
http_accept_language_t * http_accept_language_make(su_home_t *home, char const *s))
Make a header structure http_accept_language_t.
Definition http_protos.h:1543
http_accept_language_t * http_accept_language_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Language header from formatting result.
Definition http_protos.h:1516
int http_is_accept_language(http_header_t const *header)
Test if header object is instance of http_accept_language_t.
Definition http_protos.h:1382
http_accept_language_t * http_accept_language_init(http_accept_language_t x[1])
Initialize a structure http_accept_language_t.
Definition http_protos.h:1358
msg_hclass_t http_accept_language_class[]
Header class for HTTP Accept-Language header.
http_accept_language_t * http_accept_language_copy(su_home_t *home, http_accept_language_t const *hdr))
Copy a http_accept_language_t header structure.
Definition http_protos.h:1536
msg_parse_f http_accept_language_d
Decode (parse) a Accept-Language header.
Definition http_protos.h:1326
@ http_accept_language_hash
Hash of Accept-Language header.
Definition http_protos.h:1310
http_accept_ranges_t * http_accept_ranges_init(http_accept_ranges_t x[1])
Initialize a structure http_accept_ranges_t.
Definition http_protos.h:1608
http_accept_ranges_t * http_accept_ranges_copy(su_home_t *home, http_accept_ranges_t const *hdr))
Copy a http_accept_ranges_t header structure.
Definition http_protos.h:1786
http_accept_ranges_t * http_accept_ranges_make(su_home_t *home, char const *s))
Make a header structure http_accept_ranges_t.
Definition http_protos.h:1793
http_accept_ranges_t * http_accept_ranges_dup(su_home_t *home, http_accept_ranges_t const *hdr))
Duplicate (deep copy) http_accept_ranges_t.
Definition http_protos.h:1779
msg_print_f http_accept_ranges_e
Encode (print) a Accept-Ranges header.
Definition http_protos.h:1579
int http_is_accept_ranges(http_header_t const *header)
Test if header object is instance of http_accept_ranges_t.
Definition http_protos.h:1632
http_accept_ranges_t * http_accept_ranges_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Ranges header from formatting result.
Definition http_protos.h:1766
msg_hclass_t http_accept_ranges_class[]
Header class for HTTP Accept-Ranges header.
Definition http_basic.c:314
msg_parse_f http_accept_ranges_d
Decode (parse) a Accept-Ranges header.
Definition http_protos.h:1576
@ http_accept_ranges_hash
Hash of Accept-Ranges header.
Definition http_protos.h:1560
msg_print_f http_accept_e
Encode (print) a Accept header.
Definition http_protos.h:579
http_accept_t * http_accept_init(http_accept_t x[1])
Initialize a structure http_accept_t.
Definition http_protos.h:608
http_accept_t * http_accept_make(su_home_t *home, char const *s))
Make a header structure http_accept_t.
Definition http_protos.h:793
msg_parse_f http_accept_d
Decode (parse) a Accept header.
Definition http_protos.h:576
msg_hclass_t http_accept_class[]
Header class for HTTP Accept header.
int http_is_accept(http_header_t const *header)
Test if header object is instance of http_accept_t.
Definition http_protos.h:632
http_accept_t * http_accept_dup(su_home_t *home, http_accept_t const *hdr))
Duplicate (deep copy) http_accept_t.
Definition http_protos.h:779
http_accept_t * http_accept_copy(su_home_t *home, http_accept_t const *hdr))
Copy a http_accept_t header structure.
Definition http_protos.h:786
http_accept_t * http_accept_format(su_home_t *home, char const *fmt,...)))
Make a Accept header from formatting result.
Definition http_protos.h:766
@ http_accept_hash
Hash of Accept header.
Definition http_protos.h:560
http_age_t * http_age_init(http_age_t x[1])
Initialize a structure http_age_t.
Definition http_protos.h:2608
http_age_t * http_age_make(su_home_t *home, char const *s))
Make a header structure http_age_t.
Definition http_protos.h:2793
http_age_t * http_age_dup(su_home_t *home, http_age_t const *hdr))
Duplicate (deep copy) http_age_t.
Definition http_protos.h:2779
msg_hclass_t http_age_class[]
Header class for HTTP Age header.
Definition http_basic.c:324
int http_is_age(http_header_t const *header)
Test if header object is instance of http_age_t.
Definition http_protos.h:2632
http_age_t * http_age_copy(su_home_t *home, http_age_t const *hdr))
Copy a http_age_t header structure.
Definition http_protos.h:2786
msg_parse_f http_age_d
Decode (parse) a Age header.
Definition http_protos.h:2576
msg_print_f http_age_e
Encode (print) a Age header.
Definition http_protos.h:2579
http_age_t * http_age_format(su_home_t *home, char const *fmt,...)))
Make a Age header from formatting result.
Definition http_protos.h:2766
@ http_age_hash
Hash of Age header.
Definition http_protos.h:2560
http_allow_t * http_allow_make(su_home_t *home, char const *s))
Make a header structure http_allow_t.
Definition http_protos.h:2043
int http_is_allow(http_header_t const *header)
Test if header object is instance of http_allow_t.
Definition http_protos.h:1882
http_allow_t * http_allow_format(su_home_t *home, char const *fmt,...)))
Make a Allow header from formatting result.
Definition http_protos.h:2016
http_allow_t * http_allow_copy(su_home_t *home, http_allow_t const *hdr))
Copy a http_allow_t header structure.
Definition http_protos.h:2036
http_allow_t * http_allow_dup(su_home_t *home, http_allow_t const *hdr))
Duplicate (deep copy) http_allow_t.
Definition http_protos.h:2029
msg_print_f http_allow_e
Encode (print) a Allow header.
Definition http_protos.h:1829
msg_parse_f http_allow_d
Decode (parse) a Allow header.
Definition http_protos.h:1826
http_allow_t * http_allow_init(http_allow_t x[1])
Initialize a structure http_allow_t.
Definition http_protos.h:1858
msg_hclass_t http_allow_class[]
Header class for HTTP Allow header.
Definition http_basic.c:332
@ http_allow_hash
Hash of Allow header.
Definition http_protos.h:1810
http_authentication_info_t * http_authentication_info_dup(su_home_t *home, http_authentication_info_t const *hdr))
Duplicate (deep copy) http_authentication_info_t.
Definition http_protos.h:2279
http_authentication_info_t * http_authentication_info_make(su_home_t *home, char const *s))
Make a header structure http_authentication_info_t.
Definition http_protos.h:2293
msg_parse_f http_authentication_info_d
Decode (parse) a Authentication-Info header.
Definition http_protos.h:2076
http_authentication_info_t * http_authentication_info_format(su_home_t *home, char const *fmt,...)))
Make a Authentication-Info header from formatting result.
Definition http_protos.h:2266
msg_print_f http_authentication_info_e
Encode (print) a Authentication-Info header.
Definition http_protos.h:2079
int http_is_authentication_info(http_header_t const *header)
Test if header object is instance of http_authentication_info_t.
Definition http_protos.h:2132
msg_hclass_t http_authentication_info_class[]
Header class for HTTP Authentication-Info header.
Definition http_basic.c:345
http_authentication_info_t * http_authentication_info_init(http_authentication_info_t x[1])
Initialize a structure http_authentication_info_t.
Definition http_protos.h:2108
http_authentication_info_t * http_authentication_info_copy(su_home_t *home, http_authentication_info_t const *hdr))
Copy a http_authentication_info_t header structure.
Definition http_protos.h:2286
@ http_authentication_info_hash
Hash of Authentication-Info header.
Definition http_protos.h:2060
http_authorization_t * http_authorization_init(http_authorization_t x[1])
Initialize a structure http_authorization_t.
Definition http_protos.h:2358
http_authorization_t * http_authorization_make(su_home_t *home, char const *s))
Make a header structure http_authorization_t.
Definition http_protos.h:2543
http_authorization_t * http_authorization_format(su_home_t *home, char const *fmt,...)))
Make a Authorization header from formatting result.
Definition http_protos.h:2516
msg_hclass_t http_authorization_class[]
Header class for HTTP Authorization header.
Definition http_basic.c:358
msg_print_f http_authorization_e
Encode (print) a Authorization header.
Definition http_protos.h:2329
int http_is_authorization(http_header_t const *header)
Test if header object is instance of http_authorization_t.
Definition http_protos.h:2382
http_authorization_t * http_authorization_copy(su_home_t *home, http_authorization_t const *hdr))
Copy a http_authorization_t header structure.
Definition http_protos.h:2536
http_authorization_t * http_authorization_dup(su_home_t *home, http_authorization_t const *hdr))
Duplicate (deep copy) http_authorization_t.
Definition http_protos.h:2529
msg_parse_f http_authorization_d
Decode (parse) a Authorization header.
Definition http_protos.h:2326
@ http_authorization_hash
Hash of Authorization header.
Definition http_protos.h:2310
http_cache_control_t * http_cache_control_init(http_cache_control_t x[1])
Initialize a structure http_cache_control_t.
Definition http_protos.h:2858
msg_parse_f http_cache_control_d
Decode (parse) a Cache-Control header.
Definition http_protos.h:2826
http_cache_control_t * http_cache_control_dup(su_home_t *home, http_cache_control_t const *hdr))
Duplicate (deep copy) http_cache_control_t.
Definition http_protos.h:3029
msg_print_f http_cache_control_e
Encode (print) a Cache-Control header.
Definition http_protos.h:2829
int http_is_cache_control(http_header_t const *header)
Test if header object is instance of http_cache_control_t.
Definition http_protos.h:2882
http_cache_control_t * http_cache_control_copy(su_home_t *home, http_cache_control_t const *hdr))
Copy a http_cache_control_t header structure.
Definition http_protos.h:3036
http_cache_control_t * http_cache_control_format(su_home_t *home, char const *fmt,...)))
Make a Cache-Control header from formatting result.
Definition http_protos.h:3016
http_cache_control_t * http_cache_control_make(su_home_t *home, char const *s))
Make a header structure http_cache_control_t.
Definition http_protos.h:3043
msg_hclass_t http_cache_control_class[]
Header class for HTTP Cache-Control header.
Definition http_basic.c:367
@ http_cache_control_hash
Hash of Cache-Control header.
Definition http_protos.h:2810
msg_print_f http_connection_e
Encode (print) a Connection header.
Definition http_protos.h:3079
http_connection_t * http_connection_init(http_connection_t x[1])
Initialize a structure http_connection_t.
Definition http_protos.h:3108
http_connection_t * http_connection_dup(su_home_t *home, http_connection_t const *hdr))
Duplicate (deep copy) http_connection_t.
Definition http_protos.h:3279
msg_parse_f http_connection_d
Decode (parse) a Connection header.
Definition http_protos.h:3076
http_connection_t * http_connection_make(su_home_t *home, char const *s))
Make a header structure http_connection_t.
Definition http_protos.h:3293
msg_hclass_t http_connection_class[]
Header class for HTTP Connection header.
Definition http_basic.c:375
http_connection_t * http_connection_copy(su_home_t *home, http_connection_t const *hdr))
Copy a http_connection_t header structure.
Definition http_protos.h:3286
http_connection_t * http_connection_format(su_home_t *home, char const *fmt,...)))
Make a Connection header from formatting result.
Definition http_protos.h:3266
int http_is_connection(http_header_t const *header)
Test if header object is instance of http_connection_t.
Definition http_protos.h:3132
@ http_connection_hash
Hash of Connection header.
Definition http_protos.h:3060
http_content_encoding_t * http_content_encoding_copy(su_home_t *home, http_content_encoding_t const *hdr))
Copy a http_content_encoding_t header structure.
Definition http_protos.h:12036
http_content_encoding_t * http_content_encoding_init(http_content_encoding_t x[1])
Initialize a structure http_content_encoding_t.
Definition http_protos.h:11858
http_content_encoding_t * http_content_encoding_make(su_home_t *home, char const *s))
Make a header structure http_content_encoding_t.
Definition http_protos.h:12043
http_content_encoding_t * http_content_encoding_dup(su_home_t *home, http_content_encoding_t const *hdr))
Duplicate (deep copy) http_content_encoding_t.
Definition http_protos.h:12029
int http_is_content_encoding(http_header_t const *header)
Test if header object is instance of http_content_encoding_t.
Definition http_protos.h:11882
msg_hclass_t http_content_encoding_class[]
Header class for HTTP Content-Encoding header.
msg_print_f http_content_encoding_e
Encode (print) a Content-Encoding header.
Definition http_protos.h:11829
http_content_encoding_t * http_content_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Encoding header from formatting result.
Definition http_protos.h:12016
msg_parse_f http_content_encoding_d
Decode (parse) a Content-Encoding header.
Definition http_protos.h:11826
@ http_content_encoding_hash
Hash of Content-Encoding header.
Definition http_protos.h:11810
int http_is_content_language(http_header_t const *header)
Test if header object is instance of http_content_language_t.
Definition http_protos.h:12132
http_content_language_t * http_content_language_make(su_home_t *home, char const *s))
Make a header structure http_content_language_t.
Definition http_protos.h:12293
http_content_language_t * http_content_language_dup(su_home_t *home, http_content_language_t const *hdr))
Duplicate (deep copy) http_content_language_t.
Definition http_protos.h:12279
msg_hclass_t http_content_language_class[]
Header class for HTTP Content-Language header.
msg_print_f http_content_language_e
Encode (print) a Content-Language header.
Definition http_protos.h:12079
msg_parse_f http_content_language_d
Decode (parse) a Content-Language header.
Definition http_protos.h:12076
http_content_language_t * http_content_language_copy(su_home_t *home, http_content_language_t const *hdr))
Copy a http_content_language_t header structure.
Definition http_protos.h:12286
http_content_language_t * http_content_language_format(su_home_t *home, char const *fmt,...)))
Make a Content-Language header from formatting result.
Definition http_protos.h:12266
http_content_language_t * http_content_language_init(http_content_language_t x[1])
Initialize a structure http_content_language_t.
Definition http_protos.h:12108
@ http_content_language_hash
Hash of Content-Language header.
Definition http_protos.h:12060
msg_parse_f http_content_length_d
Decode (parse) a Content-Length header.
Definition http_protos.h:12326
http_content_length_t * http_content_length_make(su_home_t *home, char const *s))
Make a header structure http_content_length_t.
Definition http_protos.h:12543
http_content_length_t * http_content_length_init(http_content_length_t x[1])
Initialize a structure http_content_length_t.
Definition http_protos.h:12358
http_content_length_t * http_content_length_format(su_home_t *home, char const *fmt,...)))
Make a Content-Length header from formatting result.
Definition http_protos.h:12516
msg_print_f http_content_length_e
Encode (print) a Content-Length header.
Definition http_protos.h:12329
http_content_length_t * http_content_length_dup(su_home_t *home, http_content_length_t const *hdr))
Duplicate (deep copy) http_content_length_t.
Definition http_protos.h:12529
http_content_length_t * http_content_length_copy(su_home_t *home, http_content_length_t const *hdr))
Copy a http_content_length_t header structure.
Definition http_protos.h:12536
msg_hclass_t http_content_length_class[]
Header class for HTTP Content-Length header.
int http_is_content_length(http_header_t const *header)
Test if header object is instance of http_content_length_t.
Definition http_protos.h:12382
@ http_content_length_hash
Hash of Content-Length header.
Definition http_protos.h:12310
msg_hclass_t http_content_location_class[]
Header class for HTTP Content-Location header.
http_content_location_t * http_content_location_copy(su_home_t *home, http_content_location_t const *hdr))
Copy a http_content_location_t header structure.
Definition http_protos.h:12786
http_content_location_t * http_content_location_format(su_home_t *home, char const *fmt,...)))
Make a Content-Location header from formatting result.
Definition http_protos.h:12766
int http_is_content_location(http_header_t const *header)
Test if header object is instance of http_content_location_t.
Definition http_protos.h:12632
http_content_location_t * http_content_location_init(http_content_location_t x[1])
Initialize a structure http_content_location_t.
Definition http_protos.h:12608
http_content_location_t * http_content_location_make(su_home_t *home, char const *s))
Make a header structure http_content_location_t.
Definition http_protos.h:12793
msg_print_f http_content_location_e
Encode (print) a Content-Location header.
Definition http_protos.h:12579
http_content_location_t * http_content_location_dup(su_home_t *home, http_content_location_t const *hdr))
Duplicate (deep copy) http_content_location_t.
Definition http_protos.h:12779
msg_parse_f http_content_location_d
Decode (parse) a Content-Location header.
Definition http_protos.h:12576
@ http_content_location_hash
Hash of Content-Location header.
Definition http_protos.h:12560
msg_print_f http_content_md5_e
Encode (print) a Content-MD5 header.
Definition http_protos.h:12829
http_content_md5_t * http_content_md5_make(su_home_t *home, char const *s))
Make a header structure http_content_md5_t.
Definition http_protos.h:13043
http_content_md5_t * http_content_md5_copy(su_home_t *home, http_content_md5_t const *hdr))
Copy a http_content_md5_t header structure.
Definition http_protos.h:13036
int http_is_content_md5(http_header_t const *header)
Test if header object is instance of http_content_md5_t.
Definition http_protos.h:12882
msg_parse_f http_content_md5_d
Decode (parse) a Content-MD5 header.
Definition http_protos.h:12826
http_content_md5_t * http_content_md5_init(http_content_md5_t x[1])
Initialize a structure http_content_md5_t.
Definition http_protos.h:12858
msg_hclass_t http_content_md5_class[]
Header class for HTTP Content-MD5 header.
http_content_md5_t * http_content_md5_format(su_home_t *home, char const *fmt,...)))
Make a Content-MD5 header from formatting result.
Definition http_protos.h:13016
http_content_md5_t * http_content_md5_dup(su_home_t *home, http_content_md5_t const *hdr))
Duplicate (deep copy) http_content_md5_t.
Definition http_protos.h:13029
@ http_content_md5_hash
Hash of Content-MD5 header.
Definition http_protos.h:12810
http_content_range_t * http_content_range_dup(su_home_t *home, http_content_range_t const *hdr))
Duplicate (deep copy) http_content_range_t.
Definition http_protos.h:13279
http_content_range_t * http_content_range_copy(su_home_t *home, http_content_range_t const *hdr))
Copy a http_content_range_t header structure.
Definition http_protos.h:13286
int http_is_content_range(http_header_t const *header)
Test if header object is instance of http_content_range_t.
Definition http_protos.h:13132
msg_hclass_t http_content_range_class[]
Header class for HTTP Content-Range header.
Definition http_basic.c:501
msg_parse_f http_content_range_d
Decode (parse) a Content-Range header.
Definition http_protos.h:13076
http_content_range_t * http_content_range_format(su_home_t *home, char const *fmt,...)))
Make a Content-Range header from formatting result.
Definition http_protos.h:13266
msg_print_f http_content_range_e
Encode (print) a Content-Range header.
Definition http_protos.h:13079
http_content_range_t * http_content_range_init(http_content_range_t x[1])
Initialize a structure http_content_range_t.
Definition http_protos.h:13108
http_content_range_t * http_content_range_make(su_home_t *home, char const *s))
Make a header structure http_content_range_t.
Definition http_protos.h:13293
@ http_content_range_hash
Hash of Content-Range header.
Definition http_protos.h:13060
msg_print_f http_content_type_e
Encode (print) a Content-Type header.
Definition http_protos.h:13329
msg_parse_f http_content_type_d
Decode (parse) a Content-Type header.
Definition http_protos.h:13326
http_content_type_t * http_content_type_copy(su_home_t *home, http_content_type_t const *hdr))
Copy a http_content_type_t header structure.
Definition http_protos.h:13536
int http_is_content_type(http_header_t const *header)
Test if header object is instance of http_content_type_t.
Definition http_protos.h:13382
http_content_type_t * http_content_type_dup(su_home_t *home, http_content_type_t const *hdr))
Duplicate (deep copy) http_content_type_t.
Definition http_protos.h:13529
http_content_type_t * http_content_type_init(http_content_type_t x[1])
Initialize a structure http_content_type_t.
Definition http_protos.h:13358
msg_hclass_t http_content_type_class[]
Header class for HTTP Content-Type header.
http_content_type_t * http_content_type_make(su_home_t *home, char const *s))
Make a header structure http_content_type_t.
Definition http_protos.h:13543
http_content_type_t * http_content_type_format(su_home_t *home, char const *fmt,...)))
Make a Content-Type header from formatting result.
Definition http_protos.h:13516
@ http_content_type_hash
Hash of Content-Type header.
Definition http_protos.h:13310
http_date_t * http_date_format(su_home_t *home, char const *fmt,...)))
Make a Date header from formatting result.
Definition http_protos.h:3516
msg_print_f http_date_e
Encode (print) a Date header.
Definition http_protos.h:3329
msg_parse_f http_date_d
Decode (parse) a Date header.
Definition http_protos.h:3326
http_date_t * http_date_copy(su_home_t *home, http_date_t const *hdr))
Copy a http_date_t header structure.
Definition http_protos.h:3536
msg_hclass_t http_date_class[]
Header class for HTTP Date header.
Definition http_basic.c:598
http_date_t * http_date_init(http_date_t x[1])
Initialize a structure http_date_t.
Definition http_protos.h:3358
http_date_t * http_date_dup(su_home_t *home, http_date_t const *hdr))
Duplicate (deep copy) http_date_t.
Definition http_protos.h:3529
int http_is_date(http_header_t const *header)
Test if header object is instance of http_date_t.
Definition http_protos.h:3382
http_date_t * http_date_make(su_home_t *home, char const *s))
Make a header structure http_date_t.
Definition http_protos.h:3543
@ http_date_hash
Hash of Date header.
Definition http_protos.h:3310
http_error_t * http_error_format(su_home_t *home, char const *fmt,...)))
Make a erroneous headers from formatting result.
Definition http_protos.h:14016
msg_hclass_t http_error_class[]
Header class for HTTP erroneous headers.
http_error_t * http_error_make(su_home_t *home, char const *s))
Make a header structure http_error_t.
Definition http_protos.h:14043
msg_parse_f http_error_d
Decode (parse) a erroneous headers.
Definition http_protos.h:13826
int http_is_error(http_header_t const *header)
Test if header object is instance of http_error_t.
Definition http_protos.h:13882
http_error_t * http_error_dup(su_home_t *home, http_error_t const *hdr))
Duplicate (deep copy) http_error_t.
Definition http_protos.h:14029
msg_print_f http_error_e
Encode (print) a erroneous headers.
Definition http_protos.h:13829
http_error_t * http_error_copy(su_home_t *home, http_error_t const *hdr))
Copy a http_error_t header structure.
Definition http_protos.h:14036
http_error_t * http_error_init(http_error_t x[1])
Initialize a structure http_error_t.
Definition http_protos.h:13858
@ http_error_hash
Hash of erroneous headers.
Definition http_protos.h:13810
http_etag_t * http_etag_make(su_home_t *home, char const *s))
Make a header structure http_etag_t.
Definition http_protos.h:3793
http_etag_t * http_etag_format(su_home_t *home, char const *fmt,...)))
Make a ETag header from formatting result.
Definition http_protos.h:3766
http_etag_t * http_etag_dup(su_home_t *home, http_etag_t const *hdr))
Duplicate (deep copy) http_etag_t.
Definition http_protos.h:3779
http_etag_t * http_etag_copy(su_home_t *home, http_etag_t const *hdr))
Copy a http_etag_t header structure.
Definition http_protos.h:3786
msg_parse_f http_etag_d
Decode (parse) a ETag header.
Definition http_protos.h:3576
http_etag_t * http_etag_init(http_etag_t x[1])
Initialize a structure http_etag_t.
Definition http_protos.h:3608
msg_print_f http_etag_e
Encode (print) a ETag header.
Definition http_protos.h:3579
msg_hclass_t http_etag_class[]
Header class for HTTP ETag header.
Definition http_basic.c:608
int http_is_etag(http_header_t const *header)
Test if header object is instance of http_etag_t.
Definition http_protos.h:3632
@ http_etag_hash
Hash of ETag header.
Definition http_protos.h:3560
msg_hclass_t http_expect_class[]
Header class for HTTP Expect header.
Definition http_basic.c:617
msg_print_f http_expect_e
Encode (print) a Expect header.
Definition http_protos.h:3829
int http_is_expect(http_header_t const *header)
Test if header object is instance of http_expect_t.
Definition http_protos.h:3882
http_expect_t * http_expect_copy(su_home_t *home, http_expect_t const *hdr))
Copy a http_expect_t header structure.
Definition http_protos.h:4036
http_expect_t * http_expect_format(su_home_t *home, char const *fmt,...)))
Make a Expect header from formatting result.
Definition http_protos.h:4016
msg_parse_f http_expect_d
Decode (parse) a Expect header.
Definition http_protos.h:3826
http_expect_t * http_expect_make(su_home_t *home, char const *s))
Make a header structure http_expect_t.
Definition http_protos.h:4043
http_expect_t * http_expect_dup(su_home_t *home, http_expect_t const *hdr))
Duplicate (deep copy) http_expect_t.
Definition http_protos.h:4029
http_expect_t * http_expect_init(http_expect_t x[1])
Initialize a structure http_expect_t.
Definition http_protos.h:3858
@ http_expect_hash
Hash of Expect header.
Definition http_protos.h:3810
http_expires_t * http_expires_copy(su_home_t *home, http_expires_t const *hdr))
Copy a http_expires_t header structure.
Definition http_protos.h:4286
msg_hclass_t http_expires_class[]
Header class for HTTP Expires header.
Definition http_basic.c:653
msg_print_f http_expires_e
Encode (print) a Expires header.
Definition http_protos.h:4079
http_expires_t * http_expires_make(su_home_t *home, char const *s))
Make a header structure http_expires_t.
Definition http_protos.h:4293
http_expires_t * http_expires_format(su_home_t *home, char const *fmt,...)))
Make a Expires header from formatting result.
Definition http_protos.h:4266
http_expires_t * http_expires_dup(su_home_t *home, http_expires_t const *hdr))
Duplicate (deep copy) http_expires_t.
Definition http_protos.h:4279
msg_parse_f http_expires_d
Decode (parse) a Expires header.
Definition http_protos.h:4076
int http_is_expires(http_header_t const *header)
Test if header object is instance of http_expires_t.
Definition http_protos.h:4132
http_expires_t * http_expires_init(http_expires_t x[1])
Initialize a structure http_expires_t.
Definition http_protos.h:4108
@ http_expires_hash
Hash of Expires header.
Definition http_protos.h:4060
int http_is_from(http_header_t const *header)
Test if header object is instance of http_from_t.
Definition http_protos.h:4382
http_from_t * http_from_init(http_from_t x[1])
Initialize a structure http_from_t.
Definition http_protos.h:4358
http_from_t * http_from_dup(su_home_t *home, http_from_t const *hdr))
Duplicate (deep copy) http_from_t.
Definition http_protos.h:4529
msg_parse_f http_from_d
Decode (parse) a From header.
Definition http_protos.h:4326
http_from_t * http_from_format(su_home_t *home, char const *fmt,...)))
Make a From header from formatting result.
Definition http_protos.h:4516
msg_hclass_t http_from_class[]
Header class for HTTP From header.
Definition http_basic.c:667
http_from_t * http_from_copy(su_home_t *home, http_from_t const *hdr))
Copy a http_from_t header structure.
Definition http_protos.h:4536
msg_print_f http_from_e
Encode (print) a From header.
Definition http_protos.h:4329
http_from_t * http_from_make(su_home_t *home, char const *s))
Make a header structure http_from_t.
Definition http_protos.h:4543
@ http_from_hash
Hash of From header.
Definition http_protos.h:4310
http_host_t * http_host_dup(su_home_t *home, http_host_t const *hdr))
Duplicate (deep copy) http_host_t.
Definition http_protos.h:4779
msg_parse_f http_host_d
Decode (parse) a Host header.
Definition http_protos.h:4576
int http_is_host(http_header_t const *header)
Test if header object is instance of http_host_t.
Definition http_protos.h:4632
msg_print_f http_host_e
Encode (print) a Host header.
Definition http_protos.h:4579
http_host_t * http_host_make(su_home_t *home, char const *s))
Make a header structure http_host_t.
Definition http_protos.h:4793
http_host_t * http_host_copy(su_home_t *home, http_host_t const *hdr))
Copy a http_host_t header structure.
Definition http_protos.h:4786
http_host_t * http_host_format(su_home_t *home, char const *fmt,...)))
Make a Host header from formatting result.
Definition http_protos.h:4766
msg_hclass_t http_host_class[]
Header class for HTTP Host header.
Definition http_basic.c:750
http_host_t * http_host_init(http_host_t x[1])
Initialize a structure http_host_t.
Definition http_protos.h:4608
@ http_host_hash
Hash of Host header.
Definition http_protos.h:4560
http_if_match_t * http_if_match_copy(su_home_t *home, http_if_match_t const *hdr))
Copy a http_if_match_t header structure.
Definition http_protos.h:5036
msg_print_f http_if_match_e
Encode (print) a If-Match header.
Definition http_protos.h:4829
http_if_match_t * http_if_match_make(su_home_t *home, char const *s))
Make a header structure http_if_match_t.
Definition http_protos.h:5043
http_if_match_t * http_if_match_format(su_home_t *home, char const *fmt,...)))
Make a If-Match header from formatting result.
Definition http_protos.h:5016
msg_parse_f http_if_match_d
Decode (parse) a If-Match header.
Definition http_protos.h:4826
msg_hclass_t http_if_match_class[]
Header class for HTTP If-Match header.
Definition http_basic.c:758
http_if_match_t * http_if_match_dup(su_home_t *home, http_if_match_t const *hdr))
Duplicate (deep copy) http_if_match_t.
Definition http_protos.h:5029
http_if_match_t * http_if_match_init(http_if_match_t x[1])
Initialize a structure http_if_match_t.
Definition http_protos.h:4858
int http_is_if_match(http_header_t const *header)
Test if header object is instance of http_if_match_t.
Definition http_protos.h:4882
@ http_if_match_hash
Hash of If-Match header.
Definition http_protos.h:4810
msg_parse_f http_if_modified_since_d
Decode (parse) a If-Modified-Since header.
Definition http_protos.h:5076
http_if_modified_since_t * http_if_modified_since_make(su_home_t *home, char const *s))
Make a header structure http_if_modified_since_t.
Definition http_protos.h:5293
http_if_modified_since_t * http_if_modified_since_copy(su_home_t *home, http_if_modified_since_t const *hdr))
Copy a http_if_modified_since_t header structure.
Definition http_protos.h:5286
http_if_modified_since_t * http_if_modified_since_format(su_home_t *home, char const *fmt,...)))
Make a If-Modified-Since header from formatting result.
Definition http_protos.h:5266
msg_hclass_t http_if_modified_since_class[]
Header class for HTTP If-Modified-Since header.
Definition http_basic.c:796
http_if_modified_since_t * http_if_modified_since_init(http_if_modified_since_t x[1])
Initialize a structure http_if_modified_since_t.
Definition http_protos.h:5108
int http_is_if_modified_since(http_header_t const *header)
Test if header object is instance of http_if_modified_since_t.
Definition http_protos.h:5132
msg_print_f http_if_modified_since_e
Encode (print) a If-Modified-Since header.
Definition http_protos.h:5079
http_if_modified_since_t * http_if_modified_since_dup(su_home_t *home, http_if_modified_since_t const *hdr))
Duplicate (deep copy) http_if_modified_since_t.
Definition http_protos.h:5279
@ http_if_modified_since_hash
Hash of If-Modified-Since header.
Definition http_protos.h:5060
http_if_none_match_t * http_if_none_match_make(su_home_t *home, char const *s))
Make a header structure http_if_none_match_t.
Definition http_protos.h:5543
msg_print_f http_if_none_match_e
Encode (print) a If-None-Match header.
Definition http_protos.h:5329
msg_parse_f http_if_none_match_d
Decode (parse) a If-None-Match header.
Definition http_protos.h:5326
http_if_none_match_t * http_if_none_match_copy(su_home_t *home, http_if_none_match_t const *hdr))
Copy a http_if_none_match_t header structure.
Definition http_protos.h:5536
http_if_none_match_t * http_if_none_match_format(su_home_t *home, char const *fmt,...)))
Make a If-None-Match header from formatting result.
Definition http_protos.h:5516
http_if_none_match_t * http_if_none_match_init(http_if_none_match_t x[1])
Initialize a structure http_if_none_match_t.
Definition http_protos.h:5358
msg_hclass_t http_if_none_match_class[]
Header class for HTTP If-None-Match header.
Definition http_basic.c:805
int http_is_if_none_match(http_header_t const *header)
Test if header object is instance of http_if_none_match_t.
Definition http_protos.h:5382
http_if_none_match_t * http_if_none_match_dup(su_home_t *home, http_if_none_match_t const *hdr))
Duplicate (deep copy) http_if_none_match_t.
Definition http_protos.h:5529
@ http_if_none_match_hash
Hash of If-None-Match header.
Definition http_protos.h:5310
msg_parse_f http_if_range_d
Decode (parse) a If-Range header.
Definition http_protos.h:5576
http_if_range_t * http_if_range_make(su_home_t *home, char const *s))
Make a header structure http_if_range_t.
Definition http_protos.h:5793
http_if_range_t * http_if_range_copy(su_home_t *home, http_if_range_t const *hdr))
Copy a http_if_range_t header structure.
Definition http_protos.h:5786
http_if_range_t * http_if_range_format(su_home_t *home, char const *fmt,...)))
Make a If-Range header from formatting result.
Definition http_protos.h:5766
msg_hclass_t http_if_range_class[]
Header class for HTTP If-Range header.
Definition http_basic.c:876
msg_print_f http_if_range_e
Encode (print) a If-Range header.
Definition http_protos.h:5579
http_if_range_t * http_if_range_init(http_if_range_t x[1])
Initialize a structure http_if_range_t.
Definition http_protos.h:5608
http_if_range_t * http_if_range_dup(su_home_t *home, http_if_range_t const *hdr))
Duplicate (deep copy) http_if_range_t.
Definition http_protos.h:5779
int http_is_if_range(http_header_t const *header)
Test if header object is instance of http_if_range_t.
Definition http_protos.h:5632
@ http_if_range_hash
Hash of If-Range header.
Definition http_protos.h:5560
http_if_unmodified_since_t * http_if_unmodified_since_init(http_if_unmodified_since_t x[1])
Initialize a structure http_if_unmodified_since_t.
Definition http_protos.h:5858
msg_print_f http_if_unmodified_since_e
Encode (print) a If-Unmodified-Since header.
Definition http_protos.h:5829
msg_hclass_t http_if_unmodified_since_class[]
Header class for HTTP If-Unmodified-Since header.
Definition http_basic.c:915
http_if_unmodified_since_t * http_if_unmodified_since_dup(su_home_t *home, http_if_unmodified_since_t const *hdr))
Duplicate (deep copy) http_if_unmodified_since_t.
Definition http_protos.h:6029
msg_parse_f http_if_unmodified_since_d
Decode (parse) a If-Unmodified-Since header.
Definition http_protos.h:5826
http_if_unmodified_since_t * http_if_unmodified_since_copy(su_home_t *home, http_if_unmodified_since_t const *hdr))
Copy a http_if_unmodified_since_t header structure.
Definition http_protos.h:6036
int http_is_if_unmodified_since(http_header_t const *header)
Test if header object is instance of http_if_unmodified_since_t.
Definition http_protos.h:5882
http_if_unmodified_since_t * http_if_unmodified_since_format(su_home_t *home, char const *fmt,...)))
Make a If-Unmodified-Since header from formatting result.
Definition http_protos.h:6016
http_if_unmodified_since_t * http_if_unmodified_since_make(su_home_t *home, char const *s))
Make a header structure http_if_unmodified_since_t.
Definition http_protos.h:6043
@ http_if_unmodified_since_hash
Hash of If-Unmodified-Since header.
Definition http_protos.h:5810
http_last_modified_t * http_last_modified_init(http_last_modified_t x[1])
Initialize a structure http_last_modified_t.
Definition http_protos.h:6108
msg_print_f http_last_modified_e
Encode (print) a Last-Modified header.
Definition http_protos.h:6079
http_last_modified_t * http_last_modified_copy(su_home_t *home, http_last_modified_t const *hdr))
Copy a http_last_modified_t header structure.
Definition http_protos.h:6286
msg_hclass_t http_last_modified_class[]
Header class for HTTP Last-Modified header.
Definition http_basic.c:951
int http_is_last_modified(http_header_t const *header)
Test if header object is instance of http_last_modified_t.
Definition http_protos.h:6132
http_last_modified_t * http_last_modified_format(su_home_t *home, char const *fmt,...)))
Make a Last-Modified header from formatting result.
Definition http_protos.h:6266
http_last_modified_t * http_last_modified_make(su_home_t *home, char const *s))
Make a header structure http_last_modified_t.
Definition http_protos.h:6293
msg_parse_f http_last_modified_d
Decode (parse) a Last-Modified header.
Definition http_protos.h:6076
http_last_modified_t * http_last_modified_dup(su_home_t *home, http_last_modified_t const *hdr))
Duplicate (deep copy) http_last_modified_t.
Definition http_protos.h:6279
@ http_last_modified_hash
Hash of Last-Modified header.
Definition http_protos.h:6060
http_location_t * http_location_copy(su_home_t *home, http_location_t const *hdr))
Copy a http_location_t header structure.
Definition http_protos.h:6536
msg_parse_f http_location_d
Decode (parse) a Location header.
Definition http_protos.h:6326
msg_hclass_t http_location_class[]
Header class for HTTP Location header.
Definition http_basic.c:1026
msg_print_f http_location_e
Encode (print) a Location header.
Definition http_protos.h:6329
http_location_t * http_location_make(su_home_t *home, char const *s))
Make a header structure http_location_t.
Definition http_protos.h:6543
http_location_t * http_location_dup(su_home_t *home, http_location_t const *hdr))
Duplicate (deep copy) http_location_t.
Definition http_protos.h:6529
http_location_t * http_location_init(http_location_t x[1])
Initialize a structure http_location_t.
Definition http_protos.h:6358
http_location_t * http_location_format(su_home_t *home, char const *fmt,...)))
Make a Location header from formatting result.
Definition http_protos.h:6516
int http_is_location(http_header_t const *header)
Test if header object is instance of http_location_t.
Definition http_protos.h:6382
@ http_location_hash
Hash of Location header.
Definition http_protos.h:6310
msg_print_f http_max_forwards_e
Encode (print) a Max-Forwards header.
Definition http_protos.h:6579
int http_is_max_forwards(http_header_t const *header)
Test if header object is instance of http_max_forwards_t.
Definition http_protos.h:6632
msg_hclass_t http_max_forwards_class[]
Header class for HTTP Max-Forwards header.
Definition http_basic.c:1034
msg_parse_f http_max_forwards_d
Decode (parse) a Max-Forwards header.
Definition http_protos.h:6576
http_max_forwards_t * http_max_forwards_make(su_home_t *home, char const *s))
Make a header structure http_max_forwards_t.
Definition http_protos.h:6793
http_max_forwards_t * http_max_forwards_format(su_home_t *home, char const *fmt,...)))
Make a Max-Forwards header from formatting result.
Definition http_protos.h:6766
http_max_forwards_t * http_max_forwards_dup(su_home_t *home, http_max_forwards_t const *hdr))
Duplicate (deep copy) http_max_forwards_t.
Definition http_protos.h:6779
http_max_forwards_t * http_max_forwards_init(http_max_forwards_t x[1])
Initialize a structure http_max_forwards_t.
Definition http_protos.h:6608
http_max_forwards_t * http_max_forwards_copy(su_home_t *home, http_max_forwards_t const *hdr))
Copy a http_max_forwards_t header structure.
Definition http_protos.h:6786
@ http_max_forwards_hash
Hash of Max-Forwards header.
Definition http_protos.h:6560
msg_print_f http_mime_version_e
Encode (print) a MIME-Version header.
Definition http_protos.h:11579
http_mime_version_t * http_mime_version_dup(su_home_t *home, http_mime_version_t const *hdr))
Duplicate (deep copy) http_mime_version_t.
Definition http_protos.h:11779
http_mime_version_t * http_mime_version_format(su_home_t *home, char const *fmt,...)))
Make a MIME-Version header from formatting result.
Definition http_protos.h:11766
http_mime_version_t * http_mime_version_init(http_mime_version_t x[1])
Initialize a structure http_mime_version_t.
Definition http_protos.h:11608
int http_is_mime_version(http_header_t const *header)
Test if header object is instance of http_mime_version_t.
Definition http_protos.h:11632
http_mime_version_t * http_mime_version_copy(su_home_t *home, http_mime_version_t const *hdr))
Copy a http_mime_version_t header structure.
Definition http_protos.h:11786
msg_parse_f http_mime_version_d
Decode (parse) a MIME-Version header.
Definition http_protos.h:11576
http_mime_version_t * http_mime_version_make(su_home_t *home, char const *s))
Make a header structure http_mime_version_t.
Definition http_protos.h:11793
msg_hclass_t http_mime_version_class[]
Header class for HTTP MIME-Version header.
@ http_mime_version_hash
Hash of MIME-Version header.
Definition http_protos.h:11560
http_payload_t * http_payload_dup(su_home_t *home, http_payload_t const *hdr))
Duplicate (deep copy) http_payload_t.
Definition http_protos.h:14529
http_payload_t * http_payload_make(su_home_t *home, char const *s))
Make a header structure http_payload_t.
Definition http_protos.h:14543
http_payload_t * http_payload_copy(su_home_t *home, http_payload_t const *hdr))
Copy a http_payload_t header structure.
Definition http_protos.h:14536
msg_print_f http_payload_e
Encode (print) a message payload.
Definition http_protos.h:14329
http_payload_t * http_payload_init(http_payload_t x[1])
Initialize a structure http_payload_t.
Definition http_protos.h:14358
http_payload_t * http_payload_format(su_home_t *home, char const *fmt,...)))
Make a message payload from formatting result.
Definition http_protos.h:14516
int http_is_payload(http_header_t const *header)
Test if header object is instance of http_payload_t.
Definition http_protos.h:14382
msg_hclass_t http_payload_class[]
Header class for HTTP message payload.
msg_parse_f http_payload_d
Decode (parse) a message payload.
Definition http_protos.h:14326
@ http_payload_hash
Hash of message payload.
Definition http_protos.h:14310
http_pragma_t * http_pragma_make(su_home_t *home, char const *s))
Make a header structure http_pragma_t.
Definition http_protos.h:7043
int http_is_pragma(http_header_t const *header)
Test if header object is instance of http_pragma_t.
Definition http_protos.h:6882
http_pragma_t * http_pragma_copy(su_home_t *home, http_pragma_t const *hdr))
Copy a http_pragma_t header structure.
Definition http_protos.h:7036
http_pragma_t * http_pragma_init(http_pragma_t x[1])
Initialize a structure http_pragma_t.
Definition http_protos.h:6858
http_pragma_t * http_pragma_format(su_home_t *home, char const *fmt,...)))
Make a Pragma header from formatting result.
Definition http_protos.h:7016
msg_parse_f http_pragma_d
Decode (parse) a Pragma header.
Definition http_protos.h:6826
http_pragma_t * http_pragma_dup(su_home_t *home, http_pragma_t const *hdr))
Duplicate (deep copy) http_pragma_t.
Definition http_protos.h:7029
msg_print_f http_pragma_e
Encode (print) a Pragma header.
Definition http_protos.h:6829
msg_hclass_t http_pragma_class[]
Header class for HTTP Pragma header.
Definition http_basic.c:1042
@ http_pragma_hash
Hash of Pragma header.
Definition http_protos.h:6810
http_proxy_authenticate_t * http_proxy_authenticate_copy(su_home_t *home, http_proxy_authenticate_t const *hdr))
Copy a http_proxy_authenticate_t header structure.
Definition http_protos.h:7286
http_proxy_authenticate_t * http_proxy_authenticate_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Authenticate header from formatting result.
Definition http_protos.h:7266
msg_print_f http_proxy_authenticate_e
Encode (print) a Proxy-Authenticate header.
Definition http_protos.h:7079
http_proxy_authenticate_t * http_proxy_authenticate_dup(su_home_t *home, http_proxy_authenticate_t const *hdr))
Duplicate (deep copy) http_proxy_authenticate_t.
Definition http_protos.h:7279
msg_parse_f http_proxy_authenticate_d
Decode (parse) a Proxy-Authenticate header.
Definition http_protos.h:7076
http_proxy_authenticate_t * http_proxy_authenticate_make(su_home_t *home, char const *s))
Make a header structure http_proxy_authenticate_t.
Definition http_protos.h:7293
msg_hclass_t http_proxy_authenticate_class[]
Header class for HTTP Proxy-Authenticate header.
Definition http_basic.c:1051
http_proxy_authenticate_t * http_proxy_authenticate_init(http_proxy_authenticate_t x[1])
Initialize a structure http_proxy_authenticate_t.
Definition http_protos.h:7108
int http_is_proxy_authenticate(http_header_t const *header)
Test if header object is instance of http_proxy_authenticate_t.
Definition http_protos.h:7132
@ http_proxy_authenticate_hash
Hash of Proxy-Authenticate header.
Definition http_protos.h:7060
http_proxy_authorization_t * http_proxy_authorization_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Authorization header from formatting result.
Definition http_protos.h:7516
http_proxy_authorization_t * http_proxy_authorization_copy(su_home_t *home, http_proxy_authorization_t const *hdr))
Copy a http_proxy_authorization_t header structure.
Definition http_protos.h:7536
http_proxy_authorization_t * http_proxy_authorization_dup(su_home_t *home, http_proxy_authorization_t const *hdr))
Duplicate (deep copy) http_proxy_authorization_t.
Definition http_protos.h:7529
int http_is_proxy_authorization(http_header_t const *header)
Test if header object is instance of http_proxy_authorization_t.
Definition http_protos.h:7382
http_proxy_authorization_t * http_proxy_authorization_make(su_home_t *home, char const *s))
Make a header structure http_proxy_authorization_t.
Definition http_protos.h:7543
msg_parse_f http_proxy_authorization_d
Decode (parse) a Proxy-Authorization header.
Definition http_protos.h:7326
http_proxy_authorization_t * http_proxy_authorization_init(http_proxy_authorization_t x[1])
Initialize a structure http_proxy_authorization_t.
Definition http_protos.h:7358
msg_hclass_t http_proxy_authorization_class[]
Header class for HTTP Proxy-Authorization header.
Definition http_basic.c:1060
msg_print_f http_proxy_authorization_e
Encode (print) a Proxy-Authorization header.
Definition http_protos.h:7329
@ http_proxy_authorization_hash
Hash of Proxy-Authorization header.
Definition http_protos.h:7310
int http_is_proxy_connection(http_header_t const *header)
Test if header object is instance of http_proxy_connection_t.
Definition http_protos.h:10882
http_proxy_connection_t * http_proxy_connection_dup(su_home_t *home, http_proxy_connection_t const *hdr))
Duplicate (deep copy) http_proxy_connection_t.
Definition http_protos.h:11029
http_proxy_connection_t * http_proxy_connection_init(http_proxy_connection_t x[1])
Initialize a structure http_proxy_connection_t.
Definition http_protos.h:10858
http_proxy_connection_t * http_proxy_connection_make(su_home_t *home, char const *s))
Make a header structure http_proxy_connection_t.
Definition http_protos.h:11043
http_proxy_connection_t * http_proxy_connection_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Connection header from formatting result.
Definition http_protos.h:11016
msg_print_f http_proxy_connection_e
Encode (print) a Proxy-Connection header.
Definition http_protos.h:10829
http_proxy_connection_t * http_proxy_connection_copy(su_home_t *home, http_proxy_connection_t const *hdr))
Copy a http_proxy_connection_t header structure.
Definition http_protos.h:11036
msg_hclass_t http_proxy_connection_class[]
Header class for HTTP Proxy-Connection header.
Definition http_extra.c:56
msg_parse_f http_proxy_connection_d
Decode (parse) a Proxy-Connection header.
Definition http_protos.h:10826
@ http_proxy_connection_hash
Hash of Proxy-Connection header.
Definition http_protos.h:10810
http_range_t * http_range_dup(su_home_t *home, http_range_t const *hdr))
Duplicate (deep copy) http_range_t.
Definition http_protos.h:7779
http_range_t * http_range_init(http_range_t x[1])
Initialize a structure http_range_t.
Definition http_protos.h:7608
http_range_t * http_range_format(su_home_t *home, char const *fmt,...)))
Make a Range header from formatting result.
Definition http_protos.h:7766
http_range_t * http_range_copy(su_home_t *home, http_range_t const *hdr))
Copy a http_range_t header structure.
Definition http_protos.h:7786
msg_print_f http_range_e
Encode (print) a Range header.
Definition http_protos.h:7579
http_range_t * http_range_make(su_home_t *home, char const *s))
Make a header structure http_range_t.
Definition http_protos.h:7793
msg_parse_f http_range_d
Decode (parse) a Range header.
Definition http_protos.h:7576
int http_is_range(http_header_t const *header)
Test if header object is instance of http_range_t.
Definition http_protos.h:7632
msg_hclass_t http_range_class[]
Header class for HTTP Range header.
Definition http_basic.c:1213
@ http_range_hash
Hash of Range header.
Definition http_protos.h:7560
http_referer_t * http_referer_format(su_home_t *home, char const *fmt,...)))
Make a Referer header from formatting result.
Definition http_protos.h:8016
http_referer_t * http_referer_copy(su_home_t *home, http_referer_t const *hdr))
Copy a http_referer_t header structure.
Definition http_protos.h:8036
msg_hclass_t http_referer_class[]
Header class for HTTP Referer header.
Definition http_basic.c:1251
http_referer_t * http_referer_make(su_home_t *home, char const *s))
Make a header structure http_referer_t.
Definition http_protos.h:8043
msg_parse_f http_referer_d
Decode (parse) a Referer header.
Definition http_protos.h:7826
http_referer_t * http_referer_dup(su_home_t *home, http_referer_t const *hdr))
Duplicate (deep copy) http_referer_t.
Definition http_protos.h:8029
msg_print_f http_referer_e
Encode (print) a Referer header.
Definition http_protos.h:7829
http_referer_t * http_referer_init(http_referer_t x[1])
Initialize a structure http_referer_t.
Definition http_protos.h:7858
int http_is_referer(http_header_t const *header)
Test if header object is instance of http_referer_t.
Definition http_protos.h:7882
@ http_referer_hash
Hash of Referer header.
Definition http_protos.h:7810
http_request_t * http_request_init(http_request_t x[1])
Initialize a structure http_request_t.
Definition http_protos.h:108
msg_parse_f http_request_d
Decode (parse) a request line.
Definition http_protos.h:76
http_request_t * http_request_make(su_home_t *home, char const *s))
Make a header structure http_request_t.
Definition http_protos.h:293
msg_print_f http_request_e
Encode (print) a request line.
Definition http_protos.h:79
http_request_t * http_request_dup(su_home_t *home, http_request_t const *hdr))
Duplicate (deep copy) http_request_t.
Definition http_protos.h:279
msg_hclass_t http_request_class[]
Header class for HTTP request line.
Definition http_basic.c:180
http_request_t * http_request_copy(su_home_t *home, http_request_t const *hdr))
Copy a http_request_t header structure.
Definition http_protos.h:286
http_request_t * http_request_format(su_home_t *home, char const *fmt,...)))
Make a request line from formatting result.
Definition http_protos.h:266
int http_is_request(http_header_t const *header)
Test if header object is instance of http_request_t.
Definition http_protos.h:132
@ http_request_hash
Hash of request line.
Definition http_protos.h:60
msg_hclass_t http_retry_after_class[]
Header class for HTTP Retry-After header.
Definition http_basic.c:1317
http_retry_after_t * http_retry_after_format(su_home_t *home, char const *fmt,...)))
Make a Retry-After header from formatting result.
Definition http_protos.h:8266
int http_is_retry_after(http_header_t const *header)
Test if header object is instance of http_retry_after_t.
Definition http_protos.h:8132
http_retry_after_t * http_retry_after_copy(su_home_t *home, http_retry_after_t const *hdr))
Copy a http_retry_after_t header structure.
Definition http_protos.h:8286
http_retry_after_t * http_retry_after_init(http_retry_after_t x[1])
Initialize a structure http_retry_after_t.
Definition http_protos.h:8108
http_retry_after_t * http_retry_after_make(su_home_t *home, char const *s))
Make a header structure http_retry_after_t.
Definition http_protos.h:8293
msg_parse_f http_retry_after_d
Decode (parse) a Retry-After header.
Definition http_protos.h:8076
http_retry_after_t * http_retry_after_dup(su_home_t *home, http_retry_after_t const *hdr))
Duplicate (deep copy) http_retry_after_t.
Definition http_protos.h:8279
msg_print_f http_retry_after_e
Encode (print) a Retry-After header.
Definition http_protos.h:8079
@ http_retry_after_hash
Hash of Retry-After header.
Definition http_protos.h:8060
http_separator_t * http_separator_make(su_home_t *home, char const *s))
Make a header structure http_separator_t.
Definition http_protos.h:14293
msg_parse_f http_separator_d
Decode (parse) a separator line between headers and body.
Definition http_protos.h:14076
http_separator_t * http_separator_init(http_separator_t x[1])
Initialize a structure http_separator_t.
Definition http_protos.h:14108
http_separator_t * http_separator_copy(su_home_t *home, http_separator_t const *hdr))
Copy a http_separator_t header structure.
Definition http_protos.h:14286
int http_is_separator(http_header_t const *header)
Test if header object is instance of http_separator_t.
Definition http_protos.h:14132
msg_print_f http_separator_e
Encode (print) a separator line between headers and body.
Definition http_protos.h:14079
http_separator_t * http_separator_dup(su_home_t *home, http_separator_t const *hdr))
Duplicate (deep copy) http_separator_t.
Definition http_protos.h:14279
http_separator_t * http_separator_format(su_home_t *home, char const *fmt,...)))
Make a separator line between headers and body from formatting result.
Definition http_protos.h:14266
msg_hclass_t http_separator_class[]
Header class for HTTP separator line between headers and body.
@ http_separator_hash
Hash of separator line between headers and body.
Definition http_protos.h:14060
http_server_t * http_server_format(su_home_t *home, char const *fmt,...)))
Make a Server header from formatting result.
Definition http_protos.h:8516
http_server_t * http_server_dup(su_home_t *home, http_server_t const *hdr))
Duplicate (deep copy) http_server_t.
Definition http_protos.h:8529
http_server_t * http_server_copy(su_home_t *home, http_server_t const *hdr))
Copy a http_server_t header structure.
Definition http_protos.h:8536
msg_hclass_t http_server_class[]
Header class for HTTP Server header.
Definition http_basic.c:1325
int http_is_server(http_header_t const *header)
Test if header object is instance of http_server_t.
Definition http_protos.h:8382
msg_parse_f http_server_d
Decode (parse) a Server header.
Definition http_protos.h:8326
msg_print_f http_server_e
Encode (print) a Server header.
Definition http_protos.h:8329
http_server_t * http_server_make(su_home_t *home, char const *s))
Make a header structure http_server_t.
Definition http_protos.h:8543
http_server_t * http_server_init(http_server_t x[1])
Initialize a structure http_server_t.
Definition http_protos.h:8358
@ http_server_hash
Hash of Server header.
Definition http_protos.h:8310
http_status_t * http_status_dup(su_home_t *home, http_status_t const *hdr))
Duplicate (deep copy) http_status_t.
Definition http_protos.h:529
http_status_t * http_status_format(su_home_t *home, char const *fmt,...)))
Make a status line from formatting result.
Definition http_protos.h:516
msg_hclass_t http_status_class[]
Header class for HTTP status line.
Definition http_basic.c:282
http_status_t * http_status_init(http_status_t x[1])
Initialize a structure http_status_t.
Definition http_protos.h:358
msg_print_f http_status_e
Encode (print) a status line.
Definition http_protos.h:329
http_status_t * http_status_make(su_home_t *home, char const *s))
Make a header structure http_status_t.
Definition http_protos.h:543
http_status_t * http_status_copy(su_home_t *home, http_status_t const *hdr))
Copy a http_status_t header structure.
Definition http_protos.h:536
msg_parse_f http_status_d
Decode (parse) a status line.
Definition http_protos.h:326
int http_is_status(http_header_t const *header)
Test if header object is instance of http_status_t.
Definition http_protos.h:382
@ http_status_hash
Hash of status line.
Definition http_protos.h:310
http_te_t * http_te_format(su_home_t *home, char const *fmt,...)))
Make a TE header from formatting result.
Definition http_protos.h:8766
http_te_t * http_te_make(su_home_t *home, char const *s))
Make a header structure http_te_t.
Definition http_protos.h:8793
http_te_t * http_te_init(http_te_t x[1])
Initialize a structure http_te_t.
Definition http_protos.h:8608
int http_is_te(http_header_t const *header)
Test if header object is instance of http_te_t.
Definition http_protos.h:8632
http_te_t * http_te_dup(su_home_t *home, http_te_t const *hdr))
Duplicate (deep copy) http_te_t.
Definition http_protos.h:8779
msg_print_f http_te_e
Encode (print) a TE header.
Definition http_protos.h:8579
msg_parse_f http_te_d
Decode (parse) a TE header.
Definition http_protos.h:8576
http_te_t * http_te_copy(su_home_t *home, http_te_t const *hdr))
Copy a http_te_t header structure.
Definition http_protos.h:8786
msg_hclass_t http_te_class[]
Header class for HTTP TE header.
Definition http_basic.c:1443
@ http_te_hash
Hash of TE header.
Definition http_protos.h:8560
http_trailer_t * http_trailer_dup(su_home_t *home, http_trailer_t const *hdr))
Duplicate (deep copy) http_trailer_t.
Definition http_protos.h:9029
msg_print_f http_trailer_e
Encode (print) a Trailer header.
Definition http_protos.h:8829
http_trailer_t * http_trailer_format(su_home_t *home, char const *fmt,...)))
Make a Trailer header from formatting result.
Definition http_protos.h:9016
int http_is_trailer(http_header_t const *header)
Test if header object is instance of http_trailer_t.
Definition http_protos.h:8882
http_trailer_t * http_trailer_init(http_trailer_t x[1])
Initialize a structure http_trailer_t.
Definition http_protos.h:8858
http_trailer_t * http_trailer_copy(su_home_t *home, http_trailer_t const *hdr))
Copy a http_trailer_t header structure.
Definition http_protos.h:9036
msg_parse_f http_trailer_d
Decode (parse) a Trailer header.
Definition http_protos.h:8826
http_trailer_t * http_trailer_make(su_home_t *home, char const *s))
Make a header structure http_trailer_t.
Definition http_protos.h:9043
msg_hclass_t http_trailer_class[]
Header class for HTTP Trailer header.
Definition http_basic.c:1451
@ http_trailer_hash
Hash of Trailer header.
Definition http_protos.h:8810
msg_print_f http_transfer_encoding_e
Encode (print) a Transfer-Encoding header.
Definition http_protos.h:9079
msg_hclass_t http_transfer_encoding_class[]
Header class for HTTP Transfer-Encoding header.
Definition http_basic.c:1460
msg_parse_f http_transfer_encoding_d
Decode (parse) a Transfer-Encoding header.
Definition http_protos.h:9076
http_transfer_encoding_t * http_transfer_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Transfer-Encoding header from formatting result.
Definition http_protos.h:9266
http_transfer_encoding_t * http_transfer_encoding_make(su_home_t *home, char const *s))
Make a header structure http_transfer_encoding_t.
Definition http_protos.h:9293
http_transfer_encoding_t * http_transfer_encoding_dup(su_home_t *home, http_transfer_encoding_t const *hdr))
Duplicate (deep copy) http_transfer_encoding_t.
Definition http_protos.h:9279
int http_is_transfer_encoding(http_header_t const *header)
Test if header object is instance of http_transfer_encoding_t.
Definition http_protos.h:9132
http_transfer_encoding_t * http_transfer_encoding_copy(su_home_t *home, http_transfer_encoding_t const *hdr))
Copy a http_transfer_encoding_t header structure.
Definition http_protos.h:9286
http_transfer_encoding_t * http_transfer_encoding_init(http_transfer_encoding_t x[1])
Initialize a structure http_transfer_encoding_t.
Definition http_protos.h:9108
@ http_transfer_encoding_hash
Hash of Transfer-Encoding header.
Definition http_protos.h:9060
http_unknown_t * http_unknown_init(http_unknown_t x[1])
Initialize a structure http_unknown_t.
Definition http_protos.h:13608
http_unknown_t * http_unknown_copy(su_home_t *home, http_unknown_t const *hdr))
Copy a http_unknown_t header structure.
Definition http_protos.h:13786
http_unknown_t * http_unknown_format(su_home_t *home, char const *fmt,...)))
Make a unknown headers from formatting result.
Definition http_protos.h:13766
int http_is_unknown(http_header_t const *header)
Test if header object is instance of http_unknown_t.
Definition http_protos.h:13632
msg_print_f http_unknown_e
Encode (print) a unknown headers.
Definition http_protos.h:13579
msg_parse_f http_unknown_d
Decode (parse) a unknown headers.
Definition http_protos.h:13576
http_unknown_t * http_unknown_make(su_home_t *home, char const *s))
Make a header structure http_unknown_t.
Definition http_protos.h:13793
http_unknown_t * http_unknown_dup(su_home_t *home, http_unknown_t const *hdr))
Duplicate (deep copy) http_unknown_t.
Definition http_protos.h:13779
msg_hclass_t http_unknown_class[]
Header class for HTTP unknown headers.
@ http_unknown_hash
Hash of unknown headers.
Definition http_protos.h:13560
http_upgrade_t * http_upgrade_dup(su_home_t *home, http_upgrade_t const *hdr))
Duplicate (deep copy) http_upgrade_t.
Definition http_protos.h:9529
int http_is_upgrade(http_header_t const *header)
Test if header object is instance of http_upgrade_t.
Definition http_protos.h:9382
http_upgrade_t * http_upgrade_init(http_upgrade_t x[1])
Initialize a structure http_upgrade_t.
Definition http_protos.h:9358
http_upgrade_t * http_upgrade_copy(su_home_t *home, http_upgrade_t const *hdr))
Copy a http_upgrade_t header structure.
Definition http_protos.h:9536
http_upgrade_t * http_upgrade_make(su_home_t *home, char const *s))
Make a header structure http_upgrade_t.
Definition http_protos.h:9543
msg_print_f http_upgrade_e
Encode (print) a Upgrade header.
Definition http_protos.h:9329
msg_parse_f http_upgrade_d
Decode (parse) a Upgrade header.
Definition http_protos.h:9326
http_upgrade_t * http_upgrade_format(su_home_t *home, char const *fmt,...)))
Make a Upgrade header from formatting result.
Definition http_protos.h:9516
msg_hclass_t http_upgrade_class[]
Header class for HTTP Upgrade header.
Definition http_basic.c:1468
@ http_upgrade_hash
Hash of Upgrade header.
Definition http_protos.h:9310
msg_print_f http_user_agent_e
Encode (print) a User-Agent header.
Definition http_protos.h:9579
http_user_agent_t * http_user_agent_format(su_home_t *home, char const *fmt,...)))
Make a User-Agent header from formatting result.
Definition http_protos.h:9766
http_user_agent_t * http_user_agent_make(su_home_t *home, char const *s))
Make a header structure http_user_agent_t.
Definition http_protos.h:9793
int http_is_user_agent(http_header_t const *header)
Test if header object is instance of http_user_agent_t.
Definition http_protos.h:9632
msg_parse_f http_user_agent_d
Decode (parse) a User-Agent header.
Definition http_protos.h:9576
http_user_agent_t * http_user_agent_copy(su_home_t *home, http_user_agent_t const *hdr))
Copy a http_user_agent_t header structure.
Definition http_protos.h:9786
http_user_agent_t * http_user_agent_init(http_user_agent_t x[1])
Initialize a structure http_user_agent_t.
Definition http_protos.h:9608
http_user_agent_t * http_user_agent_dup(su_home_t *home, http_user_agent_t const *hdr))
Duplicate (deep copy) http_user_agent_t.
Definition http_protos.h:9779
msg_hclass_t http_user_agent_class[]
Header class for HTTP User-Agent header.
Definition http_basic.c:1476
@ http_user_agent_hash
Hash of User-Agent header.
Definition http_protos.h:9560
http_vary_t * http_vary_dup(su_home_t *home, http_vary_t const *hdr))
Duplicate (deep copy) http_vary_t.
Definition http_protos.h:10029
msg_hclass_t http_vary_class[]
Header class for HTTP Vary header.
Definition http_basic.c:1484
int http_is_vary(http_header_t const *header)
Test if header object is instance of http_vary_t.
Definition http_protos.h:9882
http_vary_t * http_vary_format(su_home_t *home, char const *fmt,...)))
Make a Vary header from formatting result.
Definition http_protos.h:10016
msg_parse_f http_vary_d
Decode (parse) a Vary header.
Definition http_protos.h:9826
http_vary_t * http_vary_init(http_vary_t x[1])
Initialize a structure http_vary_t.
Definition http_protos.h:9858
http_vary_t * http_vary_make(su_home_t *home, char const *s))
Make a header structure http_vary_t.
Definition http_protos.h:10043
msg_print_f http_vary_e
Encode (print) a Vary header.
Definition http_protos.h:9829
http_vary_t * http_vary_copy(su_home_t *home, http_vary_t const *hdr))
Copy a http_vary_t header structure.
Definition http_protos.h:10036
@ http_vary_hash
Hash of Vary header.
Definition http_protos.h:9810
msg_print_f http_via_e
Encode (print) a Via header.
Definition http_protos.h:10079
http_via_t * http_via_dup(su_home_t *home, http_via_t const *hdr))
Duplicate (deep copy) http_via_t.
Definition http_protos.h:10279
msg_hclass_t http_via_class[]
Header class for HTTP Via header.
Definition http_basic.c:1591
msg_parse_f http_via_d
Decode (parse) a Via header.
Definition http_protos.h:10076
http_via_t * http_via_copy(su_home_t *home, http_via_t const *hdr))
Copy a http_via_t header structure.
Definition http_protos.h:10286
http_via_t * http_via_make(su_home_t *home, char const *s))
Make a header structure http_via_t.
Definition http_protos.h:10293
http_via_t * http_via_init(http_via_t x[1])
Initialize a structure http_via_t.
Definition http_protos.h:10108
http_via_t * http_via_format(su_home_t *home, char const *fmt,...)))
Make a Via header from formatting result.
Definition http_protos.h:10266
int http_is_via(http_header_t const *header)
Test if header object is instance of http_via_t.
Definition http_protos.h:10132
@ http_via_hash
Hash of Via header.
Definition http_protos.h:10060
msg_hclass_t http_warning_class[]
Header class for HTTP Warning header.
Definition http_basic.c:1602
msg_parse_f http_warning_d
Decode (parse) a Warning header.
Definition http_protos.h:10326
http_warning_t * http_warning_dup(su_home_t *home, http_warning_t const *hdr))
Duplicate (deep copy) http_warning_t.
Definition http_protos.h:10529
http_warning_t * http_warning_copy(su_home_t *home, http_warning_t const *hdr))
Copy a http_warning_t header structure.
Definition http_protos.h:10536
int http_is_warning(http_header_t const *header)
Test if header object is instance of http_warning_t.
Definition http_protos.h:10382
http_warning_t * http_warning_make(su_home_t *home, char const *s))
Make a header structure http_warning_t.
Definition http_protos.h:10543
msg_print_f http_warning_e
Encode (print) a Warning header.
Definition http_protos.h:10329
http_warning_t * http_warning_format(su_home_t *home, char const *fmt,...)))
Make a Warning header from formatting result.
Definition http_protos.h:10516
http_warning_t * http_warning_init(http_warning_t x[1])
Initialize a structure http_warning_t.
Definition http_protos.h:10358
@ http_warning_hash
Hash of Warning header.
Definition http_protos.h:10310
http_www_authenticate_t * http_www_authenticate_copy(su_home_t *home, http_www_authenticate_t const *hdr))
Copy a http_www_authenticate_t header structure.
Definition http_protos.h:10786
http_www_authenticate_t * http_www_authenticate_make(su_home_t *home, char const *s))
Make a header structure http_www_authenticate_t.
Definition http_protos.h:10793
msg_print_f http_www_authenticate_e
Encode (print) a WWW-Authenticate header.
Definition http_protos.h:10579
msg_hclass_t http_www_authenticate_class[]
Header class for HTTP WWW-Authenticate header.
Definition http_basic.c:1611
int http_is_www_authenticate(http_header_t const *header)
Test if header object is instance of http_www_authenticate_t.
Definition http_protos.h:10632
http_www_authenticate_t * http_www_authenticate_dup(su_home_t *home, http_www_authenticate_t const *hdr))
Duplicate (deep copy) http_www_authenticate_t.
Definition http_protos.h:10779
http_www_authenticate_t * http_www_authenticate_format(su_home_t *home, char const *fmt,...)))
Make a WWW-Authenticate header from formatting result.
Definition http_protos.h:10766
msg_parse_f http_www_authenticate_d
Decode (parse) a WWW-Authenticate header.
Definition http_protos.h:10576
http_www_authenticate_t * http_www_authenticate_init(http_www_authenticate_t x[1])
Initialize a structure http_www_authenticate_t.
Definition http_protos.h:10608
@ http_www_authenticate_hash
Hash of WWW-Authenticate header.
Definition http_protos.h:10560
msg_error_t http_error_t
Erroneous header.
Definition http.h:161
msg_generic_t http_unknown_t
Unknown header.
Definition http.h:163
msg_payload_t http_payload_t
Entity-body.
Definition http.h:167
msg_separator_t http_separator_t
Separator line between headers and message contents.
Definition http.h:165
HTTP header classes.
HTTP library prototypes.
#define HTTP_HEADER_INIT(h, http_class, size)
Initialize a HTTP header structure.
Definition http_header.h:61
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
msg_header_t * msg_header_dup_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
struct msg_hclass_s const msg_hclass_t
MSG_HDR_T msg_header_t
Content-Range.
Definition http.h:210
Date, Expires, If-Modified-Since, If-Unmodified-Since, Last-Modified.
Definition http.h:219
Host.
Definition http.h:226
If-Range.
Definition http.h:234
Location, Referer.
Definition http.h:242
Max-Forwards.
Definition http.h:249
Range.
Definition http.h:257
HTTP request line.
Definition http.h:179
Retry-After.
Definition http.h:265
HTTP status line.
Definition http.h:189
TE.
Definition http.h:273
Via.
Definition http.h:282
SU_HOME_T su_home_t
#define SOFIAPUBFUN
#define SOFIAPUBVAR
#define su_inline
Union representing any HTTP header.
Definition http.h:403

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