msg  1.12.11devel
msg_mime_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 MSG_MIME_PROTOS_H
26 
27 #define MSG_MIME_PROTOS_H
28 
39 #ifndef MSG_PARSER_H
40 #include <sofia-sip/msg_parser.h>
41 #endif
42 #ifndef MSG_MIME_H
43 #include <sofia-sip/msg_mime.h>
44 #endif
45 #ifndef MSG_MCLASS_H
46 #include <sofia-sip/msg_mclass.h>
47 #endif
48 #ifndef MSG_MCLASS_H
49 #include <sofia-sip/msg_mclass.h>
50 #endif
51 
52 SOFIA_BEGIN_DECLS
53 
54 MSG_DLL extern msg_mclass_t const msg_multipart_mclass[1];
55 
56 #define msg_multipart_class ((msg_hclass_t *)msg_multipart_mclass)
57 
58 
59 /* Declare internal prototypes for Content-Type header */
60 
65 enum {
68 };
69 
71 MSG_DLL msg_parse_f msg_content_type_d;
72 
74 MSG_DLL msg_print_f msg_content_type_e;
75 
76 MSG_DLL msg_xtra_f msg_content_type_dup_xtra;
77 MSG_DLL msg_dup_f msg_content_type_dup_one;
78 
87 #ifndef msg_content_type_class
88 MSG_DLL extern msg_hclass_t msg_content_type_class[];
89 #endif
90 
102 #define MSG_CONTENT_TYPE_INIT() MSG_HDR_INIT(content_type)
103 
118 #if SU_HAVE_INLINE
120 {
122 }
123 #else
124 #define msg_content_type_init(x) \
125  MSG_HEADER_INIT(x, msg_content_type_class, sizeof(msg_content_type_t))
126 #endif
127 
140 #if SU_HAVE_INLINE
142 {
143  return header && header->sh_class->hc_hash == msg_content_type_hash;
144 }
145 #else
146 int msg_is_content_type(msg_header_t const *header);
147 #endif
148 
149 #define msg_content_type_p(h) msg_is_content_type((h))
150 
178 #if SU_HAVE_INLINE
179 su_inline
180 #endif
182  msg_content_type_t const *header);
183 
184 #if SU_HAVE_INLINE
185 su_inline
187  msg_content_type_t const *header)
188 {
189  return (msg_content_type_t *)
190  msg_header_dup_as(home, msg_content_type_class, (msg_header_t const *)header);
191 }
192 #endif
193 
194 
223 #if SU_HAVE_INLINE
224 su_inline
225 #endif
227  msg_content_type_t const *header);
228 
229 #if SU_HAVE_INLINE
230 su_inline
232  msg_content_type_t const *header)
233 {
234  return (msg_content_type_t *)
236 }
237 #endif
238 
239 
256 #if SU_HAVE_INLINE
258 {
260 }
261 #else
262 msg_content_type_t *msg_content_type_make(su_home_t *home, char const *s);
263 #endif
264 
265 
287 #if SU_HAVE_INLINE
288 su_inline
289 #endif
290 msg_content_type_t *msg_content_type_format(su_home_t *home, char const *fmt, ...)
291  __attribute__((__format__ (printf, 2, 3)));
292 
293 #if SU_HAVE_INLINE
295 {
296  msg_header_t *h;
297  va_list ap;
298 
299  va_start(ap, fmt);
300  h = msg_header_vformat(home, msg_content_type_class, fmt, ap);
301  va_end(ap);
302 
303  return (msg_content_type_t*)h;
304 }
305 #endif
306 
309 /* Declare internal prototypes for Content-Disposition header */
310 
315 enum {
318 };
319 
321 MSG_DLL msg_parse_f msg_content_disposition_d;
322 
324 MSG_DLL msg_print_f msg_content_disposition_e;
325 
326 MSG_DLL msg_xtra_f msg_content_disposition_dup_xtra;
327 MSG_DLL msg_dup_f msg_content_disposition_dup_one;
328 
337 #ifndef msg_content_disposition_class
339 #endif
340 
352 #define MSG_CONTENT_DISPOSITION_INIT() MSG_HDR_INIT(content_disposition)
353 
368 #if SU_HAVE_INLINE
370 {
372 }
373 #else
374 #define msg_content_disposition_init(x) \
375  MSG_HEADER_INIT(x, msg_content_disposition_class, sizeof(msg_content_disposition_t))
376 #endif
377 
390 #if SU_HAVE_INLINE
392 {
393  return header && header->sh_class->hc_hash == msg_content_disposition_hash;
394 }
395 #else
396 int msg_is_content_disposition(msg_header_t const *header);
397 #endif
398 
399 #define msg_content_disposition_p(h) msg_is_content_disposition((h))
400 
428 #if SU_HAVE_INLINE
429 su_inline
430 #endif
432  msg_content_disposition_t const *header);
433 
434 #if SU_HAVE_INLINE
435 su_inline
437  msg_content_disposition_t const *header)
438 {
439  return (msg_content_disposition_t *)
441 }
442 #endif
443 
444 
473 #if SU_HAVE_INLINE
474 su_inline
475 #endif
477  msg_content_disposition_t const *header);
478 
479 #if SU_HAVE_INLINE
480 su_inline
482  msg_content_disposition_t const *header)
483 {
484  return (msg_content_disposition_t *)
486 }
487 #endif
488 
489 
506 #if SU_HAVE_INLINE
508 {
510 }
511 #else
513 #endif
514 
515 
537 #if SU_HAVE_INLINE
538 su_inline
539 #endif
541  __attribute__((__format__ (printf, 2, 3)));
542 
543 #if SU_HAVE_INLINE
545 {
546  msg_header_t *h;
547  va_list ap;
548 
549  va_start(ap, fmt);
551  va_end(ap);
552 
553  return (msg_content_disposition_t*)h;
554 }
555 #endif
556 
559 /* Declare internal prototypes for Content-Location header */
560 
565 enum {
568 };
569 
571 MSG_DLL msg_parse_f msg_content_location_d;
572 
574 MSG_DLL msg_print_f msg_content_location_e;
575 
576 MSG_DLL msg_xtra_f msg_content_location_dup_xtra;
577 MSG_DLL msg_dup_f msg_content_location_dup_one;
578 
587 #ifndef msg_content_location_class
589 #endif
590 
602 #define MSG_CONTENT_LOCATION_INIT() MSG_HDR_INIT(content_location)
603 
618 #if SU_HAVE_INLINE
620 {
622 }
623 #else
624 #define msg_content_location_init(x) \
625  MSG_HEADER_INIT(x, msg_content_location_class, sizeof(msg_content_location_t))
626 #endif
627 
640 #if SU_HAVE_INLINE
642 {
643  return header && header->sh_class->hc_hash == msg_content_location_hash;
644 }
645 #else
646 int msg_is_content_location(msg_header_t const *header);
647 #endif
648 
649 #define msg_content_location_p(h) msg_is_content_location((h))
650 
678 #if SU_HAVE_INLINE
679 su_inline
680 #endif
682  msg_content_location_t const *header);
683 
684 #if SU_HAVE_INLINE
685 su_inline
687  msg_content_location_t const *header)
688 {
689  return (msg_content_location_t *)
691 }
692 #endif
693 
694 
723 #if SU_HAVE_INLINE
724 su_inline
725 #endif
727  msg_content_location_t const *header);
728 
729 #if SU_HAVE_INLINE
730 su_inline
732  msg_content_location_t const *header)
733 {
734  return (msg_content_location_t *)
736 }
737 #endif
738 
739 
756 #if SU_HAVE_INLINE
758 {
760 }
761 #else
763 #endif
764 
765 
787 #if SU_HAVE_INLINE
788 su_inline
789 #endif
791  __attribute__((__format__ (printf, 2, 3)));
792 
793 #if SU_HAVE_INLINE
795 {
796  msg_header_t *h;
797  va_list ap;
798 
799  va_start(ap, fmt);
801  va_end(ap);
802 
803  return (msg_content_location_t*)h;
804 }
805 #endif
806 
809 /* Declare internal prototypes for Content-ID header */
810 
815 enum {
818 };
819 
821 MSG_DLL msg_parse_f msg_content_id_d;
822 
824 MSG_DLL msg_print_f msg_content_id_e;
825 
826 MSG_DLL msg_xtra_f msg_content_id_dup_xtra;
827 MSG_DLL msg_dup_f msg_content_id_dup_one;
828 
837 #ifndef msg_content_id_class
838 MSG_DLL extern msg_hclass_t msg_content_id_class[];
839 #endif
840 
852 #define MSG_CONTENT_ID_INIT() MSG_HDR_INIT(content_id)
853 
868 #if SU_HAVE_INLINE
870 {
872 }
873 #else
874 #define msg_content_id_init(x) \
875  MSG_HEADER_INIT(x, msg_content_id_class, sizeof(msg_content_id_t))
876 #endif
877 
890 #if SU_HAVE_INLINE
892 {
893  return header && header->sh_class->hc_hash == msg_content_id_hash;
894 }
895 #else
896 int msg_is_content_id(msg_header_t const *header);
897 #endif
898 
899 #define msg_content_id_p(h) msg_is_content_id((h))
900 
928 #if SU_HAVE_INLINE
929 su_inline
930 #endif
932  msg_content_id_t const *header);
933 
934 #if SU_HAVE_INLINE
935 su_inline
937  msg_content_id_t const *header)
938 {
939  return (msg_content_id_t *)
940  msg_header_dup_as(home, msg_content_id_class, (msg_header_t const *)header);
941 }
942 #endif
943 
944 
973 #if SU_HAVE_INLINE
974 su_inline
975 #endif
977  msg_content_id_t const *header);
978 
979 #if SU_HAVE_INLINE
980 su_inline
982  msg_content_id_t const *header)
983 {
984  return (msg_content_id_t *)
985  msg_header_copy_as(home, msg_content_id_class, (msg_header_t const *)header);
986 }
987 #endif
988 
989 
1006 #if SU_HAVE_INLINE
1008 {
1010 }
1011 #else
1012 msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s);
1013 #endif
1014 
1015 
1037 #if SU_HAVE_INLINE
1038 su_inline
1039 #endif
1040 msg_content_id_t *msg_content_id_format(su_home_t *home, char const *fmt, ...)
1041  __attribute__((__format__ (printf, 2, 3)));
1042 
1043 #if SU_HAVE_INLINE
1045 {
1046  msg_header_t *h;
1047  va_list ap;
1048 
1049  va_start(ap, fmt);
1050  h = msg_header_vformat(home, msg_content_id_class, fmt, ap);
1051  va_end(ap);
1052 
1053  return (msg_content_id_t*)h;
1054 }
1055 #endif
1056 
1059 /* Declare internal prototypes for Content-Language header */
1060 
1065 enum {
1068 };
1069 
1071 MSG_DLL msg_parse_f msg_content_language_d;
1072 
1074 MSG_DLL msg_print_f msg_content_language_e;
1075 
1076 MSG_DLL msg_xtra_f msg_content_language_dup_xtra;
1077 MSG_DLL msg_dup_f msg_content_language_dup_one;
1078 
1087 #ifndef msg_content_language_class
1088 MSG_DLL extern msg_hclass_t msg_content_language_class[];
1089 #endif
1090 
1102 #define MSG_CONTENT_LANGUAGE_INIT() MSG_HDR_INIT(content_language)
1103 
1118 #if SU_HAVE_INLINE
1120 {
1122 }
1123 #else
1124 #define msg_content_language_init(x) \
1125  MSG_HEADER_INIT(x, msg_content_language_class, sizeof(msg_content_language_t))
1126 #endif
1127 
1140 #if SU_HAVE_INLINE
1142 {
1143  return header && header->sh_class->hc_hash == msg_content_language_hash;
1144 }
1145 #else
1146 int msg_is_content_language(msg_header_t const *header);
1147 #endif
1148 
1149 #define msg_content_language_p(h) msg_is_content_language((h))
1150 
1178 #if SU_HAVE_INLINE
1179 su_inline
1180 #endif
1182  msg_content_language_t const *header);
1183 
1184 #if SU_HAVE_INLINE
1185 su_inline
1187  msg_content_language_t const *header)
1188 {
1189  return (msg_content_language_t *)
1191 }
1192 #endif
1193 
1194 
1223 #if SU_HAVE_INLINE
1224 su_inline
1225 #endif
1227  msg_content_language_t const *header);
1228 
1229 #if SU_HAVE_INLINE
1230 su_inline
1232  msg_content_language_t const *header)
1233 {
1234  return (msg_content_language_t *)
1236 }
1237 #endif
1238 
1239 
1256 #if SU_HAVE_INLINE
1258 {
1260 }
1261 #else
1263 #endif
1264 
1265 
1287 #if SU_HAVE_INLINE
1288 su_inline
1289 #endif
1290 msg_content_language_t *msg_content_language_format(su_home_t *home, char const *fmt, ...)
1291  __attribute__((__format__ (printf, 2, 3)));
1292 
1293 #if SU_HAVE_INLINE
1295 {
1296  msg_header_t *h;
1297  va_list ap;
1298 
1299  va_start(ap, fmt);
1300  h = msg_header_vformat(home, msg_content_language_class, fmt, ap);
1301  va_end(ap);
1302 
1303  return (msg_content_language_t*)h;
1304 }
1305 #endif
1306 
1309 /* Declare internal prototypes for Content-Encoding header */
1310 
1315 enum {
1318 };
1319 
1321 MSG_DLL msg_parse_f msg_content_encoding_d;
1322 
1324 MSG_DLL msg_print_f msg_content_encoding_e;
1325 
1326 MSG_DLL msg_xtra_f msg_content_encoding_dup_xtra;
1327 MSG_DLL msg_dup_f msg_content_encoding_dup_one;
1328 
1337 #ifndef msg_content_encoding_class
1338 MSG_DLL extern msg_hclass_t msg_content_encoding_class[];
1339 #endif
1340 
1352 #define MSG_CONTENT_ENCODING_INIT() MSG_HDR_INIT(content_encoding)
1353 
1368 #if SU_HAVE_INLINE
1370 {
1372 }
1373 #else
1374 #define msg_content_encoding_init(x) \
1375  MSG_HEADER_INIT(x, msg_content_encoding_class, sizeof(msg_content_encoding_t))
1376 #endif
1377 
1390 #if SU_HAVE_INLINE
1392 {
1393  return header && header->sh_class->hc_hash == msg_content_encoding_hash;
1394 }
1395 #else
1396 int msg_is_content_encoding(msg_header_t const *header);
1397 #endif
1398 
1399 #define msg_content_encoding_p(h) msg_is_content_encoding((h))
1400 
1428 #if SU_HAVE_INLINE
1429 su_inline
1430 #endif
1432  msg_content_encoding_t const *header);
1433 
1434 #if SU_HAVE_INLINE
1435 su_inline
1437  msg_content_encoding_t const *header)
1438 {
1439  return (msg_content_encoding_t *)
1441 }
1442 #endif
1443 
1444 
1473 #if SU_HAVE_INLINE
1474 su_inline
1475 #endif
1477  msg_content_encoding_t const *header);
1478 
1479 #if SU_HAVE_INLINE
1480 su_inline
1482  msg_content_encoding_t const *header)
1483 {
1484  return (msg_content_encoding_t *)
1486 }
1487 #endif
1488 
1489 
1506 #if SU_HAVE_INLINE
1508 {
1510 }
1511 #else
1513 #endif
1514 
1515 
1537 #if SU_HAVE_INLINE
1538 su_inline
1539 #endif
1540 msg_content_encoding_t *msg_content_encoding_format(su_home_t *home, char const *fmt, ...)
1541  __attribute__((__format__ (printf, 2, 3)));
1542 
1543 #if SU_HAVE_INLINE
1545 {
1546  msg_header_t *h;
1547  va_list ap;
1548 
1549  va_start(ap, fmt);
1550  h = msg_header_vformat(home, msg_content_encoding_class, fmt, ap);
1551  va_end(ap);
1552 
1553  return (msg_content_encoding_t*)h;
1554 }
1555 #endif
1556 
1559 /* Declare internal prototypes for Content-Transfer-Encoding header */
1560 
1565 enum {
1568 };
1569 
1572 
1575 
1576 MSG_DLL msg_xtra_f msg_content_transfer_encoding_dup_xtra;
1577 MSG_DLL msg_dup_f msg_content_transfer_encoding_dup_one;
1578 
1587 #ifndef msg_content_transfer_encoding_class
1589 #endif
1590 
1602 #define MSG_CONTENT_TRANSFER_ENCODING_INIT() MSG_HDR_INIT(content_transfer_encoding)
1603 
1618 #if SU_HAVE_INLINE
1620 {
1622 }
1623 #else
1624 #define msg_content_transfer_encoding_init(x) \
1625  MSG_HEADER_INIT(x, msg_content_transfer_encoding_class, sizeof(msg_content_transfer_encoding_t))
1626 #endif
1627 
1640 #if SU_HAVE_INLINE
1642 {
1643  return header && header->sh_class->hc_hash == msg_content_transfer_encoding_hash;
1644 }
1645 #else
1647 #endif
1648 
1649 #define msg_content_transfer_encoding_p(h) msg_is_content_transfer_encoding((h))
1650 
1678 #if SU_HAVE_INLINE
1679 su_inline
1680 #endif
1682  msg_content_transfer_encoding_t const *header);
1683 
1684 #if SU_HAVE_INLINE
1685 su_inline
1687  msg_content_transfer_encoding_t const *header)
1688 {
1691 }
1692 #endif
1693 
1694 
1723 #if SU_HAVE_INLINE
1724 su_inline
1725 #endif
1727  msg_content_transfer_encoding_t const *header);
1728 
1729 #if SU_HAVE_INLINE
1730 su_inline
1732  msg_content_transfer_encoding_t const *header)
1733 {
1736 }
1737 #endif
1738 
1739 
1756 #if SU_HAVE_INLINE
1758 {
1760 }
1761 #else
1763 #endif
1764 
1765 
1787 #if SU_HAVE_INLINE
1788 su_inline
1789 #endif
1791  __attribute__((__format__ (printf, 2, 3)));
1792 
1793 #if SU_HAVE_INLINE
1795 {
1796  msg_header_t *h;
1797  va_list ap;
1798 
1799  va_start(ap, fmt);
1801  va_end(ap);
1802 
1804 }
1805 #endif
1806 
1809 /* Declare internal prototypes for Accept header */
1810 
1815 enum {
1818 };
1819 
1821 MSG_DLL msg_parse_f msg_accept_d;
1822 
1824 MSG_DLL msg_print_f msg_accept_e;
1825 
1826 MSG_DLL msg_xtra_f msg_accept_dup_xtra;
1827 MSG_DLL msg_dup_f msg_accept_dup_one;
1828 
1837 #ifndef msg_accept_class
1838 MSG_DLL extern msg_hclass_t msg_accept_class[];
1839 #endif
1840 
1852 #define MSG_ACCEPT_INIT() MSG_HDR_INIT(accept)
1853 
1868 #if SU_HAVE_INLINE
1870 {
1871  return MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t));
1872 }
1873 #else
1874 #define msg_accept_init(x) \
1875  MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t))
1876 #endif
1877 
1890 #if SU_HAVE_INLINE
1892 {
1893  return header && header->sh_class->hc_hash == msg_accept_hash;
1894 }
1895 #else
1896 int msg_is_accept(msg_header_t const *header);
1897 #endif
1898 
1899 #define msg_accept_p(h) msg_is_accept((h))
1900 
1928 #if SU_HAVE_INLINE
1929 su_inline
1930 #endif
1932  msg_accept_t const *header);
1933 
1934 #if SU_HAVE_INLINE
1935 su_inline
1937  msg_accept_t const *header)
1938 {
1939  return (msg_accept_t *)
1940  msg_header_dup_as(home, msg_accept_class, (msg_header_t const *)header);
1941 }
1942 #endif
1943 
1944 
1973 #if SU_HAVE_INLINE
1974 su_inline
1975 #endif
1977  msg_accept_t const *header);
1978 
1979 #if SU_HAVE_INLINE
1980 su_inline
1982  msg_accept_t const *header)
1983 {
1984  return (msg_accept_t *)
1985  msg_header_copy_as(home, msg_accept_class, (msg_header_t const *)header);
1986 }
1987 #endif
1988 
1989 
2006 #if SU_HAVE_INLINE
2008 {
2009  return (msg_accept_t*)msg_header_make(home, msg_accept_class, s);
2010 }
2011 #else
2012 msg_accept_t *msg_accept_make(su_home_t *home, char const *s);
2013 #endif
2014 
2015 
2037 #if SU_HAVE_INLINE
2038 su_inline
2039 #endif
2040 msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
2041  __attribute__((__format__ (printf, 2, 3)));
2042 
2043 #if SU_HAVE_INLINE
2044 su_inline msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
2045 {
2046  msg_header_t *h;
2047  va_list ap;
2048 
2049  va_start(ap, fmt);
2050  h = msg_header_vformat(home, msg_accept_class, fmt, ap);
2051  va_end(ap);
2052 
2053  return (msg_accept_t*)h;
2054 }
2055 #endif
2056 
2059 /* Declare internal prototypes for Accept-Charset header */
2060 
2065 enum {
2068 };
2069 
2071 MSG_DLL msg_parse_f msg_accept_charset_d;
2072 
2074 MSG_DLL msg_print_f msg_accept_charset_e;
2075 
2076 MSG_DLL msg_xtra_f msg_accept_charset_dup_xtra;
2077 MSG_DLL msg_dup_f msg_accept_charset_dup_one;
2078 
2087 #ifndef msg_accept_charset_class
2088 MSG_DLL extern msg_hclass_t msg_accept_charset_class[];
2089 #endif
2090 
2102 #define MSG_ACCEPT_CHARSET_INIT() MSG_HDR_INIT(accept_charset)
2103 
2118 #if SU_HAVE_INLINE
2120 {
2122 }
2123 #else
2124 #define msg_accept_charset_init(x) \
2125  MSG_HEADER_INIT(x, msg_accept_charset_class, sizeof(msg_accept_charset_t))
2126 #endif
2127 
2140 #if SU_HAVE_INLINE
2142 {
2143  return header && header->sh_class->hc_hash == msg_accept_charset_hash;
2144 }
2145 #else
2146 int msg_is_accept_charset(msg_header_t const *header);
2147 #endif
2148 
2149 #define msg_accept_charset_p(h) msg_is_accept_charset((h))
2150 
2178 #if SU_HAVE_INLINE
2179 su_inline
2180 #endif
2182  msg_accept_charset_t const *header);
2183 
2184 #if SU_HAVE_INLINE
2185 su_inline
2187  msg_accept_charset_t const *header)
2188 {
2189  return (msg_accept_charset_t *)
2191 }
2192 #endif
2193 
2194 
2223 #if SU_HAVE_INLINE
2224 su_inline
2225 #endif
2227  msg_accept_charset_t const *header);
2228 
2229 #if SU_HAVE_INLINE
2230 su_inline
2232  msg_accept_charset_t const *header)
2233 {
2234  return (msg_accept_charset_t *)
2236 }
2237 #endif
2238 
2239 
2256 #if SU_HAVE_INLINE
2258 {
2260 }
2261 #else
2263 #endif
2264 
2265 
2287 #if SU_HAVE_INLINE
2288 su_inline
2289 #endif
2290 msg_accept_charset_t *msg_accept_charset_format(su_home_t *home, char const *fmt, ...)
2291  __attribute__((__format__ (printf, 2, 3)));
2292 
2293 #if SU_HAVE_INLINE
2295 {
2296  msg_header_t *h;
2297  va_list ap;
2298 
2299  va_start(ap, fmt);
2300  h = msg_header_vformat(home, msg_accept_charset_class, fmt, ap);
2301  va_end(ap);
2302 
2303  return (msg_accept_charset_t*)h;
2304 }
2305 #endif
2306 
2309 /* Declare internal prototypes for Accept-Encoding header */
2310 
2315 enum {
2318 };
2319 
2321 MSG_DLL msg_parse_f msg_accept_encoding_d;
2322 
2324 MSG_DLL msg_print_f msg_accept_encoding_e;
2325 
2326 MSG_DLL msg_xtra_f msg_accept_encoding_dup_xtra;
2327 MSG_DLL msg_dup_f msg_accept_encoding_dup_one;
2328 
2337 #ifndef msg_accept_encoding_class
2338 MSG_DLL extern msg_hclass_t msg_accept_encoding_class[];
2339 #endif
2340 
2352 #define MSG_ACCEPT_ENCODING_INIT() MSG_HDR_INIT(accept_encoding)
2353 
2368 #if SU_HAVE_INLINE
2370 {
2372 }
2373 #else
2374 #define msg_accept_encoding_init(x) \
2375  MSG_HEADER_INIT(x, msg_accept_encoding_class, sizeof(msg_accept_encoding_t))
2376 #endif
2377 
2390 #if SU_HAVE_INLINE
2392 {
2393  return header && header->sh_class->hc_hash == msg_accept_encoding_hash;
2394 }
2395 #else
2396 int msg_is_accept_encoding(msg_header_t const *header);
2397 #endif
2398 
2399 #define msg_accept_encoding_p(h) msg_is_accept_encoding((h))
2400 
2428 #if SU_HAVE_INLINE
2429 su_inline
2430 #endif
2432  msg_accept_encoding_t const *header);
2433 
2434 #if SU_HAVE_INLINE
2435 su_inline
2437  msg_accept_encoding_t const *header)
2438 {
2439  return (msg_accept_encoding_t *)
2441 }
2442 #endif
2443 
2444 
2473 #if SU_HAVE_INLINE
2474 su_inline
2475 #endif
2477  msg_accept_encoding_t const *header);
2478 
2479 #if SU_HAVE_INLINE
2480 su_inline
2482  msg_accept_encoding_t const *header)
2483 {
2484  return (msg_accept_encoding_t *)
2486 }
2487 #endif
2488 
2489 
2506 #if SU_HAVE_INLINE
2508 {
2510 }
2511 #else
2513 #endif
2514 
2515 
2537 #if SU_HAVE_INLINE
2538 su_inline
2539 #endif
2540 msg_accept_encoding_t *msg_accept_encoding_format(su_home_t *home, char const *fmt, ...)
2541  __attribute__((__format__ (printf, 2, 3)));
2542 
2543 #if SU_HAVE_INLINE
2545 {
2546  msg_header_t *h;
2547  va_list ap;
2548 
2549  va_start(ap, fmt);
2550  h = msg_header_vformat(home, msg_accept_encoding_class, fmt, ap);
2551  va_end(ap);
2552 
2553  return (msg_accept_encoding_t*)h;
2554 }
2555 #endif
2556 
2559 /* Declare internal prototypes for Accept-Language header */
2560 
2565 enum {
2568 };
2569 
2571 MSG_DLL msg_parse_f msg_accept_language_d;
2572 
2574 MSG_DLL msg_print_f msg_accept_language_e;
2575 
2576 MSG_DLL msg_xtra_f msg_accept_language_dup_xtra;
2577 MSG_DLL msg_dup_f msg_accept_language_dup_one;
2578 
2587 #ifndef msg_accept_language_class
2588 MSG_DLL extern msg_hclass_t msg_accept_language_class[];
2589 #endif
2590 
2602 #define MSG_ACCEPT_LANGUAGE_INIT() MSG_HDR_INIT(accept_language)
2603 
2618 #if SU_HAVE_INLINE
2620 {
2622 }
2623 #else
2624 #define msg_accept_language_init(x) \
2625  MSG_HEADER_INIT(x, msg_accept_language_class, sizeof(msg_accept_language_t))
2626 #endif
2627 
2640 #if SU_HAVE_INLINE
2642 {
2643  return header && header->sh_class->hc_hash == msg_accept_language_hash;
2644 }
2645 #else
2646 int msg_is_accept_language(msg_header_t const *header);
2647 #endif
2648 
2649 #define msg_accept_language_p(h) msg_is_accept_language((h))
2650 
2678 #if SU_HAVE_INLINE
2679 su_inline
2680 #endif
2682  msg_accept_language_t const *header);
2683 
2684 #if SU_HAVE_INLINE
2685 su_inline
2687  msg_accept_language_t const *header)
2688 {
2689  return (msg_accept_language_t *)
2691 }
2692 #endif
2693 
2694 
2723 #if SU_HAVE_INLINE
2724 su_inline
2725 #endif
2727  msg_accept_language_t const *header);
2728 
2729 #if SU_HAVE_INLINE
2730 su_inline
2732  msg_accept_language_t const *header)
2733 {
2734  return (msg_accept_language_t *)
2736 }
2737 #endif
2738 
2739 
2756 #if SU_HAVE_INLINE
2758 {
2760 }
2761 #else
2763 #endif
2764 
2765 
2787 #if SU_HAVE_INLINE
2788 su_inline
2789 #endif
2790 msg_accept_language_t *msg_accept_language_format(su_home_t *home, char const *fmt, ...)
2791  __attribute__((__format__ (printf, 2, 3)));
2792 
2793 #if SU_HAVE_INLINE
2795 {
2796  msg_header_t *h;
2797  va_list ap;
2798 
2799  va_start(ap, fmt);
2800  h = msg_header_vformat(home, msg_accept_language_class, fmt, ap);
2801  va_end(ap);
2802 
2803  return (msg_accept_language_t*)h;
2804 }
2805 #endif
2806 
2809 /* Declare internal prototypes for MIME-Version header */
2810 
2815 enum {
2818 };
2819 
2821 MSG_DLL msg_parse_f msg_mime_version_d;
2822 
2824 MSG_DLL msg_print_f msg_mime_version_e;
2825 
2826 MSG_DLL msg_xtra_f msg_mime_version_dup_xtra;
2827 MSG_DLL msg_dup_f msg_mime_version_dup_one;
2828 
2837 #ifndef msg_mime_version_class
2838 MSG_DLL extern msg_hclass_t msg_mime_version_class[];
2839 #endif
2840 
2852 #define MSG_MIME_VERSION_INIT() MSG_HDR_INIT(mime_version)
2853 
2868 #if SU_HAVE_INLINE
2870 {
2872 }
2873 #else
2874 #define msg_mime_version_init(x) \
2875  MSG_HEADER_INIT(x, msg_mime_version_class, sizeof(msg_mime_version_t))
2876 #endif
2877 
2890 #if SU_HAVE_INLINE
2892 {
2893  return header && header->sh_class->hc_hash == msg_mime_version_hash;
2894 }
2895 #else
2896 int msg_is_mime_version(msg_header_t const *header);
2897 #endif
2898 
2899 #define msg_mime_version_p(h) msg_is_mime_version((h))
2900 
2928 #if SU_HAVE_INLINE
2929 su_inline
2930 #endif
2932  msg_mime_version_t const *header);
2933 
2934 #if SU_HAVE_INLINE
2935 su_inline
2937  msg_mime_version_t const *header)
2938 {
2939  return (msg_mime_version_t *)
2940  msg_header_dup_as(home, msg_mime_version_class, (msg_header_t const *)header);
2941 }
2942 #endif
2943 
2944 
2973 #if SU_HAVE_INLINE
2974 su_inline
2975 #endif
2977  msg_mime_version_t const *header);
2978 
2979 #if SU_HAVE_INLINE
2980 su_inline
2982  msg_mime_version_t const *header)
2983 {
2984  return (msg_mime_version_t *)
2985  msg_header_copy_as(home, msg_mime_version_class, (msg_header_t const *)header);
2986 }
2987 #endif
2988 
2989 
3006 #if SU_HAVE_INLINE
3008 {
3010 }
3011 #else
3012 msg_mime_version_t *msg_mime_version_make(su_home_t *home, char const *s);
3013 #endif
3014 
3015 
3037 #if SU_HAVE_INLINE
3038 su_inline
3039 #endif
3040 msg_mime_version_t *msg_mime_version_format(su_home_t *home, char const *fmt, ...)
3041  __attribute__((__format__ (printf, 2, 3)));
3042 
3043 #if SU_HAVE_INLINE
3045 {
3046  msg_header_t *h;
3047  va_list ap;
3048 
3049  va_start(ap, fmt);
3050  h = msg_header_vformat(home, msg_mime_version_class, fmt, ap);
3051  va_end(ap);
3052 
3053  return (msg_mime_version_t*)h;
3054 }
3055 #endif
3056 
3059 /* Declare internal prototypes for Content-MD5 header */
3060 
3065 enum {
3068 };
3069 
3071 MSG_DLL msg_parse_f msg_content_md5_d;
3072 
3074 MSG_DLL msg_print_f msg_content_md5_e;
3075 
3076 MSG_DLL msg_xtra_f msg_content_md5_dup_xtra;
3077 MSG_DLL msg_dup_f msg_content_md5_dup_one;
3078 
3087 #ifndef msg_content_md5_class
3088 MSG_DLL extern msg_hclass_t msg_content_md5_class[];
3089 #endif
3090 
3102 #define MSG_CONTENT_MD5_INIT() MSG_HDR_INIT(content_md5)
3103 
3118 #if SU_HAVE_INLINE
3120 {
3122 }
3123 #else
3124 #define msg_content_md5_init(x) \
3125  MSG_HEADER_INIT(x, msg_content_md5_class, sizeof(msg_content_md5_t))
3126 #endif
3127 
3140 #if SU_HAVE_INLINE
3142 {
3143  return header && header->sh_class->hc_hash == msg_content_md5_hash;
3144 }
3145 #else
3146 int msg_is_content_md5(msg_header_t const *header);
3147 #endif
3148 
3149 #define msg_content_md5_p(h) msg_is_content_md5((h))
3150 
3178 #if SU_HAVE_INLINE
3179 su_inline
3180 #endif
3182  msg_content_md5_t const *header);
3183 
3184 #if SU_HAVE_INLINE
3185 su_inline
3187  msg_content_md5_t const *header)
3188 {
3189  return (msg_content_md5_t *)
3190  msg_header_dup_as(home, msg_content_md5_class, (msg_header_t const *)header);
3191 }
3192 #endif
3193 
3194 
3223 #if SU_HAVE_INLINE
3224 su_inline
3225 #endif
3227  msg_content_md5_t const *header);
3228 
3229 #if SU_HAVE_INLINE
3230 su_inline
3232  msg_content_md5_t const *header)
3233 {
3234  return (msg_content_md5_t *)
3235  msg_header_copy_as(home, msg_content_md5_class, (msg_header_t const *)header);
3236 }
3237 #endif
3238 
3239 
3256 #if SU_HAVE_INLINE
3258 {
3260 }
3261 #else
3262 msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s);
3263 #endif
3264 
3265 
3287 #if SU_HAVE_INLINE
3288 su_inline
3289 #endif
3290 msg_content_md5_t *msg_content_md5_format(su_home_t *home, char const *fmt, ...)
3291  __attribute__((__format__ (printf, 2, 3)));
3292 
3293 #if SU_HAVE_INLINE
3295 {
3296  msg_header_t *h;
3297  va_list ap;
3298 
3299  va_start(ap, fmt);
3300  h = msg_header_vformat(home, msg_content_md5_class, fmt, ap);
3301  va_end(ap);
3302 
3303  return (msg_content_md5_t*)h;
3304 }
3305 #endif
3306 
3309 /* Declare internal prototypes for Content-Length header */
3310 
3315 enum {
3318 };
3319 
3321 MSG_DLL msg_parse_f msg_content_length_d;
3322 
3324 MSG_DLL msg_print_f msg_content_length_e;
3325 
3326 MSG_DLL msg_xtra_f msg_content_length_dup_xtra;
3327 MSG_DLL msg_dup_f msg_content_length_dup_one;
3328 
3337 #ifndef msg_content_length_class
3338 MSG_DLL extern msg_hclass_t msg_content_length_class[];
3339 #endif
3340 
3352 #define MSG_CONTENT_LENGTH_INIT() MSG_HDR_INIT(content_length)
3353 
3368 #if SU_HAVE_INLINE
3370 {
3372 }
3373 #else
3374 #define msg_content_length_init(x) \
3375  MSG_HEADER_INIT(x, msg_content_length_class, sizeof(msg_content_length_t))
3376 #endif
3377 
3390 #if SU_HAVE_INLINE
3392 {
3393  return header && header->sh_class->hc_hash == msg_content_length_hash;
3394 }
3395 #else
3396 int msg_is_content_length(msg_header_t const *header);
3397 #endif
3398 
3399 #define msg_content_length_p(h) msg_is_content_length((h))
3400 
3428 #if SU_HAVE_INLINE
3429 su_inline
3430 #endif
3432  msg_content_length_t const *header);
3433 
3434 #if SU_HAVE_INLINE
3435 su_inline
3437  msg_content_length_t const *header)
3438 {
3439  return (msg_content_length_t *)
3441 }
3442 #endif
3443 
3444 
3473 #if SU_HAVE_INLINE
3474 su_inline
3475 #endif
3477  msg_content_length_t const *header);
3478 
3479 #if SU_HAVE_INLINE
3480 su_inline
3482  msg_content_length_t const *header)
3483 {
3484  return (msg_content_length_t *)
3486 }
3487 #endif
3488 
3489 
3506 #if SU_HAVE_INLINE
3508 {
3510 }
3511 #else
3513 #endif
3514 
3515 
3537 #if SU_HAVE_INLINE
3538 su_inline
3539 #endif
3540 msg_content_length_t *msg_content_length_format(su_home_t *home, char const *fmt, ...)
3541  __attribute__((__format__ (printf, 2, 3)));
3542 
3543 #if SU_HAVE_INLINE
3545 {
3546  msg_header_t *h;
3547  va_list ap;
3548 
3549  va_start(ap, fmt);
3550  h = msg_header_vformat(home, msg_content_length_class, fmt, ap);
3551  va_end(ap);
3552 
3553  return (msg_content_length_t*)h;
3554 }
3555 #endif
3556 
3559 /* Declare internal prototypes for Recursive multipart header */
3560 
3565 enum {
3568 };
3569 
3571 MSG_DLL msg_parse_f msg_multipart_d;
3572 
3574 MSG_DLL msg_print_f msg_multipart_e;
3575 
3576 MSG_DLL msg_xtra_f msg_multipart_dup_xtra;
3577 MSG_DLL msg_dup_f msg_multipart_dup_one;
3578 
3587 #ifndef msg_multipart_class
3588 MSG_DLL extern msg_hclass_t msg_multipart_class[];
3589 #endif
3590 
3602 #define MSG_MULTIPART_INIT() MSG_HDR_INIT(multipart)
3603 
3618 #if SU_HAVE_INLINE
3620 {
3621  return MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t));
3622 }
3623 #else
3624 #define msg_multipart_init(x) \
3625  MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t))
3626 #endif
3627 
3640 #if SU_HAVE_INLINE
3642 {
3643  return header && header->sh_class->hc_hash == msg_multipart_hash;
3644 }
3645 #else
3646 int msg_is_multipart(msg_header_t const *header);
3647 #endif
3648 
3649 #define msg_multipart_p(h) msg_is_multipart((h))
3650 
3678 #if SU_HAVE_INLINE
3679 su_inline
3680 #endif
3682  msg_multipart_t const *header);
3683 
3684 #if SU_HAVE_INLINE
3685 su_inline
3687  msg_multipart_t const *header)
3688 {
3689  return (msg_multipart_t *)
3690  msg_header_dup_as(home, msg_multipart_class, (msg_header_t const *)header);
3691 }
3692 #endif
3693 
3694 
3723 #if SU_HAVE_INLINE
3724 su_inline
3725 #endif
3727  msg_multipart_t const *header);
3728 
3729 #if SU_HAVE_INLINE
3730 su_inline
3732  msg_multipart_t const *header)
3733 {
3734  return (msg_multipart_t *)
3735  msg_header_copy_as(home, msg_multipart_class, (msg_header_t const *)header);
3736 }
3737 #endif
3738 
3739 
3756 #if SU_HAVE_INLINE
3758 {
3759  return (msg_multipart_t*)msg_header_make(home, msg_multipart_class, s);
3760 }
3761 #else
3762 msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s);
3763 #endif
3764 
3765 
3787 #if SU_HAVE_INLINE
3788 su_inline
3789 #endif
3790 msg_multipart_t *msg_multipart_format(su_home_t *home, char const *fmt, ...)
3791  __attribute__((__format__ (printf, 2, 3)));
3792 
3793 #if SU_HAVE_INLINE
3795 {
3796  msg_header_t *h;
3797  va_list ap;
3798 
3799  va_start(ap, fmt);
3800  h = msg_header_vformat(home, msg_multipart_class, fmt, ap);
3801  va_end(ap);
3802 
3803  return (msg_multipart_t*)h;
3804 }
3805 #endif
3806 
3809 /* Declare internal prototypes for Warning header */
3810 
3815 enum {
3818 };
3819 
3821 MSG_DLL msg_parse_f msg_warning_d;
3822 
3824 MSG_DLL msg_print_f msg_warning_e;
3825 
3826 MSG_DLL msg_xtra_f msg_warning_dup_xtra;
3827 MSG_DLL msg_dup_f msg_warning_dup_one;
3828 
3837 #ifndef msg_warning_class
3838 MSG_DLL extern msg_hclass_t msg_warning_class[];
3839 #endif
3840 
3852 #define MSG_WARNING_INIT() MSG_HDR_INIT(warning)
3853 
3868 #if SU_HAVE_INLINE
3870 {
3871  return MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t));
3872 }
3873 #else
3874 #define msg_warning_init(x) \
3875  MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t))
3876 #endif
3877 
3890 #if SU_HAVE_INLINE
3892 {
3893  return header && header->sh_class->hc_hash == msg_warning_hash;
3894 }
3895 #else
3896 int msg_is_warning(msg_header_t const *header);
3897 #endif
3898 
3899 #define msg_warning_p(h) msg_is_warning((h))
3900 
3928 #if SU_HAVE_INLINE
3929 su_inline
3930 #endif
3932  msg_warning_t const *header);
3933 
3934 #if SU_HAVE_INLINE
3935 su_inline
3937  msg_warning_t const *header)
3938 {
3939  return (msg_warning_t *)
3940  msg_header_dup_as(home, msg_warning_class, (msg_header_t const *)header);
3941 }
3942 #endif
3943 
3944 
3973 #if SU_HAVE_INLINE
3974 su_inline
3975 #endif
3977  msg_warning_t const *header);
3978 
3979 #if SU_HAVE_INLINE
3980 su_inline
3982  msg_warning_t const *header)
3983 {
3984  return (msg_warning_t *)
3985  msg_header_copy_as(home, msg_warning_class, (msg_header_t const *)header);
3986 }
3987 #endif
3988 
3989 
4006 #if SU_HAVE_INLINE
4008 {
4009  return (msg_warning_t*)msg_header_make(home, msg_warning_class, s);
4010 }
4011 #else
4012 msg_warning_t *msg_warning_make(su_home_t *home, char const *s);
4013 #endif
4014 
4015 
4037 #if SU_HAVE_INLINE
4038 su_inline
4039 #endif
4040 msg_warning_t *msg_warning_format(su_home_t *home, char const *fmt, ...)
4041  __attribute__((__format__ (printf, 2, 3)));
4042 
4043 #if SU_HAVE_INLINE
4045 {
4046  msg_header_t *h;
4047  va_list ap;
4048 
4049  va_start(ap, fmt);
4050  h = msg_header_vformat(home, msg_warning_class, fmt, ap);
4051  va_end(ap);
4052 
4053  return (msg_warning_t*)h;
4054 }
4055 #endif
4056 
4060 /* Internal prototypes */
4061 MSG_DLL msg_update_f msg_accept_update;
4062 MSG_DLL msg_update_f msg_accept_any_update;
4063 MSG_DLL msg_update_f msg_content_disposition_update;
4064 
4065 SOFIA_END_DECLS
4066 
4067 #endif
msg_accept_language_format
msg_accept_language_t * msg_accept_language_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Language header from formatting result.
Definition: msg_mime_protos.h:2794
msg_content_length_hash
@ msg_content_length_hash
Hash of Content-Length header.
Definition: msg_mime_protos.h:3317
msg_content_transfer_encoding_format
msg_content_transfer_encoding_t * msg_content_transfer_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Transfer-Encoding header from formatting result.
Definition: msg_mime_protos.h:1794
msg_content_encoding_class
msg_hclass_t msg_content_encoding_class[]
Header class for Content-Encoding header.
Definition: msg_mime.c:1623
msg_content_transfer_encoding_d
msg_parse_f msg_content_transfer_encoding_d
Parse a Content-Transfer-Encoding header.
Definition: msg_mime_protos.h:1571
msg_is_content_encoding
int msg_is_content_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_encoding_t.
Definition: msg_mime_protos.h:1391
su_home_t
SU_HOME_T su_home_t
msg_content_id_init
msg_content_id_t * msg_content_id_init(msg_content_id_t x[1])
Initialize an msg_content_id_t structure.
Definition: msg_mime_protos.h:869
msg_content_type_dup
msg_content_type_t * msg_content_type_dup(su_home_t *home, msg_content_type_t const *header)
Duplicate (deep copy) msg_content_type_t.
Definition: msg_mime_protos.h:186
msg_mime.h
msg_mime_version_make
msg_mime_version_t * msg_mime_version_make(su_home_t *home, char const *s)
Make a header structure msg_mime_version_t.
Definition: msg_mime_protos.h:3007
msg_content_transfer_encoding_hash
@ msg_content_transfer_encoding_hash
Hash of Content-Transfer-Encoding header.
Definition: msg_mime_protos.h:1567
msg_is_content_language
int msg_is_content_language(msg_header_t const *header)
Test if header object is an instance of msg_content_language_t.
Definition: msg_mime_protos.h:1141
MSG_HEADER_INIT
#define MSG_HEADER_INIT(h, msg_class, size)
Initialize a header structure.
Definition: msg_header.h:298
msg_content_disposition_e
msg_print_f msg_content_disposition_e
Print a Content-Disposition header.
Definition: msg_mime_protos.h:324
msg_content_language_init
msg_content_language_t * msg_content_language_init(msg_content_language_t x[1])
Initialize an msg_content_language_t structure.
Definition: msg_mime_protos.h:1119
msg_mime_version_e
msg_print_f msg_mime_version_e
Print a MIME-Version header.
Definition: msg_mime_protos.h:2824
msg_content_location_d
msg_parse_f msg_content_location_d
Parse a Content-Location header.
Definition: msg_mime_protos.h:571
msg_warning_hash
@ msg_warning_hash
Hash of Warning header.
Definition: msg_mime_protos.h:3817
msg_content_md5_format
msg_content_md5_t * msg_content_md5_format(su_home_t *home, char const *fmt,...)))
Make a Content-MD5 header from formatting result.
Definition: msg_mime_protos.h:3294
msg_content_md5_class
msg_hclass_t msg_content_md5_class[]
Header class for Content-MD5 header.
Definition: msg_mime.c:1792
msg_accept_encoding_dup
msg_accept_encoding_t * msg_accept_encoding_dup(su_home_t *home, msg_accept_encoding_t const *header)
Duplicate (deep copy) msg_accept_encoding_t.
Definition: msg_mime_protos.h:2436
msg_accept_copy
msg_accept_t * msg_accept_copy(su_home_t *home, msg_accept_t const *header)
Copy an msg_accept_t header structure.
Definition: msg_mime_protos.h:1981
msg_content_md5_init
msg_content_md5_t * msg_content_md5_init(msg_content_md5_t x[1])
Initialize an msg_content_md5_t structure.
Definition: msg_mime_protos.h:3119
msg_accept_language_hash
@ msg_accept_language_hash
Hash of Accept-Language header.
Definition: msg_mime_protos.h:2567
msg_content_transfer_encoding_init
msg_content_transfer_encoding_t * msg_content_transfer_encoding_init(msg_content_transfer_encoding_t x[1])
Initialize an msg_content_transfer_encoding_t structure.
Definition: msg_mime_protos.h:1619
msg_content_id_class
msg_hclass_t msg_content_id_class[]
Header class for Content-ID header.
Definition: msg_mime.c:1829
msg_accept_charset_e
msg_print_f msg_accept_charset_e
Print a Accept-Charset header.
Definition: msg_mime_protos.h:2074
msg_accept_charset_class
msg_hclass_t msg_accept_charset_class[]
Header class for Accept-Charset header.
Definition: msg_mime.c:1333
msg_mime_version_copy
msg_mime_version_t * msg_mime_version_copy(su_home_t *home, msg_mime_version_t const *header)
Copy an msg_mime_version_t header structure.
Definition: msg_mime_protos.h:2981
msg_is_accept_language
int msg_is_accept_language(msg_header_t const *header)
Test if header object is an instance of msg_accept_language_t.
Definition: msg_mime_protos.h:2641
msg_content_location_copy
msg_content_location_t * msg_content_location_copy(su_home_t *home, msg_content_location_t const *header)
Copy an msg_content_location_t header structure.
Definition: msg_mime_protos.h:731
msg_warning_class
msg_hclass_t msg_warning_class[]
Header class for Warning header.
Definition: msg_mime.c:2202
msg_parser.h
msg_accept_encoding_make
msg_accept_encoding_t * msg_accept_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_accept_encoding_t.
Definition: msg_mime_protos.h:2507
msg_is_content_length
int msg_is_content_length(msg_header_t const *header)
Test if header object is an instance of msg_content_length_t.
Definition: msg_mime_protos.h:3391
msg_accept_language_copy
msg_accept_language_t * msg_accept_language_copy(su_home_t *home, msg_accept_language_t const *header)
Copy an msg_accept_language_t header structure.
Definition: msg_mime_protos.h:2731
msg_is_content_disposition
int msg_is_content_disposition(msg_header_t const *header)
Test if header object is an instance of msg_content_disposition_t.
Definition: msg_mime_protos.h:391
msg_multipart_dup
msg_multipart_t * msg_multipart_dup(su_home_t *home, msg_multipart_t const *header)
Duplicate (deep copy) msg_multipart_t.
Definition: msg_mime_protos.h:3686
su_inline
#define su_inline
msg_warning_e
msg_print_f msg_warning_e
Print a Warning header.
Definition: msg_mime_protos.h:3824
msg_content_id_e
msg_print_f msg_content_id_e
Print a Content-ID header.
Definition: msg_mime_protos.h:824
msg_content_id_d
msg_parse_f msg_content_id_d
Parse a Content-ID header.
Definition: msg_mime_protos.h:821
msg_content_disposition_init
msg_content_disposition_t * msg_content_disposition_init(msg_content_disposition_t x[1])
Initialize an msg_content_disposition_t structure.
Definition: msg_mime_protos.h:369
msg_list_s
List header.
Definition: msg_types.h:161
msg_accept_charset_make
msg_accept_charset_t * msg_accept_charset_make(su_home_t *home, char const *s)
Make a header structure msg_accept_charset_t.
Definition: msg_mime_protos.h:2257
msg_accept_language_make
msg_accept_language_t * msg_accept_language_make(su_home_t *home, char const *s)
Make a header structure msg_accept_language_t.
Definition: msg_mime_protos.h:2757
msg_mime_version_hash
@ msg_mime_version_hash
Hash of MIME-Version header.
Definition: msg_mime_protos.h:2817
msg_content_location_hash
@ msg_content_location_hash
Hash of Content-Location header.
Definition: msg_mime_protos.h:567
msg_accept_any_s
Structure for Accept-Charset, Accept-Encoding and Accept-Language headers.
Definition: msg_mime.h:93
msg_content_type_format
msg_content_type_t * msg_content_type_format(su_home_t *home, char const *fmt,...)))
Make a Content-Type header from formatting result.
Definition: msg_mime_protos.h:294
msg_content_language_hash
@ msg_content_language_hash
Hash of Content-Language header.
Definition: msg_mime_protos.h:1067
msg_accept_language_d
msg_parse_f msg_accept_language_d
Parse a Accept-Language header.
Definition: msg_mime_protos.h:2571
msg_content_length_d
msg_parse_f msg_content_length_d
Parse a Content-Length header.
Definition: msg_mime_protos.h:3321
msg_generic_s
Generic header.
Definition: msg_types.h:151
msg_accept_dup
msg_accept_t * msg_accept_dup(su_home_t *home, msg_accept_t const *header)
Duplicate (deep copy) msg_accept_t.
Definition: msg_mime_protos.h:1936
msg_header_make
msg_header_t * msg_header_make(su_home_t *home, msg_hclass_t *hc, char const *s))
Make a header from a value string.
Definition: msg_header_make.c:64
msg_accept_init
msg_accept_t * msg_accept_init(msg_accept_t x[1])
Initialize an msg_accept_t structure.
Definition: msg_mime_protos.h:1869
msg_content_type_make
msg_content_type_t * msg_content_type_make(su_home_t *home, char const *s)
Make a header structure msg_content_type_t.
Definition: msg_mime_protos.h:257
msg_accept_encoding_class
msg_hclass_t msg_accept_encoding_class[]
Header class for Accept-Encoding header.
Definition: msg_mime.c:1384
msg_accept_e
msg_print_f msg_accept_e
Print a Accept header.
Definition: msg_mime_protos.h:1824
msg_warning_make
msg_warning_t * msg_warning_make(su_home_t *home, char const *s)
Make a header structure msg_warning_t.
Definition: msg_mime_protos.h:4007
msg_content_disposition_format
msg_content_disposition_t * msg_content_disposition_format(su_home_t *home, char const *fmt,...)))
Make a Content-Disposition header from formatting result.
Definition: msg_mime_protos.h:544
msg_content_md5_d
msg_parse_f msg_content_md5_d
Parse a Content-MD5 header.
Definition: msg_mime_protos.h:3071
msg_is_content_md5
int msg_is_content_md5(msg_header_t const *header)
Test if header object is an instance of msg_content_md5_t.
Definition: msg_mime_protos.h:3141
msg_content_language_class
msg_hclass_t msg_content_language_class[]
Header class for Content-Language header.
Definition: msg_mime.c:1678
msg_content_encoding_d
msg_parse_f msg_content_encoding_d
Parse a Content-Encoding header.
Definition: msg_mime_protos.h:1321
msg_content_encoding_init
msg_content_encoding_t * msg_content_encoding_init(msg_content_encoding_t x[1])
Initialize an msg_content_encoding_t structure.
Definition: msg_mime_protos.h:1369
msg_content_language_make
msg_content_language_t * msg_content_language_make(su_home_t *home, char const *s)
Make a header structure msg_content_language_t.
Definition: msg_mime_protos.h:1257
msg_content_id_copy
msg_content_id_t * msg_content_id_copy(su_home_t *home, msg_content_id_t const *header)
Copy an msg_content_id_t header structure.
Definition: msg_mime_protos.h:981
msg_content_disposition_s
Structure for Content-Disposition header.
Definition: msg_mime.h:105
msg_is_accept_encoding
int msg_is_accept_encoding(msg_header_t const *header)
Test if header object is an instance of msg_accept_encoding_t.
Definition: msg_mime_protos.h:2391
msg_is_mime_version
int msg_is_mime_version(msg_header_t const *header)
Test if header object is an instance of msg_mime_version_t.
Definition: msg_mime_protos.h:2891
msg_content_disposition_copy
msg_content_disposition_t * msg_content_disposition_copy(su_home_t *home, msg_content_disposition_t const *header)
Copy an msg_content_disposition_t header structure.
Definition: msg_mime_protos.h:481
msg_content_type_s
Structure for Content-Type header.
Definition: msg_mime.h:131
msg_content_disposition_d
msg_parse_f msg_content_disposition_d
Parse a Content-Disposition header.
Definition: msg_mime_protos.h:321
msg_accept_class
msg_hclass_t msg_accept_class[]
Header class for Accept header.
Definition: msg_mime.c:1070
msg_is_content_transfer_encoding
int msg_is_content_transfer_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_transfer_encoding_t.
Definition: msg_mime_protos.h:1641
msg_header_dup_as
msg_header_t * msg_header_dup_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
Duplicate a header as class hc.
Definition: msg_header_copy.c:259
msg_is_content_id
int msg_is_content_id(msg_header_t const *header)
Test if header object is an instance of msg_content_id_t.
Definition: msg_mime_protos.h:891
msg_content_disposition_hash
@ msg_content_disposition_hash
Hash of Content-Disposition header.
Definition: msg_mime_protos.h:317
msg_content_language_dup
msg_content_language_t * msg_content_language_dup(su_home_t *home, msg_content_language_t const *header)
Duplicate (deep copy) msg_content_language_t.
Definition: msg_mime_protos.h:1186
msg_content_location_init
msg_content_location_t * msg_content_location_init(msg_content_location_t x[1])
Initialize an msg_content_location_t structure.
Definition: msg_mime_protos.h:619
msg_content_type_class
msg_hclass_t msg_content_type_class[]
Header class for Content-Type header.
Definition: msg_mime.c:1872
msg_content_language_e
msg_print_f msg_content_language_e
Print a Content-Language header.
Definition: msg_mime_protos.h:1074
msg_content_encoding_make
msg_content_encoding_t * msg_content_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_encoding_t.
Definition: msg_mime_protos.h:1507
msg_accept_charset_d
msg_parse_f msg_accept_charset_d
Parse a Accept-Charset header.
Definition: msg_mime_protos.h:2071
msg_accept_charset_init
msg_accept_charset_t * msg_accept_charset_init(msg_accept_charset_t x[1])
Initialize an msg_accept_charset_t structure.
Definition: msg_mime_protos.h:2119
msg_is_warning
int msg_is_warning(msg_header_t const *header)
Test if header object is an instance of msg_warning_t.
Definition: msg_mime_protos.h:3891
msg_content_length_dup
msg_content_length_t * msg_content_length_dup(su_home_t *home, msg_content_length_t const *header)
Duplicate (deep copy) msg_content_length_t.
Definition: msg_mime_protos.h:3436
msg_accept_charset_dup
msg_accept_charset_t * msg_accept_charset_dup(su_home_t *home, msg_accept_charset_t const *header)
Duplicate (deep copy) msg_accept_charset_t.
Definition: msg_mime_protos.h:2186
msg_content_length_e
msg_print_f msg_content_length_e
Print a Content-Length header.
Definition: msg_mime_protos.h:3324
msg_content_location_dup
msg_content_location_t * msg_content_location_dup(su_home_t *home, msg_content_location_t const *header)
Duplicate (deep copy) msg_content_location_t.
Definition: msg_mime_protos.h:686
msg_mime_version_format
msg_mime_version_t * msg_mime_version_format(su_home_t *home, char const *fmt,...)))
Make a MIME-Version header from formatting result.
Definition: msg_mime_protos.h:3044
msg_warning_init
msg_warning_t * msg_warning_init(msg_warning_t x[1])
Initialize an msg_warning_t structure.
Definition: msg_mime_protos.h:3869
msg_is_accept
int msg_is_accept(msg_header_t const *header)
Test if header object is an instance of msg_accept_t.
Definition: msg_mime_protos.h:1891
msg_mclass_s
Factory object for protocol messages.
Definition: msg_mclass.h:96
msg_warning_format
msg_warning_t * msg_warning_format(su_home_t *home, char const *fmt,...)))
Make a Warning header from formatting result.
Definition: msg_mime_protos.h:4044
msg_is_accept_charset
int msg_is_accept_charset(msg_header_t const *header)
Test if header object is an instance of msg_accept_charset_t.
Definition: msg_mime_protos.h:2141
msg_content_length_class
msg_hclass_t msg_content_length_class[]
Header class for Content-Length header.
Definition: msg_mime.c:1727
msg_content_location_format
msg_content_location_t * msg_content_location_format(su_home_t *home, char const *fmt,...)))
Make a Content-Location header from formatting result.
Definition: msg_mime_protos.h:794
msg_header_copy_as
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
Copy a list of header objects.
Definition: msg_header_copy.c:148
msg_accept_charset_format
msg_accept_charset_t * msg_accept_charset_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Charset header from formatting result.
Definition: msg_mime_protos.h:2294
msg_header_t
MSG_HDR_T msg_header_t
Any protocol-specific header object.
Definition: msg_types.h:87
msg_warning_d
msg_parse_f msg_warning_d
Parse a Warning header.
Definition: msg_mime_protos.h:3821
msg_content_encoding_dup
msg_content_encoding_t * msg_content_encoding_dup(su_home_t *home, msg_content_encoding_t const *header)
Duplicate (deep copy) msg_content_encoding_t.
Definition: msg_mime_protos.h:1436
msg_accept_charset_copy
msg_accept_charset_t * msg_accept_charset_copy(su_home_t *home, msg_accept_charset_t const *header)
Copy an msg_accept_charset_t header structure.
Definition: msg_mime_protos.h:2231
msg_content_md5_e
msg_print_f msg_content_md5_e
Print a Content-MD5 header.
Definition: msg_mime_protos.h:3074
msg_content_id_make
msg_content_id_t * msg_content_id_make(su_home_t *home, char const *s)
Make a header structure msg_content_id_t.
Definition: msg_mime_protos.h:1007
msg_is_content_type
int msg_is_content_type(msg_header_t const *header)
Test if header object is an instance of msg_content_type_t.
Definition: msg_mime_protos.h:141
msg_content_type_init
msg_content_type_t * msg_content_type_init(msg_content_type_t x[1])
Initialize an msg_content_type_t structure.
Definition: msg_mime_protos.h:119
msg_accept_encoding_hash
@ msg_accept_encoding_hash
Hash of Accept-Encoding header.
Definition: msg_mime_protos.h:2317
msg_content_md5_hash
@ msg_content_md5_hash
Hash of Content-MD5 header.
Definition: msg_mime_protos.h:3067
msg_content_transfer_encoding_make
msg_content_transfer_encoding_t * msg_content_transfer_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_transfer_encoding_t.
Definition: msg_mime_protos.h:1757
msg_warning_dup
msg_warning_t * msg_warning_dup(su_home_t *home, msg_warning_t const *header)
Duplicate (deep copy) msg_warning_t.
Definition: msg_mime_protos.h:3936
msg_multipart_hash
@ msg_multipart_hash
Hash of Recursive multipart header.
Definition: msg_mime_protos.h:3567
msg_content_language_d
msg_parse_f msg_content_language_d
Parse a Content-Language header.
Definition: msg_mime_protos.h:1071
msg_accept_encoding_d
msg_parse_f msg_accept_encoding_d
Parse a Accept-Encoding header.
Definition: msg_mime_protos.h:2321
msg_multipart_e
msg_print_f msg_multipart_e
Print a Recursive multipart header.
Definition: msg_mime_protos.h:3574
msg_content_md5_make
msg_content_md5_t * msg_content_md5_make(su_home_t *home, char const *s)
Make a header structure msg_content_md5_t.
Definition: msg_mime_protos.h:3257
msg_hclass_t
struct msg_hclass_s const msg_hclass_t
Header class.
Definition: msg_types.h:48
msg_content_id_hash
@ msg_content_id_hash
Hash of Content-ID header.
Definition: msg_mime_protos.h:817
msg_content_length_copy
msg_content_length_t * msg_content_length_copy(su_home_t *home, msg_content_length_t const *header)
Copy an msg_content_length_t header structure.
Definition: msg_mime_protos.h:3481
msg_content_type_e
msg_print_f msg_content_type_e
Print a Content-Type header.
Definition: msg_mime_protos.h:74
msg_content_type_copy
msg_content_type_t * msg_content_type_copy(su_home_t *home, msg_content_type_t const *header)
Copy an msg_content_type_t header structure.
Definition: msg_mime_protos.h:231
msg_mclass.h
Parser table and message factory object.
msg_content_encoding_copy
msg_content_encoding_t * msg_content_encoding_copy(su_home_t *home, msg_content_encoding_t const *header)
Copy an msg_content_encoding_t header structure.
Definition: msg_mime_protos.h:1481
msg_content_id_dup
msg_content_id_t * msg_content_id_dup(su_home_t *home, msg_content_id_t const *header)
Duplicate (deep copy) msg_content_id_t.
Definition: msg_mime_protos.h:936
msg_warning_s
Structure for Warning header.
Definition: msg_mime.h:144
msg_content_transfer_encoding_dup
msg_content_transfer_encoding_t * msg_content_transfer_encoding_dup(su_home_t *home, msg_content_transfer_encoding_t const *header)
Duplicate (deep copy) msg_content_transfer_encoding_t.
Definition: msg_mime_protos.h:1686
msg_multipart_format
msg_multipart_t * msg_multipart_format(su_home_t *home, char const *fmt,...)))
Make a Recursive multipart header from formatting result.
Definition: msg_mime_protos.h:3794
msg_accept_encoding_init
msg_accept_encoding_t * msg_accept_encoding_init(msg_accept_encoding_t x[1])
Initialize an msg_accept_encoding_t structure.
Definition: msg_mime_protos.h:2369
msg_content_transfer_encoding_class
msg_hclass_t msg_content_transfer_encoding_class[]
Header class for Content-Transfer-Encoding header.
Definition: msg_mime.c:2078
msg_content_length_format
msg_content_length_t * msg_content_length_format(su_home_t *home, char const *fmt,...)))
Make a Content-Length header from formatting result.
Definition: msg_mime_protos.h:3544
msg_warning_copy
msg_warning_t * msg_warning_copy(su_home_t *home, msg_warning_t const *header)
Copy an msg_warning_t header structure.
Definition: msg_mime_protos.h:3981
msg_content_transfer_encoding_e
msg_print_f msg_content_transfer_encoding_e
Print a Content-Transfer-Encoding header.
Definition: msg_mime_protos.h:1574
msg_is_multipart
int msg_is_multipart(msg_header_t const *header)
Test if header object is an instance of msg_multipart_t.
Definition: msg_mime_protos.h:3641
msg_content_encoding_format
msg_content_encoding_t * msg_content_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Encoding header from formatting result.
Definition: msg_mime_protos.h:1544
msg_accept_encoding_e
msg_print_f msg_accept_encoding_e
Print a Accept-Encoding header.
Definition: msg_mime_protos.h:2324
msg_content_language_copy
msg_content_language_t * msg_content_language_copy(su_home_t *home, msg_content_language_t const *header)
Copy an msg_content_language_t header structure.
Definition: msg_mime_protos.h:1231
msg_multipart_s
Structure for a part in MIME multipart message.
Definition: msg_mime.h:159
msg_content_location_e
msg_print_f msg_content_location_e
Print a Content-Location header.
Definition: msg_mime_protos.h:574
msg_multipart_d
msg_parse_f msg_multipart_d
Parse a Recursive multipart header.
Definition: msg_mime_protos.h:3571
msg_accept_d
msg_parse_f msg_accept_d
Parse a Accept header.
Definition: msg_mime_protos.h:1821
msg_mime_version_dup
msg_mime_version_t * msg_mime_version_dup(su_home_t *home, msg_mime_version_t const *header)
Duplicate (deep copy) msg_mime_version_t.
Definition: msg_mime_protos.h:2936
msg_accept_make
msg_accept_t * msg_accept_make(su_home_t *home, char const *s)
Make a header structure msg_accept_t.
Definition: msg_mime_protos.h:2007
msg_content_id_format
msg_content_id_t * msg_content_id_format(su_home_t *home, char const *fmt,...)))
Make a Content-ID header from formatting result.
Definition: msg_mime_protos.h:1044
msg_is_content_location
int msg_is_content_location(msg_header_t const *header)
Test if header object is an instance of msg_content_location_t.
Definition: msg_mime_protos.h:641
msg_multipart_init
msg_multipart_t * msg_multipart_init(msg_multipart_t x[1])
Initialize an msg_multipart_t structure.
Definition: msg_mime_protos.h:3619
msg_content_encoding_hash
@ msg_content_encoding_hash
Hash of Content-Encoding header.
Definition: msg_mime_protos.h:1317
msg_mime_version_class
msg_hclass_t msg_mime_version_class[]
Header class for MIME-Version header.
Definition: msg_mime.c:1971
msg_content_location_class
msg_hclass_t msg_content_location_class[]
Header class for Content-Location header.
Definition: msg_mime.c:2012
msg_content_disposition_class
msg_hclass_t msg_content_disposition_class[]
Header class for Content-Disposition header.
Definition: msg_mime.c:1510
msg_mime_version_init
msg_mime_version_t * msg_mime_version_init(msg_mime_version_t x[1])
Initialize an msg_mime_version_t structure.
Definition: msg_mime_protos.h:2869
msg_header_vformat
msg_header_t * msg_header_vformat(su_home_t *home, msg_hclass_t *hc, char const *fmt, va_list ap))
Make a MSG header with formatting provided.
Definition: msg_header_make.c:105
msg_content_length_init
msg_content_length_t * msg_content_length_init(msg_content_length_t x[1])
Initialize an msg_content_length_t structure.
Definition: msg_mime_protos.h:3369
msg_content_type_hash
@ msg_content_type_hash
Hash of Content-Type header.
Definition: msg_mime_protos.h:67
msg_accept_language_e
msg_print_f msg_accept_language_e
Print a Accept-Language header.
Definition: msg_mime_protos.h:2574
msg_content_md5_dup
msg_content_md5_t * msg_content_md5_dup(su_home_t *home, msg_content_md5_t const *header)
Duplicate (deep copy) msg_content_md5_t.
Definition: msg_mime_protos.h:3186
msg_content_md5_copy
msg_content_md5_t * msg_content_md5_copy(su_home_t *home, msg_content_md5_t const *header)
Copy an msg_content_md5_t header structure.
Definition: msg_mime_protos.h:3231
msg_accept_charset_hash
@ msg_accept_charset_hash
Hash of Accept-Charset header.
Definition: msg_mime_protos.h:2067
msg_accept_language_init
msg_accept_language_t * msg_accept_language_init(msg_accept_language_t x[1])
Initialize an msg_accept_language_t structure.
Definition: msg_mime_protos.h:2619
msg_accept_encoding_copy
msg_accept_encoding_t * msg_accept_encoding_copy(su_home_t *home, msg_accept_encoding_t const *header)
Copy an msg_accept_encoding_t header structure.
Definition: msg_mime_protos.h:2481
msg_multipart_copy
msg_multipart_t * msg_multipart_copy(su_home_t *home, msg_multipart_t const *header)
Copy an msg_multipart_t header structure.
Definition: msg_mime_protos.h:3731
msg_content_type_d
msg_parse_f msg_content_type_d
Parse a Content-Type header.
Definition: msg_mime_protos.h:71
msg_content_location_make
msg_content_location_t * msg_content_location_make(su_home_t *home, char const *s)
Make a header structure msg_content_location_t.
Definition: msg_mime_protos.h:757
msg_content_length_s
Structure for Content-Length header.
Definition: msg_mime.h:120
msg_content_disposition_dup
msg_content_disposition_t * msg_content_disposition_dup(su_home_t *home, msg_content_disposition_t const *header)
Duplicate (deep copy) msg_content_disposition_t.
Definition: msg_mime_protos.h:436
msg_content_disposition_make
msg_content_disposition_t * msg_content_disposition_make(su_home_t *home, char const *s)
Make a header structure msg_content_disposition_t.
Definition: msg_mime_protos.h:507
msg_content_length_make
msg_content_length_t * msg_content_length_make(su_home_t *home, char const *s)
Make a header structure msg_content_length_t.
Definition: msg_mime_protos.h:3507
msg_accept_format
msg_accept_t * msg_accept_format(su_home_t *home, char const *fmt,...)))
Make a Accept header from formatting result.
Definition: msg_mime_protos.h:2044
msg_content_encoding_e
msg_print_f msg_content_encoding_e
Print a Content-Encoding header.
Definition: msg_mime_protos.h:1324
msg_accept_s
Structure for Accept header.
Definition: msg_mime.h:79
msg_accept_hash
@ msg_accept_hash
Hash of Accept header.
Definition: msg_mime_protos.h:1817
msg_content_language_format
msg_content_language_t * msg_content_language_format(su_home_t *home, char const *fmt,...)))
Make a Content-Language header from formatting result.
Definition: msg_mime_protos.h:1294
msg_accept_language_class
msg_hclass_t msg_accept_language_class[]
Header class for Accept-Language header.
Definition: msg_mime.c:1435
msg_content_transfer_encoding_copy
msg_content_transfer_encoding_t * msg_content_transfer_encoding_copy(su_home_t *home, msg_content_transfer_encoding_t const *header)
Copy an msg_content_transfer_encoding_t header structure.
Definition: msg_mime_protos.h:1731
msg_multipart_make
msg_multipart_t * msg_multipart_make(su_home_t *home, char const *s)
Make a header structure msg_multipart_t.
Definition: msg_mime_protos.h:3757
msg_accept_language_dup
msg_accept_language_t * msg_accept_language_dup(su_home_t *home, msg_accept_language_t const *header)
Duplicate (deep copy) msg_accept_language_t.
Definition: msg_mime_protos.h:2686
msg_accept_encoding_format
msg_accept_encoding_t * msg_accept_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Encoding header from formatting result.
Definition: msg_mime_protos.h:2544
msg_mime_version_d
msg_parse_f msg_mime_version_d
Parse a MIME-Version header.
Definition: msg_mime_protos.h:2821

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