http  1.12.11devel
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
26 
27 #define HTTP_PROTOS_H
28 
38 #include <sofia-sip/su_config.h>
39 
40 #ifndef HTTP_HEADER_H
41 #include <sofia-sip/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 
52 SOFIA_BEGIN_DECLS
53 
54 /* Declare internal prototypes for request line */
55 
58 enum {
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
109 {
111 }
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
131 su_inline
132 int http_is_request(http_header_t const *header)
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
169 su_inline
170 #endif
172  http_request_t const *hdr)
173  __attribute__((__malloc__));
174 
203 #if SU_HAVE_INLINE
204 su_inline
205 #endif
207  http_request_t const *hdr)
208  __attribute__((__malloc__));
209 
228 #if SU_HAVE_INLINE
229 su_inline
230 #endif
231 http_request_t *http_request_make(su_home_t *home, char const *s)
232  __attribute__((__malloc__));
233 
256 #if SU_HAVE_INLINE
257 su_inline
258 #endif
259 http_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
265 su_inline
266 http_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 
278 su_inline
280 {
281  return (http_request_t *)
283 }
284 
285 su_inline
287 {
288  return (http_request_t *)
290 }
291 
292 su_inline
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 
308 enum {
310  http_status_hash = -2
311 };
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
359 {
361 }
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
381 su_inline
382 int http_is_status(http_header_t const *header)
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
419 su_inline
420 #endif
422  http_status_t const *hdr)
423  __attribute__((__malloc__));
424 
453 #if SU_HAVE_INLINE
454 su_inline
455 #endif
457  http_status_t const *hdr)
458  __attribute__((__malloc__));
459 
478 #if SU_HAVE_INLINE
479 su_inline
480 #endif
481 http_status_t *http_status_make(su_home_t *home, char const *s)
482  __attribute__((__malloc__));
483 
506 #if SU_HAVE_INLINE
507 su_inline
508 #endif
509 http_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
515 su_inline
516 http_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 
528 su_inline
530 {
531  return (http_status_t *)
533 }
534 
535 su_inline
537 {
538  return (http_status_t *)
540 }
541 
542 su_inline
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 
558 enum {
560  http_accept_hash = 29344
561 };
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
609 {
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
631 su_inline
632 int http_is_accept(http_header_t const *header)
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
669 su_inline
670 #endif
672  http_accept_t const *hdr)
673  __attribute__((__malloc__));
674 
703 #if SU_HAVE_INLINE
704 su_inline
705 #endif
707  http_accept_t const *hdr)
708  __attribute__((__malloc__));
709 
728 #if SU_HAVE_INLINE
729 su_inline
730 #endif
731 http_accept_t *http_accept_make(su_home_t *home, char const *s)
732  __attribute__((__malloc__));
733 
756 #if SU_HAVE_INLINE
757 su_inline
758 #endif
759 http_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
765 su_inline
766 http_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 
778 su_inline
780 {
781  return (http_accept_t *)
783 }
784 
785 su_inline
787 {
788  return (http_accept_t *)
790 }
791 
792 su_inline
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 
808 enum {
811 };
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
858 su_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
881 su_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
919 su_inline
920 #endif
921 http_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
954 su_inline
955 #endif
956 http_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
979 su_inline
980 #endif
981 http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
982  __attribute__((__malloc__));
983 
1006 #if SU_HAVE_INLINE
1007 su_inline
1008 #endif
1009 http_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
1015 su_inline
1016 http_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 
1028 su_inline
1029 http_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 
1035 su_inline
1036 http_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 
1042 su_inline
1043 http_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 
1058 enum {
1061 };
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
1108 su_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
1131 su_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
1169 su_inline
1170 #endif
1171 http_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
1204 su_inline
1205 #endif
1206 http_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
1229 su_inline
1230 #endif
1231 http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
1232  __attribute__((__malloc__));
1233 
1256 #if SU_HAVE_INLINE
1257 su_inline
1258 #endif
1259 http_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
1265 su_inline
1266 http_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 
1278 su_inline
1279 http_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 
1285 su_inline
1286 http_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 
1292 su_inline
1293 http_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 
1308 enum {
1311 };
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
1358 su_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
1381 su_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
1419 su_inline
1420 #endif
1421 http_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
1454 su_inline
1455 #endif
1456 http_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
1479 su_inline
1480 #endif
1481 http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
1482  __attribute__((__malloc__));
1483 
1506 #if SU_HAVE_INLINE
1507 su_inline
1508 #endif
1509 http_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
1515 su_inline
1516 http_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 
1528 su_inline
1529 http_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 
1535 su_inline
1536 http_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 
1542 su_inline
1543 http_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 
1558 enum {
1560  http_accept_ranges_hash = 59733
1561 };
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
1609 {
1611 }
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
1631 su_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
1669 su_inline
1670 #endif
1672  http_accept_ranges_t const *hdr)
1673  __attribute__((__malloc__));
1674 
1703 #if SU_HAVE_INLINE
1704 su_inline
1705 #endif
1707  http_accept_ranges_t const *hdr)
1708  __attribute__((__malloc__));
1709 
1728 #if SU_HAVE_INLINE
1729 su_inline
1730 #endif
1732  __attribute__((__malloc__));
1733 
1756 #if SU_HAVE_INLINE
1757 su_inline
1758 #endif
1759 http_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
1765 su_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 
1778 su_inline
1780 {
1781  return (http_accept_ranges_t *)
1783 }
1784 
1785 su_inline
1787 {
1788  return (http_accept_ranges_t *)
1790 }
1791 
1792 su_inline
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 
1808 enum {
1810  http_allow_hash = 44519
1811 };
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
1859 {
1860  return HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t));
1861 }
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
1881 su_inline
1882 int http_is_allow(http_header_t const *header)
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
1919 su_inline
1920 #endif
1922  http_allow_t const *hdr)
1923  __attribute__((__malloc__));
1924 
1953 #if SU_HAVE_INLINE
1954 su_inline
1955 #endif
1957  http_allow_t const *hdr)
1958  __attribute__((__malloc__));
1959 
1978 #if SU_HAVE_INLINE
1979 su_inline
1980 #endif
1981 http_allow_t *http_allow_make(su_home_t *home, char const *s)
1982  __attribute__((__malloc__));
1983 
2006 #if SU_HAVE_INLINE
2007 su_inline
2008 #endif
2009 http_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
2015 su_inline
2016 http_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 
2028 su_inline
2030 {
2031  return (http_allow_t *)
2032  msg_header_dup_as(home, http_allow_class, (msg_header_t const *)o);
2033 }
2034 
2035 su_inline
2037 {
2038  return (http_allow_t *)
2040 }
2041 
2042 su_inline
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 
2058 enum {
2061 };
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
2108 su_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
2131 su_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
2169 su_inline
2170 #endif
2171 http_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
2204 su_inline
2205 #endif
2206 http_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
2229 su_inline
2230 #endif
2231 http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
2232  __attribute__((__malloc__));
2233 
2256 #if SU_HAVE_INLINE
2257 su_inline
2258 #endif
2259 http_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
2265 su_inline
2266 http_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 
2278 su_inline
2279 http_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 
2285 su_inline
2286 http_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 
2292 su_inline
2293 http_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 
2308 enum {
2310  http_authorization_hash = 36397
2311 };
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
2358 su_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
2381 su_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
2419 su_inline
2420 #endif
2421 http_authorization_t *http_authorization_dup(su_home_t *home,
2422  http_authorization_t const *hdr)
2423  __attribute__((__malloc__));
2424 
2453 #if SU_HAVE_INLINE
2454 su_inline
2455 #endif
2456 http_authorization_t *http_authorization_copy(su_home_t *home,
2457  http_authorization_t const *hdr)
2458  __attribute__((__malloc__));
2459 
2478 #if SU_HAVE_INLINE
2479 su_inline
2480 #endif
2481 http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
2482  __attribute__((__malloc__));
2483 
2506 #if SU_HAVE_INLINE
2507 su_inline
2508 #endif
2509 http_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
2515 su_inline
2516 http_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 
2528 su_inline
2529 http_authorization_t *http_authorization_dup(su_home_t *home, http_authorization_t const *o)
2530 {
2531  return (http_authorization_t *)
2533 }
2534 
2535 su_inline
2536 http_authorization_t *http_authorization_copy(su_home_t *home, http_authorization_t const *o)
2537 {
2538  return (http_authorization_t *)
2540 }
2541 
2542 su_inline
2543 http_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 
2558 enum {
2560  http_age_hash = 34725
2561 };
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
2608 su_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
2631 su_inline
2632 int 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
2669 su_inline
2670 #endif
2671 http_age_t *http_age_dup(su_home_t *home,
2672  http_age_t const *hdr)
2673  __attribute__((__malloc__));
2674 
2703 #if SU_HAVE_INLINE
2704 su_inline
2705 #endif
2706 http_age_t *http_age_copy(su_home_t *home,
2707  http_age_t const *hdr)
2708  __attribute__((__malloc__));
2709 
2728 #if SU_HAVE_INLINE
2729 su_inline
2730 #endif
2731 http_age_t *http_age_make(su_home_t *home, char const *s)
2732  __attribute__((__malloc__));
2733 
2756 #if SU_HAVE_INLINE
2757 su_inline
2758 #endif
2759 http_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
2765 su_inline
2766 http_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 
2778 su_inline
2779 http_age_t *http_age_dup(su_home_t *home, http_age_t const *o)
2780 {
2781  return (http_age_t *)
2782  msg_header_dup_as(home, http_age_class, (msg_header_t const *)o);
2783 }
2784 
2785 su_inline
2786 http_age_t *http_age_copy(su_home_t *home, http_age_t const *o)
2787 {
2788  return (http_age_t *)
2789  msg_header_copy_as(home, http_age_class, (msg_header_t const *)o);
2790 }
2791 
2792 su_inline
2793 http_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 
2808 enum {
2810  http_cache_control_hash = 48250
2811 };
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
2859 {
2861 }
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
2881 su_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
2919 su_inline
2920 #endif
2922  http_cache_control_t const *hdr)
2923  __attribute__((__malloc__));
2924 
2953 #if SU_HAVE_INLINE
2954 su_inline
2955 #endif
2957  http_cache_control_t const *hdr)
2958  __attribute__((__malloc__));
2959 
2978 #if SU_HAVE_INLINE
2979 su_inline
2980 #endif
2982  __attribute__((__malloc__));
2983 
3006 #if SU_HAVE_INLINE
3007 su_inline
3008 #endif
3009 http_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
3015 su_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 
3028 su_inline
3030 {
3031  return (http_cache_control_t *)
3033 }
3034 
3035 su_inline
3037 {
3038  return (http_cache_control_t *)
3040 }
3041 
3042 su_inline
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 
3058 enum {
3060  http_connection_hash = 32700
3061 };
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
3109 {
3111 }
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
3131 su_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
3169 su_inline
3170 #endif
3172  http_connection_t const *hdr)
3173  __attribute__((__malloc__));
3174 
3203 #if SU_HAVE_INLINE
3204 su_inline
3205 #endif
3207  http_connection_t const *hdr)
3208  __attribute__((__malloc__));
3209 
3228 #if SU_HAVE_INLINE
3229 su_inline
3230 #endif
3231 http_connection_t *http_connection_make(su_home_t *home, char const *s)
3232  __attribute__((__malloc__));
3233 
3256 #if SU_HAVE_INLINE
3257 su_inline
3258 #endif
3259 http_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
3265 su_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 
3278 su_inline
3280 {
3281  return (http_connection_t *)
3283 }
3284 
3285 su_inline
3287 {
3288  return (http_connection_t *)
3290 }
3291 
3292 su_inline
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 
3308 enum {
3310  http_date_hash = 43982
3311 };
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
3359 {
3360  return HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t));
3361 }
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
3381 su_inline
3382 int 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
3419 su_inline
3420 #endif
3422  http_date_t const *hdr)
3423  __attribute__((__malloc__));
3424 
3453 #if SU_HAVE_INLINE
3454 su_inline
3455 #endif
3457  http_date_t const *hdr)
3458  __attribute__((__malloc__));
3459 
3478 #if SU_HAVE_INLINE
3479 su_inline
3480 #endif
3481 http_date_t *http_date_make(su_home_t *home, char const *s)
3482  __attribute__((__malloc__));
3483 
3506 #if SU_HAVE_INLINE
3507 su_inline
3508 #endif
3509 http_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
3515 su_inline
3516 http_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 
3528 su_inline
3530 {
3531  return (http_date_t *)
3532  msg_header_dup_as(home, http_date_class, (msg_header_t const *)o);
3533 }
3534 
3535 su_inline
3537 {
3538  return (http_date_t *)
3539  msg_header_copy_as(home, http_date_class, (msg_header_t const *)o);
3540 }
3541 
3542 su_inline
3543 http_date_t *http_date_make(su_home_t *home, char const *s)
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 
3558 enum {
3560  http_etag_hash = 1813
3561 };
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
3608 su_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
3631 su_inline
3632 int 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
3669 su_inline
3670 #endif
3671 http_etag_t *http_etag_dup(su_home_t *home,
3672  http_etag_t const *hdr)
3673  __attribute__((__malloc__));
3674 
3703 #if SU_HAVE_INLINE
3704 su_inline
3705 #endif
3706 http_etag_t *http_etag_copy(su_home_t *home,
3707  http_etag_t const *hdr)
3708  __attribute__((__malloc__));
3709 
3728 #if SU_HAVE_INLINE
3729 su_inline
3730 #endif
3731 http_etag_t *http_etag_make(su_home_t *home, char const *s)
3732  __attribute__((__malloc__));
3733 
3756 #if SU_HAVE_INLINE
3757 su_inline
3758 #endif
3759 http_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
3765 su_inline
3766 http_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 
3778 su_inline
3779 http_etag_t *http_etag_dup(su_home_t *home, http_etag_t const *o)
3780 {
3781  return (http_etag_t *)
3782  msg_header_dup_as(home, http_etag_class, (msg_header_t const *)o);
3783 }
3784 
3785 su_inline
3786 http_etag_t *http_etag_copy(su_home_t *home, http_etag_t const *o)
3787 {
3788  return (http_etag_t *)
3789  msg_header_copy_as(home, http_etag_class, (msg_header_t const *)o);
3790 }
3791 
3792 su_inline
3793 http_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 
3808 enum {
3810  http_expect_hash = 30389
3811 };
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
3858 su_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
3881 su_inline
3882 int http_is_expect(http_header_t const *header)
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
3919 su_inline
3920 #endif
3921 http_expect_t *http_expect_dup(su_home_t *home,
3922  http_expect_t const *hdr)
3923  __attribute__((__malloc__));
3924 
3953 #if SU_HAVE_INLINE
3954 su_inline
3955 #endif
3956 http_expect_t *http_expect_copy(su_home_t *home,
3957  http_expect_t const *hdr)
3958  __attribute__((__malloc__));
3959 
3978 #if SU_HAVE_INLINE
3979 su_inline
3980 #endif
3981 http_expect_t *http_expect_make(su_home_t *home, char const *s)
3982  __attribute__((__malloc__));
3983 
4006 #if SU_HAVE_INLINE
4007 su_inline
4008 #endif
4009 http_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
4015 su_inline
4016 http_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 
4028 su_inline
4029 http_expect_t *http_expect_dup(su_home_t *home, http_expect_t const *o)
4030 {
4031  return (http_expect_t *)
4033 }
4034 
4035 su_inline
4036 http_expect_t *http_expect_copy(su_home_t *home, http_expect_t const *o)
4037 {
4038  return (http_expect_t *)
4040 }
4041 
4042 su_inline
4043 http_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 
4058 enum {
4060  http_expires_hash = 28680
4061 };
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
4109 {
4111 }
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
4131 su_inline
4132 int http_is_expires(http_header_t const *header)
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
4169 su_inline
4170 #endif
4172  http_expires_t const *hdr)
4173  __attribute__((__malloc__));
4174 
4203 #if SU_HAVE_INLINE
4204 su_inline
4205 #endif
4207  http_expires_t const *hdr)
4208  __attribute__((__malloc__));
4209 
4228 #if SU_HAVE_INLINE
4229 su_inline
4230 #endif
4231 http_expires_t *http_expires_make(su_home_t *home, char const *s)
4232  __attribute__((__malloc__));
4233 
4256 #if SU_HAVE_INLINE
4257 su_inline
4258 #endif
4259 http_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
4265 su_inline
4266 http_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 
4278 su_inline
4280 {
4281  return (http_expires_t *)
4283 }
4284 
4285 su_inline
4287 {
4288  return (http_expires_t *)
4290 }
4291 
4292 su_inline
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 
4308 enum {
4310  http_from_hash = 15368
4311 };
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
4358 su_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
4381 su_inline
4382 int 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
4419 su_inline
4420 #endif
4421 http_from_t *http_from_dup(su_home_t *home,
4422  http_from_t const *hdr)
4423  __attribute__((__malloc__));
4424 
4453 #if SU_HAVE_INLINE
4454 su_inline
4455 #endif
4456 http_from_t *http_from_copy(su_home_t *home,
4457  http_from_t const *hdr)
4458  __attribute__((__malloc__));
4459 
4478 #if SU_HAVE_INLINE
4479 su_inline
4480 #endif
4481 http_from_t *http_from_make(su_home_t *home, char const *s)
4482  __attribute__((__malloc__));
4483 
4506 #if SU_HAVE_INLINE
4507 su_inline
4508 #endif
4509 http_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
4515 su_inline
4516 http_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 
4528 su_inline
4529 http_from_t *http_from_dup(su_home_t *home, http_from_t const *o)
4530 {
4531  return (http_from_t *)
4532  msg_header_dup_as(home, http_from_class, (msg_header_t const *)o);
4533 }
4534 
4535 su_inline
4536 http_from_t *http_from_copy(su_home_t *home, http_from_t const *o)
4537 {
4538  return (http_from_t *)
4539  msg_header_copy_as(home, http_from_class, (msg_header_t const *)o);
4540 }
4541 
4542 su_inline
4543 http_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 
4558 enum {
4560  http_host_hash = 33850
4561 };
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
4609 {
4610  return HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t));
4611 }
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
4631 su_inline
4632 int 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
4669 su_inline
4670 #endif
4672  http_host_t const *hdr)
4673  __attribute__((__malloc__));
4674 
4703 #if SU_HAVE_INLINE
4704 su_inline
4705 #endif
4707  http_host_t const *hdr)
4708  __attribute__((__malloc__));
4709 
4728 #if SU_HAVE_INLINE
4729 su_inline
4730 #endif
4731 http_host_t *http_host_make(su_home_t *home, char const *s)
4732  __attribute__((__malloc__));
4733 
4756 #if SU_HAVE_INLINE
4757 su_inline
4758 #endif
4759 http_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
4765 su_inline
4766 http_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 
4778 su_inline
4780 {
4781  return (http_host_t *)
4782  msg_header_dup_as(home, http_host_class, (msg_header_t const *)o);
4783 }
4784 
4785 su_inline
4787 {
4788  return (http_host_t *)
4789  msg_header_copy_as(home, http_host_class, (msg_header_t const *)o);
4790 }
4791 
4792 su_inline
4793 http_host_t *http_host_make(su_home_t *home, char const *s)
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 
4808 enum {
4810  http_if_match_hash = 805
4811 };
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
4859 {
4861 }
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
4881 su_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
4919 su_inline
4920 #endif
4922  http_if_match_t const *hdr)
4923  __attribute__((__malloc__));
4924 
4953 #if SU_HAVE_INLINE
4954 su_inline
4955 #endif
4957  http_if_match_t const *hdr)
4958  __attribute__((__malloc__));
4959 
4978 #if SU_HAVE_INLINE
4979 su_inline
4980 #endif
4981 http_if_match_t *http_if_match_make(su_home_t *home, char const *s)
4982  __attribute__((__malloc__));
4983 
5006 #if SU_HAVE_INLINE
5007 su_inline
5008 #endif
5009 http_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
5015 su_inline
5016 http_if_match_t *http_if_match_format(su_home_t *home, char const *fmt, ...)
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 
5028 su_inline
5030 {
5031  return (http_if_match_t *)
5033 }
5034 
5035 su_inline
5037 {
5038  return (http_if_match_t *)
5040 }
5041 
5042 su_inline
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 
5058 enum {
5061 };
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
5109 {
5111 }
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
5131 su_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
5169 su_inline
5170 #endif
5172  http_if_modified_since_t const *hdr)
5173  __attribute__((__malloc__));
5174 
5203 #if SU_HAVE_INLINE
5204 su_inline
5205 #endif
5207  http_if_modified_since_t const *hdr)
5208  __attribute__((__malloc__));
5209 
5228 #if SU_HAVE_INLINE
5229 su_inline
5230 #endif
5232  __attribute__((__malloc__));
5233 
5256 #if SU_HAVE_INLINE
5257 su_inline
5258 #endif
5260  __attribute__((__malloc__, __format__ (printf, 2, 3)));
5261 
5262 
5263 /* Inlined functions */
5264 #if SU_HAVE_INLINE
5265 su_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 
5278 su_inline
5280 {
5281  return (http_if_modified_since_t *)
5283 }
5284 
5285 su_inline
5287 {
5288  return (http_if_modified_since_t *)
5290 }
5291 
5292 su_inline
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 
5308 enum {
5310  http_if_none_match_hash = 64610
5311 };
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
5359 {
5361 }
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
5381 su_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
5419 su_inline
5420 #endif
5422  http_if_none_match_t const *hdr)
5423  __attribute__((__malloc__));
5424 
5453 #if SU_HAVE_INLINE
5454 su_inline
5455 #endif
5457  http_if_none_match_t const *hdr)
5458  __attribute__((__malloc__));
5459 
5478 #if SU_HAVE_INLINE
5479 su_inline
5480 #endif
5482  __attribute__((__malloc__));
5483 
5506 #if SU_HAVE_INLINE
5507 su_inline
5508 #endif
5509 http_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
5515 su_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 
5528 su_inline
5530 {
5531  return (http_if_none_match_t *)
5533 }
5534 
5535 su_inline
5537 {
5538  return (http_if_none_match_t *)
5540 }
5541 
5542 su_inline
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 
5558 enum {
5560  http_if_range_hash = 40469
5561 };
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
5609 {
5611 }
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
5631 su_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
5669 su_inline
5670 #endif
5672  http_if_range_t const *hdr)
5673  __attribute__((__malloc__));
5674 
5703 #if SU_HAVE_INLINE
5704 su_inline
5705 #endif
5707  http_if_range_t const *hdr)
5708  __attribute__((__malloc__));
5709 
5728 #if SU_HAVE_INLINE
5729 su_inline
5730 #endif
5731 http_if_range_t *http_if_range_make(su_home_t *home, char const *s)
5732  __attribute__((__malloc__));
5733 
5756 #if SU_HAVE_INLINE
5757 su_inline
5758 #endif
5759 http_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
5765 su_inline
5766 http_if_range_t *http_if_range_format(su_home_t *home, char const *fmt, ...)
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 
5778 su_inline
5780 {
5781  return (http_if_range_t *)
5783 }
5784 
5785 su_inline
5787 {
5788  return (http_if_range_t *)
5790 }
5791 
5792 su_inline
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 
5808 enum {
5811 };
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
5859 {
5861 }
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
5881 su_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
5919 su_inline
5920 #endif
5922  http_if_unmodified_since_t const *hdr)
5923  __attribute__((__malloc__));
5924 
5953 #if SU_HAVE_INLINE
5954 su_inline
5955 #endif
5957  http_if_unmodified_since_t const *hdr)
5958  __attribute__((__malloc__));
5959 
5978 #if SU_HAVE_INLINE
5979 su_inline
5980 #endif
5982  __attribute__((__malloc__));
5983 
6006 #if SU_HAVE_INLINE
6007 su_inline
6008 #endif
6010  __attribute__((__malloc__, __format__ (printf, 2, 3)));
6011 
6012 
6013 /* Inlined functions */
6014 #if SU_HAVE_INLINE
6015 su_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 
6028 su_inline
6030 {
6031  return (http_if_unmodified_since_t *)
6033 }
6034 
6035 su_inline
6037 {
6038  return (http_if_unmodified_since_t *)
6040 }
6041 
6042 su_inline
6044 {
6045  return (http_if_unmodified_since_t *)http_header_make(home, http_if_unmodified_since_class, s);
6046 }
6047 #endif
6048 
6049 #endif /* !define HTTP_HCLASSES_ONLY */
6050 
6054 /* Declare internal prototypes for Last-Modified header */
6055 
6058 enum {
6060  http_last_modified_hash = 19958
6061 };
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
6109 {
6111 }
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
6131 su_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
6169 su_inline
6170 #endif
6172  http_last_modified_t const *hdr)
6173  __attribute__((__malloc__));
6174 
6203 #if SU_HAVE_INLINE
6204 su_inline
6205 #endif
6207  http_last_modified_t const *hdr)
6208  __attribute__((__malloc__));
6209 
6228 #if SU_HAVE_INLINE
6229 su_inline
6230 #endif
6232  __attribute__((__malloc__));
6233 
6256 #if SU_HAVE_INLINE
6257 su_inline
6258 #endif
6259 http_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
6265 su_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 
6278 su_inline
6280 {
6281  return (http_last_modified_t *)
6283 }
6284 
6285 su_inline
6287 {
6288  return (http_last_modified_t *)
6290 }
6291 
6292 su_inline
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 
6308 enum {
6310  http_location_hash = 60949
6311 };
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
6359 {
6361 }
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
6381 su_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
6419 su_inline
6420 #endif
6422  http_location_t const *hdr)
6423  __attribute__((__malloc__));
6424 
6453 #if SU_HAVE_INLINE
6454 su_inline
6455 #endif
6457  http_location_t const *hdr)
6458  __attribute__((__malloc__));
6459 
6478 #if SU_HAVE_INLINE
6479 su_inline
6480 #endif
6481 http_location_t *http_location_make(su_home_t *home, char const *s)
6482  __attribute__((__malloc__));
6483 
6506 #if SU_HAVE_INLINE
6507 su_inline
6508 #endif
6509 http_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
6515 su_inline
6516 http_location_t *http_location_format(su_home_t *home, char const *fmt, ...)
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 
6528 su_inline
6530 {
6531  return (http_location_t *)
6533 }
6534 
6535 su_inline
6537 {
6538  return (http_location_t *)
6540 }
6541 
6542 su_inline
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 
6558 enum {
6560  http_max_forwards_hash = 27231
6561 };
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
6609 {
6611 }
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
6631 su_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
6669 su_inline
6670 #endif
6672  http_max_forwards_t const *hdr)
6673  __attribute__((__malloc__));
6674 
6703 #if SU_HAVE_INLINE
6704 su_inline
6705 #endif
6707  http_max_forwards_t const *hdr)
6708  __attribute__((__malloc__));
6709 
6728 #if SU_HAVE_INLINE
6729 su_inline
6730 #endif
6732  __attribute__((__malloc__));
6733 
6756 #if SU_HAVE_INLINE
6757 su_inline
6758 #endif
6759 http_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
6765 su_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 
6778 su_inline
6780 {
6781  return (http_max_forwards_t *)
6783 }
6784 
6785 su_inline
6787 {
6788  return (http_max_forwards_t *)
6790 }
6791 
6792 su_inline
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 
6808 enum {
6810  http_pragma_hash = 49776
6811 };
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
6859 {
6860  return HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t));
6861 }
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
6881 su_inline
6882 int http_is_pragma(http_header_t const *header)
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
6919 su_inline
6920 #endif
6922  http_pragma_t const *hdr)
6923  __attribute__((__malloc__));
6924 
6953 #if SU_HAVE_INLINE
6954 su_inline
6955 #endif
6957  http_pragma_t const *hdr)
6958  __attribute__((__malloc__));
6959 
6978 #if SU_HAVE_INLINE
6979 su_inline
6980 #endif
6981 http_pragma_t *http_pragma_make(su_home_t *home, char const *s)
6982  __attribute__((__malloc__));
6983 
7006 #if SU_HAVE_INLINE
7007 su_inline
7008 #endif
7009 http_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
7015 su_inline
7016 http_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 
7028 su_inline
7030 {
7031  return (http_pragma_t *)
7033 }
7034 
7035 su_inline
7037 {
7038  return (http_pragma_t *)
7040 }
7041 
7042 su_inline
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 
7058 enum {
7061 };
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
7108 su_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
7131 su_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
7169 su_inline
7170 #endif
7171 http_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
7204 su_inline
7205 #endif
7206 http_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
7229 su_inline
7230 #endif
7231 http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
7232  __attribute__((__malloc__));
7233 
7256 #if SU_HAVE_INLINE
7257 su_inline
7258 #endif
7259 http_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
7265 su_inline
7266 http_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 
7278 su_inline
7279 http_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 
7285 su_inline
7286 http_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 
7292 su_inline
7293 http_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 
7308 enum {
7311 };
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
7358 su_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
7381 su_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
7419 su_inline
7420 #endif
7421 http_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
7454 su_inline
7455 #endif
7456 http_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
7479 su_inline
7480 #endif
7481 http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
7482  __attribute__((__malloc__));
7483 
7506 #if SU_HAVE_INLINE
7507 su_inline
7508 #endif
7509 http_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
7515 su_inline
7516 http_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 
7528 su_inline
7529 http_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 
7535 su_inline
7536 http_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 
7542 su_inline
7543 http_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 
7558 enum {
7560  http_range_hash = 20297
7561 };
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
7609 {
7610  return HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t));
7611 }
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
7631 su_inline
7632 int http_is_range(http_header_t const *header)
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
7669 su_inline
7670 #endif
7672  http_range_t const *hdr)
7673  __attribute__((__malloc__));
7674 
7703 #if SU_HAVE_INLINE
7704 su_inline
7705 #endif
7707  http_range_t const *hdr)
7708  __attribute__((__malloc__));
7709 
7728 #if SU_HAVE_INLINE
7729 su_inline
7730 #endif
7731 http_range_t *http_range_make(su_home_t *home, char const *s)
7732  __attribute__((__malloc__));
7733 
7756 #if SU_HAVE_INLINE
7757 su_inline
7758 #endif
7759 http_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
7765 su_inline
7766 http_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 
7778 su_inline
7780 {
7781  return (http_range_t *)
7782  msg_header_dup_as(home, http_range_class, (msg_header_t const *)o);
7783 }
7784 
7785 su_inline
7787 {
7788  return (http_range_t *)
7790 }
7791 
7792 su_inline
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 
7808 enum {
7810  http_referer_hash = 64523
7811 };
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
7859 {
7861 }
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
7881 su_inline
7882 int http_is_referer(http_header_t const *header)
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
7919 su_inline
7920 #endif
7922  http_referer_t const *hdr)
7923  __attribute__((__malloc__));
7924 
7953 #if SU_HAVE_INLINE
7954 su_inline
7955 #endif
7957  http_referer_t const *hdr)
7958  __attribute__((__malloc__));
7959 
7978 #if SU_HAVE_INLINE
7979 su_inline
7980 #endif
7981 http_referer_t *http_referer_make(su_home_t *home, char const *s)
7982  __attribute__((__malloc__));
7983 
8006 #if SU_HAVE_INLINE
8007 su_inline
8008 #endif
8009 http_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
8015 su_inline
8016 http_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 
8028 su_inline
8030 {
8031  return (http_referer_t *)
8033 }
8034 
8035 su_inline
8037 {
8038  return (http_referer_t *)
8040 }
8041 
8042 su_inline
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 
8058 enum {
8060  http_retry_after_hash = 30349
8061 };
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
8109 {
8111 }
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
8131 su_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
8169 su_inline
8170 #endif
8172  http_retry_after_t const *hdr)
8173  __attribute__((__malloc__));
8174 
8203 #if SU_HAVE_INLINE
8204 su_inline
8205 #endif
8207  http_retry_after_t const *hdr)
8208  __attribute__((__malloc__));
8209 
8228 #if SU_HAVE_INLINE
8229 su_inline
8230 #endif
8231 http_retry_after_t *http_retry_after_make(su_home_t *home, char const *s)
8232  __attribute__((__malloc__));
8233 
8256 #if SU_HAVE_INLINE
8257 su_inline
8258 #endif
8259 http_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
8265 su_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 
8278 su_inline
8280 {
8281  return (http_retry_after_t *)
8283 }
8284 
8285 su_inline
8287 {
8288  return (http_retry_after_t *)
8290 }
8291 
8292 su_inline
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 
8308 enum {
8310  http_server_hash = 31323
8311 };
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
8358 su_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
8381 su_inline
8382 int http_is_server(http_header_t const *header)
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
8419 su_inline
8420 #endif
8421 http_server_t *http_server_dup(su_home_t *home,
8422  http_server_t const *hdr)
8423  __attribute__((__malloc__));
8424 
8453 #if SU_HAVE_INLINE
8454 su_inline
8455 #endif
8456 http_server_t *http_server_copy(su_home_t *home,
8457  http_server_t const *hdr)
8458  __attribute__((__malloc__));
8459 
8478 #if SU_HAVE_INLINE
8479 su_inline
8480 #endif
8481 http_server_t *http_server_make(su_home_t *home, char const *s)
8482  __attribute__((__malloc__));
8483 
8506 #if SU_HAVE_INLINE
8507 su_inline
8508 #endif
8509 http_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
8515 su_inline
8516 http_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 
8528 su_inline
8529 http_server_t *http_server_dup(su_home_t *home, http_server_t const *o)
8530 {
8531  return (http_server_t *)
8533 }
8534 
8535 su_inline
8536 http_server_t *http_server_copy(su_home_t *home, http_server_t const *o)
8537 {
8538  return (http_server_t *)
8540 }
8541 
8542 su_inline
8543 http_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 
8558 enum {
8560  http_te_hash = 5165
8561 };
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
8609 {
8610  return HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t));
8611 }
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
8631 su_inline
8632 int 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
8669 su_inline
8670 #endif
8672  http_te_t const *hdr)
8673  __attribute__((__malloc__));
8674 
8703 #if SU_HAVE_INLINE
8704 su_inline
8705 #endif
8707  http_te_t const *hdr)
8708  __attribute__((__malloc__));
8709 
8728 #if SU_HAVE_INLINE
8729 su_inline
8730 #endif
8731 http_te_t *http_te_make(su_home_t *home, char const *s)
8732  __attribute__((__malloc__));
8733 
8756 #if SU_HAVE_INLINE
8757 su_inline
8758 #endif
8759 http_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
8765 su_inline
8766 http_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 
8778 su_inline
8780 {
8781  return (http_te_t *)
8782  msg_header_dup_as(home, http_te_class, (msg_header_t const *)o);
8783 }
8784 
8785 su_inline
8787 {
8788  return (http_te_t *)
8789  msg_header_copy_as(home, http_te_class, (msg_header_t const *)o);
8790 }
8791 
8792 su_inline
8793 http_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 
8808 enum {
8810  http_trailer_hash = 11015
8811 };
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
8859 {
8861 }
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
8881 su_inline
8882 int http_is_trailer(http_header_t const *header)
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
8919 su_inline
8920 #endif
8922  http_trailer_t const *hdr)
8923  __attribute__((__malloc__));
8924 
8953 #if SU_HAVE_INLINE
8954 su_inline
8955 #endif
8957  http_trailer_t const *hdr)
8958  __attribute__((__malloc__));
8959 
8978 #if SU_HAVE_INLINE
8979 su_inline
8980 #endif
8981 http_trailer_t *http_trailer_make(su_home_t *home, char const *s)
8982  __attribute__((__malloc__));
8983 
9006 #if SU_HAVE_INLINE
9007 su_inline
9008 #endif
9009 http_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
9015 su_inline
9016 http_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 
9028 su_inline
9030 {
9031  return (http_trailer_t *)
9033 }
9034 
9035 su_inline
9037 {
9038  return (http_trailer_t *)
9040 }
9041 
9042 su_inline
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 
9058 enum {
9061 };
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
9109 {
9111 }
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
9131 su_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
9169 su_inline
9170 #endif
9172  http_transfer_encoding_t const *hdr)
9173  __attribute__((__malloc__));
9174 
9203 #if SU_HAVE_INLINE
9204 su_inline
9205 #endif
9207  http_transfer_encoding_t const *hdr)
9208  __attribute__((__malloc__));
9209 
9228 #if SU_HAVE_INLINE
9229 su_inline
9230 #endif
9232  __attribute__((__malloc__));
9233 
9256 #if SU_HAVE_INLINE
9257 su_inline
9258 #endif
9260  __attribute__((__malloc__, __format__ (printf, 2, 3)));
9261 
9262 
9263 /* Inlined functions */
9264 #if SU_HAVE_INLINE
9265 su_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 
9278 su_inline
9280 {
9281  return (http_transfer_encoding_t *)
9283 }
9284 
9285 su_inline
9287 {
9288  return (http_transfer_encoding_t *)
9290 }
9291 
9292 su_inline
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 
9308 enum {
9310  http_upgrade_hash = 16256
9311 };
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
9359 {
9361 }
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
9381 su_inline
9382 int http_is_upgrade(http_header_t const *header)
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
9419 su_inline
9420 #endif
9422  http_upgrade_t const *hdr)
9423  __attribute__((__malloc__));
9424 
9453 #if SU_HAVE_INLINE
9454 su_inline
9455 #endif
9457  http_upgrade_t const *hdr)
9458  __attribute__((__malloc__));
9459 
9478 #if SU_HAVE_INLINE
9479 su_inline
9480 #endif
9481 http_upgrade_t *http_upgrade_make(su_home_t *home, char const *s)
9482  __attribute__((__malloc__));
9483 
9506 #if SU_HAVE_INLINE
9507 su_inline
9508 #endif
9509 http_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
9515 su_inline
9516 http_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 
9528 su_inline
9530 {
9531  return (http_upgrade_t *)
9533 }
9534 
9535 su_inline
9537 {
9538  return (http_upgrade_t *)
9540 }
9541 
9542 su_inline
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 
9558 enum {
9560  http_user_agent_hash = 40911
9561 };
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
9608 su_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
9631 su_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
9669 su_inline
9670 #endif
9671 http_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
9704 su_inline
9705 #endif
9706 http_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
9729 su_inline
9730 #endif
9731 http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
9732  __attribute__((__malloc__));
9733 
9756 #if SU_HAVE_INLINE
9757 su_inline
9758 #endif
9759 http_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
9765 su_inline
9766 http_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 
9778 su_inline
9779 http_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 
9785 su_inline
9786 http_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 
9792 su_inline
9793 http_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 
9808 enum {
9810  http_vary_hash = 57074
9811 };
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
9859 {
9860  return HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t));
9861 }
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
9881 su_inline
9882 int 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
9919 su_inline
9920 #endif
9922  http_vary_t const *hdr)
9923  __attribute__((__malloc__));
9924 
9953 #if SU_HAVE_INLINE
9954 su_inline
9955 #endif
9957  http_vary_t const *hdr)
9958  __attribute__((__malloc__));
9959 
9978 #if SU_HAVE_INLINE
9979 su_inline
9980 #endif
9981 http_vary_t *http_vary_make(su_home_t *home, char const *s)
9982  __attribute__((__malloc__));
9983 
10006 #if SU_HAVE_INLINE
10007 su_inline
10008 #endif
10009 http_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
10015 su_inline
10016 http_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 
10028 su_inline
10030 {
10031  return (http_vary_t *)
10032  msg_header_dup_as(home, http_vary_class, (msg_header_t const *)o);
10033 }
10034 
10035 su_inline
10037 {
10038  return (http_vary_t *)
10039  msg_header_copy_as(home, http_vary_class, (msg_header_t const *)o);
10040 }
10041 
10042 su_inline
10043 http_vary_t *http_vary_make(su_home_t *home, char const *s)
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 
10058 enum {
10060  http_via_hash = 46244
10061 };
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
10109 {
10110  return HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t));
10111 }
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
10131 su_inline
10132 int 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
10169 su_inline
10170 #endif
10172  http_via_t const *hdr)
10173  __attribute__((__malloc__));
10174 
10203 #if SU_HAVE_INLINE
10204 su_inline
10205 #endif
10207  http_via_t const *hdr)
10208  __attribute__((__malloc__));
10209 
10228 #if SU_HAVE_INLINE
10229 su_inline
10230 #endif
10231 http_via_t *http_via_make(su_home_t *home, char const *s)
10232  __attribute__((__malloc__));
10233 
10256 #if SU_HAVE_INLINE
10257 su_inline
10258 #endif
10259 http_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
10265 su_inline
10266 http_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 
10278 su_inline
10280 {
10281  return (http_via_t *)
10282  msg_header_dup_as(home, http_via_class, (msg_header_t const *)o);
10283 }
10284 
10285 su_inline
10287 {
10288  return (http_via_t *)
10289  msg_header_copy_as(home, http_via_class, (msg_header_t const *)o);
10290 }
10291 
10292 su_inline
10293 http_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 
10308 enum {
10310  http_warning_hash = 4130
10311 };
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
10359 {
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
10381 su_inline
10382 int http_is_warning(http_header_t const *header)
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
10419 su_inline
10420 #endif
10422  http_warning_t const *hdr)
10423  __attribute__((__malloc__));
10424 
10453 #if SU_HAVE_INLINE
10454 su_inline
10455 #endif
10457  http_warning_t const *hdr)
10458  __attribute__((__malloc__));
10459 
10478 #if SU_HAVE_INLINE
10479 su_inline
10480 #endif
10481 http_warning_t *http_warning_make(su_home_t *home, char const *s)
10482  __attribute__((__malloc__));
10483 
10506 #if SU_HAVE_INLINE
10507 su_inline
10508 #endif
10509 http_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
10515 su_inline
10516 http_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 
10528 su_inline
10530 {
10531  return (http_warning_t *)
10533 }
10534 
10535 su_inline
10537 {
10538  return (http_warning_t *)
10540 }
10541 
10542 su_inline
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 
10558 enum {
10561 };
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
10608 su_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
10631 su_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
10669 su_inline
10670 #endif
10671 http_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
10704 su_inline
10705 #endif
10706 http_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
10729 su_inline
10730 #endif
10731 http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
10732  __attribute__((__malloc__));
10733 
10756 #if SU_HAVE_INLINE
10757 su_inline
10758 #endif
10759 http_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
10765 su_inline
10766 http_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 
10778 su_inline
10779 http_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 
10785 su_inline
10786 http_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 
10792 su_inline
10793 http_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 
10808 enum {
10811 };
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
10859 {
10861 }
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
10881 su_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
10919 su_inline
10920 #endif
10922  http_proxy_connection_t const *hdr)
10923  __attribute__((__malloc__));
10924 
10953 #if SU_HAVE_INLINE
10954 su_inline
10955 #endif
10957  http_proxy_connection_t const *hdr)
10958  __attribute__((__malloc__));
10959 
10978 #if SU_HAVE_INLINE
10979 su_inline
10980 #endif
10982  __attribute__((__malloc__));
10983 
11006 #if SU_HAVE_INLINE
11007 su_inline
11008 #endif
11010  __attribute__((__malloc__, __format__ (printf, 2, 3)));
11011 
11012 
11013 /* Inlined functions */
11014 #if SU_HAVE_INLINE
11015 su_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 
11028 su_inline
11030 {
11031  return (http_proxy_connection_t *)
11033 }
11034 
11035 su_inline
11037 {
11038  return (http_proxy_connection_t *)
11040 }
11041 
11042 su_inline
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 
11058 enum {
11060  http_set_cookie_hash = 57887
11061 };
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
11109 {
11111 }
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
11131 su_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
11169 su_inline
11170 #endif
11172  http_set_cookie_t const *hdr)
11173  __attribute__((__malloc__));
11174 
11203 #if SU_HAVE_INLINE
11204 su_inline
11205 #endif
11207  http_set_cookie_t const *hdr)
11208  __attribute__((__malloc__));
11209 
11228 #if SU_HAVE_INLINE
11229 su_inline
11230 #endif
11231 http_set_cookie_t *http_set_cookie_make(su_home_t *home, char const *s)
11232  __attribute__((__malloc__));
11233 
11256 #if SU_HAVE_INLINE
11257 su_inline
11258 #endif
11259 http_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
11265 su_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 
11278 su_inline
11280 {
11281  return (http_set_cookie_t *)
11283 }
11284 
11285 su_inline
11287 {
11288  return (http_set_cookie_t *)
11290 }
11291 
11292 su_inline
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 
11308 enum {
11310  http_cookie_hash = 78
11311 };
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
11359 {
11360  return HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t));
11361 }
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
11381 su_inline
11382 int http_is_cookie(http_header_t const *header)
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
11419 su_inline
11420 #endif
11422  http_cookie_t const *hdr)
11423  __attribute__((__malloc__));
11424 
11453 #if SU_HAVE_INLINE
11454 su_inline
11455 #endif
11457  http_cookie_t const *hdr)
11458  __attribute__((__malloc__));
11459 
11478 #if SU_HAVE_INLINE
11479 su_inline
11480 #endif
11481 http_cookie_t *http_cookie_make(su_home_t *home, char const *s)
11482  __attribute__((__malloc__));
11483 
11506 #if SU_HAVE_INLINE
11507 su_inline
11508 #endif
11509 http_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
11515 su_inline
11516 http_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 
11528 su_inline
11530 {
11531  return (http_cookie_t *)
11533 }
11534 
11535 su_inline
11537 {
11538  return (http_cookie_t *)
11540 }
11541 
11542 su_inline
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 
11558 enum {
11560  http_mime_version_hash = 49047
11561 };
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
11608 su_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
11631 su_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
11669 su_inline
11670 #endif
11671 http_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
11704 su_inline
11705 #endif
11706 http_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
11729 su_inline
11730 #endif
11731 http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
11732  __attribute__((__malloc__));
11733 
11756 #if SU_HAVE_INLINE
11757 su_inline
11758 #endif
11759 http_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
11765 su_inline
11766 http_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 
11778 su_inline
11779 http_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 
11785 su_inline
11786 http_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 
11792 su_inline
11793 http_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 
11808 enum {
11811 };
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
11859 {
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
11881 su_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
11919 su_inline
11920 #endif
11922  http_content_encoding_t const *hdr)
11923  __attribute__((__malloc__));
11924 
11953 #if SU_HAVE_INLINE
11954 su_inline
11955 #endif
11957  http_content_encoding_t const *hdr)
11958  __attribute__((__malloc__));
11959 
11978 #if SU_HAVE_INLINE
11979 su_inline
11980 #endif
11982  __attribute__((__malloc__));
11983 
12006 #if SU_HAVE_INLINE
12007 su_inline
12008 #endif
12010  __attribute__((__malloc__, __format__ (printf, 2, 3)));
12011 
12012 
12013 /* Inlined functions */
12014 #if SU_HAVE_INLINE
12015 su_inline
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 
12028 su_inline
12030 {
12031  return (http_content_encoding_t *)
12033 }
12034 
12035 su_inline
12037 {
12038  return (http_content_encoding_t *)
12040 }
12041 
12042 su_inline
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 
12058 enum {
12061 };
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
12109 {
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
12131 su_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
12169 su_inline
12170 #endif
12172  http_content_language_t const *hdr)
12173  __attribute__((__malloc__));
12174 
12203 #if SU_HAVE_INLINE
12204 su_inline
12205 #endif
12207  http_content_language_t const *hdr)
12208  __attribute__((__malloc__));
12209 
12228 #if SU_HAVE_INLINE
12229 su_inline
12230 #endif
12232  __attribute__((__malloc__));
12233 
12256 #if SU_HAVE_INLINE
12257 su_inline
12258 #endif
12260  __attribute__((__malloc__, __format__ (printf, 2, 3)));
12261 
12262 
12263 /* Inlined functions */
12264 #if SU_HAVE_INLINE
12265 su_inline
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 
12278 su_inline
12280 {
12281  return (http_content_language_t *)
12283 }
12284 
12285 su_inline
12287 {
12288  return (http_content_language_t *)
12290 }
12291 
12292 su_inline
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 
12308 enum {
12311 };
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
12359 {
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
12381 su_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
12419 su_inline
12420 #endif
12422  http_content_length_t const *hdr)
12423  __attribute__((__malloc__));
12424 
12453 #if SU_HAVE_INLINE
12454 su_inline
12455 #endif
12457  http_content_length_t const *hdr)
12458  __attribute__((__malloc__));
12459 
12478 #if SU_HAVE_INLINE
12479 su_inline
12480 #endif
12482  __attribute__((__malloc__));
12483 
12506 #if SU_HAVE_INLINE
12507 su_inline
12508 #endif
12509 http_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
12515 su_inline
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 
12528 su_inline
12530 {
12531  return (http_content_length_t *)
12533 }
12534 
12535 su_inline
12537 {
12538  return (http_content_length_t *)
12540 }
12541 
12542 su_inline
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 
12558 enum {
12561 };
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
12608 su_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
12631 su_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
12669 su_inline
12670 #endif
12671 http_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
12704 su_inline
12705 #endif
12706 http_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
12729 su_inline
12730 #endif
12731 http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
12732  __attribute__((__malloc__));
12733 
12756 #if SU_HAVE_INLINE
12757 su_inline
12758 #endif
12759 http_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
12765 su_inline
12766 http_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 
12778 su_inline
12779 http_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 
12785 su_inline
12786 http_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 
12792 su_inline
12793 http_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 
12808 enum {
12810  http_content_md5_hash = 60494
12811 };
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
12858 su_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
12881 su_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
12919 su_inline
12920 #endif
12921 http_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
12954 su_inline
12955 #endif
12956 http_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
12979 su_inline
12980 #endif
12981 http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
12982  __attribute__((__malloc__));
12983 
13006 #if SU_HAVE_INLINE
13007 su_inline
13008 #endif
13009 http_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
13015 su_inline
13016 http_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 
13028 su_inline
13029 http_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 
13035 su_inline
13036 http_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 
13042 su_inline
13043 http_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 
13058 enum {
13060  http_content_range_hash = 64465
13061 };
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
13109 {
13111 }
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
13131 su_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
13169 su_inline
13170 #endif
13172  http_content_range_t const *hdr)
13173  __attribute__((__malloc__));
13174 
13203 #if SU_HAVE_INLINE
13204 su_inline
13205 #endif
13207  http_content_range_t const *hdr)
13208  __attribute__((__malloc__));
13209 
13228 #if SU_HAVE_INLINE
13229 su_inline
13230 #endif
13232  __attribute__((__malloc__));
13233 
13256 #if SU_HAVE_INLINE
13257 su_inline
13258 #endif
13259 http_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
13265 su_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 
13278 su_inline
13280 {
13281  return (http_content_range_t *)
13283 }
13284 
13285 su_inline
13287 {
13288  return (http_content_range_t *)
13290 }
13291 
13292 su_inline
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 
13308 enum {
13310  http_content_type_hash = 51226
13311 };
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
13359 {
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
13381 su_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
13419 su_inline
13420 #endif
13422  http_content_type_t const *hdr)
13423  __attribute__((__malloc__));
13424 
13453 #if SU_HAVE_INLINE
13454 su_inline
13455 #endif
13457  http_content_type_t const *hdr)
13458  __attribute__((__malloc__));
13459 
13478 #if SU_HAVE_INLINE
13479 su_inline
13480 #endif
13482  __attribute__((__malloc__));
13483 
13506 #if SU_HAVE_INLINE
13507 su_inline
13508 #endif
13509 http_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
13515 su_inline
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 
13528 su_inline
13530 {
13531  return (http_content_type_t *)
13533 }
13534 
13535 su_inline
13537 {
13538  return (http_content_type_t *)
13540 }
13541 
13542 su_inline
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 
13558 enum {
13560  http_unknown_hash = -3
13561 };
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
13609 {
13611 }
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
13631 su_inline
13632 int http_is_unknown(http_header_t const *header)
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
13669 su_inline
13670 #endif
13672  http_unknown_t const *hdr)
13673  __attribute__((__malloc__));
13674 
13703 #if SU_HAVE_INLINE
13704 su_inline
13705 #endif
13707  http_unknown_t const *hdr)
13708  __attribute__((__malloc__));
13709 
13728 #if SU_HAVE_INLINE
13729 su_inline
13730 #endif
13731 http_unknown_t *http_unknown_make(su_home_t *home, char const *s)
13732  __attribute__((__malloc__));
13733 
13756 #if SU_HAVE_INLINE
13757 su_inline
13758 #endif
13759 http_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
13765 su_inline
13766 http_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 
13778 su_inline
13780 {
13781  return (http_unknown_t *)
13783 }
13784 
13785 su_inline
13787 {
13788  return (http_unknown_t *)
13790 }
13791 
13792 su_inline
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 
13808 enum {
13810  http_error_hash = -4
13811 };
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
13859 {
13860  return HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t));
13861 }
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
13881 su_inline
13882 int http_is_error(http_header_t const *header)
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
13919 su_inline
13920 #endif
13922  http_error_t const *hdr)
13923  __attribute__((__malloc__));
13924 
13953 #if SU_HAVE_INLINE
13954 su_inline
13955 #endif
13957  http_error_t const *hdr)
13958  __attribute__((__malloc__));
13959 
13978 #if SU_HAVE_INLINE
13979 su_inline
13980 #endif
13981 http_error_t *http_error_make(su_home_t *home, char const *s)
13982  __attribute__((__malloc__));
13983 
14006 #if SU_HAVE_INLINE
14007 su_inline
14008 #endif
14009 http_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
14015 su_inline
14016 http_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 
14028 su_inline
14030 {
14031  return (http_error_t *)
14032  msg_header_dup_as(home, http_error_class, (msg_header_t const *)o);
14033 }
14034 
14035 su_inline
14037 {
14038  return (http_error_t *)
14040 }
14041 
14042 su_inline
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 
14058 enum {
14060  http_separator_hash = -5
14061 };
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
14109 {
14111 }
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
14131 su_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
14169 su_inline
14170 #endif
14172  http_separator_t const *hdr)
14173  __attribute__((__malloc__));
14174 
14203 #if SU_HAVE_INLINE
14204 su_inline
14205 #endif
14207  http_separator_t const *hdr)
14208  __attribute__((__malloc__));
14209 
14228 #if SU_HAVE_INLINE
14229 su_inline
14230 #endif
14231 http_separator_t *http_separator_make(su_home_t *home, char const *s)
14232  __attribute__((__malloc__));
14233 
14256 #if SU_HAVE_INLINE
14257 su_inline
14258 #endif
14259 http_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
14265 su_inline
14266 http_separator_t *http_separator_format(su_home_t *home, char const *fmt, ...)
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 
14278 su_inline
14280 {
14281  return (http_separator_t *)
14283 }
14284 
14285 su_inline
14287 {
14288  return (http_separator_t *)
14290 }
14291 
14292 su_inline
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 
14308 enum {
14310  http_payload_hash = -6
14311 };
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
14359 {
14361 }
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
14381 su_inline
14382 int http_is_payload(http_header_t const *header)
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
14419 su_inline
14420 #endif
14422  http_payload_t const *hdr)
14423  __attribute__((__malloc__));
14424 
14453 #if SU_HAVE_INLINE
14454 su_inline
14455 #endif
14457  http_payload_t const *hdr)
14458  __attribute__((__malloc__));
14459 
14478 #if SU_HAVE_INLINE
14479 su_inline
14480 #endif
14481 http_payload_t *http_payload_make(su_home_t *home, char const *s)
14482  __attribute__((__malloc__));
14483 
14506 #if SU_HAVE_INLINE
14507 su_inline
14508 #endif
14509 http_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
14515 su_inline
14516 http_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 
14528 su_inline
14530 {
14531  return (http_payload_t *)
14533 }
14534 
14535 su_inline
14537 {
14538  return (http_payload_t *)
14540 }
14541 
14542 su_inline
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 
14554 SOFIA_END_DECLS
14555 #endif /* !defined(HTTP_PROTOS_H) */
http_accept_e
msg_print_f http_accept_e
Encode (print) a Accept header.
Definition: http_protos.h:579
http_expires_hash
@ http_expires_hash
Hash of Expires header.
Definition: http_protos.h:4060
http_error_init
http_error_t * http_error_init(http_error_t x[1])
Initialize a structure http_error_t.
Definition: http_protos.h:13858
http_mime_version_e
msg_print_f http_mime_version_e
Encode (print) a MIME-Version header.
Definition: http_protos.h:11579
http_content_length_e
msg_print_f http_content_length_e
Encode (print) a Content-Length header.
Definition: http_protos.h:12329
http_upgrade_d
msg_parse_f http_upgrade_d
Decode (parse) a Upgrade header.
Definition: http_protos.h:9326
http_etag_copy
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
http_status_make
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_te_copy
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
http_if_range_dup
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
http_is_accept_language
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_content_language_e
msg_print_f http_content_language_e
Encode (print) a Content-Language header.
Definition: http_protos.h:12079
http_connection_init
http_connection_t * http_connection_init(http_connection_t x[1])
Initialize a structure http_connection_t.
Definition: http_protos.h:3108
http_expires_dup
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
su_home_t
SU_HOME_T su_home_t
http_unknown_init
http_unknown_t * http_unknown_init(http_unknown_t x[1])
Initialize a structure http_unknown_t.
Definition: http_protos.h:13608
http_date_copy
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
http_status_dup
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_request_dup
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
http_accept_copy
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_location_make
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_last_modified_hash
@ http_last_modified_hash
Hash of Last-Modified header.
Definition: http_protos.h:6060
http_is_accept
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_max_forwards_d
msg_parse_f http_max_forwards_d
Decode (parse) a Max-Forwards header.
Definition: http_protos.h:6576
http_is_te
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_user_agent_format
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_is_allow
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_unknown_format
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
http_if_modified_since_format
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
http_trailer_d
msg_parse_f http_trailer_d
Decode (parse) a Trailer header.
Definition: http_protos.h:8826
http_content_md5_hash
@ http_content_md5_hash
Hash of Content-MD5 header.
Definition: http_protos.h:12810
http_date_e
msg_print_f http_date_e
Encode (print) a Date header.
Definition: http_protos.h:3329
http_content_md5_d
msg_parse_f http_content_md5_d
Decode (parse) a Content-MD5 header.
Definition: http_protos.h:12826
http_separator_format
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
http_connection_hash
@ http_connection_hash
Hash of Connection header.
Definition: http_protos.h:3060
http_age_copy
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
http_date_class
msg_hclass_t http_date_class[]
Header class for HTTP Date header.
Definition: http_basic.c:598
http_from_e
msg_print_f http_from_e
Encode (print) a From header.
Definition: http_protos.h:4329
http_accept_encoding_dup
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_warning_copy
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
http_location_dup
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_accept_charset_hash
@ http_accept_charset_hash
Hash of Accept-Charset header.
Definition: http_protos.h:810
http_expect_d
msg_parse_f http_expect_d
Decode (parse) a Expect header.
Definition: http_protos.h:3826
http_via_format
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
http_server_init
http_server_t * http_server_init(http_server_t x[1])
Initialize a structure http_server_t.
Definition: http_protos.h:8358
http_warning_class
msg_hclass_t http_warning_class[]
Header class for HTTP Warning header.
Definition: http_basic.c:1602
http_content_language_init
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_is_content_length
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_if_none_match_make
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
http_host_format
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
http_server_class
msg_hclass_t http_server_class[]
Header class for HTTP Server header.
Definition: http_basic.c:1325
http_from_init
http_from_t * http_from_init(http_from_t x[1])
Initialize a structure http_from_t.
Definition: http_protos.h:4358
http_proxy_authorization_copy
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_authentication_info_dup
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_is_user_agent
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
http_is_if_none_match
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_proxy_authenticate_e
msg_print_f http_proxy_authenticate_e
Encode (print) a Proxy-Authenticate header.
Definition: http_protos.h:7079
http_if_range_hash
@ http_if_range_hash
Hash of If-Range header.
Definition: http_protos.h:5560
http_from_format
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
http_max_forwards_dup
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_is_pragma
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_expires_copy
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
http_accept_language_copy
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
http_te_s
TE.
Definition: http.h:273
http_accept_make
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
http_retry_after_class
msg_hclass_t http_retry_after_class[]
Header class for HTTP Retry-After header.
Definition: http_basic.c:1317
http_warning_hash
@ http_warning_hash
Hash of Warning header.
Definition: http_protos.h:10310
http_is_payload
int http_is_payload(http_header_t const *header)
Test if header object is instance of http_payload_t.
Definition: http_protos.h:14382
http_connection_copy
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_location_init
http_location_t * http_location_init(http_location_t x[1])
Initialize a structure http_location_t.
Definition: http_protos.h:6358
http_is_max_forwards
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
http_transfer_encoding_class
msg_hclass_t http_transfer_encoding_class[]
Header class for HTTP Transfer-Encoding header.
Definition: http_basic.c:1460
http_accept_encoding_hash
@ http_accept_encoding_hash
Hash of Accept-Encoding header.
Definition: http_protos.h:1060
http_range_init
http_range_t * http_range_init(http_range_t x[1])
Initialize a structure http_range_t.
Definition: http_protos.h:7608
http_if_match_d
msg_parse_f http_if_match_d
Decode (parse) a If-Match header.
Definition: http_protos.h:4826
http_range_hash
@ http_range_hash
Hash of Range header.
Definition: http_protos.h:7560
http_retry_after_s
Retry-After.
Definition: http.h:265
http_max_forwards_copy
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_server_e
msg_print_f http_server_e
Encode (print) a Server header.
Definition: http_protos.h:8329
http_accept_encoding_e
msg_print_f http_accept_encoding_e
Encode (print) a Accept-Encoding header.
Definition: http_protos.h:1079
http_content_language_d
msg_parse_f http_content_language_d
Decode (parse) a Content-Language header.
Definition: http_protos.h:12076
http_content_location_init
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_range_format
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
http_retry_after_d
msg_parse_f http_retry_after_d
Decode (parse) a Retry-After header.
Definition: http_protos.h:8076
http_is_transfer_encoding
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_dup
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
http_content_range_copy
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
http_range_e
msg_print_f http_range_e
Encode (print) a Range header.
Definition: http_protos.h:7579
http_upgrade_make
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
http_accept_dup
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_range_s
Range.
Definition: http.h:257
msg_payload_s
http_age_make
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_vary_format
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
http_date_s
Date, Expires, If-Modified-Since, If-Unmodified-Since, Last-Modified.
Definition: http.h:219
http_location_copy
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
http_retry_after_init
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_unknown_copy
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_last_modified_format
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_is_date
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_content_location_dup
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
http_if_none_match_format
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_content_range_dup
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_type_init
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
http_from_hash
@ http_from_hash
Hash of From header.
Definition: http_protos.h:4310
http_if_none_match_init
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
http_pragma_class
msg_hclass_t http_pragma_class[]
Header class for HTTP Pragma header.
Definition: http_basic.c:1042
http_content_length_d
msg_parse_f http_content_length_d
Decode (parse) a Content-Length header.
Definition: http_protos.h:12326
http_content_encoding_dup
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
http_via_copy
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_server_make
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_accept_charset_copy
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
http_cache_control_init
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
http_authorization_d
msg_parse_f http_authorization_d
Decode (parse) a Authorization header.
Definition: http_protos.h:2326
http_expect_init
http_expect_t * http_expect_init(http_expect_t x[1])
Initialize a structure http_expect_t.
Definition: http_protos.h:3858
http_content_md5_dup
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_status_format
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
http_if_range_class
msg_hclass_t http_if_range_class[]
Header class for HTTP If-Range header.
Definition: http_basic.c:876
http_accept_charset_d
msg_parse_f http_accept_charset_d
Decode (parse) a Accept-Charset header.
Definition: http_protos.h:826
http_proxy_connection_make
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_authorization_make
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
http_content_encoding_class
msg_hclass_t http_content_encoding_class[]
Header class for HTTP Content-Encoding header.
http_www_authenticate_hash
@ http_www_authenticate_hash
Hash of WWW-Authenticate header.
Definition: http_protos.h:10560
http_retry_after_format
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
http_if_range_copy
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_vary_hash
@ http_vary_hash
Hash of Vary header.
Definition: http_protos.h:9810
http_content_length_copy
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
su_inline
#define su_inline
http_content_encoding_init
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_proxy_connection_copy
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
http_expires_make
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_if_unmodified_since_e
msg_print_f http_if_unmodified_since_e
Encode (print) a If-Unmodified-Since header.
Definition: http_protos.h:5829
http_trailer_copy
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
http_accept_encoding_d
msg_parse_f http_accept_encoding_d
Decode (parse) a Accept-Encoding header.
Definition: http_protos.h:1076
http_retry_after_hash
@ http_retry_after_hash
Hash of Retry-After header.
Definition: http_protos.h:8060
http_accept_ranges_d
msg_parse_f http_accept_ranges_d
Decode (parse) a Accept-Ranges header.
Definition: http_protos.h:1576
http_date_dup
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
http_host_e
msg_print_f http_host_e
Encode (print) a Host header.
Definition: http_protos.h:4579
http_is_etag
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_accept_charset_init
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_language_class
msg_hclass_t http_accept_language_class[]
Header class for HTTP Accept-Language header.
http_host_hash
@ http_host_hash
Hash of Host header.
Definition: http_protos.h:4560
http_content_md5_init
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
http_if_unmodified_since_dup
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
http_is_from
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_is_expires
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_server_copy
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
http_request_format
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
http_content_type_make
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_if_modified_since_dup
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_accept_ranges_class
msg_hclass_t http_accept_ranges_class[]
Header class for HTTP Accept-Ranges header.
Definition: http_basic.c:314
msg_list_s
http_unknown_dup
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
http_if_modified_since_copy
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_authentication_info_e
msg_print_f http_authentication_info_e
Encode (print) a Authentication-Info header.
Definition: http_protos.h:2079
http_is_request
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_error_format
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
http_is_separator
int http_is_separator(http_header_t const *header)
Test if header object is instance of http_separator_t.
Definition: http_protos.h:14132
http_www_authenticate_class
msg_hclass_t http_www_authenticate_class[]
Header class for HTTP WWW-Authenticate header.
Definition: http_basic.c:1611
http_transfer_encoding_init
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_retry_after_dup
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
http_host_copy
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_accept_ranges_dup
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
http_is_connection
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_if_range_format
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
http_max_forwards_s
Max-Forwards.
Definition: http.h:249
http_location_e
msg_print_f http_location_e
Encode (print) a Location header.
Definition: http_protos.h:6329
http_range_make
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
http_content_language_class
msg_hclass_t http_content_language_class[]
Header class for HTTP Content-Language header.
http_expect_dup
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_location_class
msg_hclass_t http_location_class[]
Header class for HTTP Location header.
Definition: http_basic.c:1026
http_range_format
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_accept_encoding_format
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_HEADER_INIT
#define HTTP_HEADER_INIT(h, http_class, size)
Initialize a HTTP header structure.
Definition: http_header.h:61
http_is_if_match
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_host_init
http_host_t * http_host_init(http_host_t x[1])
Initialize a structure http_host_t.
Definition: http_protos.h:4608
http_cache_control_make
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
http_is_authorization
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_init
http_authorization_t * http_authorization_init(http_authorization_t x[1])
Initialize a structure http_authorization_t.
Definition: http_protos.h:2358
http_pragma_make
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
http_referer_format
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_content_location_d
msg_parse_f http_content_location_d
Decode (parse) a Content-Location header.
Definition: http_protos.h:12576
http_via_init
http_via_t * http_via_init(http_via_t x[1])
Initialize a structure http_via_t.
Definition: http_protos.h:10108
http_vary_copy
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_init
http_vary_t * http_vary_init(http_vary_t x[1])
Initialize a structure http_vary_t.
Definition: http_protos.h:9858
http_is_last_modified
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_host_class
msg_hclass_t http_host_class[]
Header class for HTTP Host header.
Definition: http_basic.c:750
http_content_range_d
msg_parse_f http_content_range_d
Decode (parse) a Content-Range header.
Definition: http_protos.h:13076
http_is_proxy_connection
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_allow_copy
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_separator_hash
@ http_separator_hash
Hash of separator line between headers and body.
Definition: http_protos.h:14060
http_error_class
msg_hclass_t http_error_class[]
Header class for HTTP erroneous headers.
http_content_language_dup
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
http_unknown_e
msg_print_f http_unknown_e
Encode (print) a unknown headers.
Definition: http_protos.h:13579
http_is_unknown
int http_is_unknown(http_header_t const *header)
Test if header object is instance of http_unknown_t.
Definition: http_protos.h:13632
http_age_d
msg_parse_f http_age_d
Decode (parse) a Age header.
Definition: http_protos.h:2576
http_last_modified_class
msg_hclass_t http_last_modified_class[]
Header class for HTTP Last-Modified header.
Definition: http_basic.c:951
http_host_s
Host.
Definition: http.h:226
http_if_match_copy
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
http_allow_hash
@ http_allow_hash
Hash of Allow header.
Definition: http_protos.h:1810
http_separator_d
msg_parse_f http_separator_d
Decode (parse) a separator line between headers and body.
Definition: http_protos.h:14076
http_payload_copy
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
http_is_www_authenticate
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_proxy_authorization_class
msg_hclass_t http_proxy_authorization_class[]
Header class for HTTP Proxy-Authorization header.
Definition: http_basic.c:1060
http_expires_d
msg_parse_f http_expires_d
Decode (parse) a Expires header.
Definition: http_protos.h:4076
http_allow_e
msg_print_f http_allow_e
Encode (print) a Allow header.
Definition: http_protos.h:1829
http_is_via
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_if_none_match_e
msg_print_f http_if_none_match_e
Encode (print) a If-None-Match header.
Definition: http_protos.h:5329
http_allow_format
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_vary_make
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
http_www_authenticate_copy
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_age_dup
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
http_proxy_authenticate_format
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
http_cache_control_dup
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
http_te_e
msg_print_f http_te_e
Encode (print) a TE header.
Definition: http_protos.h:8579
http_unknown_t
msg_generic_t http_unknown_t
Unknown header.
Definition: http.h:163
http_pragma_format
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
http_transfer_encoding_d
msg_parse_f http_transfer_encoding_d
Decode (parse) a Transfer-Encoding header.
Definition: http_protos.h:9076
http_allow_make
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
http_proxy_authenticate_init
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
http_is_vary
int http_is_vary(http_header_t const *header)
Test if header object is instance of http_vary_t.
Definition: http_protos.h:9882
msg_separator_s
http_te_dup
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
http_authorization_copy
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_error_copy
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_status_init
http_status_t * http_status_init(http_status_t x[1])
Initialize a structure http_status_t.
Definition: http_protos.h:358
http_from_dup
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
http_last_modified_e
msg_print_f http_last_modified_e
Encode (print) a Last-Modified header.
Definition: http_protos.h:6079
http_user_agent_d
msg_parse_f http_user_agent_d
Decode (parse) a User-Agent header.
Definition: http_protos.h:9576
http_if_range_e
msg_print_f http_if_range_e
Encode (print) a If-Range header.
Definition: http_protos.h:5579
http_vary_class
msg_hclass_t http_vary_class[]
Header class for HTTP Vary header.
Definition: http_basic.c:1484
http_is_content_type
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_user_agent_e
msg_print_f http_user_agent_e
Encode (print) a User-Agent header.
Definition: http_protos.h:9579
http_if_unmodified_since_class
msg_hclass_t http_if_unmodified_since_class[]
Header class for HTTP If-Unmodified-Since header.
Definition: http_basic.c:915
msg_content_type_s
http_separator_make
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
http_transfer_encoding_copy
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_accept_encoding_make
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_is_authentication_info
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
http_www_authenticate_d
msg_parse_f http_www_authenticate_d
Decode (parse) a WWW-Authenticate header.
Definition: http_protos.h:10576
http_upgrade_format
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
http_mime_version_make
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_header_dup_as
msg_header_t * msg_header_dup_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
http_if_modified_since_make
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_date_make
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_via_s
Via.
Definition: http.h:282
http_accept_encoding_class
msg_hclass_t http_accept_encoding_class[]
Header class for HTTP Accept-Encoding header.
http_content_encoding_make
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_max_forwards_hash
@ http_max_forwards_hash
Hash of Max-Forwards header.
Definition: http_protos.h:6560
http_accept_ranges_init
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_is_proxy_authorization
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_upgrade_dup
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
http_is_age
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_connection_format
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
http_retry_after_make
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
http_if_modified_since_d
msg_parse_f http_if_modified_since_d
Decode (parse) a If-Modified-Since header.
Definition: http_protos.h:5076
http_authentication_info_make
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
http_content_location_copy
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_proxy_authenticate_make
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
http_user_agent_copy
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_warning_d
msg_parse_f http_warning_d
Decode (parse) a Warning header.
Definition: http_protos.h:10326
http_if_none_match_copy
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_content_location_make
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
http_request_init
http_request_t * http_request_init(http_request_t x[1])
Initialize a structure http_request_t.
Definition: http_protos.h:108
http_accept_charset_dup
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_is_referer
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_upgrade_e
msg_print_f http_upgrade_e
Encode (print) a Upgrade header.
Definition: http_protos.h:9329
http_is_cache_control
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_referer_make
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
http_allow_dup
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
http_content_type_format
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_md5_copy
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
http_is_range
int http_is_range(http_header_t const *header)
Test if header object is instance of http_range_t.
Definition: http_protos.h:7632
http_is_accept_charset
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_content_language_format
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_md5_e
msg_print_f http_content_md5_e
Encode (print) a Content-MD5 header.
Definition: http_protos.h:12829
http_content_location_class
msg_hclass_t http_content_location_class[]
Header class for HTTP Content-Location header.
http_te_hash
@ http_te_hash
Hash of TE header.
Definition: http_protos.h:8560
http_if_unmodified_since_format
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_age_class
msg_hclass_t http_age_class[]
Header class for HTTP Age header.
Definition: http_basic.c:324
http_cache_control_format
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_content_type_d
msg_parse_f http_content_type_d
Decode (parse) a Content-Type header.
Definition: http_protos.h:13326
http_via_dup
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
http_accept_language_init
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
http_expires_class
msg_hclass_t http_expires_class[]
Header class for HTTP Expires header.
Definition: http_basic.c:653
http_range_class
msg_hclass_t http_range_class[]
Header class for HTTP Range header.
Definition: http_basic.c:1213
http_if_modified_since_hash
@ http_if_modified_since_hash
Hash of If-Modified-Since header.
Definition: http_protos.h:5060
http_is_accept_ranges
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_if_none_match_hash
@ http_if_none_match_hash
Hash of If-None-Match header.
Definition: http_protos.h:5310
http_pragma_dup
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
http_header.h
HTTP library prototypes.
http_status_copy
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
http_content_range_init
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_host_d
msg_parse_f http_host_d
Decode (parse) a Host header.
Definition: http_protos.h:4576
http_warning_init
http_warning_t * http_warning_init(http_warning_t x[1])
Initialize a structure http_warning_t.
Definition: http_protos.h:10358
http_accept_ranges_e
msg_print_f http_accept_ranges_e
Encode (print) a Accept-Ranges header.
Definition: http_protos.h:1579
http_content_encoding_copy
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_location_hash
@ http_location_hash
Hash of Location header.
Definition: http_protos.h:6310
http_unknown_class
msg_hclass_t http_unknown_class[]
Header class for HTTP unknown headers.
http_content_type_e
msg_print_f http_content_type_e
Encode (print) a Content-Type header.
Definition: http_protos.h:13329
http_content_length_init
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_connection_e
msg_print_f http_connection_e
Encode (print) a Connection header.
Definition: http_protos.h:3079
http_proxy_authenticate_class
msg_hclass_t http_proxy_authenticate_class[]
Header class for HTTP Proxy-Authenticate header.
Definition: http_basic.c:1051
http_referer_init
http_referer_t * http_referer_init(http_referer_t x[1])
Initialize a structure http_referer_t.
Definition: http_protos.h:7858
http_pragma_init
http_pragma_t * http_pragma_init(http_pragma_t x[1])
Initialize a structure http_pragma_t.
Definition: http_protos.h:6858
http_payload_make
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_error_d
msg_parse_f http_error_d
Decode (parse) a erroneous headers.
Definition: http_protos.h:13826
http_request_e
msg_print_f http_request_e
Encode (print) a request line.
Definition: http_protos.h:79
http_expect_class
msg_hclass_t http_expect_class[]
Header class for HTTP Expect header.
Definition: http_basic.c:617
http_status_hash
@ http_status_hash
Hash of status line.
Definition: http_protos.h:310
http_accept_ranges_make
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_content_type_hash
@ http_content_type_hash
Hash of Content-Type header.
Definition: http_protos.h:13310
http_content_encoding_hash
@ http_content_encoding_hash
Hash of Content-Encoding header.
Definition: http_protos.h:11810
http_content_range_s
Content-Range.
Definition: http.h:210
http_separator_e
msg_print_f http_separator_e
Encode (print) a separator line between headers and body.
Definition: http_protos.h:14079
http_payload_d
msg_parse_f http_payload_d
Decode (parse) a message payload.
Definition: http_protos.h:14326
http_referer_e
msg_print_f http_referer_e
Encode (print) a Referer header.
Definition: http_protos.h:7829
http_proxy_authorization_d
msg_parse_f http_proxy_authorization_d
Decode (parse) a Proxy-Authorization header.
Definition: http_protos.h:7326
http_accept_encoding_init
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_class
msg_hclass_t http_accept_class[]
Header class for HTTP Accept header.
http_trailer_init
http_trailer_t * http_trailer_init(http_trailer_t x[1])
Initialize a structure http_trailer_t.
Definition: http_protos.h:8858
http_location_d
msg_parse_f http_location_d
Decode (parse) a Location header.
Definition: http_protos.h:6326
http_separator_copy
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
http_proxy_connection_format
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
http_if_match_dup
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_allow_d
msg_parse_f http_allow_d
Decode (parse) a Allow header.
Definition: http_protos.h:1826
http_error_e
msg_print_f http_error_e
Encode (print) a erroneous headers.
Definition: http_protos.h:13829
http_proxy_authorization_format
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
msg_header_copy_as
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
http_content_location_e
msg_print_f http_content_location_e
Encode (print) a Content-Location header.
Definition: http_protos.h:12579
http_retry_after_copy
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_if_match_init
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
http_location_s
Location, Referer.
Definition: http.h:242
http_if_match_format
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
http_request_d
msg_parse_f http_request_d
Decode (parse) a request line.
Definition: http_protos.h:76
http_authorization_format
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
http_max_forwards_init
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_upgrade_init
http_upgrade_t * http_upgrade_init(http_upgrade_t x[1])
Initialize a structure http_upgrade_t.
Definition: http_protos.h:9358
http_is_upgrade
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_accept_language_make
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_if_range_s
If-Range.
Definition: http.h:234
http_allow_init
http_allow_t * http_allow_init(http_allow_t x[1])
Initialize a structure http_allow_t.
Definition: http_protos.h:1858
http_accept_language_d
msg_parse_f http_accept_language_d
Decode (parse) a Accept-Language header.
Definition: http_protos.h:1326
http_user_agent_dup
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
SOFIAPUBVAR
#define SOFIAPUBVAR
http_if_unmodified_since_hash
@ http_if_unmodified_since_hash
Hash of If-Unmodified-Since header.
Definition: http_protos.h:5810
http_request_s
HTTP request line.
Definition: http.h:179
http_if_none_match_d
msg_parse_f http_if_none_match_d
Decode (parse) a If-None-Match header.
Definition: http_protos.h:5326
msg_header_t
MSG_HDR_T msg_header_t
http_content_length_dup
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_via_d
msg_parse_f http_via_d
Decode (parse) a Via header.
Definition: http_protos.h:10076
http_hclasses.h
HTTP header classes.
http_accept_ranges_format
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
http_payload_hash
@ http_payload_hash
Hash of message payload.
Definition: http_protos.h:14310
http_proxy_connection_d
msg_parse_f http_proxy_connection_d
Decode (parse) a Proxy-Connection header.
Definition: http_protos.h:10826
http_last_modified_dup
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_if_match_class
msg_hclass_t http_if_match_class[]
Header class for HTTP If-Match header.
Definition: http_basic.c:758
http_is_expect
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_mime_version_hash
@ http_mime_version_hash
Hash of MIME-Version header.
Definition: http_protos.h:11560
http_expires_format
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_etag_make
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_if_unmodified_since_d
msg_parse_f http_if_unmodified_since_d
Decode (parse) a If-Unmodified-Since header.
Definition: http_protos.h:5826
http_authentication_info_d
msg_parse_f http_authentication_info_d
Decode (parse) a Authentication-Info header.
Definition: http_protos.h:2076
http_mime_version_init
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
http_date_d
msg_parse_f http_date_d
Decode (parse) a Date header.
Definition: http_protos.h:3326
http_is_host
int http_is_host(http_header_t const *header)
Test if header object is instance of http_host_t.
Definition: http_protos.h:4632
http_mime_version_d
msg_parse_f http_mime_version_d
Decode (parse) a MIME-Version header.
Definition: http_protos.h:11576
http_max_forwards_make
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_if_range_make
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_date_init
http_date_t * http_date_init(http_date_t x[1])
Initialize a structure http_date_t.
Definition: http_protos.h:3358
http_cache_control_hash
@ http_cache_control_hash
Hash of Cache-Control header.
Definition: http_protos.h:2810
http_if_range_d
msg_parse_f http_if_range_d
Decode (parse) a If-Range header.
Definition: http_protos.h:5576
http_content_range_hash
@ http_content_range_hash
Hash of Content-Range header.
Definition: http_protos.h:13060
http_content_encoding_format
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
http_unknown_d
msg_parse_f http_unknown_d
Decode (parse) a unknown headers.
Definition: http_protos.h:13576
http_max_forwards_class
msg_hclass_t http_max_forwards_class[]
Header class for HTTP Max-Forwards header.
Definition: http_basic.c:1034
http_accept_language_format
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
http_content_length_class
msg_hclass_t http_content_length_class[]
Header class for HTTP Content-Length header.
http_accept_charset_class
msg_hclass_t http_accept_charset_class[]
Header class for HTTP Accept-Charset header.
http_content_encoding_e
msg_print_f http_content_encoding_e
Encode (print) a Content-Encoding header.
Definition: http_protos.h:11829
http_is_content_location
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
SOFIAPUBFUN
#define SOFIAPUBFUN
http_via_make
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_vary_d
msg_parse_f http_vary_d
Decode (parse) a Vary header.
Definition: http_protos.h:9826
http_te_d
msg_parse_f http_te_d
Decode (parse) a TE header.
Definition: http_protos.h:8576
http_is_server
int http_is_server(http_header_t const *header)
Test if header object is instance of http_server_t.
Definition: http_protos.h:8382
http_if_modified_since_class
msg_hclass_t http_if_modified_since_class[]
Header class for HTTP If-Modified-Since header.
Definition: http_basic.c:796
http_status_e
msg_print_f http_status_e
Encode (print) a status line.
Definition: http_protos.h:329
http_content_md5_make
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_te_class
msg_hclass_t http_te_class[]
Header class for HTTP TE header.
Definition: http_basic.c:1443
http_accept_encoding_copy
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
http_server_format
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_mime_version_class
msg_hclass_t http_mime_version_class[]
Header class for HTTP MIME-Version header.
http_cache_control_class
msg_hclass_t http_cache_control_class[]
Header class for HTTP Cache-Control header.
Definition: http_basic.c:367
http_proxy_authorization_e
msg_print_f http_proxy_authorization_e
Encode (print) a Proxy-Authorization header.
Definition: http_protos.h:7329
http_proxy_authenticate_copy
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_via_class
msg_hclass_t http_via_class[]
Header class for HTTP Via header.
Definition: http_basic.c:1591
http_expect_copy
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_content_md5_format
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_accept_hash
@ http_accept_hash
Hash of Accept header.
Definition: http_protos.h:560
http_vary_dup
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
http_error_hash
@ http_error_hash
Hash of erroneous headers.
Definition: http_protos.h:13810
http_if_match_hash
@ http_if_match_hash
Hash of If-Match header.
Definition: http_protos.h:4810
http_status_d
msg_parse_f http_status_d
Decode (parse) a status line.
Definition: http_protos.h:326
http_user_agent_make
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
http_authorization_dup
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_hclass_t
struct msg_hclass_s const msg_hclass_t
http_accept_charset_make
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
http_is_warning
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_etag_hash
@ http_etag_hash
Hash of ETag header.
Definition: http_protos.h:3560
http_proxy_authenticate_hash
@ http_proxy_authenticate_hash
Hash of Proxy-Authenticate header.
Definition: http_protos.h:7060
http_accept_language_hash
@ http_accept_language_hash
Hash of Accept-Language header.
Definition: http_protos.h:1310
http_proxy_connection_dup
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_range_copy
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
http_expect_make
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_proxy_authorization_hash
@ http_proxy_authorization_hash
Hash of Proxy-Authorization header.
Definition: http_protos.h:7310
http_if_unmodified_since_init
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
http_last_modified_d
msg_parse_f http_last_modified_d
Decode (parse) a Last-Modified header.
Definition: http_protos.h:6076
http_mime_version_copy
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
http_mime_version_dup
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_is_accept_encoding
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
http_max_forwards_e
msg_print_f http_max_forwards_e
Encode (print) a Max-Forwards header.
Definition: http_protos.h:6579
http_error_make
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
http_authorization_make
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
msg_warning_s
http_authorization_e
msg_print_f http_authorization_e
Encode (print) a Authorization header.
Definition: http_protos.h:2329
http_is_content_encoding
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
http_expires_init
http_expires_t * http_expires_init(http_expires_t x[1])
Initialize a structure http_expires_t.
Definition: http_protos.h:4108
http_transfer_encoding_e
msg_print_f http_transfer_encoding_e
Encode (print) a Transfer-Encoding header.
Definition: http_protos.h:9079
http_proxy_authorization_init
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
http_mime_version_format
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_pragma_d
msg_parse_f http_pragma_d
Decode (parse) a Pragma header.
Definition: http_protos.h:6826
http_content_type_class
msg_hclass_t http_content_type_class[]
Header class for HTTP Content-Type header.
http_age_e
msg_print_f http_age_e
Encode (print) a Age header.
Definition: http_protos.h:2579
http_content_location_hash
@ http_content_location_hash
Hash of Content-Location header.
Definition: http_protos.h:12560
http_proxy_connection_e
msg_print_f http_proxy_connection_e
Encode (print) a Proxy-Connection header.
Definition: http_protos.h:10829
http_last_modified_init
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
http_accept_ranges_hash
@ http_accept_ranges_hash
Hash of Accept-Ranges header.
Definition: http_protos.h:1560
http_content_location_format
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
http_warning_e
msg_print_f http_warning_e
Encode (print) a Warning header.
Definition: http_protos.h:10329
http_authentication_info_copy
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_content_length_make
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_host_make
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_accept_init
http_accept_t * http_accept_init(http_accept_t x[1])
Initialize a structure http_accept_t.
Definition: http_protos.h:608
http_via_hash
@ http_via_hash
Hash of Via header.
Definition: http_protos.h:10060
http_accept_d
msg_parse_f http_accept_d
Decode (parse) a Accept header.
Definition: http_protos.h:576
http_content_encoding_d
msg_parse_f http_content_encoding_d
Decode (parse) a Content-Encoding header.
Definition: http_protos.h:11826
http_range_dup
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_payload_e
msg_print_f http_payload_e
Encode (print) a message payload.
Definition: http_protos.h:14329
http_authentication_info_class
msg_hclass_t http_authentication_info_class[]
Header class for HTTP Authentication-Info header.
Definition: http_basic.c:345
http_trailer_dup
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
http_age_format
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_trailer_hash
@ http_trailer_hash
Hash of Trailer header.
Definition: http_protos.h:8810
http_accept_charset_format
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_te_format
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_www_authenticate_e
msg_print_f http_www_authenticate_e
Encode (print) a WWW-Authenticate header.
Definition: http_protos.h:10579
http_trailer_format
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
http_etag_d
msg_parse_f http_etag_d
Decode (parse) a ETag header.
Definition: http_protos.h:3576
http_date_hash
@ http_date_hash
Hash of Date header.
Definition: http_protos.h:3310
http_proxy_authenticate_dup
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
http_content_type_dup
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_pragma_e
msg_print_f http_pragma_e
Encode (print) a Pragma header.
Definition: http_protos.h:6829
http_is_status
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_separator_class
msg_hclass_t http_separator_class[]
Header class for HTTP separator line between headers and body.
http_content_length_hash
@ http_content_length_hash
Hash of Content-Length header.
Definition: http_protos.h:12310
http_status_s
HTTP status line.
Definition: http.h:189
http_via_e
msg_print_f http_via_e
Encode (print) a Via header.
Definition: http_protos.h:10079
http_etag_class
msg_hclass_t http_etag_class[]
Header class for HTTP ETag header.
Definition: http_basic.c:608
http_from_make
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_is_if_range
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_unknown_hash
@ http_unknown_hash
Hash of unknown headers.
Definition: http_protos.h:13560
http_referer_dup
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
http_server_dup
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_trailer_e
msg_print_f http_trailer_e
Encode (print) a Trailer header.
Definition: http_protos.h:8829
http_transfer_encoding_hash
@ http_transfer_encoding_hash
Hash of Transfer-Encoding header.
Definition: http_protos.h:9060
http_te_make
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_status_class
msg_hclass_t http_status_class[]
Header class for HTTP status line.
Definition: http_basic.c:282
http_unknown_make
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_content_type_copy
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
http_proxy_authorization_dup
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
http_www_authenticate_format
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
http_expires_e
msg_print_f http_expires_e
Encode (print) a Expires header.
Definition: http_protos.h:4079
http_if_match_e
msg_print_f http_if_match_e
Encode (print) a If-Match header.
Definition: http_protos.h:4829
http_is_retry_after
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_expect_format
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
http_server_hash
@ http_server_hash
Hash of Server header.
Definition: http_protos.h:8310
http_if_unmodified_since_copy
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
http_proxy_connection_init
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_upgrade_hash
@ http_upgrade_hash
Hash of Upgrade header.
Definition: http_protos.h:9310
http_if_range_init
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_request_class
msg_hclass_t http_request_class[]
Header class for HTTP request line.
Definition: http_basic.c:180
http_expect_e
msg_print_f http_expect_e
Encode (print) a Expect header.
Definition: http_protos.h:3829
http_from_d
msg_parse_f http_from_d
Decode (parse) a From header.
Definition: http_protos.h:4326
http_is_content_language
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_user_agent_init
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_authorization_class
msg_hclass_t http_authorization_class[]
Header class for HTTP Authorization header.
Definition: http_basic.c:358
http_etag_e
msg_print_f http_etag_e
Encode (print) a ETag header.
Definition: http_protos.h:3579
http_connection_class
msg_hclass_t http_connection_class[]
Header class for HTTP Connection header.
Definition: http_basic.c:375
http_pragma_copy
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_payload_format
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
http_te_init
http_te_t * http_te_init(http_te_t x[1])
Initialize a structure http_te_t.
Definition: http_protos.h:8608
http_is_mime_version
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_cache_control_e
msg_print_f http_cache_control_e
Encode (print) a Cache-Control header.
Definition: http_protos.h:2829
http_is_proxy_authenticate
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_error_dup
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
http_warning_dup
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_location_format
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
http_connection_d
msg_parse_f http_connection_d
Decode (parse) a Connection header.
Definition: http_protos.h:3076
http_is_location
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_content_language_copy
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_range_d
msg_parse_f http_range_d
Decode (parse) a Range header.
Definition: http_protos.h:7576
http_is_if_modified_since
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
http_trailer_make
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
http_pragma_hash
@ http_pragma_hash
Hash of Pragma header.
Definition: http_protos.h:6810
http_is_content_range
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
http_accept_language_e
msg_print_f http_accept_language_e
Encode (print) a Accept-Language header.
Definition: http_protos.h:1329
http_is_trailer
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_request_hash
@ http_request_hash
Hash of request line.
Definition: http_protos.h:60
http_separator_dup
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_connection_dup
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
http_request_make
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
http_accept_charset_e
msg_print_f http_accept_charset_e
Encode (print) a Accept-Charset header.
Definition: http_protos.h:829
http_www_authenticate_init
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_user_agent_hash
@ http_user_agent_hash
Hash of User-Agent header.
Definition: http_protos.h:9560
http_header_u
Union representing any HTTP header.
Definition: http.h:403
http_if_none_match_class
msg_hclass_t http_if_none_match_class[]
Header class for HTTP If-None-Match header.
Definition: http_basic.c:805
http_etag_format
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_authentication_info_init
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_from_copy
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
http_accept_format
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_authentication_info_format
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
http_retry_after_e
msg_print_f http_retry_after_e
Encode (print) a Retry-After header.
Definition: http_protos.h:8079
http_referer_d
msg_parse_f http_referer_d
Decode (parse) a Referer header.
Definition: http_protos.h:7826
http_content_range_class
msg_hclass_t http_content_range_class[]
Header class for HTTP Content-Range header.
Definition: http_basic.c:501
http_upgrade_class
msg_hclass_t http_upgrade_class[]
Header class for HTTP Upgrade header.
Definition: http_basic.c:1468
http_accept_language_dup
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_warning_format
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_if_modified_since_e
msg_print_f http_if_modified_since_e
Encode (print) a If-Modified-Since header.
Definition: http_protos.h:5079
http_content_language_make
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_transfer_encoding_make
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_is_if_unmodified_since
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_expect_hash
@ http_expect_hash
Hash of Expect header.
Definition: http_protos.h:3810
http_referer_hash
@ http_referer_hash
Hash of Referer header.
Definition: http_protos.h:7810
http_host_dup
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
http_if_modified_since_init
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
http_payload_init
http_payload_t * http_payload_init(http_payload_t x[1])
Initialize a structure http_payload_t.
Definition: http_protos.h:14358
http_server_d
msg_parse_f http_server_d
Decode (parse) a Server header.
Definition: http_protos.h:8326
http_accept_ranges_copy
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_age_hash
@ http_age_hash
Hash of Age header.
Definition: http_protos.h:2560
http_if_match_make
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_request_copy
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_if_unmodified_since_make
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_warning_make
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
http_cache_control_copy
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_content_range_e
msg_print_f http_content_range_e
Encode (print) a Content-Range header.
Definition: http_protos.h:13079
http_proxy_connection_hash
@ http_proxy_connection_hash
Hash of Proxy-Connection header.
Definition: http_protos.h:10810
http_authentication_info_hash
@ http_authentication_info_hash
Hash of Authentication-Info header.
Definition: http_protos.h:2060
http_proxy_connection_class
msg_hclass_t http_proxy_connection_class[]
Header class for HTTP Proxy-Connection header.
Definition: http_extra.c:56
http_referer_copy
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_content_length_s
http_content_language_hash
@ http_content_language_hash
Hash of Content-Language header.
Definition: http_protos.h:12060
http_www_authenticate_dup
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_etag_dup
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_separator_init
http_separator_t * http_separator_init(http_separator_t x[1])
Initialize a structure http_separator_t.
Definition: http_protos.h:14108
http_last_modified_make
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
http_transfer_encoding_format
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_max_forwards_format
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_trailer_class
msg_hclass_t http_trailer_class[]
Header class for HTTP Trailer header.
Definition: http_basic.c:1451
http_upgrade_copy
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_vary_e
msg_print_f http_vary_e
Encode (print) a Vary header.
Definition: http_protos.h:9829
http_age_init
http_age_t * http_age_init(http_age_t x[1])
Initialize a structure http_age_t.
Definition: http_protos.h:2608
http_user_agent_class
msg_hclass_t http_user_agent_class[]
Header class for HTTP User-Agent header.
Definition: http_basic.c:1476
msg_accept_s
http_last_modified_copy
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
http_cache_control_d
msg_parse_f http_cache_control_d
Decode (parse) a Cache-Control header.
Definition: http_protos.h:2826
http_proxy_authenticate_d
msg_parse_f http_proxy_authenticate_d
Decode (parse) a Proxy-Authenticate header.
Definition: http_protos.h:7076
http_payload_class
msg_hclass_t http_payload_class[]
Header class for HTTP message payload.
http_if_none_match_dup
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_allow_class
msg_hclass_t http_allow_class[]
Header class for HTTP Allow header.
Definition: http_basic.c:332
http_authorization_hash
@ http_authorization_hash
Hash of Authorization header.
Definition: http_protos.h:2310
http_is_content_md5
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
http_from_class
msg_hclass_t http_from_class[]
Header class for HTTP From header.
Definition: http_basic.c:667
http_content_md5_class
msg_hclass_t http_content_md5_class[]
Header class for HTTP Content-MD5 header.
http_date_format
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
su_config.h
http_referer_class
msg_hclass_t http_referer_class[]
Header class for HTTP Referer header.
Definition: http_basic.c:1251
http_www_authenticate_make
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_error_s
http_payload_dup
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_is_error
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_content_range_make
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_etag_init
http_etag_t * http_etag_init(http_etag_t x[1])
Initialize a structure http_etag_t.
Definition: http_protos.h:3608
http_connection_make
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
http_content_length_format
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

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