msg 1.12.11devel
Loading...
Searching...
No Matches
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
27#define MSG_MIME_PROTOS_H
28
39#ifndef MSG_PARSER_H
41#endif
42#ifndef MSG_MIME_H
43#include <sofia-sip/msg_mime.h>
44#endif
45#ifndef MSG_MCLASS_H
47#endif
48#ifndef MSG_MCLASS_H
50#endif
51
52SOFIA_BEGIN_DECLS
53
54MSG_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
65enum {
68};
69
71MSG_DLL msg_parse_f msg_content_type_d;
72
74MSG_DLL msg_print_f msg_content_type_e;
75
76MSG_DLL msg_xtra_f msg_content_type_dup_xtra;
77MSG_DLL msg_dup_f msg_content_type_dup_one;
78
87#ifndef msg_content_type_class
89#endif
90
102#define MSG_CONTENT_TYPE_INIT() MSG_HDR_INIT(content_type)
103
118#if SU_HAVE_INLINE
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
146int 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
180#endif
182 msg_content_type_t const *header);
183
184#if SU_HAVE_INLINE
192#endif
193
194
223#if SU_HAVE_INLINE
225#endif
227 msg_content_type_t const *header);
228
229#if SU_HAVE_INLINE
237#endif
238
239
256#if SU_HAVE_INLINE
261#else
263#endif
264
265
287#if SU_HAVE_INLINE
289#endif
290msg_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
315enum {
319
321MSG_DLL msg_parse_f msg_content_disposition_d;
322
324MSG_DLL msg_print_f msg_content_disposition_e;
325
326MSG_DLL msg_xtra_f msg_content_disposition_dup_xtra;
327MSG_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
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
397#endif
398
399#define msg_content_disposition_p(h) msg_is_content_disposition((h))
400
428#if SU_HAVE_INLINE
430#endif
432 msg_content_disposition_t const *header);
433
434#if SU_HAVE_INLINE
442#endif
443
444
473#if SU_HAVE_INLINE
475#endif
477 msg_content_disposition_t const *header);
478
479#if SU_HAVE_INLINE
487#endif
488
489
506#if SU_HAVE_INLINE
511#else
513#endif
514
515
537#if SU_HAVE_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
565enum {
569
571MSG_DLL msg_parse_f msg_content_location_d;
572
574MSG_DLL msg_print_f msg_content_location_e;
575
576MSG_DLL msg_xtra_f msg_content_location_dup_xtra;
577MSG_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
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
646int 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
680#endif
682 msg_content_location_t const *header);
683
684#if SU_HAVE_INLINE
692#endif
693
694
723#if SU_HAVE_INLINE
725#endif
727 msg_content_location_t const *header);
728
729#if SU_HAVE_INLINE
737#endif
738
739
756#if SU_HAVE_INLINE
761#else
763#endif
764
765
787#if SU_HAVE_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
815enum {
817 msg_content_id_hash = 42909
819
821MSG_DLL msg_parse_f msg_content_id_d;
822
824MSG_DLL msg_print_f msg_content_id_e;
825
826MSG_DLL msg_xtra_f msg_content_id_dup_xtra;
827MSG_DLL msg_dup_f msg_content_id_dup_one;
828
837#ifndef msg_content_id_class
838MSG_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
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
896int 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
930#endif
932 msg_content_id_t const *header);
933
934#if SU_HAVE_INLINE
937 msg_content_id_t const *header)
938{
939 return (msg_content_id_t *)
941}
942#endif
943
944
973#if SU_HAVE_INLINE
975#endif
977 msg_content_id_t const *header);
978
979#if SU_HAVE_INLINE
982 msg_content_id_t const *header)
983{
984 return (msg_content_id_t *)
986}
987#endif
988
989
1006#if SU_HAVE_INLINE
1011#else
1012msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s);
1013#endif
1014
1015
1037#if SU_HAVE_INLINE
1039#endif
1040msg_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
1065enum {
1069
1071MSG_DLL msg_parse_f msg_content_language_d;
1072
1074MSG_DLL msg_print_f msg_content_language_e;
1075
1076MSG_DLL msg_xtra_f msg_content_language_dup_xtra;
1077MSG_DLL msg_dup_f msg_content_language_dup_one;
1078
1087#ifndef msg_content_language_class
1089#endif
1090
1102#define MSG_CONTENT_LANGUAGE_INIT() MSG_HDR_INIT(content_language)
1103
1118#if SU_HAVE_INLINE
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
1146int 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
1180#endif
1182 msg_content_language_t const *header);
1183
1184#if SU_HAVE_INLINE
1192#endif
1193
1194
1223#if SU_HAVE_INLINE
1225#endif
1227 msg_content_language_t const *header);
1228
1229#if SU_HAVE_INLINE
1237#endif
1238
1239
1256#if SU_HAVE_INLINE
1261#else
1263#endif
1264
1265
1287#if SU_HAVE_INLINE
1289#endif
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);
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
1315enum {
1319
1321MSG_DLL msg_parse_f msg_content_encoding_d;
1322
1324MSG_DLL msg_print_f msg_content_encoding_e;
1325
1326MSG_DLL msg_xtra_f msg_content_encoding_dup_xtra;
1327MSG_DLL msg_dup_f msg_content_encoding_dup_one;
1328
1337#ifndef msg_content_encoding_class
1339#endif
1340
1352#define MSG_CONTENT_ENCODING_INIT() MSG_HDR_INIT(content_encoding)
1353
1368#if SU_HAVE_INLINE
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
1396int 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
1430#endif
1432 msg_content_encoding_t const *header);
1433
1434#if SU_HAVE_INLINE
1442#endif
1443
1444
1473#if SU_HAVE_INLINE
1475#endif
1477 msg_content_encoding_t const *header);
1478
1479#if SU_HAVE_INLINE
1487#endif
1488
1489
1506#if SU_HAVE_INLINE
1511#else
1513#endif
1514
1515
1537#if SU_HAVE_INLINE
1539#endif
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);
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
1565enum {
1569
1572
1575
1576MSG_DLL msg_xtra_f msg_content_transfer_encoding_dup_xtra;
1577MSG_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
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
1680#endif
1682 msg_content_transfer_encoding_t const *header);
1683
1684#if SU_HAVE_INLINE
1692#endif
1693
1694
1723#if SU_HAVE_INLINE
1725#endif
1727 msg_content_transfer_encoding_t const *header);
1728
1729#if SU_HAVE_INLINE
1737#endif
1738
1739
1756#if SU_HAVE_INLINE
1761#else
1763#endif
1764
1765
1787#if SU_HAVE_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
1815enum {
1817 msg_accept_hash = 29344
1819
1821MSG_DLL msg_parse_f msg_accept_d;
1822
1824MSG_DLL msg_print_f msg_accept_e;
1825
1826MSG_DLL msg_xtra_f msg_accept_dup_xtra;
1827MSG_DLL msg_dup_f msg_accept_dup_one;
1828
1837#ifndef msg_accept_class
1838MSG_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
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
1896int 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
1930#endif
1932 msg_accept_t const *header);
1933
1934#if SU_HAVE_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
1975#endif
1977 msg_accept_t const *header);
1978
1979#if SU_HAVE_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{
2010}
2011#else
2012msg_accept_t *msg_accept_make(su_home_t *home, char const *s);
2013#endif
2014
2015
2037#if SU_HAVE_INLINE
2039#endif
2040msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
2041 __attribute__((__format__ (printf, 2, 3)));
2042
2043#if SU_HAVE_INLINE
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
2065enum {
2069
2071MSG_DLL msg_parse_f msg_accept_charset_d;
2072
2074MSG_DLL msg_print_f msg_accept_charset_e;
2075
2076MSG_DLL msg_xtra_f msg_accept_charset_dup_xtra;
2077MSG_DLL msg_dup_f msg_accept_charset_dup_one;
2078
2087#ifndef msg_accept_charset_class
2088MSG_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
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
2146int 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
2180#endif
2182 msg_accept_charset_t const *header);
2183
2184#if SU_HAVE_INLINE
2192#endif
2193
2194
2223#if SU_HAVE_INLINE
2225#endif
2227 msg_accept_charset_t const *header);
2228
2229#if SU_HAVE_INLINE
2237#endif
2238
2239
2256#if SU_HAVE_INLINE
2261#else
2263#endif
2264
2265
2287#if SU_HAVE_INLINE
2289#endif
2290msg_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
2315enum {
2319
2321MSG_DLL msg_parse_f msg_accept_encoding_d;
2322
2324MSG_DLL msg_print_f msg_accept_encoding_e;
2325
2326MSG_DLL msg_xtra_f msg_accept_encoding_dup_xtra;
2327MSG_DLL msg_dup_f msg_accept_encoding_dup_one;
2328
2337#ifndef msg_accept_encoding_class
2339#endif
2340
2352#define MSG_ACCEPT_ENCODING_INIT() MSG_HDR_INIT(accept_encoding)
2353
2368#if SU_HAVE_INLINE
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
2396int 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
2430#endif
2432 msg_accept_encoding_t const *header);
2433
2434#if SU_HAVE_INLINE
2442#endif
2443
2444
2473#if SU_HAVE_INLINE
2475#endif
2477 msg_accept_encoding_t const *header);
2478
2479#if SU_HAVE_INLINE
2487#endif
2488
2489
2506#if SU_HAVE_INLINE
2511#else
2513#endif
2514
2515
2537#if SU_HAVE_INLINE
2539#endif
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);
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
2565enum {
2569
2571MSG_DLL msg_parse_f msg_accept_language_d;
2572
2574MSG_DLL msg_print_f msg_accept_language_e;
2575
2576MSG_DLL msg_xtra_f msg_accept_language_dup_xtra;
2577MSG_DLL msg_dup_f msg_accept_language_dup_one;
2578
2587#ifndef msg_accept_language_class
2589#endif
2590
2602#define MSG_ACCEPT_LANGUAGE_INIT() MSG_HDR_INIT(accept_language)
2603
2618#if SU_HAVE_INLINE
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
2646int 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
2680#endif
2682 msg_accept_language_t const *header);
2683
2684#if SU_HAVE_INLINE
2692#endif
2693
2694
2723#if SU_HAVE_INLINE
2725#endif
2727 msg_accept_language_t const *header);
2728
2729#if SU_HAVE_INLINE
2737#endif
2738
2739
2756#if SU_HAVE_INLINE
2761#else
2763#endif
2764
2765
2787#if SU_HAVE_INLINE
2789#endif
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);
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
2815enum {
2817 msg_mime_version_hash = 49047
2819
2821MSG_DLL msg_parse_f msg_mime_version_d;
2822
2824MSG_DLL msg_print_f msg_mime_version_e;
2825
2826MSG_DLL msg_xtra_f msg_mime_version_dup_xtra;
2827MSG_DLL msg_dup_f msg_mime_version_dup_one;
2828
2837#ifndef msg_mime_version_class
2838MSG_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
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
2896int 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
2930#endif
2932 msg_mime_version_t const *header);
2933
2934#if SU_HAVE_INLINE
2937 msg_mime_version_t const *header)
2938{
2939 return (msg_mime_version_t *)
2941}
2942#endif
2943
2944
2973#if SU_HAVE_INLINE
2975#endif
2977 msg_mime_version_t const *header);
2978
2979#if SU_HAVE_INLINE
2982 msg_mime_version_t const *header)
2983{
2984 return (msg_mime_version_t *)
2986}
2987#endif
2988
2989
3006#if SU_HAVE_INLINE
3011#else
3013#endif
3014
3015
3037#if SU_HAVE_INLINE
3039#endif
3040msg_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
3065enum {
3067 msg_content_md5_hash = 60494
3069
3071MSG_DLL msg_parse_f msg_content_md5_d;
3072
3074MSG_DLL msg_print_f msg_content_md5_e;
3075
3076MSG_DLL msg_xtra_f msg_content_md5_dup_xtra;
3077MSG_DLL msg_dup_f msg_content_md5_dup_one;
3078
3087#ifndef msg_content_md5_class
3088MSG_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
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
3146int 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
3180#endif
3182 msg_content_md5_t const *header);
3183
3184#if SU_HAVE_INLINE
3187 msg_content_md5_t const *header)
3188{
3189 return (msg_content_md5_t *)
3191}
3192#endif
3193
3194
3223#if SU_HAVE_INLINE
3225#endif
3227 msg_content_md5_t const *header);
3228
3229#if SU_HAVE_INLINE
3232 msg_content_md5_t const *header)
3233{
3234 return (msg_content_md5_t *)
3236}
3237#endif
3238
3239
3256#if SU_HAVE_INLINE
3261#else
3262msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s);
3263#endif
3264
3265
3287#if SU_HAVE_INLINE
3289#endif
3290msg_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
3315enum {
3319
3321MSG_DLL msg_parse_f msg_content_length_d;
3322
3324MSG_DLL msg_print_f msg_content_length_e;
3325
3326MSG_DLL msg_xtra_f msg_content_length_dup_xtra;
3327MSG_DLL msg_dup_f msg_content_length_dup_one;
3328
3337#ifndef msg_content_length_class
3338MSG_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
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
3396int 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
3430#endif
3432 msg_content_length_t const *header);
3433
3434#if SU_HAVE_INLINE
3442#endif
3443
3444
3473#if SU_HAVE_INLINE
3475#endif
3477 msg_content_length_t const *header);
3478
3479#if SU_HAVE_INLINE
3487#endif
3488
3489
3506#if SU_HAVE_INLINE
3511#else
3513#endif
3514
3515
3537#if SU_HAVE_INLINE
3539#endif
3540msg_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
3565enum {
3567 msg_multipart_hash = 58884
3569
3571MSG_DLL msg_parse_f msg_multipart_d;
3572
3574MSG_DLL msg_print_f msg_multipart_e;
3575
3576MSG_DLL msg_xtra_f msg_multipart_dup_xtra;
3577MSG_DLL msg_dup_f msg_multipart_dup_one;
3578
3587#ifndef msg_multipart_class
3588MSG_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
3646int 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
3680#endif
3682 msg_multipart_t const *header);
3683
3684#if SU_HAVE_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
3725#endif
3727 msg_multipart_t const *header);
3728
3729#if SU_HAVE_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
3762msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s);
3763#endif
3764
3765
3787#if SU_HAVE_INLINE
3789#endif
3790msg_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
3815enum {
3817 msg_warning_hash = 4130
3819
3821MSG_DLL msg_parse_f msg_warning_d;
3822
3824MSG_DLL msg_print_f msg_warning_e;
3825
3826MSG_DLL msg_xtra_f msg_warning_dup_xtra;
3827MSG_DLL msg_dup_f msg_warning_dup_one;
3828
3837#ifndef msg_warning_class
3838MSG_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
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
3896int 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
3930#endif
3932 msg_warning_t const *header);
3933
3934#if SU_HAVE_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
3975#endif
3977 msg_warning_t const *header);
3978
3979#if SU_HAVE_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{
4010}
4011#else
4012msg_warning_t *msg_warning_make(su_home_t *home, char const *s);
4013#endif
4014
4015
4037#if SU_HAVE_INLINE
4039#endif
4040msg_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 */
4061MSG_DLL msg_update_f msg_accept_update;
4062MSG_DLL msg_update_f msg_accept_any_update;
4063MSG_DLL msg_update_f msg_content_disposition_update;
4064
4065SOFIA_END_DECLS
4066
4067#endif
msg_accept_charset_t * msg_accept_charset_init(msg_accept_charset_t x[1])
Initialize an msg_accept_charset_t structure.
Definition msg_mime_protos.h:2119
msg_accept_charset_t * msg_accept_charset_dup(su_home_t *home, msg_accept_charset_t const *header)
Duplicate (deep copy) msg_accept_charset_t.
Definition msg_mime_protos.h:2186
msg_accept_charset_t * msg_accept_charset_copy(su_home_t *home, msg_accept_charset_t const *header)
Copy an msg_accept_charset_t header structure.
Definition msg_mime_protos.h:2231
msg_accept_charset_t * msg_accept_charset_make(su_home_t *home, char const *s)
Make a header structure msg_accept_charset_t.
Definition msg_mime_protos.h:2257
msg_accept_charset_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_parse_f msg_accept_charset_d
Parse a Accept-Charset header.
Definition msg_mime_protos.h:2071
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_print_f msg_accept_charset_e
Print a Accept-Charset header.
Definition msg_mime_protos.h:2074
msg_hclass_t msg_accept_charset_class[]
Header class for Accept-Charset header.
Definition msg_mime.c:1333
@ msg_accept_charset_hash
Hash of Accept-Charset header.
Definition msg_mime_protos.h:2067
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_parse_f msg_accept_encoding_d
Parse a Accept-Encoding header.
Definition msg_mime_protos.h:2321
msg_print_f msg_accept_encoding_e
Print a Accept-Encoding header.
Definition msg_mime_protos.h:2324
msg_accept_encoding_t * msg_accept_encoding_init(msg_accept_encoding_t x[1])
Initialize an msg_accept_encoding_t structure.
Definition msg_mime_protos.h:2369
msg_accept_encoding_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_hclass_t msg_accept_encoding_class[]
Header class for Accept-Encoding header.
Definition msg_mime.c:1384
msg_accept_encoding_t * msg_accept_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Encoding header from formatting result.
Definition msg_mime_protos.h:2544
msg_accept_encoding_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
int msg_is_accept_encoding(msg_header_t const *header)
Test if header object is an instance of msg_accept_encoding_t.
Definition msg_mime_protos.h:2391
@ msg_accept_encoding_hash
Hash of Accept-Encoding header.
Definition msg_mime_protos.h:2317
msg_print_f msg_accept_language_e
Print a Accept-Language header.
Definition msg_mime_protos.h:2574
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_hclass_t msg_accept_language_class[]
Header class for Accept-Language header.
Definition msg_mime.c:1435
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
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_parse_f msg_accept_language_d
Parse a Accept-Language header.
Definition msg_mime_protos.h:2571
msg_accept_language_t * msg_accept_language_copy(su_home_t *home, msg_accept_language_t const *header)
Copy an msg_accept_language_t header structure.
Definition msg_mime_protos.h:2731
msg_accept_language_t * msg_accept_language_make(su_home_t *home, char const *s)
Make a header structure msg_accept_language_t.
Definition msg_mime_protos.h:2757
msg_accept_language_t * msg_accept_language_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Language header from formatting result.
Definition msg_mime_protos.h:2794
@ msg_accept_language_hash
Hash of Accept-Language header.
Definition msg_mime_protos.h:2567
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
int msg_is_accept(msg_header_t const *header)
Test if header object is an instance of msg_accept_t.
Definition msg_mime_protos.h:1891
msg_accept_t * msg_accept_init(msg_accept_t x[1])
Initialize an msg_accept_t structure.
Definition msg_mime_protos.h:1869
msg_parse_f msg_accept_d
Parse a Accept header.
Definition msg_mime_protos.h:1821
msg_print_f msg_accept_e
Print a Accept header.
Definition msg_mime_protos.h:1824
msg_accept_t * msg_accept_make(su_home_t *home, char const *s)
Make a header structure msg_accept_t.
Definition msg_mime_protos.h:2007
msg_accept_t * msg_accept_format(su_home_t *home, char const *fmt,...)))
Make a Accept header from formatting result.
Definition msg_mime_protos.h:2044
msg_accept_t * 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_hclass_t msg_accept_class[]
Header class for Accept header.
Definition msg_mime.c:1070
@ msg_accept_hash
Hash of Accept header.
Definition msg_mime_protos.h:1817
msg_print_f msg_content_disposition_e
Print a Content-Disposition header.
Definition msg_mime_protos.h:324
msg_content_disposition_t * msg_content_disposition_init(msg_content_disposition_t x[1])
Initialize an msg_content_disposition_t structure.
Definition msg_mime_protos.h:369
msg_content_disposition_t * msg_content_disposition_dup(su_home_t *home, msg_content_disposition_t const *header)
Duplicate (deep copy) msg_content_disposition_t.
Definition msg_mime_protos.h:436
msg_content_disposition_t * 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_parse_f msg_content_disposition_d
Parse a Content-Disposition header.
Definition msg_mime_protos.h:321
msg_hclass_t msg_content_disposition_class[]
Header class for Content-Disposition header.
Definition msg_mime.c:1510
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
int msg_is_content_disposition(msg_header_t const *header)
Test if header object is an instance of msg_content_disposition_t.
Definition msg_mime_protos.h:391
msg_content_disposition_t * msg_content_disposition_make(su_home_t *home, char const *s)
Make a header structure msg_content_disposition_t.
Definition msg_mime_protos.h:507
@ msg_content_disposition_hash
Hash of Content-Disposition header.
Definition msg_mime_protos.h:317
msg_content_encoding_t * msg_content_encoding_init(msg_content_encoding_t x[1])
Initialize an msg_content_encoding_t structure.
Definition msg_mime_protos.h:1369
msg_content_encoding_t * msg_content_encoding_copy(su_home_t *home, msg_content_encoding_t const *header)
Copy an msg_content_encoding_t header structure.
Definition msg_mime_protos.h:1481
msg_content_encoding_t * msg_content_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_encoding_t.
Definition msg_mime_protos.h:1507
msg_content_encoding_t * msg_content_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Encoding header from formatting result.
Definition msg_mime_protos.h:1544
msg_content_encoding_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
int msg_is_content_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_encoding_t.
Definition msg_mime_protos.h:1391
msg_print_f msg_content_encoding_e
Print a Content-Encoding header.
Definition msg_mime_protos.h:1324
msg_parse_f msg_content_encoding_d
Parse a Content-Encoding header.
Definition msg_mime_protos.h:1321
msg_hclass_t msg_content_encoding_class[]
Header class for Content-Encoding header.
Definition msg_mime.c:1623
@ msg_content_encoding_hash
Hash of Content-Encoding header.
Definition msg_mime_protos.h:1317
msg_content_id_t * msg_content_id_copy(su_home_t *home, msg_content_id_t const *header)
Copy an msg_content_id_t header structure.
Definition msg_mime_protos.h:981
msg_content_id_t * msg_content_id_init(msg_content_id_t x[1])
Initialize an msg_content_id_t structure.
Definition msg_mime_protos.h:869
msg_content_id_t * msg_content_id_make(su_home_t *home, char const *s)
Make a header structure msg_content_id_t.
Definition msg_mime_protos.h:1007
msg_content_id_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_print_f msg_content_id_e
Print a Content-ID header.
Definition msg_mime_protos.h:824
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_parse_f msg_content_id_d
Parse a Content-ID header.
Definition msg_mime_protos.h:821
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_hclass_t msg_content_id_class[]
Header class for Content-ID header.
Definition msg_mime.c:1829
@ msg_content_id_hash
Hash of Content-ID header.
Definition msg_mime_protos.h:817
int msg_is_content_language(msg_header_t const *header)
Test if header object is an instance of msg_content_language_t.
Definition msg_mime_protos.h:1141
msg_content_language_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_hclass_t msg_content_language_class[]
Header class for Content-Language header.
Definition msg_mime.c:1678
msg_parse_f msg_content_language_d
Parse a Content-Language header.
Definition msg_mime_protos.h:1071
msg_content_language_t * msg_content_language_format(su_home_t *home, char const *fmt,...)))
Make a Content-Language header from formatting result.
Definition msg_mime_protos.h:1294
msg_content_language_t * msg_content_language_dup(su_home_t *home, msg_content_language_t const *header)
Duplicate (deep copy) msg_content_language_t.
Definition msg_mime_protos.h:1186
msg_content_language_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_print_f msg_content_language_e
Print a Content-Language header.
Definition msg_mime_protos.h:1074
msg_content_language_t * msg_content_language_init(msg_content_language_t x[1])
Initialize an msg_content_language_t structure.
Definition msg_mime_protos.h:1119
@ msg_content_language_hash
Hash of Content-Language header.
Definition msg_mime_protos.h:1067
msg_content_length_t * msg_content_length_make(su_home_t *home, char const *s)
Make a header structure msg_content_length_t.
Definition msg_mime_protos.h:3507
msg_content_length_t * msg_content_length_init(msg_content_length_t x[1])
Initialize an msg_content_length_t structure.
Definition msg_mime_protos.h:3369
int msg_is_content_length(msg_header_t const *header)
Test if header object is an instance of msg_content_length_t.
Definition msg_mime_protos.h:3391
msg_content_length_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_hclass_t msg_content_length_class[]
Header class for Content-Length header.
Definition msg_mime.c:1727
msg_print_f msg_content_length_e
Print a Content-Length header.
Definition msg_mime_protos.h:3324
msg_parse_f msg_content_length_d
Parse a Content-Length header.
Definition msg_mime_protos.h:3321
msg_content_length_t * msg_content_length_copy(su_home_t *home, msg_content_length_t const *header)
Copy an msg_content_length_t header structure.
Definition msg_mime_protos.h:3481
msg_content_length_t * msg_content_length_dup(su_home_t *home, msg_content_length_t const *header)
Duplicate (deep copy) msg_content_length_t.
Definition msg_mime_protos.h:3436
@ msg_content_length_hash
Hash of Content-Length header.
Definition msg_mime_protos.h:3317
msg_parse_f msg_content_location_d
Parse a Content-Location header.
Definition msg_mime_protos.h:571
msg_content_location_t * msg_content_location_format(su_home_t *home, char const *fmt,...)))
Make a Content-Location header from formatting result.
Definition msg_mime_protos.h:794
msg_content_location_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
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_hclass_t msg_content_location_class[]
Header class for Content-Location header.
Definition msg_mime.c:2012
msg_content_location_t * msg_content_location_copy(su_home_t *home, msg_content_location_t const *header)
Copy an msg_content_location_t header structure.
Definition msg_mime_protos.h:731
msg_content_location_t * msg_content_location_init(msg_content_location_t x[1])
Initialize an msg_content_location_t structure.
Definition msg_mime_protos.h:619
msg_content_location_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_print_f msg_content_location_e
Print a Content-Location header.
Definition msg_mime_protos.h:574
@ msg_content_location_hash
Hash of Content-Location header.
Definition msg_mime_protos.h:567
int msg_is_content_md5(msg_header_t const *header)
Test if header object is an instance of msg_content_md5_t.
Definition msg_mime_protos.h:3141
msg_content_md5_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_print_f msg_content_md5_e
Print a Content-MD5 header.
Definition msg_mime_protos.h:3074
msg_parse_f msg_content_md5_d
Parse a Content-MD5 header.
Definition msg_mime_protos.h:3071
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_hclass_t msg_content_md5_class[]
Header class for Content-MD5 header.
Definition msg_mime.c:1792
msg_content_md5_t * msg_content_md5_init(msg_content_md5_t x[1])
Initialize an msg_content_md5_t structure.
Definition msg_mime_protos.h:3119
msg_content_md5_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_t * msg_content_md5_make(su_home_t *home, char const *s)
Make a header structure msg_content_md5_t.
Definition msg_mime_protos.h:3257
@ msg_content_md5_hash
Hash of Content-MD5 header.
Definition msg_mime_protos.h:3067
int msg_is_content_transfer_encoding(msg_header_t const *header)
Test if header object is an instance of msg_content_transfer_encoding_t.
Definition msg_mime_protos.h:1641
msg_content_transfer_encoding_t * msg_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_parse_f msg_content_transfer_encoding_d
Parse a Content-Transfer-Encoding header.
Definition msg_mime_protos.h:1571
msg_content_transfer_encoding_t * msg_content_transfer_encoding_make(su_home_t *home, char const *s)
Make a header structure msg_content_transfer_encoding_t.
Definition msg_mime_protos.h:1757
msg_content_transfer_encoding_t * msg_content_transfer_encoding_init(msg_content_transfer_encoding_t x[1])
Initialize an msg_content_transfer_encoding_t structure.
Definition msg_mime_protos.h:1619
msg_content_transfer_encoding_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_print_f msg_content_transfer_encoding_e
Print a Content-Transfer-Encoding header.
Definition msg_mime_protos.h:1574
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_hclass_t msg_content_transfer_encoding_class[]
Header class for Content-Transfer-Encoding header.
Definition msg_mime.c:2078
@ msg_content_transfer_encoding_hash
Hash of Content-Transfer-Encoding header.
Definition msg_mime_protos.h:1567
msg_parse_f msg_content_type_d
Parse a Content-Type header.
Definition msg_mime_protos.h:71
msg_content_type_t * msg_content_type_dup(su_home_t *home, msg_content_type_t const *header)
Duplicate (deep copy) msg_content_type_t.
Definition msg_mime_protos.h:186
msg_content_type_t * msg_content_type_copy(su_home_t *home, msg_content_type_t const *header)
Copy an msg_content_type_t header structure.
Definition msg_mime_protos.h:231
msg_content_type_t * msg_content_type_init(msg_content_type_t x[1])
Initialize an msg_content_type_t structure.
Definition msg_mime_protos.h:119
msg_content_type_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_print_f msg_content_type_e
Print a Content-Type header.
Definition msg_mime_protos.h:74
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_hclass_t msg_content_type_class[]
Header class for Content-Type header.
Definition msg_mime.c:1872
int msg_is_content_type(msg_header_t const *header)
Test if header object is an instance of msg_content_type_t.
Definition msg_mime_protos.h:141
@ msg_content_type_hash
Hash of Content-Type header.
Definition msg_mime_protos.h:67
msg_mime_version_t * msg_mime_version_copy(su_home_t *home, msg_mime_version_t const *header)
Copy an msg_mime_version_t header structure.
Definition msg_mime_protos.h:2981
msg_mime_version_t * msg_mime_version_init(msg_mime_version_t x[1])
Initialize an msg_mime_version_t structure.
Definition msg_mime_protos.h:2869
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_print_f msg_mime_version_e
Print a MIME-Version header.
Definition msg_mime_protos.h:2824
msg_hclass_t msg_mime_version_class[]
Header class for MIME-Version header.
Definition msg_mime.c:1971
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_parse_f msg_mime_version_d
Parse a MIME-Version header.
Definition msg_mime_protos.h:2821
msg_mime_version_t * msg_mime_version_format(su_home_t *home, char const *fmt,...)))
Make a MIME-Version header from formatting result.
Definition msg_mime_protos.h:3044
msg_mime_version_t * msg_mime_version_make(su_home_t *home, char const *s)
Make a header structure msg_mime_version_t.
Definition msg_mime_protos.h:3007
@ msg_mime_version_hash
Hash of MIME-Version header.
Definition msg_mime_protos.h:2817
msg_parse_f msg_multipart_d
Parse a Recursive multipart header.
Definition msg_mime_protos.h:3571
msg_multipart_t * msg_multipart_init(msg_multipart_t x[1])
Initialize an msg_multipart_t structure.
Definition msg_mime_protos.h:3619
msg_multipart_t * msg_multipart_make(su_home_t *home, char const *s)
Make a header structure msg_multipart_t.
Definition msg_mime_protos.h:3757
msg_multipart_t * msg_multipart_copy(su_home_t *home, msg_multipart_t const *header)
Copy an msg_multipart_t header structure.
Definition msg_mime_protos.h:3731
msg_multipart_t * msg_multipart_dup(su_home_t *home, msg_multipart_t const *header)
Duplicate (deep copy) msg_multipart_t.
Definition msg_mime_protos.h:3686
msg_multipart_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
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_print_f msg_multipart_e
Print a Recursive multipart header.
Definition msg_mime_protos.h:3574
@ msg_multipart_hash
Hash of Recursive multipart header.
Definition msg_mime_protos.h:3567
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_hclass_t msg_warning_class[]
Header class for Warning header.
Definition msg_mime.c:2202
msg_warning_t * msg_warning_copy(su_home_t *home, msg_warning_t const *header)
Copy an msg_warning_t header structure.
Definition msg_mime_protos.h:3981
msg_warning_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_print_f msg_warning_e
Print a Warning header.
Definition msg_mime_protos.h:3824
msg_warning_t * msg_warning_format(su_home_t *home, char const *fmt,...)))
Make a Warning header from formatting result.
Definition msg_mime_protos.h:4044
msg_warning_t * msg_warning_make(su_home_t *home, char const *s)
Make a header structure msg_warning_t.
Definition msg_mime_protos.h:4007
msg_warning_t * msg_warning_init(msg_warning_t x[1])
Initialize an msg_warning_t structure.
Definition msg_mime_protos.h:3869
msg_parse_f msg_warning_d
Parse a Warning header.
Definition msg_mime_protos.h:3821
@ msg_warning_hash
Hash of Warning header.
Definition msg_mime_protos.h:3817
msg_header_t * msg_header_make(su_home_t *home, msg_hclass_t *hc, char const *s))
Make a header from a value string.
Definition msg_header_make.c:64
msg_header_t * msg_header_vformat(su_home_t *home, msg_hclass_t *hc, char const *fmt, va_list ap))
Make a MSG header with formatting provided.
Definition msg_header_make.c:105
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
Copy a list of header objects.
Definition msg_header_copy.c:148
msg_header_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
#define MSG_HEADER_INIT(h, msg_class, size)
Initialize a header structure.
Definition msg_header.h:298
Parser table and message factory object.
MIME headers and multipart messages (RFC 2045).
Message parser interface.
struct msg_hclass_s const msg_hclass_t
Header class.
Definition msg_types.h:48
MSG_HDR_T msg_header_t
Any protocol-specific header object.
Definition msg_types.h:87
Structure for Accept-Charset, Accept-Encoding and Accept-Language headers.
Definition msg_mime.h:94
Structure for Accept header.
Definition msg_mime.h:80
Structure for Content-Disposition header.
Definition msg_mime.h:106
Structure for Content-Length header.
Definition msg_mime.h:121
Structure for Content-Type header.
Definition msg_mime.h:132
Generic header.
Definition msg_types.h:151
List header.
Definition msg_types.h:161
Factory object for protocol messages.
Definition msg_mclass.h:97
Structure for a part in MIME multipart message.
Definition msg_mime.h:160
Structure for Warning header.
Definition msg_mime.h:145
SU_HOME_T su_home_t
#define su_inline

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