sip 1.12.11devel
Loading...
Searching...
No Matches
sip_protos.h
Go to the documentation of this file.
1/* -*- C -*-
2 *
3 * This file is part of the Sofia-SIP package
4 *
5 * Copyright (C) 2005 Nokia Corporation.
6 *
7 * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public License
11 * as published by the Free Software Foundation; either version 2.1 of
12 * the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
22 * 02110-1301 USA
23 *
24 */
25
26#ifndef SIP_PROTOS_H
28#define SIP_PROTOS_H
29
40#include <sofia-sip/su_config.h>
41
42#ifndef SIP_HEADER_H
44#endif
45
46#ifndef SIP_HCLASSES_H
48#endif
49
50SOFIA_BEGIN_DECLS
51
52#if SU_HAVE_INLINE
56{
57 return (sip_t *)msg_public(msg, SIP_PROTOCOL_TAG);
58}
59
80{
81 return msg_header_insert(msg, (msg_pub_t *)sip, (msg_header_t *)h);
82}
83
87{
88 return msg_header_remove(msg, (msg_pub_t *)sip, (msg_header_t *)h);
89}
90
93char const *sip_header_name(sip_header_t const *h, int compact)
94{
95 if (compact && h->sh_class->hc_short[0])
96 return h->sh_class->hc_short;
97 else
98 return h->sh_class->hc_name;
99}
100
104{
105 return h && h != SIP_NONE ? h->sh_class->hc_size + (char *)h : NULL;
106}
107#else
108sip_t *sip_object(msg_t *msg);
109int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h);
110int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h);
111char const *sip_header_name(sip_header_t const *h, int compact);
113#endif
114
121 char *s, isize_t slen);
122
124SOFIAPUBFUN issize_t sip_request_e(char b[], isize_t bsiz,
125 msg_header_t const *h, int flags);
126
131#define sip_request(sip) \
132 ((sip_request_t *)msg_header_access((msg_pub_t*)(sip), sip_request_class))
133
148#define SIP_REQUEST_INIT() SIP_HDR_INIT(request)
149
165#if SU_HAVE_INLINE
170#else
171#define sip_request_init(x) \
172 SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t))
173#endif
174
187#if SU_HAVE_INLINE
189{
190 return header && header->sh_class->hc_hash == sip_request_hash;
191}
192#else
193int sip_is_request(sip_header_t const *header);
194#endif
195
196#define sip_request_p(h) sip_is_request((h))
197
198
227#if SU_HAVE_INLINE
229#endif
231 __attribute__((__malloc__));
232
233#if SU_HAVE_INLINE
236{
237 return (sip_request_t *)
239}
240#endif
241
270#if SU_HAVE_INLINE
272#endif
274 __attribute__((__malloc__));
275
276#if SU_HAVE_INLINE
279{
280 return (sip_request_t *)
282}
283#endif
284
300#if SU_HAVE_INLINE
302#endif
303sip_request_t *sip_request_make(su_home_t *home, char const *s)
304 __attribute__((__malloc__));
305
306#if SU_HAVE_INLINE
308{
309 return (sip_request_t *)sip_header_make(home, sip_request_class, s);
310}
311#endif
312
331#if SU_HAVE_INLINE
333#endif
334sip_request_t *sip_request_format(su_home_t *home, char const *fmt, ...)
335 __attribute__((__malloc__, __format__ (printf, 2, 3)));
336
337#if SU_HAVE_INLINE
339{
340 sip_header_t *h;
341 va_list ap;
342
343 va_start(ap, fmt);
344 h = sip_header_vformat(home, sip_request_class, fmt, ap);
345 va_end(ap);
346
347 return (sip_request_t *)h;
348}
349#endif
350
359 char *s, isize_t slen);
360
362SOFIAPUBFUN issize_t sip_status_e(char b[], isize_t bsiz,
363 msg_header_t const *h, int flags);
364
369#define sip_status(sip) \
370 ((sip_status_t *)msg_header_access((msg_pub_t*)(sip), sip_status_class))
371
386#define SIP_STATUS_INIT() SIP_HDR_INIT(status)
387
403#if SU_HAVE_INLINE
408#else
409#define sip_status_init(x) \
410 SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t))
411#endif
412
425#if SU_HAVE_INLINE
427{
428 return header && header->sh_class->hc_hash == sip_status_hash;
429}
430#else
431int sip_is_status(sip_header_t const *header);
432#endif
433
434#define sip_status_p(h) sip_is_status((h))
435
436
465#if SU_HAVE_INLINE
467#endif
469 __attribute__((__malloc__));
470
471#if SU_HAVE_INLINE
474{
475 return (sip_status_t *)
477}
478#endif
479
508#if SU_HAVE_INLINE
510#endif
512 __attribute__((__malloc__));
513
514#if SU_HAVE_INLINE
517{
518 return (sip_status_t *)
520}
521#endif
522
538#if SU_HAVE_INLINE
540#endif
541sip_status_t *sip_status_make(su_home_t *home, char const *s)
542 __attribute__((__malloc__));
543
544#if SU_HAVE_INLINE
546{
547 return (sip_status_t *)sip_header_make(home, sip_status_class, s);
548}
549#endif
550
569#if SU_HAVE_INLINE
571#endif
572sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
573 __attribute__((__malloc__, __format__ (printf, 2, 3)));
574
575#if SU_HAVE_INLINE
577{
578 sip_header_t *h;
579 va_list ap;
580
581 va_start(ap, fmt);
582 h = sip_header_vformat(home, sip_status_class, fmt, ap);
583 va_end(ap);
584
585 return (sip_status_t *)h;
586}
587#endif
588
597 char *s, isize_t slen);
598
600SOFIAPUBFUN issize_t sip_via_e(char b[], isize_t bsiz,
601 msg_header_t const *h, int flags);
602
607#define sip_via(sip) \
608 ((sip_via_t *)msg_header_access((msg_pub_t*)(sip), sip_via_class))
609
624#define SIP_VIA_INIT() SIP_HDR_INIT(via)
625
641#if SU_HAVE_INLINE
646#else
647#define sip_via_init(x) \
648 SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t))
649#endif
650
663#if SU_HAVE_INLINE
665{
666 return header && header->sh_class->hc_hash == sip_via_hash;
667}
668#else
669int sip_is_via(sip_header_t const *header);
670#endif
671
672#define sip_via_p(h) sip_is_via((h))
673
674
703#if SU_HAVE_INLINE
705#endif
706sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
707 __attribute__((__malloc__));
708
709#if SU_HAVE_INLINE
712{
713 return (sip_via_t *)
714 msg_header_dup_as(home, sip_via_class, (msg_header_t const *)hdr);
715}
716#endif
717
746#if SU_HAVE_INLINE
748#endif
749sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
750 __attribute__((__malloc__));
751
752#if SU_HAVE_INLINE
755{
756 return (sip_via_t *)
757 msg_header_copy_as(home, sip_via_class, (msg_header_t const *)hdr);
758}
759#endif
760
776#if SU_HAVE_INLINE
778#endif
779sip_via_t *sip_via_make(su_home_t *home, char const *s)
780 __attribute__((__malloc__));
781
782#if SU_HAVE_INLINE
784{
785 return (sip_via_t *)sip_header_make(home, sip_via_class, s);
786}
787#endif
788
807#if SU_HAVE_INLINE
809#endif
810sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
811 __attribute__((__malloc__, __format__ (printf, 2, 3)));
812
813#if SU_HAVE_INLINE
814su_inline sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
815{
816 sip_header_t *h;
817 va_list ap;
818
819 va_start(ap, fmt);
820 h = sip_header_vformat(home, sip_via_class, fmt, ap);
821 va_end(ap);
822
823 return (sip_via_t *)h;
824}
825#endif
826
835 char *s, isize_t slen);
836
838SOFIAPUBFUN issize_t sip_route_e(char b[], isize_t bsiz,
839 msg_header_t const *h, int flags);
840
845#define sip_route(sip) \
846 ((sip_route_t *)msg_header_access((msg_pub_t*)(sip), sip_route_class))
847
862#define SIP_ROUTE_INIT() SIP_HDR_INIT(route)
863
879#if SU_HAVE_INLINE
884#else
885#define sip_route_init(x) \
886 SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t))
887#endif
888
901#if SU_HAVE_INLINE
903{
904 return header && header->sh_class->hc_hash == sip_route_hash;
905}
906#else
907int sip_is_route(sip_header_t const *header);
908#endif
909
910#define sip_route_p(h) sip_is_route((h))
911
912
941#if SU_HAVE_INLINE
943#endif
945 __attribute__((__malloc__));
946
947#if SU_HAVE_INLINE
950{
951 return (sip_route_t *)
953}
954#endif
955
984#if SU_HAVE_INLINE
986#endif
988 __attribute__((__malloc__));
989
990#if SU_HAVE_INLINE
993{
994 return (sip_route_t *)
996}
997#endif
998
1014#if SU_HAVE_INLINE
1016#endif
1017sip_route_t *sip_route_make(su_home_t *home, char const *s)
1018 __attribute__((__malloc__));
1019
1020#if SU_HAVE_INLINE
1022{
1023 return (sip_route_t *)sip_header_make(home, sip_route_class, s);
1024}
1025#endif
1026
1045#if SU_HAVE_INLINE
1047#endif
1048sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
1049 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1050
1051#if SU_HAVE_INLINE
1053{
1054 sip_header_t *h;
1055 va_list ap;
1056
1057 va_start(ap, fmt);
1058 h = sip_header_vformat(home, sip_route_class, fmt, ap);
1059 va_end(ap);
1060
1061 return (sip_route_t *)h;
1062}
1063#endif
1064
1073 char *s, isize_t slen);
1074
1076SOFIAPUBFUN issize_t sip_record_route_e(char b[], isize_t bsiz,
1077 msg_header_t const *h, int flags);
1078
1083#define sip_record_route(sip) \
1084 ((sip_record_route_t *)msg_header_access((msg_pub_t*)(sip), sip_record_route_class))
1085
1100#define SIP_RECORD_ROUTE_INIT() SIP_HDR_INIT(record_route)
1101
1117#if SU_HAVE_INLINE
1122#else
1123#define sip_record_route_init(x) \
1124 SIP_HEADER_INIT(x, sip_record_route_class, sizeof(sip_record_route_t))
1125#endif
1126
1139#if SU_HAVE_INLINE
1141{
1142 return header && header->sh_class->hc_hash == sip_record_route_hash;
1143}
1144#else
1145int sip_is_record_route(sip_header_t const *header);
1146#endif
1147
1148#define sip_record_route_p(h) sip_is_record_route((h))
1149
1150
1179#if SU_HAVE_INLINE
1181#endif
1183 __attribute__((__malloc__));
1184
1185#if SU_HAVE_INLINE
1192#endif
1193
1222#if SU_HAVE_INLINE
1224#endif
1226 __attribute__((__malloc__));
1227
1228#if SU_HAVE_INLINE
1235#endif
1236
1252#if SU_HAVE_INLINE
1254#endif
1256 __attribute__((__malloc__));
1257
1258#if SU_HAVE_INLINE
1260{
1261 return (sip_record_route_t *)sip_header_make(home, sip_record_route_class, s);
1262}
1263#endif
1264
1283#if SU_HAVE_INLINE
1285#endif
1286sip_record_route_t *sip_record_route_format(su_home_t *home, char const *fmt, ...)
1287 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1288
1289#if SU_HAVE_INLINE
1291{
1292 sip_header_t *h;
1293 va_list ap;
1294
1295 va_start(ap, fmt);
1296 h = sip_header_vformat(home, sip_record_route_class, fmt, ap);
1297 va_end(ap);
1298
1299 return (sip_record_route_t *)h;
1300}
1301#endif
1302
1311 char *s, isize_t slen);
1312
1314SOFIAPUBFUN issize_t sip_max_forwards_e(char b[], isize_t bsiz,
1315 msg_header_t const *h, int flags);
1316
1321#define sip_max_forwards(sip) \
1322 ((sip_max_forwards_t *)msg_header_access((msg_pub_t*)(sip), sip_max_forwards_class))
1323
1338#define SIP_MAX_FORWARDS_INIT() SIP_HDR_INIT(max_forwards)
1339
1355#if SU_HAVE_INLINE
1360#else
1361#define sip_max_forwards_init(x) \
1362 SIP_HEADER_INIT(x, sip_max_forwards_class, sizeof(sip_max_forwards_t))
1363#endif
1364
1377#if SU_HAVE_INLINE
1379{
1380 return header && header->sh_class->hc_hash == sip_max_forwards_hash;
1381}
1382#else
1383int sip_is_max_forwards(sip_header_t const *header);
1384#endif
1385
1386#define sip_max_forwards_p(h) sip_is_max_forwards((h))
1387
1388
1417#if SU_HAVE_INLINE
1419#endif
1421 __attribute__((__malloc__));
1422
1423#if SU_HAVE_INLINE
1430#endif
1431
1460#if SU_HAVE_INLINE
1462#endif
1464 __attribute__((__malloc__));
1465
1466#if SU_HAVE_INLINE
1473#endif
1474
1490#if SU_HAVE_INLINE
1492#endif
1494 __attribute__((__malloc__));
1495
1496#if SU_HAVE_INLINE
1498{
1499 return (sip_max_forwards_t *)sip_header_make(home, sip_max_forwards_class, s);
1500}
1501#endif
1502
1521#if SU_HAVE_INLINE
1523#endif
1524sip_max_forwards_t *sip_max_forwards_format(su_home_t *home, char const *fmt, ...)
1525 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1526
1527#if SU_HAVE_INLINE
1529{
1530 sip_header_t *h;
1531 va_list ap;
1532
1533 va_start(ap, fmt);
1534 h = sip_header_vformat(home, sip_max_forwards_class, fmt, ap);
1535 va_end(ap);
1536
1537 return (sip_max_forwards_t *)h;
1538}
1539#endif
1540
1549 char *s, isize_t slen);
1550
1552SOFIAPUBFUN issize_t sip_proxy_require_e(char b[], isize_t bsiz,
1553 msg_header_t const *h, int flags);
1554
1559#define sip_proxy_require(sip) \
1560 ((sip_proxy_require_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_require_class))
1561
1576#define SIP_PROXY_REQUIRE_INIT() SIP_HDR_INIT(proxy_require)
1577
1593#if SU_HAVE_INLINE
1598#else
1599#define sip_proxy_require_init(x) \
1600 SIP_HEADER_INIT(x, sip_proxy_require_class, sizeof(sip_proxy_require_t))
1601#endif
1602
1615#if SU_HAVE_INLINE
1617{
1618 return header && header->sh_class->hc_hash == sip_proxy_require_hash;
1619}
1620#else
1621int sip_is_proxy_require(sip_header_t const *header);
1622#endif
1623
1624#define sip_proxy_require_p(h) sip_is_proxy_require((h))
1625
1626
1655#if SU_HAVE_INLINE
1657#endif
1659 __attribute__((__malloc__));
1660
1661#if SU_HAVE_INLINE
1668#endif
1669
1698#if SU_HAVE_INLINE
1700#endif
1702 __attribute__((__malloc__));
1703
1704#if SU_HAVE_INLINE
1711#endif
1712
1728#if SU_HAVE_INLINE
1730#endif
1732 __attribute__((__malloc__));
1733
1734#if SU_HAVE_INLINE
1736{
1737 return (sip_proxy_require_t *)sip_header_make(home, sip_proxy_require_class, s);
1738}
1739#endif
1740
1759#if SU_HAVE_INLINE
1761#endif
1762sip_proxy_require_t *sip_proxy_require_format(su_home_t *home, char const *fmt, ...)
1763 __attribute__((__malloc__, __format__ (printf, 2, 3)));
1764
1765#if SU_HAVE_INLINE
1767{
1768 sip_header_t *h;
1769 va_list ap;
1770
1771 va_start(ap, fmt);
1772 h = sip_header_vformat(home, sip_proxy_require_class, fmt, ap);
1773 va_end(ap);
1774
1775 return (sip_proxy_require_t *)h;
1776}
1777#endif
1778
1787 char *s, isize_t slen);
1788
1790SOFIAPUBFUN issize_t sip_from_e(char b[], isize_t bsiz,
1791 msg_header_t const *h, int flags);
1792
1797#define sip_from(sip) \
1798 ((sip_from_t *)msg_header_access((msg_pub_t*)(sip), sip_from_class))
1799
1814#define SIP_FROM_INIT() SIP_HDR_INIT(from)
1815
1831#if SU_HAVE_INLINE
1836#else
1837#define sip_from_init(x) \
1838 SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t))
1839#endif
1840
1853#if SU_HAVE_INLINE
1855{
1856 return header && header->sh_class->hc_hash == sip_from_hash;
1857}
1858#else
1859int sip_is_from(sip_header_t const *header);
1860#endif
1861
1862#define sip_from_p(h) sip_is_from((h))
1863
1864
1893#if SU_HAVE_INLINE
1895#endif
1896sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
1897 __attribute__((__malloc__));
1898
1899#if SU_HAVE_INLINE
1902{
1903 return (sip_from_t *)
1904 msg_header_dup_as(home, sip_from_class, (msg_header_t const *)hdr);
1905}
1906#endif
1907
1936#if SU_HAVE_INLINE
1938#endif
1939sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
1940 __attribute__((__malloc__));
1941
1942#if SU_HAVE_INLINE
1945{
1946 return (sip_from_t *)
1947 msg_header_copy_as(home, sip_from_class, (msg_header_t const *)hdr);
1948}
1949#endif
1950
1966#if SU_HAVE_INLINE
1968#endif
1969sip_from_t *sip_from_make(su_home_t *home, char const *s)
1970 __attribute__((__malloc__));
1971
1972#if SU_HAVE_INLINE
1974{
1975 return (sip_from_t *)sip_header_make(home, sip_from_class, s);
1976}
1977#endif
1978
1997#if SU_HAVE_INLINE
1999#endif
2000sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
2001 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2002
2003#if SU_HAVE_INLINE
2004su_inline sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
2005{
2006 sip_header_t *h;
2007 va_list ap;
2008
2009 va_start(ap, fmt);
2010 h = sip_header_vformat(home, sip_from_class, fmt, ap);
2011 va_end(ap);
2012
2013 return (sip_from_t *)h;
2014}
2015#endif
2016
2025 char *s, isize_t slen);
2026
2028SOFIAPUBFUN issize_t sip_to_e(char b[], isize_t bsiz,
2029 msg_header_t const *h, int flags);
2030
2035#define sip_to(sip) \
2036 ((sip_to_t *)msg_header_access((msg_pub_t*)(sip), sip_to_class))
2037
2052#define SIP_TO_INIT() SIP_HDR_INIT(to)
2053
2069#if SU_HAVE_INLINE
2071{
2072 return SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t));
2073}
2074#else
2075#define sip_to_init(x) \
2076 SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t))
2077#endif
2078
2091#if SU_HAVE_INLINE
2093{
2094 return header && header->sh_class->hc_hash == sip_to_hash;
2095}
2096#else
2097int sip_is_to(sip_header_t const *header);
2098#endif
2099
2100#define sip_to_p(h) sip_is_to((h))
2101
2102
2131#if SU_HAVE_INLINE
2133#endif
2134sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
2135 __attribute__((__malloc__));
2136
2137#if SU_HAVE_INLINE
2140{
2141 return (sip_to_t *)
2142 msg_header_dup_as(home, sip_to_class, (msg_header_t const *)hdr);
2143}
2144#endif
2145
2174#if SU_HAVE_INLINE
2176#endif
2177sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
2178 __attribute__((__malloc__));
2179
2180#if SU_HAVE_INLINE
2183{
2184 return (sip_to_t *)
2185 msg_header_copy_as(home, sip_to_class, (msg_header_t const *)hdr);
2186}
2187#endif
2188
2204#if SU_HAVE_INLINE
2206#endif
2207sip_to_t *sip_to_make(su_home_t *home, char const *s)
2208 __attribute__((__malloc__));
2209
2210#if SU_HAVE_INLINE
2212{
2213 return (sip_to_t *)sip_header_make(home, sip_to_class, s);
2214}
2215#endif
2216
2235#if SU_HAVE_INLINE
2237#endif
2238sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
2239 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2240
2241#if SU_HAVE_INLINE
2242su_inline sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
2243{
2244 sip_header_t *h;
2245 va_list ap;
2246
2247 va_start(ap, fmt);
2248 h = sip_header_vformat(home, sip_to_class, fmt, ap);
2249 va_end(ap);
2250
2251 return (sip_to_t *)h;
2252}
2253#endif
2254
2263 char *s, isize_t slen);
2264
2266SOFIAPUBFUN issize_t sip_call_id_e(char b[], isize_t bsiz,
2267 msg_header_t const *h, int flags);
2268
2273#define sip_call_id(sip) \
2274 ((sip_call_id_t *)msg_header_access((msg_pub_t*)(sip), sip_call_id_class))
2275
2290#define SIP_CALL_ID_INIT() SIP_HDR_INIT(call_id)
2291
2307#if SU_HAVE_INLINE
2312#else
2313#define sip_call_id_init(x) \
2314 SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t))
2315#endif
2316
2329#if SU_HAVE_INLINE
2331{
2332 return header && header->sh_class->hc_hash == sip_call_id_hash;
2333}
2334#else
2335int sip_is_call_id(sip_header_t const *header);
2336#endif
2337
2338#define sip_call_id_p(h) sip_is_call_id((h))
2339
2340
2369#if SU_HAVE_INLINE
2371#endif
2373 __attribute__((__malloc__));
2374
2375#if SU_HAVE_INLINE
2378{
2379 return (sip_call_id_t *)
2381}
2382#endif
2383
2412#if SU_HAVE_INLINE
2414#endif
2416 __attribute__((__malloc__));
2417
2418#if SU_HAVE_INLINE
2421{
2422 return (sip_call_id_t *)
2424}
2425#endif
2426
2442#if SU_HAVE_INLINE
2444#endif
2445sip_call_id_t *sip_call_id_make(su_home_t *home, char const *s)
2446 __attribute__((__malloc__));
2447
2448#if SU_HAVE_INLINE
2450{
2451 return (sip_call_id_t *)sip_header_make(home, sip_call_id_class, s);
2452}
2453#endif
2454
2473#if SU_HAVE_INLINE
2475#endif
2476sip_call_id_t *sip_call_id_format(su_home_t *home, char const *fmt, ...)
2477 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2478
2479#if SU_HAVE_INLINE
2481{
2482 sip_header_t *h;
2483 va_list ap;
2484
2485 va_start(ap, fmt);
2486 h = sip_header_vformat(home, sip_call_id_class, fmt, ap);
2487 va_end(ap);
2488
2489 return (sip_call_id_t *)h;
2490}
2491#endif
2492
2501 char *s, isize_t slen);
2502
2504SOFIAPUBFUN issize_t sip_cseq_e(char b[], isize_t bsiz,
2505 msg_header_t const *h, int flags);
2506
2511#define sip_cseq(sip) \
2512 ((sip_cseq_t *)msg_header_access((msg_pub_t*)(sip), sip_cseq_class))
2513
2528#define SIP_CSEQ_INIT() SIP_HDR_INIT(cseq)
2529
2545#if SU_HAVE_INLINE
2550#else
2551#define sip_cseq_init(x) \
2552 SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t))
2553#endif
2554
2567#if SU_HAVE_INLINE
2569{
2570 return header && header->sh_class->hc_hash == sip_cseq_hash;
2571}
2572#else
2573int sip_is_cseq(sip_header_t const *header);
2574#endif
2575
2576#define sip_cseq_p(h) sip_is_cseq((h))
2577
2578
2607#if SU_HAVE_INLINE
2609#endif
2610sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
2611 __attribute__((__malloc__));
2612
2613#if SU_HAVE_INLINE
2616{
2617 return (sip_cseq_t *)
2618 msg_header_dup_as(home, sip_cseq_class, (msg_header_t const *)hdr);
2619}
2620#endif
2621
2650#if SU_HAVE_INLINE
2652#endif
2653sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
2654 __attribute__((__malloc__));
2655
2656#if SU_HAVE_INLINE
2659{
2660 return (sip_cseq_t *)
2661 msg_header_copy_as(home, sip_cseq_class, (msg_header_t const *)hdr);
2662}
2663#endif
2664
2680#if SU_HAVE_INLINE
2682#endif
2683sip_cseq_t *sip_cseq_make(su_home_t *home, char const *s)
2684 __attribute__((__malloc__));
2685
2686#if SU_HAVE_INLINE
2688{
2689 return (sip_cseq_t *)sip_header_make(home, sip_cseq_class, s);
2690}
2691#endif
2692
2711#if SU_HAVE_INLINE
2713#endif
2714sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
2715 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2716
2717#if SU_HAVE_INLINE
2718su_inline sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
2719{
2720 sip_header_t *h;
2721 va_list ap;
2722
2723 va_start(ap, fmt);
2724 h = sip_header_vformat(home, sip_cseq_class, fmt, ap);
2725 va_end(ap);
2726
2727 return (sip_cseq_t *)h;
2728}
2729#endif
2730
2739 char *s, isize_t slen);
2740
2742SOFIAPUBFUN issize_t sip_contact_e(char b[], isize_t bsiz,
2743 msg_header_t const *h, int flags);
2744
2749#define sip_contact(sip) \
2750 ((sip_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_contact_class))
2751
2766#define SIP_CONTACT_INIT() SIP_HDR_INIT(contact)
2767
2783#if SU_HAVE_INLINE
2788#else
2789#define sip_contact_init(x) \
2790 SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t))
2791#endif
2792
2805#if SU_HAVE_INLINE
2807{
2808 return header && header->sh_class->hc_hash == sip_contact_hash;
2809}
2810#else
2811int sip_is_contact(sip_header_t const *header);
2812#endif
2813
2814#define sip_contact_p(h) sip_is_contact((h))
2815
2816
2845#if SU_HAVE_INLINE
2847#endif
2849 __attribute__((__malloc__));
2850
2851#if SU_HAVE_INLINE
2854{
2855 return (sip_contact_t *)
2857}
2858#endif
2859
2888#if SU_HAVE_INLINE
2890#endif
2892 __attribute__((__malloc__));
2893
2894#if SU_HAVE_INLINE
2897{
2898 return (sip_contact_t *)
2900}
2901#endif
2902
2918#if SU_HAVE_INLINE
2920#endif
2921sip_contact_t *sip_contact_make(su_home_t *home, char const *s)
2922 __attribute__((__malloc__));
2923
2924#if SU_HAVE_INLINE
2926{
2927 return (sip_contact_t *)sip_header_make(home, sip_contact_class, s);
2928}
2929#endif
2930
2949#if SU_HAVE_INLINE
2951#endif
2952sip_contact_t *sip_contact_format(su_home_t *home, char const *fmt, ...)
2953 __attribute__((__malloc__, __format__ (printf, 2, 3)));
2954
2955#if SU_HAVE_INLINE
2957{
2958 sip_header_t *h;
2959 va_list ap;
2960
2961 va_start(ap, fmt);
2962 h = sip_header_vformat(home, sip_contact_class, fmt, ap);
2963 va_end(ap);
2964
2965 return (sip_contact_t *)h;
2966}
2967#endif
2968
2977 char *s, isize_t slen);
2978
2980SOFIAPUBFUN issize_t sip_rseq_e(char b[], isize_t bsiz,
2981 msg_header_t const *h, int flags);
2982
2987#define sip_rseq(sip) \
2988 ((sip_rseq_t *)msg_header_access((msg_pub_t*)(sip), sip_rseq_class))
2989
3004#define SIP_RSEQ_INIT() SIP_HDR_INIT(rseq)
3005
3021#if SU_HAVE_INLINE
3026#else
3027#define sip_rseq_init(x) \
3028 SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t))
3029#endif
3030
3043#if SU_HAVE_INLINE
3045{
3046 return header && header->sh_class->hc_hash == sip_rseq_hash;
3047}
3048#else
3049int sip_is_rseq(sip_header_t const *header);
3050#endif
3051
3052#define sip_rseq_p(h) sip_is_rseq((h))
3053
3054
3083#if SU_HAVE_INLINE
3085#endif
3086sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
3087 __attribute__((__malloc__));
3088
3089#if SU_HAVE_INLINE
3092{
3093 return (sip_rseq_t *)
3094 msg_header_dup_as(home, sip_rseq_class, (msg_header_t const *)hdr);
3095}
3096#endif
3097
3126#if SU_HAVE_INLINE
3128#endif
3129sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
3130 __attribute__((__malloc__));
3131
3132#if SU_HAVE_INLINE
3135{
3136 return (sip_rseq_t *)
3137 msg_header_copy_as(home, sip_rseq_class, (msg_header_t const *)hdr);
3138}
3139#endif
3140
3156#if SU_HAVE_INLINE
3158#endif
3159sip_rseq_t *sip_rseq_make(su_home_t *home, char const *s)
3160 __attribute__((__malloc__));
3161
3162#if SU_HAVE_INLINE
3164{
3165 return (sip_rseq_t *)sip_header_make(home, sip_rseq_class, s);
3166}
3167#endif
3168
3187#if SU_HAVE_INLINE
3189#endif
3190sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
3191 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3192
3193#if SU_HAVE_INLINE
3194su_inline sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
3195{
3196 sip_header_t *h;
3197 va_list ap;
3198
3199 va_start(ap, fmt);
3200 h = sip_header_vformat(home, sip_rseq_class, fmt, ap);
3201 va_end(ap);
3202
3203 return (sip_rseq_t *)h;
3204}
3205#endif
3206
3215 char *s, isize_t slen);
3216
3218SOFIAPUBFUN issize_t sip_rack_e(char b[], isize_t bsiz,
3219 msg_header_t const *h, int flags);
3220
3225#define sip_rack(sip) \
3226 ((sip_rack_t *)msg_header_access((msg_pub_t*)(sip), sip_rack_class))
3227
3242#define SIP_RACK_INIT() SIP_HDR_INIT(rack)
3243
3259#if SU_HAVE_INLINE
3264#else
3265#define sip_rack_init(x) \
3266 SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t))
3267#endif
3268
3281#if SU_HAVE_INLINE
3283{
3284 return header && header->sh_class->hc_hash == sip_rack_hash;
3285}
3286#else
3287int sip_is_rack(sip_header_t const *header);
3288#endif
3289
3290#define sip_rack_p(h) sip_is_rack((h))
3291
3292
3321#if SU_HAVE_INLINE
3323#endif
3324sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
3325 __attribute__((__malloc__));
3326
3327#if SU_HAVE_INLINE
3330{
3331 return (sip_rack_t *)
3332 msg_header_dup_as(home, sip_rack_class, (msg_header_t const *)hdr);
3333}
3334#endif
3335
3364#if SU_HAVE_INLINE
3366#endif
3367sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
3368 __attribute__((__malloc__));
3369
3370#if SU_HAVE_INLINE
3373{
3374 return (sip_rack_t *)
3375 msg_header_copy_as(home, sip_rack_class, (msg_header_t const *)hdr);
3376}
3377#endif
3378
3394#if SU_HAVE_INLINE
3396#endif
3397sip_rack_t *sip_rack_make(su_home_t *home, char const *s)
3398 __attribute__((__malloc__));
3399
3400#if SU_HAVE_INLINE
3402{
3403 return (sip_rack_t *)sip_header_make(home, sip_rack_class, s);
3404}
3405#endif
3406
3425#if SU_HAVE_INLINE
3427#endif
3428sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
3429 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3430
3431#if SU_HAVE_INLINE
3432su_inline sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
3433{
3434 sip_header_t *h;
3435 va_list ap;
3436
3437 va_start(ap, fmt);
3438 h = sip_header_vformat(home, sip_rack_class, fmt, ap);
3439 va_end(ap);
3440
3441 return (sip_rack_t *)h;
3442}
3443#endif
3444
3453 char *s, isize_t slen);
3454
3456SOFIAPUBFUN issize_t sip_request_disposition_e(char b[], isize_t bsiz,
3457 msg_header_t const *h, int flags);
3458
3463#define sip_request_disposition(sip) \
3464 ((sip_request_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_request_disposition_class))
3465
3480#define SIP_REQUEST_DISPOSITION_INIT() SIP_HDR_INIT(request_disposition)
3481
3497#if SU_HAVE_INLINE
3502#else
3503#define sip_request_disposition_init(x) \
3504 SIP_HEADER_INIT(x, sip_request_disposition_class, sizeof(sip_request_disposition_t))
3505#endif
3506
3519#if SU_HAVE_INLINE
3521{
3522 return header && header->sh_class->hc_hash == sip_request_disposition_hash;
3523}
3524#else
3525int sip_is_request_disposition(sip_header_t const *header);
3526#endif
3527
3528#define sip_request_disposition_p(h) sip_is_request_disposition((h))
3529
3530
3559#if SU_HAVE_INLINE
3561#endif
3563 __attribute__((__malloc__));
3564
3565#if SU_HAVE_INLINE
3572#endif
3573
3602#if SU_HAVE_INLINE
3604#endif
3606 __attribute__((__malloc__));
3607
3608#if SU_HAVE_INLINE
3615#endif
3616
3632#if SU_HAVE_INLINE
3634#endif
3636 __attribute__((__malloc__));
3637
3638#if SU_HAVE_INLINE
3643#endif
3644
3663#if SU_HAVE_INLINE
3665#endif
3667 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3668
3669#if SU_HAVE_INLINE
3671{
3672 sip_header_t *h;
3673 va_list ap;
3674
3675 va_start(ap, fmt);
3676 h = sip_header_vformat(home, sip_request_disposition_class, fmt, ap);
3677 va_end(ap);
3678
3679 return (sip_request_disposition_t *)h;
3680}
3681#endif
3682
3691 char *s, isize_t slen);
3692
3694SOFIAPUBFUN issize_t sip_accept_contact_e(char b[], isize_t bsiz,
3695 msg_header_t const *h, int flags);
3696
3701#define sip_accept_contact(sip) \
3702 ((sip_accept_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_contact_class))
3703
3718#define SIP_ACCEPT_CONTACT_INIT() SIP_HDR_INIT(accept_contact)
3719
3735#if SU_HAVE_INLINE
3740#else
3741#define sip_accept_contact_init(x) \
3742 SIP_HEADER_INIT(x, sip_accept_contact_class, sizeof(sip_accept_contact_t))
3743#endif
3744
3757#if SU_HAVE_INLINE
3759{
3760 return header && header->sh_class->hc_hash == sip_accept_contact_hash;
3761}
3762#else
3763int sip_is_accept_contact(sip_header_t const *header);
3764#endif
3765
3766#define sip_accept_contact_p(h) sip_is_accept_contact((h))
3767
3768
3797#if SU_HAVE_INLINE
3799#endif
3801 __attribute__((__malloc__));
3802
3803#if SU_HAVE_INLINE
3810#endif
3811
3840#if SU_HAVE_INLINE
3842#endif
3844 __attribute__((__malloc__));
3845
3846#if SU_HAVE_INLINE
3853#endif
3854
3870#if SU_HAVE_INLINE
3872#endif
3874 __attribute__((__malloc__));
3875
3876#if SU_HAVE_INLINE
3878{
3879 return (sip_accept_contact_t *)sip_header_make(home, sip_accept_contact_class, s);
3880}
3881#endif
3882
3901#if SU_HAVE_INLINE
3903#endif
3904sip_accept_contact_t *sip_accept_contact_format(su_home_t *home, char const *fmt, ...)
3905 __attribute__((__malloc__, __format__ (printf, 2, 3)));
3906
3907#if SU_HAVE_INLINE
3909{
3910 sip_header_t *h;
3911 va_list ap;
3912
3913 va_start(ap, fmt);
3914 h = sip_header_vformat(home, sip_accept_contact_class, fmt, ap);
3915 va_end(ap);
3916
3917 return (sip_accept_contact_t *)h;
3918}
3919#endif
3920
3929 char *s, isize_t slen);
3930
3932SOFIAPUBFUN issize_t sip_reject_contact_e(char b[], isize_t bsiz,
3933 msg_header_t const *h, int flags);
3934
3939#define sip_reject_contact(sip) \
3940 ((sip_reject_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_reject_contact_class))
3941
3956#define SIP_REJECT_CONTACT_INIT() SIP_HDR_INIT(reject_contact)
3957
3973#if SU_HAVE_INLINE
3978#else
3979#define sip_reject_contact_init(x) \
3980 SIP_HEADER_INIT(x, sip_reject_contact_class, sizeof(sip_reject_contact_t))
3981#endif
3982
3995#if SU_HAVE_INLINE
3997{
3998 return header && header->sh_class->hc_hash == sip_reject_contact_hash;
3999}
4000#else
4001int sip_is_reject_contact(sip_header_t const *header);
4002#endif
4003
4004#define sip_reject_contact_p(h) sip_is_reject_contact((h))
4005
4006
4035#if SU_HAVE_INLINE
4037#endif
4039 __attribute__((__malloc__));
4040
4041#if SU_HAVE_INLINE
4048#endif
4049
4078#if SU_HAVE_INLINE
4080#endif
4082 __attribute__((__malloc__));
4083
4084#if SU_HAVE_INLINE
4091#endif
4092
4108#if SU_HAVE_INLINE
4110#endif
4112 __attribute__((__malloc__));
4113
4114#if SU_HAVE_INLINE
4116{
4117 return (sip_reject_contact_t *)sip_header_make(home, sip_reject_contact_class, s);
4118}
4119#endif
4120
4139#if SU_HAVE_INLINE
4141#endif
4142sip_reject_contact_t *sip_reject_contact_format(su_home_t *home, char const *fmt, ...)
4143 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4144
4145#if SU_HAVE_INLINE
4147{
4148 sip_header_t *h;
4149 va_list ap;
4150
4151 va_start(ap, fmt);
4152 h = sip_header_vformat(home, sip_reject_contact_class, fmt, ap);
4153 va_end(ap);
4154
4155 return (sip_reject_contact_t *)h;
4156}
4157#endif
4158
4167 char *s, isize_t slen);
4168
4170SOFIAPUBFUN issize_t sip_expires_e(char b[], isize_t bsiz,
4171 msg_header_t const *h, int flags);
4172
4177#define sip_expires(sip) \
4178 ((sip_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_expires_class))
4179
4194#define SIP_EXPIRES_INIT() SIP_HDR_INIT(expires)
4195
4211#if SU_HAVE_INLINE
4216#else
4217#define sip_expires_init(x) \
4218 SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t))
4219#endif
4220
4233#if SU_HAVE_INLINE
4235{
4236 return header && header->sh_class->hc_hash == sip_expires_hash;
4237}
4238#else
4239int sip_is_expires(sip_header_t const *header);
4240#endif
4241
4242#define sip_expires_p(h) sip_is_expires((h))
4243
4244
4273#if SU_HAVE_INLINE
4275#endif
4277 __attribute__((__malloc__));
4278
4279#if SU_HAVE_INLINE
4282{
4283 return (sip_expires_t *)
4285}
4286#endif
4287
4316#if SU_HAVE_INLINE
4318#endif
4320 __attribute__((__malloc__));
4321
4322#if SU_HAVE_INLINE
4325{
4326 return (sip_expires_t *)
4328}
4329#endif
4330
4346#if SU_HAVE_INLINE
4348#endif
4349sip_expires_t *sip_expires_make(su_home_t *home, char const *s)
4350 __attribute__((__malloc__));
4351
4352#if SU_HAVE_INLINE
4354{
4355 return (sip_expires_t *)sip_header_make(home, sip_expires_class, s);
4356}
4357#endif
4358
4377#if SU_HAVE_INLINE
4379#endif
4380sip_expires_t *sip_expires_format(su_home_t *home, char const *fmt, ...)
4381 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4382
4383#if SU_HAVE_INLINE
4385{
4386 sip_header_t *h;
4387 va_list ap;
4388
4389 va_start(ap, fmt);
4390 h = sip_header_vformat(home, sip_expires_class, fmt, ap);
4391 va_end(ap);
4392
4393 return (sip_expires_t *)h;
4394}
4395#endif
4396
4405 char *s, isize_t slen);
4406
4408SOFIAPUBFUN issize_t sip_date_e(char b[], isize_t bsiz,
4409 msg_header_t const *h, int flags);
4410
4415#define sip_date(sip) \
4416 ((sip_date_t *)msg_header_access((msg_pub_t*)(sip), sip_date_class))
4417
4432#define SIP_DATE_INIT() SIP_HDR_INIT(date)
4433
4449#if SU_HAVE_INLINE
4454#else
4455#define sip_date_init(x) \
4456 SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t))
4457#endif
4458
4471#if SU_HAVE_INLINE
4473{
4474 return header && header->sh_class->hc_hash == sip_date_hash;
4475}
4476#else
4477int sip_is_date(sip_header_t const *header);
4478#endif
4479
4480#define sip_date_p(h) sip_is_date((h))
4481
4482
4511#if SU_HAVE_INLINE
4513#endif
4514sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
4515 __attribute__((__malloc__));
4516
4517#if SU_HAVE_INLINE
4520{
4521 return (sip_date_t *)
4522 msg_header_dup_as(home, sip_date_class, (msg_header_t const *)hdr);
4523}
4524#endif
4525
4554#if SU_HAVE_INLINE
4556#endif
4557sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
4558 __attribute__((__malloc__));
4559
4560#if SU_HAVE_INLINE
4563{
4564 return (sip_date_t *)
4565 msg_header_copy_as(home, sip_date_class, (msg_header_t const *)hdr);
4566}
4567#endif
4568
4584#if SU_HAVE_INLINE
4586#endif
4587sip_date_t *sip_date_make(su_home_t *home, char const *s)
4588 __attribute__((__malloc__));
4589
4590#if SU_HAVE_INLINE
4592{
4593 return (sip_date_t *)sip_header_make(home, sip_date_class, s);
4594}
4595#endif
4596
4615#if SU_HAVE_INLINE
4617#endif
4618sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
4619 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4620
4621#if SU_HAVE_INLINE
4622su_inline sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
4623{
4624 sip_header_t *h;
4625 va_list ap;
4626
4627 va_start(ap, fmt);
4628 h = sip_header_vformat(home, sip_date_class, fmt, ap);
4629 va_end(ap);
4630
4631 return (sip_date_t *)h;
4632}
4633#endif
4634
4643 char *s, isize_t slen);
4644
4646SOFIAPUBFUN issize_t sip_retry_after_e(char b[], isize_t bsiz,
4647 msg_header_t const *h, int flags);
4648
4653#define sip_retry_after(sip) \
4654 ((sip_retry_after_t *)msg_header_access((msg_pub_t*)(sip), sip_retry_after_class))
4655
4670#define SIP_RETRY_AFTER_INIT() SIP_HDR_INIT(retry_after)
4671
4687#if SU_HAVE_INLINE
4692#else
4693#define sip_retry_after_init(x) \
4694 SIP_HEADER_INIT(x, sip_retry_after_class, sizeof(sip_retry_after_t))
4695#endif
4696
4709#if SU_HAVE_INLINE
4711{
4712 return header && header->sh_class->hc_hash == sip_retry_after_hash;
4713}
4714#else
4715int sip_is_retry_after(sip_header_t const *header);
4716#endif
4717
4718#define sip_retry_after_p(h) sip_is_retry_after((h))
4719
4720
4749#if SU_HAVE_INLINE
4751#endif
4753 __attribute__((__malloc__));
4754
4755#if SU_HAVE_INLINE
4762#endif
4763
4792#if SU_HAVE_INLINE
4794#endif
4796 __attribute__((__malloc__));
4797
4798#if SU_HAVE_INLINE
4805#endif
4806
4822#if SU_HAVE_INLINE
4824#endif
4826 __attribute__((__malloc__));
4827
4828#if SU_HAVE_INLINE
4830{
4831 return (sip_retry_after_t *)sip_header_make(home, sip_retry_after_class, s);
4832}
4833#endif
4834
4853#if SU_HAVE_INLINE
4855#endif
4856sip_retry_after_t *sip_retry_after_format(su_home_t *home, char const *fmt, ...)
4857 __attribute__((__malloc__, __format__ (printf, 2, 3)));
4858
4859#if SU_HAVE_INLINE
4861{
4862 sip_header_t *h;
4863 va_list ap;
4864
4865 va_start(ap, fmt);
4866 h = sip_header_vformat(home, sip_retry_after_class, fmt, ap);
4867 va_end(ap);
4868
4869 return (sip_retry_after_t *)h;
4870}
4871#endif
4872
4881 char *s, isize_t slen);
4882
4884SOFIAPUBFUN issize_t sip_timestamp_e(char b[], isize_t bsiz,
4885 msg_header_t const *h, int flags);
4886
4891#define sip_timestamp(sip) \
4892 ((sip_timestamp_t *)msg_header_access((msg_pub_t*)(sip), sip_timestamp_class))
4893
4908#define SIP_TIMESTAMP_INIT() SIP_HDR_INIT(timestamp)
4909
4925#if SU_HAVE_INLINE
4930#else
4931#define sip_timestamp_init(x) \
4932 SIP_HEADER_INIT(x, sip_timestamp_class, sizeof(sip_timestamp_t))
4933#endif
4934
4947#if SU_HAVE_INLINE
4949{
4950 return header && header->sh_class->hc_hash == sip_timestamp_hash;
4951}
4952#else
4953int sip_is_timestamp(sip_header_t const *header);
4954#endif
4955
4956#define sip_timestamp_p(h) sip_is_timestamp((h))
4957
4958
4987#if SU_HAVE_INLINE
4989#endif
4991 __attribute__((__malloc__));
4992
4993#if SU_HAVE_INLINE
4996{
4997 return (sip_timestamp_t *)
4999}
5000#endif
5001
5030#if SU_HAVE_INLINE
5032#endif
5034 __attribute__((__malloc__));
5035
5036#if SU_HAVE_INLINE
5043#endif
5044
5060#if SU_HAVE_INLINE
5062#endif
5063sip_timestamp_t *sip_timestamp_make(su_home_t *home, char const *s)
5064 __attribute__((__malloc__));
5065
5066#if SU_HAVE_INLINE
5068{
5069 return (sip_timestamp_t *)sip_header_make(home, sip_timestamp_class, s);
5070}
5071#endif
5072
5091#if SU_HAVE_INLINE
5093#endif
5094sip_timestamp_t *sip_timestamp_format(su_home_t *home, char const *fmt, ...)
5095 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5096
5097#if SU_HAVE_INLINE
5099{
5100 sip_header_t *h;
5101 va_list ap;
5102
5103 va_start(ap, fmt);
5104 h = sip_header_vformat(home, sip_timestamp_class, fmt, ap);
5105 va_end(ap);
5106
5107 return (sip_timestamp_t *)h;
5108}
5109#endif
5110
5119 char *s, isize_t slen);
5120
5122SOFIAPUBFUN issize_t sip_min_expires_e(char b[], isize_t bsiz,
5123 msg_header_t const *h, int flags);
5124
5129#define sip_min_expires(sip) \
5130 ((sip_min_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_min_expires_class))
5131
5146#define SIP_MIN_EXPIRES_INIT() SIP_HDR_INIT(min_expires)
5147
5163#if SU_HAVE_INLINE
5168#else
5169#define sip_min_expires_init(x) \
5170 SIP_HEADER_INIT(x, sip_min_expires_class, sizeof(sip_min_expires_t))
5171#endif
5172
5185#if SU_HAVE_INLINE
5187{
5188 return header && header->sh_class->hc_hash == sip_min_expires_hash;
5189}
5190#else
5191int sip_is_min_expires(sip_header_t const *header);
5192#endif
5193
5194#define sip_min_expires_p(h) sip_is_min_expires((h))
5195
5196
5225#if SU_HAVE_INLINE
5227#endif
5229 __attribute__((__malloc__));
5230
5231#if SU_HAVE_INLINE
5238#endif
5239
5268#if SU_HAVE_INLINE
5270#endif
5272 __attribute__((__malloc__));
5273
5274#if SU_HAVE_INLINE
5281#endif
5282
5298#if SU_HAVE_INLINE
5300#endif
5302 __attribute__((__malloc__));
5303
5304#if SU_HAVE_INLINE
5306{
5307 return (sip_min_expires_t *)sip_header_make(home, sip_min_expires_class, s);
5308}
5309#endif
5310
5329#if SU_HAVE_INLINE
5331#endif
5332sip_min_expires_t *sip_min_expires_format(su_home_t *home, char const *fmt, ...)
5333 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5334
5335#if SU_HAVE_INLINE
5337{
5338 sip_header_t *h;
5339 va_list ap;
5340
5341 va_start(ap, fmt);
5342 h = sip_header_vformat(home, sip_min_expires_class, fmt, ap);
5343 va_end(ap);
5344
5345 return (sip_min_expires_t *)h;
5346}
5347#endif
5348
5357 char *s, isize_t slen);
5358
5360SOFIAPUBFUN issize_t sip_subject_e(char b[], isize_t bsiz,
5361 msg_header_t const *h, int flags);
5362
5367#define sip_subject(sip) \
5368 ((sip_subject_t *)msg_header_access((msg_pub_t*)(sip), sip_subject_class))
5369
5384#define SIP_SUBJECT_INIT() SIP_HDR_INIT(subject)
5385
5401#if SU_HAVE_INLINE
5406#else
5407#define sip_subject_init(x) \
5408 SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t))
5409#endif
5410
5423#if SU_HAVE_INLINE
5425{
5426 return header && header->sh_class->hc_hash == sip_subject_hash;
5427}
5428#else
5429int sip_is_subject(sip_header_t const *header);
5430#endif
5431
5432#define sip_subject_p(h) sip_is_subject((h))
5433
5434
5463#if SU_HAVE_INLINE
5465#endif
5467 __attribute__((__malloc__));
5468
5469#if SU_HAVE_INLINE
5472{
5473 return (sip_subject_t *)
5475}
5476#endif
5477
5506#if SU_HAVE_INLINE
5508#endif
5510 __attribute__((__malloc__));
5511
5512#if SU_HAVE_INLINE
5515{
5516 return (sip_subject_t *)
5518}
5519#endif
5520
5536#if SU_HAVE_INLINE
5538#endif
5539sip_subject_t *sip_subject_make(su_home_t *home, char const *s)
5540 __attribute__((__malloc__));
5541
5542#if SU_HAVE_INLINE
5544{
5545 return (sip_subject_t *)sip_header_make(home, sip_subject_class, s);
5546}
5547#endif
5548
5567#if SU_HAVE_INLINE
5569#endif
5570sip_subject_t *sip_subject_format(su_home_t *home, char const *fmt, ...)
5571 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5572
5573#if SU_HAVE_INLINE
5575{
5576 sip_header_t *h;
5577 va_list ap;
5578
5579 va_start(ap, fmt);
5580 h = sip_header_vformat(home, sip_subject_class, fmt, ap);
5581 va_end(ap);
5582
5583 return (sip_subject_t *)h;
5584}
5585#endif
5586
5595 char *s, isize_t slen);
5596
5598SOFIAPUBFUN issize_t sip_priority_e(char b[], isize_t bsiz,
5599 msg_header_t const *h, int flags);
5600
5605#define sip_priority(sip) \
5606 ((sip_priority_t *)msg_header_access((msg_pub_t*)(sip), sip_priority_class))
5607
5622#define SIP_PRIORITY_INIT() SIP_HDR_INIT(priority)
5623
5639#if SU_HAVE_INLINE
5644#else
5645#define sip_priority_init(x) \
5646 SIP_HEADER_INIT(x, sip_priority_class, sizeof(sip_priority_t))
5647#endif
5648
5661#if SU_HAVE_INLINE
5663{
5664 return header && header->sh_class->hc_hash == sip_priority_hash;
5665}
5666#else
5667int sip_is_priority(sip_header_t const *header);
5668#endif
5669
5670#define sip_priority_p(h) sip_is_priority((h))
5671
5672
5701#if SU_HAVE_INLINE
5703#endif
5705 __attribute__((__malloc__));
5706
5707#if SU_HAVE_INLINE
5710{
5711 return (sip_priority_t *)
5713}
5714#endif
5715
5744#if SU_HAVE_INLINE
5746#endif
5748 __attribute__((__malloc__));
5749
5750#if SU_HAVE_INLINE
5753{
5754 return (sip_priority_t *)
5756}
5757#endif
5758
5774#if SU_HAVE_INLINE
5776#endif
5777sip_priority_t *sip_priority_make(su_home_t *home, char const *s)
5778 __attribute__((__malloc__));
5779
5780#if SU_HAVE_INLINE
5782{
5783 return (sip_priority_t *)sip_header_make(home, sip_priority_class, s);
5784}
5785#endif
5786
5805#if SU_HAVE_INLINE
5807#endif
5808sip_priority_t *sip_priority_format(su_home_t *home, char const *fmt, ...)
5809 __attribute__((__malloc__, __format__ (printf, 2, 3)));
5810
5811#if SU_HAVE_INLINE
5813{
5814 sip_header_t *h;
5815 va_list ap;
5816
5817 va_start(ap, fmt);
5818 h = sip_header_vformat(home, sip_priority_class, fmt, ap);
5819 va_end(ap);
5820
5821 return (sip_priority_t *)h;
5822}
5823#endif
5824
5833 char *s, isize_t slen);
5834
5836SOFIAPUBFUN issize_t sip_call_info_e(char b[], isize_t bsiz,
5837 msg_header_t const *h, int flags);
5838
5843#define sip_call_info(sip) \
5844 ((sip_call_info_t *)msg_header_access((msg_pub_t*)(sip), sip_call_info_class))
5845
5860#define SIP_CALL_INFO_INIT() SIP_HDR_INIT(call_info)
5861
5877#if SU_HAVE_INLINE
5882#else
5883#define sip_call_info_init(x) \
5884 SIP_HEADER_INIT(x, sip_call_info_class, sizeof(sip_call_info_t))
5885#endif
5886
5899#if SU_HAVE_INLINE
5901{
5902 return header && header->sh_class->hc_hash == sip_call_info_hash;
5903}
5904#else
5905int sip_is_call_info(sip_header_t const *header);
5906#endif
5907
5908#define sip_call_info_p(h) sip_is_call_info((h))
5909
5910
5939#if SU_HAVE_INLINE
5941#endif
5943 __attribute__((__malloc__));
5944
5945#if SU_HAVE_INLINE
5948{
5949 return (sip_call_info_t *)
5951}
5952#endif
5953
5982#if SU_HAVE_INLINE
5984#endif
5986 __attribute__((__malloc__));
5987
5988#if SU_HAVE_INLINE
5995#endif
5996
6012#if SU_HAVE_INLINE
6014#endif
6015sip_call_info_t *sip_call_info_make(su_home_t *home, char const *s)
6016 __attribute__((__malloc__));
6017
6018#if SU_HAVE_INLINE
6020{
6021 return (sip_call_info_t *)sip_header_make(home, sip_call_info_class, s);
6022}
6023#endif
6024
6043#if SU_HAVE_INLINE
6045#endif
6046sip_call_info_t *sip_call_info_format(su_home_t *home, char const *fmt, ...)
6047 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6048
6049#if SU_HAVE_INLINE
6051{
6052 sip_header_t *h;
6053 va_list ap;
6054
6055 va_start(ap, fmt);
6056 h = sip_header_vformat(home, sip_call_info_class, fmt, ap);
6057 va_end(ap);
6058
6059 return (sip_call_info_t *)h;
6060}
6061#endif
6062
6071 char *s, isize_t slen);
6072
6074SOFIAPUBFUN issize_t sip_organization_e(char b[], isize_t bsiz,
6075 msg_header_t const *h, int flags);
6076
6081#define sip_organization(sip) \
6082 ((sip_organization_t *)msg_header_access((msg_pub_t*)(sip), sip_organization_class))
6083
6098#define SIP_ORGANIZATION_INIT() SIP_HDR_INIT(organization)
6099
6115#if SU_HAVE_INLINE
6120#else
6121#define sip_organization_init(x) \
6122 SIP_HEADER_INIT(x, sip_organization_class, sizeof(sip_organization_t))
6123#endif
6124
6137#if SU_HAVE_INLINE
6139{
6140 return header && header->sh_class->hc_hash == sip_organization_hash;
6141}
6142#else
6143int sip_is_organization(sip_header_t const *header);
6144#endif
6145
6146#define sip_organization_p(h) sip_is_organization((h))
6147
6148
6177#if SU_HAVE_INLINE
6179#endif
6181 __attribute__((__malloc__));
6182
6183#if SU_HAVE_INLINE
6190#endif
6191
6220#if SU_HAVE_INLINE
6222#endif
6224 __attribute__((__malloc__));
6225
6226#if SU_HAVE_INLINE
6233#endif
6234
6250#if SU_HAVE_INLINE
6252#endif
6254 __attribute__((__malloc__));
6255
6256#if SU_HAVE_INLINE
6258{
6259 return (sip_organization_t *)sip_header_make(home, sip_organization_class, s);
6260}
6261#endif
6262
6281#if SU_HAVE_INLINE
6283#endif
6284sip_organization_t *sip_organization_format(su_home_t *home, char const *fmt, ...)
6285 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6286
6287#if SU_HAVE_INLINE
6289{
6290 sip_header_t *h;
6291 va_list ap;
6292
6293 va_start(ap, fmt);
6294 h = sip_header_vformat(home, sip_organization_class, fmt, ap);
6295 va_end(ap);
6296
6297 return (sip_organization_t *)h;
6298}
6299#endif
6300
6309 char *s, isize_t slen);
6310
6312SOFIAPUBFUN issize_t sip_server_e(char b[], isize_t bsiz,
6313 msg_header_t const *h, int flags);
6314
6319#define sip_server(sip) \
6320 ((sip_server_t *)msg_header_access((msg_pub_t*)(sip), sip_server_class))
6321
6336#define SIP_SERVER_INIT() SIP_HDR_INIT(server)
6337
6353#if SU_HAVE_INLINE
6358#else
6359#define sip_server_init(x) \
6360 SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t))
6361#endif
6362
6375#if SU_HAVE_INLINE
6377{
6378 return header && header->sh_class->hc_hash == sip_server_hash;
6379}
6380#else
6381int sip_is_server(sip_header_t const *header);
6382#endif
6383
6384#define sip_server_p(h) sip_is_server((h))
6385
6386
6415#if SU_HAVE_INLINE
6417#endif
6419 __attribute__((__malloc__));
6420
6421#if SU_HAVE_INLINE
6424{
6425 return (sip_server_t *)
6426 msg_header_dup_as(home, sip_server_class, (msg_header_t const *)hdr);
6427}
6428#endif
6429
6458#if SU_HAVE_INLINE
6460#endif
6462 __attribute__((__malloc__));
6463
6464#if SU_HAVE_INLINE
6467{
6468 return (sip_server_t *)
6470}
6471#endif
6472
6488#if SU_HAVE_INLINE
6490#endif
6491sip_server_t *sip_server_make(su_home_t *home, char const *s)
6492 __attribute__((__malloc__));
6493
6494#if SU_HAVE_INLINE
6496{
6497 return (sip_server_t *)sip_header_make(home, sip_server_class, s);
6498}
6499#endif
6500
6519#if SU_HAVE_INLINE
6521#endif
6522sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
6523 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6524
6525#if SU_HAVE_INLINE
6527{
6528 sip_header_t *h;
6529 va_list ap;
6530
6531 va_start(ap, fmt);
6532 h = sip_header_vformat(home, sip_server_class, fmt, ap);
6533 va_end(ap);
6534
6535 return (sip_server_t *)h;
6536}
6537#endif
6538
6547 char *s, isize_t slen);
6548
6550SOFIAPUBFUN issize_t sip_user_agent_e(char b[], isize_t bsiz,
6551 msg_header_t const *h, int flags);
6552
6557#define sip_user_agent(sip) \
6558 ((sip_user_agent_t *)msg_header_access((msg_pub_t*)(sip), sip_user_agent_class))
6559
6574#define SIP_USER_AGENT_INIT() SIP_HDR_INIT(user_agent)
6575
6591#if SU_HAVE_INLINE
6596#else
6597#define sip_user_agent_init(x) \
6598 SIP_HEADER_INIT(x, sip_user_agent_class, sizeof(sip_user_agent_t))
6599#endif
6600
6613#if SU_HAVE_INLINE
6615{
6616 return header && header->sh_class->hc_hash == sip_user_agent_hash;
6617}
6618#else
6619int sip_is_user_agent(sip_header_t const *header);
6620#endif
6621
6622#define sip_user_agent_p(h) sip_is_user_agent((h))
6623
6624
6653#if SU_HAVE_INLINE
6655#endif
6657 __attribute__((__malloc__));
6658
6659#if SU_HAVE_INLINE
6666#endif
6667
6696#if SU_HAVE_INLINE
6698#endif
6700 __attribute__((__malloc__));
6701
6702#if SU_HAVE_INLINE
6709#endif
6710
6726#if SU_HAVE_INLINE
6728#endif
6729sip_user_agent_t *sip_user_agent_make(su_home_t *home, char const *s)
6730 __attribute__((__malloc__));
6731
6732#if SU_HAVE_INLINE
6734{
6735 return (sip_user_agent_t *)sip_header_make(home, sip_user_agent_class, s);
6736}
6737#endif
6738
6757#if SU_HAVE_INLINE
6759#endif
6760sip_user_agent_t *sip_user_agent_format(su_home_t *home, char const *fmt, ...)
6761 __attribute__((__malloc__, __format__ (printf, 2, 3)));
6762
6763#if SU_HAVE_INLINE
6765{
6766 sip_header_t *h;
6767 va_list ap;
6768
6769 va_start(ap, fmt);
6770 h = sip_header_vformat(home, sip_user_agent_class, fmt, ap);
6771 va_end(ap);
6772
6773 return (sip_user_agent_t *)h;
6774}
6775#endif
6776
6785 char *s, isize_t slen);
6786
6788SOFIAPUBFUN issize_t sip_in_reply_to_e(char b[], isize_t bsiz,
6789 msg_header_t const *h, int flags);
6790
6795#define sip_in_reply_to(sip) \
6796 ((sip_in_reply_to_t *)msg_header_access((msg_pub_t*)(sip), sip_in_reply_to_class))
6797
6812#define SIP_IN_REPLY_TO_INIT() SIP_HDR_INIT(in_reply_to)
6813
6829#if SU_HAVE_INLINE
6834#else
6835#define sip_in_reply_to_init(x) \
6836 SIP_HEADER_INIT(x, sip_in_reply_to_class, sizeof(sip_in_reply_to_t))
6837#endif
6838
6851#if SU_HAVE_INLINE
6853{
6854 return header && header->sh_class->hc_hash == sip_in_reply_to_hash;
6855}
6856#else
6857int sip_is_in_reply_to(sip_header_t const *header);
6858#endif
6859
6860#define sip_in_reply_to_p(h) sip_is_in_reply_to((h))
6861
6862
6891#if SU_HAVE_INLINE
6893#endif
6895 __attribute__((__malloc__));
6896
6897#if SU_HAVE_INLINE
6904#endif
6905
6934#if SU_HAVE_INLINE
6936#endif
6938 __attribute__((__malloc__));
6939
6940#if SU_HAVE_INLINE
6947#endif
6948
6964#if SU_HAVE_INLINE
6966#endif
6968 __attribute__((__malloc__));
6969
6970#if SU_HAVE_INLINE
6972{
6973 return (sip_in_reply_to_t *)sip_header_make(home, sip_in_reply_to_class, s);
6974}
6975#endif
6976
6995#if SU_HAVE_INLINE
6997#endif
6998sip_in_reply_to_t *sip_in_reply_to_format(su_home_t *home, char const *fmt, ...)
6999 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7000
7001#if SU_HAVE_INLINE
7003{
7004 sip_header_t *h;
7005 va_list ap;
7006
7007 va_start(ap, fmt);
7008 h = sip_header_vformat(home, sip_in_reply_to_class, fmt, ap);
7009 va_end(ap);
7010
7011 return (sip_in_reply_to_t *)h;
7012}
7013#endif
7014
7023 char *s, isize_t slen);
7024
7026SOFIAPUBFUN issize_t sip_accept_e(char b[], isize_t bsiz,
7027 msg_header_t const *h, int flags);
7028
7033#define sip_accept(sip) \
7034 ((sip_accept_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_class))
7035
7050#define SIP_ACCEPT_INIT() SIP_HDR_INIT(accept)
7051
7067#if SU_HAVE_INLINE
7072#else
7073#define sip_accept_init(x) \
7074 SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t))
7075#endif
7076
7089#if SU_HAVE_INLINE
7091{
7092 return header && header->sh_class->hc_hash == sip_accept_hash;
7093}
7094#else
7095int sip_is_accept(sip_header_t const *header);
7096#endif
7097
7098#define sip_accept_p(h) sip_is_accept((h))
7099
7100
7129#if SU_HAVE_INLINE
7131#endif
7133 __attribute__((__malloc__));
7134
7135#if SU_HAVE_INLINE
7138{
7139 return (sip_accept_t *)
7140 msg_header_dup_as(home, sip_accept_class, (msg_header_t const *)hdr);
7141}
7142#endif
7143
7172#if SU_HAVE_INLINE
7174#endif
7176 __attribute__((__malloc__));
7177
7178#if SU_HAVE_INLINE
7181{
7182 return (sip_accept_t *)
7184}
7185#endif
7186
7202#if SU_HAVE_INLINE
7204#endif
7205sip_accept_t *sip_accept_make(su_home_t *home, char const *s)
7206 __attribute__((__malloc__));
7207
7208#if SU_HAVE_INLINE
7210{
7211 return (sip_accept_t *)sip_header_make(home, sip_accept_class, s);
7212}
7213#endif
7214
7233#if SU_HAVE_INLINE
7235#endif
7236sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
7237 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7238
7239#if SU_HAVE_INLINE
7241{
7242 sip_header_t *h;
7243 va_list ap;
7244
7245 va_start(ap, fmt);
7246 h = sip_header_vformat(home, sip_accept_class, fmt, ap);
7247 va_end(ap);
7248
7249 return (sip_accept_t *)h;
7250}
7251#endif
7252
7261 char *s, isize_t slen);
7262
7264SOFIAPUBFUN issize_t sip_accept_encoding_e(char b[], isize_t bsiz,
7265 msg_header_t const *h, int flags);
7266
7271#define sip_accept_encoding(sip) \
7272 ((sip_accept_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_encoding_class))
7273
7288#define SIP_ACCEPT_ENCODING_INIT() SIP_HDR_INIT(accept_encoding)
7289
7305#if SU_HAVE_INLINE
7306su_inline sip_accept_encoding_t *sip_accept_encoding_init(sip_accept_encoding_t x[1])
7307{
7308 return SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t));
7309}
7310#else
7311#define sip_accept_encoding_init(x) \
7312 SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t))
7313#endif
7314
7327#if SU_HAVE_INLINE
7329{
7330 return header && header->sh_class->hc_hash == sip_accept_encoding_hash;
7331}
7332#else
7333int sip_is_accept_encoding(sip_header_t const *header);
7334#endif
7335
7336#define sip_accept_encoding_p(h) sip_is_accept_encoding((h))
7337
7338
7367#if SU_HAVE_INLINE
7369#endif
7370sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
7371 __attribute__((__malloc__));
7372
7373#if SU_HAVE_INLINE
7375sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
7376{
7377 return (sip_accept_encoding_t *)
7379}
7380#endif
7381
7410#if SU_HAVE_INLINE
7412#endif
7413sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
7414 __attribute__((__malloc__));
7415
7416#if SU_HAVE_INLINE
7418sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
7419{
7420 return (sip_accept_encoding_t *)
7422}
7423#endif
7424
7440#if SU_HAVE_INLINE
7442#endif
7443sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
7444 __attribute__((__malloc__));
7445
7446#if SU_HAVE_INLINE
7447su_inline sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
7448{
7449 return (sip_accept_encoding_t *)sip_header_make(home, sip_accept_encoding_class, s);
7450}
7451#endif
7452
7471#if SU_HAVE_INLINE
7473#endif
7474sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
7475 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7476
7477#if SU_HAVE_INLINE
7478su_inline sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
7479{
7480 sip_header_t *h;
7481 va_list ap;
7482
7483 va_start(ap, fmt);
7484 h = sip_header_vformat(home, sip_accept_encoding_class, fmt, ap);
7485 va_end(ap);
7486
7487 return (sip_accept_encoding_t *)h;
7488}
7489#endif
7490
7499 char *s, isize_t slen);
7500
7502SOFIAPUBFUN issize_t sip_accept_language_e(char b[], isize_t bsiz,
7503 msg_header_t const *h, int flags);
7504
7509#define sip_accept_language(sip) \
7510 ((sip_accept_language_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_language_class))
7511
7526#define SIP_ACCEPT_LANGUAGE_INIT() SIP_HDR_INIT(accept_language)
7527
7543#if SU_HAVE_INLINE
7544su_inline sip_accept_language_t *sip_accept_language_init(sip_accept_language_t x[1])
7545{
7546 return SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t));
7547}
7548#else
7549#define sip_accept_language_init(x) \
7550 SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t))
7551#endif
7552
7565#if SU_HAVE_INLINE
7567{
7568 return header && header->sh_class->hc_hash == sip_accept_language_hash;
7569}
7570#else
7571int sip_is_accept_language(sip_header_t const *header);
7572#endif
7573
7574#define sip_accept_language_p(h) sip_is_accept_language((h))
7575
7576
7605#if SU_HAVE_INLINE
7607#endif
7608sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
7609 __attribute__((__malloc__));
7610
7611#if SU_HAVE_INLINE
7613sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
7614{
7615 return (sip_accept_language_t *)
7617}
7618#endif
7619
7648#if SU_HAVE_INLINE
7650#endif
7651sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
7652 __attribute__((__malloc__));
7653
7654#if SU_HAVE_INLINE
7656sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
7657{
7658 return (sip_accept_language_t *)
7660}
7661#endif
7662
7678#if SU_HAVE_INLINE
7680#endif
7681sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
7682 __attribute__((__malloc__));
7683
7684#if SU_HAVE_INLINE
7685su_inline sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
7686{
7687 return (sip_accept_language_t *)sip_header_make(home, sip_accept_language_class, s);
7688}
7689#endif
7690
7709#if SU_HAVE_INLINE
7711#endif
7712sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
7713 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7714
7715#if SU_HAVE_INLINE
7716su_inline sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
7717{
7718 sip_header_t *h;
7719 va_list ap;
7720
7721 va_start(ap, fmt);
7722 h = sip_header_vformat(home, sip_accept_language_class, fmt, ap);
7723 va_end(ap);
7724
7725 return (sip_accept_language_t *)h;
7726}
7727#endif
7728
7737 char *s, isize_t slen);
7738
7740SOFIAPUBFUN issize_t sip_allow_e(char b[], isize_t bsiz,
7741 msg_header_t const *h, int flags);
7742
7747#define sip_allow(sip) \
7748 ((sip_allow_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_class))
7749
7764#define SIP_ALLOW_INIT() SIP_HDR_INIT(allow)
7765
7781#if SU_HAVE_INLINE
7786#else
7787#define sip_allow_init(x) \
7788 SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t))
7789#endif
7790
7803#if SU_HAVE_INLINE
7805{
7806 return header && header->sh_class->hc_hash == sip_allow_hash;
7807}
7808#else
7809int sip_is_allow(sip_header_t const *header);
7810#endif
7811
7812#define sip_allow_p(h) sip_is_allow((h))
7813
7814
7843#if SU_HAVE_INLINE
7845#endif
7847 __attribute__((__malloc__));
7848
7849#if SU_HAVE_INLINE
7852{
7853 return (sip_allow_t *)
7854 msg_header_dup_as(home, sip_allow_class, (msg_header_t const *)hdr);
7855}
7856#endif
7857
7886#if SU_HAVE_INLINE
7888#endif
7890 __attribute__((__malloc__));
7891
7892#if SU_HAVE_INLINE
7895{
7896 return (sip_allow_t *)
7897 msg_header_copy_as(home, sip_allow_class, (msg_header_t const *)hdr);
7898}
7899#endif
7900
7916#if SU_HAVE_INLINE
7918#endif
7919sip_allow_t *sip_allow_make(su_home_t *home, char const *s)
7920 __attribute__((__malloc__));
7921
7922#if SU_HAVE_INLINE
7924{
7925 return (sip_allow_t *)sip_header_make(home, sip_allow_class, s);
7926}
7927#endif
7928
7947#if SU_HAVE_INLINE
7949#endif
7950sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
7951 __attribute__((__malloc__, __format__ (printf, 2, 3)));
7952
7953#if SU_HAVE_INLINE
7955{
7956 sip_header_t *h;
7957 va_list ap;
7958
7959 va_start(ap, fmt);
7960 h = sip_header_vformat(home, sip_allow_class, fmt, ap);
7961 va_end(ap);
7962
7963 return (sip_allow_t *)h;
7964}
7965#endif
7966
7975 char *s, isize_t slen);
7976
7978SOFIAPUBFUN issize_t sip_require_e(char b[], isize_t bsiz,
7979 msg_header_t const *h, int flags);
7980
7985#define sip_require(sip) \
7986 ((sip_require_t *)msg_header_access((msg_pub_t*)(sip), sip_require_class))
7987
8002#define SIP_REQUIRE_INIT() SIP_HDR_INIT(require)
8003
8019#if SU_HAVE_INLINE
8024#else
8025#define sip_require_init(x) \
8026 SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t))
8027#endif
8028
8041#if SU_HAVE_INLINE
8043{
8044 return header && header->sh_class->hc_hash == sip_require_hash;
8045}
8046#else
8047int sip_is_require(sip_header_t const *header);
8048#endif
8049
8050#define sip_require_p(h) sip_is_require((h))
8051
8052
8081#if SU_HAVE_INLINE
8083#endif
8085 __attribute__((__malloc__));
8086
8087#if SU_HAVE_INLINE
8090{
8091 return (sip_require_t *)
8093}
8094#endif
8095
8124#if SU_HAVE_INLINE
8126#endif
8128 __attribute__((__malloc__));
8129
8130#if SU_HAVE_INLINE
8133{
8134 return (sip_require_t *)
8136}
8137#endif
8138
8154#if SU_HAVE_INLINE
8156#endif
8157sip_require_t *sip_require_make(su_home_t *home, char const *s)
8158 __attribute__((__malloc__));
8159
8160#if SU_HAVE_INLINE
8162{
8163 return (sip_require_t *)sip_header_make(home, sip_require_class, s);
8164}
8165#endif
8166
8185#if SU_HAVE_INLINE
8187#endif
8188sip_require_t *sip_require_format(su_home_t *home, char const *fmt, ...)
8189 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8190
8191#if SU_HAVE_INLINE
8193{
8194 sip_header_t *h;
8195 va_list ap;
8196
8197 va_start(ap, fmt);
8198 h = sip_header_vformat(home, sip_require_class, fmt, ap);
8199 va_end(ap);
8200
8201 return (sip_require_t *)h;
8202}
8203#endif
8204
8213 char *s, isize_t slen);
8214
8216SOFIAPUBFUN issize_t sip_supported_e(char b[], isize_t bsiz,
8217 msg_header_t const *h, int flags);
8218
8223#define sip_supported(sip) \
8224 ((sip_supported_t *)msg_header_access((msg_pub_t*)(sip), sip_supported_class))
8225
8240#define SIP_SUPPORTED_INIT() SIP_HDR_INIT(supported)
8241
8257#if SU_HAVE_INLINE
8262#else
8263#define sip_supported_init(x) \
8264 SIP_HEADER_INIT(x, sip_supported_class, sizeof(sip_supported_t))
8265#endif
8266
8279#if SU_HAVE_INLINE
8281{
8282 return header && header->sh_class->hc_hash == sip_supported_hash;
8283}
8284#else
8285int sip_is_supported(sip_header_t const *header);
8286#endif
8287
8288#define sip_supported_p(h) sip_is_supported((h))
8289
8290
8319#if SU_HAVE_INLINE
8321#endif
8323 __attribute__((__malloc__));
8324
8325#if SU_HAVE_INLINE
8328{
8329 return (sip_supported_t *)
8331}
8332#endif
8333
8362#if SU_HAVE_INLINE
8364#endif
8366 __attribute__((__malloc__));
8367
8368#if SU_HAVE_INLINE
8375#endif
8376
8392#if SU_HAVE_INLINE
8394#endif
8395sip_supported_t *sip_supported_make(su_home_t *home, char const *s)
8396 __attribute__((__malloc__));
8397
8398#if SU_HAVE_INLINE
8400{
8401 return (sip_supported_t *)sip_header_make(home, sip_supported_class, s);
8402}
8403#endif
8404
8423#if SU_HAVE_INLINE
8425#endif
8426sip_supported_t *sip_supported_format(su_home_t *home, char const *fmt, ...)
8427 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8428
8429#if SU_HAVE_INLINE
8431{
8432 sip_header_t *h;
8433 va_list ap;
8434
8435 va_start(ap, fmt);
8436 h = sip_header_vformat(home, sip_supported_class, fmt, ap);
8437 va_end(ap);
8438
8439 return (sip_supported_t *)h;
8440}
8441#endif
8442
8451 char *s, isize_t slen);
8452
8454SOFIAPUBFUN issize_t sip_unsupported_e(char b[], isize_t bsiz,
8455 msg_header_t const *h, int flags);
8456
8461#define sip_unsupported(sip) \
8462 ((sip_unsupported_t *)msg_header_access((msg_pub_t*)(sip), sip_unsupported_class))
8463
8478#define SIP_UNSUPPORTED_INIT() SIP_HDR_INIT(unsupported)
8479
8495#if SU_HAVE_INLINE
8500#else
8501#define sip_unsupported_init(x) \
8502 SIP_HEADER_INIT(x, sip_unsupported_class, sizeof(sip_unsupported_t))
8503#endif
8504
8517#if SU_HAVE_INLINE
8519{
8520 return header && header->sh_class->hc_hash == sip_unsupported_hash;
8521}
8522#else
8523int sip_is_unsupported(sip_header_t const *header);
8524#endif
8525
8526#define sip_unsupported_p(h) sip_is_unsupported((h))
8527
8528
8557#if SU_HAVE_INLINE
8559#endif
8561 __attribute__((__malloc__));
8562
8563#if SU_HAVE_INLINE
8570#endif
8571
8600#if SU_HAVE_INLINE
8602#endif
8604 __attribute__((__malloc__));
8605
8606#if SU_HAVE_INLINE
8613#endif
8614
8630#if SU_HAVE_INLINE
8632#endif
8634 __attribute__((__malloc__));
8635
8636#if SU_HAVE_INLINE
8638{
8639 return (sip_unsupported_t *)sip_header_make(home, sip_unsupported_class, s);
8640}
8641#endif
8642
8661#if SU_HAVE_INLINE
8663#endif
8664sip_unsupported_t *sip_unsupported_format(su_home_t *home, char const *fmt, ...)
8665 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8666
8667#if SU_HAVE_INLINE
8669{
8670 sip_header_t *h;
8671 va_list ap;
8672
8673 va_start(ap, fmt);
8674 h = sip_header_vformat(home, sip_unsupported_class, fmt, ap);
8675 va_end(ap);
8676
8677 return (sip_unsupported_t *)h;
8678}
8679#endif
8680
8689 char *s, isize_t slen);
8690
8692SOFIAPUBFUN issize_t sip_event_e(char b[], isize_t bsiz,
8693 msg_header_t const *h, int flags);
8694
8699#define sip_event(sip) \
8700 ((sip_event_t *)msg_header_access((msg_pub_t*)(sip), sip_event_class))
8701
8716#define SIP_EVENT_INIT() SIP_HDR_INIT(event)
8717
8733#if SU_HAVE_INLINE
8738#else
8739#define sip_event_init(x) \
8740 SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t))
8741#endif
8742
8755#if SU_HAVE_INLINE
8757{
8758 return header && header->sh_class->hc_hash == sip_event_hash;
8759}
8760#else
8761int sip_is_event(sip_header_t const *header);
8762#endif
8763
8764#define sip_event_p(h) sip_is_event((h))
8765
8766
8795#if SU_HAVE_INLINE
8797#endif
8799 __attribute__((__malloc__));
8800
8801#if SU_HAVE_INLINE
8804{
8805 return (sip_event_t *)
8806 msg_header_dup_as(home, sip_event_class, (msg_header_t const *)hdr);
8807}
8808#endif
8809
8838#if SU_HAVE_INLINE
8840#endif
8842 __attribute__((__malloc__));
8843
8844#if SU_HAVE_INLINE
8847{
8848 return (sip_event_t *)
8849 msg_header_copy_as(home, sip_event_class, (msg_header_t const *)hdr);
8850}
8851#endif
8852
8868#if SU_HAVE_INLINE
8870#endif
8871sip_event_t *sip_event_make(su_home_t *home, char const *s)
8872 __attribute__((__malloc__));
8873
8874#if SU_HAVE_INLINE
8876{
8877 return (sip_event_t *)sip_header_make(home, sip_event_class, s);
8878}
8879#endif
8880
8899#if SU_HAVE_INLINE
8901#endif
8902sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
8903 __attribute__((__malloc__, __format__ (printf, 2, 3)));
8904
8905#if SU_HAVE_INLINE
8907{
8908 sip_header_t *h;
8909 va_list ap;
8910
8911 va_start(ap, fmt);
8912 h = sip_header_vformat(home, sip_event_class, fmt, ap);
8913 va_end(ap);
8914
8915 return (sip_event_t *)h;
8916}
8917#endif
8918
8927 char *s, isize_t slen);
8928
8930SOFIAPUBFUN issize_t sip_allow_events_e(char b[], isize_t bsiz,
8931 msg_header_t const *h, int flags);
8932
8937#define sip_allow_events(sip) \
8938 ((sip_allow_events_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_events_class))
8939
8954#define SIP_ALLOW_EVENTS_INIT() SIP_HDR_INIT(allow_events)
8955
8971#if SU_HAVE_INLINE
8976#else
8977#define sip_allow_events_init(x) \
8978 SIP_HEADER_INIT(x, sip_allow_events_class, sizeof(sip_allow_events_t))
8979#endif
8980
8993#if SU_HAVE_INLINE
8995{
8996 return header && header->sh_class->hc_hash == sip_allow_events_hash;
8997}
8998#else
8999int sip_is_allow_events(sip_header_t const *header);
9000#endif
9001
9002#define sip_allow_events_p(h) sip_is_allow_events((h))
9003
9004
9033#if SU_HAVE_INLINE
9035#endif
9037 __attribute__((__malloc__));
9038
9039#if SU_HAVE_INLINE
9046#endif
9047
9076#if SU_HAVE_INLINE
9078#endif
9080 __attribute__((__malloc__));
9081
9082#if SU_HAVE_INLINE
9089#endif
9090
9106#if SU_HAVE_INLINE
9108#endif
9110 __attribute__((__malloc__));
9111
9112#if SU_HAVE_INLINE
9114{
9115 return (sip_allow_events_t *)sip_header_make(home, sip_allow_events_class, s);
9116}
9117#endif
9118
9137#if SU_HAVE_INLINE
9139#endif
9140sip_allow_events_t *sip_allow_events_format(su_home_t *home, char const *fmt, ...)
9141 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9142
9143#if SU_HAVE_INLINE
9145{
9146 sip_header_t *h;
9147 va_list ap;
9148
9149 va_start(ap, fmt);
9150 h = sip_header_vformat(home, sip_allow_events_class, fmt, ap);
9151 va_end(ap);
9152
9153 return (sip_allow_events_t *)h;
9154}
9155#endif
9156
9165 char *s, isize_t slen);
9166
9168SOFIAPUBFUN issize_t sip_subscription_state_e(char b[], isize_t bsiz,
9169 msg_header_t const *h, int flags);
9170
9175#define sip_subscription_state(sip) \
9176 ((sip_subscription_state_t *)msg_header_access((msg_pub_t*)(sip), sip_subscription_state_class))
9177
9192#define SIP_SUBSCRIPTION_STATE_INIT() SIP_HDR_INIT(subscription_state)
9193
9209#if SU_HAVE_INLINE
9214#else
9215#define sip_subscription_state_init(x) \
9216 SIP_HEADER_INIT(x, sip_subscription_state_class, sizeof(sip_subscription_state_t))
9217#endif
9218
9231#if SU_HAVE_INLINE
9233{
9234 return header && header->sh_class->hc_hash == sip_subscription_state_hash;
9235}
9236#else
9237int sip_is_subscription_state(sip_header_t const *header);
9238#endif
9239
9240#define sip_subscription_state_p(h) sip_is_subscription_state((h))
9241
9242
9271#if SU_HAVE_INLINE
9273#endif
9275 __attribute__((__malloc__));
9276
9277#if SU_HAVE_INLINE
9284#endif
9285
9314#if SU_HAVE_INLINE
9316#endif
9318 __attribute__((__malloc__));
9319
9320#if SU_HAVE_INLINE
9327#endif
9328
9344#if SU_HAVE_INLINE
9346#endif
9348 __attribute__((__malloc__));
9349
9350#if SU_HAVE_INLINE
9355#endif
9356
9375#if SU_HAVE_INLINE
9377#endif
9379 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9380
9381#if SU_HAVE_INLINE
9383{
9384 sip_header_t *h;
9385 va_list ap;
9386
9387 va_start(ap, fmt);
9388 h = sip_header_vformat(home, sip_subscription_state_class, fmt, ap);
9389 va_end(ap);
9390
9391 return (sip_subscription_state_t *)h;
9392}
9393#endif
9394
9403 char *s, isize_t slen);
9404
9406SOFIAPUBFUN issize_t sip_proxy_authenticate_e(char b[], isize_t bsiz,
9407 msg_header_t const *h, int flags);
9408
9413#define sip_proxy_authenticate(sip) \
9414 ((sip_proxy_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authenticate_class))
9415
9430#define SIP_PROXY_AUTHENTICATE_INIT() SIP_HDR_INIT(proxy_authenticate)
9431
9447#if SU_HAVE_INLINE
9452#else
9453#define sip_proxy_authenticate_init(x) \
9454 SIP_HEADER_INIT(x, sip_proxy_authenticate_class, sizeof(sip_proxy_authenticate_t))
9455#endif
9456
9469#if SU_HAVE_INLINE
9471{
9472 return header && header->sh_class->hc_hash == sip_proxy_authenticate_hash;
9473}
9474#else
9475int sip_is_proxy_authenticate(sip_header_t const *header);
9476#endif
9477
9478#define sip_proxy_authenticate_p(h) sip_is_proxy_authenticate((h))
9479
9480
9509#if SU_HAVE_INLINE
9511#endif
9513 __attribute__((__malloc__));
9514
9515#if SU_HAVE_INLINE
9522#endif
9523
9552#if SU_HAVE_INLINE
9554#endif
9556 __attribute__((__malloc__));
9557
9558#if SU_HAVE_INLINE
9565#endif
9566
9582#if SU_HAVE_INLINE
9584#endif
9586 __attribute__((__malloc__));
9587
9588#if SU_HAVE_INLINE
9593#endif
9594
9613#if SU_HAVE_INLINE
9615#endif
9617 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9618
9619#if SU_HAVE_INLINE
9621{
9622 sip_header_t *h;
9623 va_list ap;
9624
9625 va_start(ap, fmt);
9626 h = sip_header_vformat(home, sip_proxy_authenticate_class, fmt, ap);
9627 va_end(ap);
9628
9629 return (sip_proxy_authenticate_t *)h;
9630}
9631#endif
9632
9641 char *s, isize_t slen);
9642
9644SOFIAPUBFUN issize_t sip_proxy_authentication_info_e(char b[], isize_t bsiz,
9645 msg_header_t const *h, int flags);
9646
9651#define sip_proxy_authentication_info(sip) \
9652 ((sip_proxy_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authentication_info_class))
9653
9668#define SIP_PROXY_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(proxy_authentication_info)
9669
9685#if SU_HAVE_INLINE
9690#else
9691#define sip_proxy_authentication_info_init(x) \
9692 SIP_HEADER_INIT(x, sip_proxy_authentication_info_class, sizeof(sip_proxy_authentication_info_t))
9693#endif
9694
9707#if SU_HAVE_INLINE
9709{
9710 return header && header->sh_class->hc_hash == sip_proxy_authentication_info_hash;
9711}
9712#else
9714#endif
9715
9716#define sip_proxy_authentication_info_p(h) sip_is_proxy_authentication_info((h))
9717
9718
9747#if SU_HAVE_INLINE
9749#endif
9751 __attribute__((__malloc__));
9752
9753#if SU_HAVE_INLINE
9760#endif
9761
9790#if SU_HAVE_INLINE
9792#endif
9794 __attribute__((__malloc__));
9795
9796#if SU_HAVE_INLINE
9803#endif
9804
9820#if SU_HAVE_INLINE
9822#endif
9824 __attribute__((__malloc__));
9825
9826#if SU_HAVE_INLINE
9831#endif
9832
9851#if SU_HAVE_INLINE
9853#endif
9855 __attribute__((__malloc__, __format__ (printf, 2, 3)));
9856
9857#if SU_HAVE_INLINE
9859{
9860 sip_header_t *h;
9861 va_list ap;
9862
9863 va_start(ap, fmt);
9864 h = sip_header_vformat(home, sip_proxy_authentication_info_class, fmt, ap);
9865 va_end(ap);
9866
9868}
9869#endif
9870
9879 char *s, isize_t slen);
9880
9882SOFIAPUBFUN issize_t sip_proxy_authorization_e(char b[], isize_t bsiz,
9883 msg_header_t const *h, int flags);
9884
9889#define sip_proxy_authorization(sip) \
9890 ((sip_proxy_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authorization_class))
9891
9906#define SIP_PROXY_AUTHORIZATION_INIT() SIP_HDR_INIT(proxy_authorization)
9907
9923#if SU_HAVE_INLINE
9928#else
9929#define sip_proxy_authorization_init(x) \
9930 SIP_HEADER_INIT(x, sip_proxy_authorization_class, sizeof(sip_proxy_authorization_t))
9931#endif
9932
9945#if SU_HAVE_INLINE
9947{
9948 return header && header->sh_class->hc_hash == sip_proxy_authorization_hash;
9949}
9950#else
9951int sip_is_proxy_authorization(sip_header_t const *header);
9952#endif
9953
9954#define sip_proxy_authorization_p(h) sip_is_proxy_authorization((h))
9955
9956
9985#if SU_HAVE_INLINE
9987#endif
9989 __attribute__((__malloc__));
9990
9991#if SU_HAVE_INLINE
9998#endif
9999
10028#if SU_HAVE_INLINE
10030#endif
10032 __attribute__((__malloc__));
10033
10034#if SU_HAVE_INLINE
10041#endif
10042
10058#if SU_HAVE_INLINE
10060#endif
10062 __attribute__((__malloc__));
10063
10064#if SU_HAVE_INLINE
10066{
10067 return (sip_proxy_authorization_t *)sip_header_make(home, sip_proxy_authorization_class, s);
10068}
10069#endif
10070
10089#if SU_HAVE_INLINE
10091#endif
10093 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10094
10095#if SU_HAVE_INLINE
10097{
10098 sip_header_t *h;
10099 va_list ap;
10100
10101 va_start(ap, fmt);
10102 h = sip_header_vformat(home, sip_proxy_authorization_class, fmt, ap);
10103 va_end(ap);
10104
10105 return (sip_proxy_authorization_t *)h;
10106}
10107#endif
10108
10117 char *s, isize_t slen);
10118
10120SOFIAPUBFUN issize_t sip_authorization_e(char b[], isize_t bsiz,
10121 msg_header_t const *h, int flags);
10122
10127#define sip_authorization(sip) \
10128 ((sip_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_authorization_class))
10129
10144#define SIP_AUTHORIZATION_INIT() SIP_HDR_INIT(authorization)
10145
10161#if SU_HAVE_INLINE
10166#else
10167#define sip_authorization_init(x) \
10168 SIP_HEADER_INIT(x, sip_authorization_class, sizeof(sip_authorization_t))
10169#endif
10170
10183#if SU_HAVE_INLINE
10185{
10186 return header && header->sh_class->hc_hash == sip_authorization_hash;
10187}
10188#else
10189int sip_is_authorization(sip_header_t const *header);
10190#endif
10191
10192#define sip_authorization_p(h) sip_is_authorization((h))
10193
10194
10223#if SU_HAVE_INLINE
10225#endif
10227 __attribute__((__malloc__));
10228
10229#if SU_HAVE_INLINE
10236#endif
10237
10266#if SU_HAVE_INLINE
10268#endif
10270 __attribute__((__malloc__));
10271
10272#if SU_HAVE_INLINE
10279#endif
10280
10296#if SU_HAVE_INLINE
10298#endif
10300 __attribute__((__malloc__));
10301
10302#if SU_HAVE_INLINE
10304{
10305 return (sip_authorization_t *)sip_header_make(home, sip_authorization_class, s);
10306}
10307#endif
10308
10327#if SU_HAVE_INLINE
10329#endif
10330sip_authorization_t *sip_authorization_format(su_home_t *home, char const *fmt, ...)
10331 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10332
10333#if SU_HAVE_INLINE
10335{
10336 sip_header_t *h;
10337 va_list ap;
10338
10339 va_start(ap, fmt);
10340 h = sip_header_vformat(home, sip_authorization_class, fmt, ap);
10341 va_end(ap);
10342
10343 return (sip_authorization_t *)h;
10344}
10345#endif
10346
10355 char *s, isize_t slen);
10356
10358SOFIAPUBFUN issize_t sip_www_authenticate_e(char b[], isize_t bsiz,
10359 msg_header_t const *h, int flags);
10360
10365#define sip_www_authenticate(sip) \
10366 ((sip_www_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_www_authenticate_class))
10367
10382#define SIP_WWW_AUTHENTICATE_INIT() SIP_HDR_INIT(www_authenticate)
10383
10399#if SU_HAVE_INLINE
10404#else
10405#define sip_www_authenticate_init(x) \
10406 SIP_HEADER_INIT(x, sip_www_authenticate_class, sizeof(sip_www_authenticate_t))
10407#endif
10408
10421#if SU_HAVE_INLINE
10423{
10424 return header && header->sh_class->hc_hash == sip_www_authenticate_hash;
10425}
10426#else
10427int sip_is_www_authenticate(sip_header_t const *header);
10428#endif
10429
10430#define sip_www_authenticate_p(h) sip_is_www_authenticate((h))
10431
10432
10461#if SU_HAVE_INLINE
10463#endif
10465 __attribute__((__malloc__));
10466
10467#if SU_HAVE_INLINE
10474#endif
10475
10504#if SU_HAVE_INLINE
10506#endif
10508 __attribute__((__malloc__));
10509
10510#if SU_HAVE_INLINE
10517#endif
10518
10534#if SU_HAVE_INLINE
10536#endif
10538 __attribute__((__malloc__));
10539
10540#if SU_HAVE_INLINE
10542{
10543 return (sip_www_authenticate_t *)sip_header_make(home, sip_www_authenticate_class, s);
10544}
10545#endif
10546
10565#if SU_HAVE_INLINE
10567#endif
10569 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10570
10571#if SU_HAVE_INLINE
10573{
10574 sip_header_t *h;
10575 va_list ap;
10576
10577 va_start(ap, fmt);
10578 h = sip_header_vformat(home, sip_www_authenticate_class, fmt, ap);
10579 va_end(ap);
10580
10581 return (sip_www_authenticate_t *)h;
10582}
10583#endif
10584
10593 char *s, isize_t slen);
10594
10596SOFIAPUBFUN issize_t sip_authentication_info_e(char b[], isize_t bsiz,
10597 msg_header_t const *h, int flags);
10598
10603#define sip_authentication_info(sip) \
10604 ((sip_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_authentication_info_class))
10605
10620#define SIP_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(authentication_info)
10621
10637#if SU_HAVE_INLINE
10642#else
10643#define sip_authentication_info_init(x) \
10644 SIP_HEADER_INIT(x, sip_authentication_info_class, sizeof(sip_authentication_info_t))
10645#endif
10646
10659#if SU_HAVE_INLINE
10661{
10662 return header && header->sh_class->hc_hash == sip_authentication_info_hash;
10663}
10664#else
10665int sip_is_authentication_info(sip_header_t const *header);
10666#endif
10667
10668#define sip_authentication_info_p(h) sip_is_authentication_info((h))
10669
10670
10699#if SU_HAVE_INLINE
10701#endif
10703 __attribute__((__malloc__));
10704
10705#if SU_HAVE_INLINE
10712#endif
10713
10742#if SU_HAVE_INLINE
10744#endif
10746 __attribute__((__malloc__));
10747
10748#if SU_HAVE_INLINE
10755#endif
10756
10772#if SU_HAVE_INLINE
10774#endif
10776 __attribute__((__malloc__));
10777
10778#if SU_HAVE_INLINE
10780{
10781 return (sip_authentication_info_t *)sip_header_make(home, sip_authentication_info_class, s);
10782}
10783#endif
10784
10803#if SU_HAVE_INLINE
10805#endif
10807 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10808
10809#if SU_HAVE_INLINE
10811{
10812 sip_header_t *h;
10813 va_list ap;
10814
10815 va_start(ap, fmt);
10816 h = sip_header_vformat(home, sip_authentication_info_class, fmt, ap);
10817 va_end(ap);
10818
10819 return (sip_authentication_info_t *)h;
10820}
10821#endif
10822
10831 char *s, isize_t slen);
10832
10834SOFIAPUBFUN issize_t sip_error_info_e(char b[], isize_t bsiz,
10835 msg_header_t const *h, int flags);
10836
10841#define sip_error_info(sip) \
10842 ((sip_error_info_t *)msg_header_access((msg_pub_t*)(sip), sip_error_info_class))
10843
10858#define SIP_ERROR_INFO_INIT() SIP_HDR_INIT(error_info)
10859
10875#if SU_HAVE_INLINE
10880#else
10881#define sip_error_info_init(x) \
10882 SIP_HEADER_INIT(x, sip_error_info_class, sizeof(sip_error_info_t))
10883#endif
10884
10897#if SU_HAVE_INLINE
10899{
10900 return header && header->sh_class->hc_hash == sip_error_info_hash;
10901}
10902#else
10903int sip_is_error_info(sip_header_t const *header);
10904#endif
10905
10906#define sip_error_info_p(h) sip_is_error_info((h))
10907
10908
10937#if SU_HAVE_INLINE
10939#endif
10941 __attribute__((__malloc__));
10942
10943#if SU_HAVE_INLINE
10946{
10947 return (sip_error_info_t *)
10949}
10950#endif
10951
10980#if SU_HAVE_INLINE
10982#endif
10984 __attribute__((__malloc__));
10985
10986#if SU_HAVE_INLINE
10989{
10990 return (sip_error_info_t *)
10992}
10993#endif
10994
11010#if SU_HAVE_INLINE
11012#endif
11013sip_error_info_t *sip_error_info_make(su_home_t *home, char const *s)
11014 __attribute__((__malloc__));
11015
11016#if SU_HAVE_INLINE
11018{
11019 return (sip_error_info_t *)sip_header_make(home, sip_error_info_class, s);
11020}
11021#endif
11022
11041#if SU_HAVE_INLINE
11043#endif
11044sip_error_info_t *sip_error_info_format(su_home_t *home, char const *fmt, ...)
11045 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11046
11047#if SU_HAVE_INLINE
11049{
11050 sip_header_t *h;
11051 va_list ap;
11052
11053 va_start(ap, fmt);
11054 h = sip_header_vformat(home, sip_error_info_class, fmt, ap);
11055 va_end(ap);
11056
11057 return (sip_error_info_t *)h;
11058}
11059#endif
11060
11069 char *s, isize_t slen);
11070
11072SOFIAPUBFUN issize_t sip_warning_e(char b[], isize_t bsiz,
11073 msg_header_t const *h, int flags);
11074
11079#define sip_warning(sip) \
11080 ((sip_warning_t *)msg_header_access((msg_pub_t*)(sip), sip_warning_class))
11081
11096#define SIP_WARNING_INIT() SIP_HDR_INIT(warning)
11097
11113#if SU_HAVE_INLINE
11114su_inline sip_warning_t *sip_warning_init(sip_warning_t x[1])
11115{
11116 return SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t));
11117}
11118#else
11119#define sip_warning_init(x) \
11120 SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t))
11121#endif
11122
11135#if SU_HAVE_INLINE
11137{
11138 return header && header->sh_class->hc_hash == sip_warning_hash;
11139}
11140#else
11141int sip_is_warning(sip_header_t const *header);
11142#endif
11143
11144#define sip_warning_p(h) sip_is_warning((h))
11145
11146
11175#if SU_HAVE_INLINE
11177#endif
11178sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
11179 __attribute__((__malloc__));
11180
11181#if SU_HAVE_INLINE
11183sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
11184{
11185 return (sip_warning_t *)
11187}
11188#endif
11189
11218#if SU_HAVE_INLINE
11220#endif
11221sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
11222 __attribute__((__malloc__));
11223
11224#if SU_HAVE_INLINE
11226sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
11227{
11228 return (sip_warning_t *)
11230}
11231#endif
11232
11248#if SU_HAVE_INLINE
11250#endif
11251sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
11252 __attribute__((__malloc__));
11253
11254#if SU_HAVE_INLINE
11255su_inline sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
11256{
11257 return (sip_warning_t *)sip_header_make(home, sip_warning_class, s);
11258}
11259#endif
11260
11279#if SU_HAVE_INLINE
11281#endif
11282sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
11283 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11284
11285#if SU_HAVE_INLINE
11286su_inline sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
11287{
11288 sip_header_t *h;
11289 va_list ap;
11290
11291 va_start(ap, fmt);
11292 h = sip_header_vformat(home, sip_warning_class, fmt, ap);
11293 va_end(ap);
11294
11295 return (sip_warning_t *)h;
11296}
11297#endif
11298
11307 char *s, isize_t slen);
11308
11310SOFIAPUBFUN issize_t sip_refer_to_e(char b[], isize_t bsiz,
11311 msg_header_t const *h, int flags);
11312
11317#define sip_refer_to(sip) \
11318 ((sip_refer_to_t *)msg_header_access((msg_pub_t*)(sip), sip_refer_to_class))
11319
11334#define SIP_REFER_TO_INIT() SIP_HDR_INIT(refer_to)
11335
11351#if SU_HAVE_INLINE
11356#else
11357#define sip_refer_to_init(x) \
11358 SIP_HEADER_INIT(x, sip_refer_to_class, sizeof(sip_refer_to_t))
11359#endif
11360
11373#if SU_HAVE_INLINE
11375{
11376 return header && header->sh_class->hc_hash == sip_refer_to_hash;
11377}
11378#else
11379int sip_is_refer_to(sip_header_t const *header);
11380#endif
11381
11382#define sip_refer_to_p(h) sip_is_refer_to((h))
11383
11384
11413#if SU_HAVE_INLINE
11415#endif
11417 __attribute__((__malloc__));
11418
11419#if SU_HAVE_INLINE
11422{
11423 return (sip_refer_to_t *)
11425}
11426#endif
11427
11456#if SU_HAVE_INLINE
11458#endif
11460 __attribute__((__malloc__));
11461
11462#if SU_HAVE_INLINE
11465{
11466 return (sip_refer_to_t *)
11468}
11469#endif
11470
11486#if SU_HAVE_INLINE
11488#endif
11489sip_refer_to_t *sip_refer_to_make(su_home_t *home, char const *s)
11490 __attribute__((__malloc__));
11491
11492#if SU_HAVE_INLINE
11494{
11495 return (sip_refer_to_t *)sip_header_make(home, sip_refer_to_class, s);
11496}
11497#endif
11498
11517#if SU_HAVE_INLINE
11519#endif
11520sip_refer_to_t *sip_refer_to_format(su_home_t *home, char const *fmt, ...)
11521 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11522
11523#if SU_HAVE_INLINE
11525{
11526 sip_header_t *h;
11527 va_list ap;
11528
11529 va_start(ap, fmt);
11530 h = sip_header_vformat(home, sip_refer_to_class, fmt, ap);
11531 va_end(ap);
11532
11533 return (sip_refer_to_t *)h;
11534}
11535#endif
11536
11545 char *s, isize_t slen);
11546
11548SOFIAPUBFUN issize_t sip_referred_by_e(char b[], isize_t bsiz,
11549 msg_header_t const *h, int flags);
11550
11555#define sip_referred_by(sip) \
11556 ((sip_referred_by_t *)msg_header_access((msg_pub_t*)(sip), sip_referred_by_class))
11557
11572#define SIP_REFERRED_BY_INIT() SIP_HDR_INIT(referred_by)
11573
11589#if SU_HAVE_INLINE
11594#else
11595#define sip_referred_by_init(x) \
11596 SIP_HEADER_INIT(x, sip_referred_by_class, sizeof(sip_referred_by_t))
11597#endif
11598
11611#if SU_HAVE_INLINE
11613{
11614 return header && header->sh_class->hc_hash == sip_referred_by_hash;
11615}
11616#else
11617int sip_is_referred_by(sip_header_t const *header);
11618#endif
11619
11620#define sip_referred_by_p(h) sip_is_referred_by((h))
11621
11622
11651#if SU_HAVE_INLINE
11653#endif
11655 __attribute__((__malloc__));
11656
11657#if SU_HAVE_INLINE
11664#endif
11665
11694#if SU_HAVE_INLINE
11696#endif
11698 __attribute__((__malloc__));
11699
11700#if SU_HAVE_INLINE
11707#endif
11708
11724#if SU_HAVE_INLINE
11726#endif
11728 __attribute__((__malloc__));
11729
11730#if SU_HAVE_INLINE
11732{
11733 return (sip_referred_by_t *)sip_header_make(home, sip_referred_by_class, s);
11734}
11735#endif
11736
11755#if SU_HAVE_INLINE
11757#endif
11758sip_referred_by_t *sip_referred_by_format(su_home_t *home, char const *fmt, ...)
11759 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11760
11761#if SU_HAVE_INLINE
11763{
11764 sip_header_t *h;
11765 va_list ap;
11766
11767 va_start(ap, fmt);
11768 h = sip_header_vformat(home, sip_referred_by_class, fmt, ap);
11769 va_end(ap);
11770
11771 return (sip_referred_by_t *)h;
11772}
11773#endif
11774
11783 char *s, isize_t slen);
11784
11786SOFIAPUBFUN issize_t sip_replaces_e(char b[], isize_t bsiz,
11787 msg_header_t const *h, int flags);
11788
11793#define sip_replaces(sip) \
11794 ((sip_replaces_t *)msg_header_access((msg_pub_t*)(sip), sip_replaces_class))
11795
11810#define SIP_REPLACES_INIT() SIP_HDR_INIT(replaces)
11811
11827#if SU_HAVE_INLINE
11832#else
11833#define sip_replaces_init(x) \
11834 SIP_HEADER_INIT(x, sip_replaces_class, sizeof(sip_replaces_t))
11835#endif
11836
11849#if SU_HAVE_INLINE
11851{
11852 return header && header->sh_class->hc_hash == sip_replaces_hash;
11853}
11854#else
11855int sip_is_replaces(sip_header_t const *header);
11856#endif
11857
11858#define sip_replaces_p(h) sip_is_replaces((h))
11859
11860
11889#if SU_HAVE_INLINE
11891#endif
11893 __attribute__((__malloc__));
11894
11895#if SU_HAVE_INLINE
11898{
11899 return (sip_replaces_t *)
11901}
11902#endif
11903
11932#if SU_HAVE_INLINE
11934#endif
11936 __attribute__((__malloc__));
11937
11938#if SU_HAVE_INLINE
11941{
11942 return (sip_replaces_t *)
11944}
11945#endif
11946
11962#if SU_HAVE_INLINE
11964#endif
11965sip_replaces_t *sip_replaces_make(su_home_t *home, char const *s)
11966 __attribute__((__malloc__));
11967
11968#if SU_HAVE_INLINE
11970{
11971 return (sip_replaces_t *)sip_header_make(home, sip_replaces_class, s);
11972}
11973#endif
11974
11993#if SU_HAVE_INLINE
11995#endif
11996sip_replaces_t *sip_replaces_format(su_home_t *home, char const *fmt, ...)
11997 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11998
11999#if SU_HAVE_INLINE
12001{
12002 sip_header_t *h;
12003 va_list ap;
12004
12005 va_start(ap, fmt);
12006 h = sip_header_vformat(home, sip_replaces_class, fmt, ap);
12007 va_end(ap);
12008
12009 return (sip_replaces_t *)h;
12010}
12011#endif
12012
12021 char *s, isize_t slen);
12022
12024SOFIAPUBFUN issize_t sip_session_expires_e(char b[], isize_t bsiz,
12025 msg_header_t const *h, int flags);
12026
12031#define sip_session_expires(sip) \
12032 ((sip_session_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_session_expires_class))
12033
12048#define SIP_SESSION_EXPIRES_INIT() SIP_HDR_INIT(session_expires)
12049
12065#if SU_HAVE_INLINE
12070#else
12071#define sip_session_expires_init(x) \
12072 SIP_HEADER_INIT(x, sip_session_expires_class, sizeof(sip_session_expires_t))
12073#endif
12074
12087#if SU_HAVE_INLINE
12089{
12090 return header && header->sh_class->hc_hash == sip_session_expires_hash;
12091}
12092#else
12093int sip_is_session_expires(sip_header_t const *header);
12094#endif
12095
12096#define sip_session_expires_p(h) sip_is_session_expires((h))
12097
12098
12127#if SU_HAVE_INLINE
12129#endif
12131 __attribute__((__malloc__));
12132
12133#if SU_HAVE_INLINE
12140#endif
12141
12170#if SU_HAVE_INLINE
12172#endif
12174 __attribute__((__malloc__));
12175
12176#if SU_HAVE_INLINE
12183#endif
12184
12200#if SU_HAVE_INLINE
12202#endif
12204 __attribute__((__malloc__));
12205
12206#if SU_HAVE_INLINE
12208{
12209 return (sip_session_expires_t *)sip_header_make(home, sip_session_expires_class, s);
12210}
12211#endif
12212
12231#if SU_HAVE_INLINE
12233#endif
12235 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12236
12237#if SU_HAVE_INLINE
12239{
12240 sip_header_t *h;
12241 va_list ap;
12242
12243 va_start(ap, fmt);
12244 h = sip_header_vformat(home, sip_session_expires_class, fmt, ap);
12245 va_end(ap);
12246
12247 return (sip_session_expires_t *)h;
12248}
12249#endif
12250
12259 char *s, isize_t slen);
12260
12262SOFIAPUBFUN issize_t sip_min_se_e(char b[], isize_t bsiz,
12263 msg_header_t const *h, int flags);
12264
12269#define sip_min_se(sip) \
12270 ((sip_min_se_t *)msg_header_access((msg_pub_t*)(sip), sip_min_se_class))
12271
12286#define SIP_MIN_SE_INIT() SIP_HDR_INIT(min_se)
12287
12303#if SU_HAVE_INLINE
12308#else
12309#define sip_min_se_init(x) \
12310 SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t))
12311#endif
12312
12325#if SU_HAVE_INLINE
12327{
12328 return header && header->sh_class->hc_hash == sip_min_se_hash;
12329}
12330#else
12331int sip_is_min_se(sip_header_t const *header);
12332#endif
12333
12334#define sip_min_se_p(h) sip_is_min_se((h))
12335
12336
12365#if SU_HAVE_INLINE
12367#endif
12369 __attribute__((__malloc__));
12370
12371#if SU_HAVE_INLINE
12374{
12375 return (sip_min_se_t *)
12376 msg_header_dup_as(home, sip_min_se_class, (msg_header_t const *)hdr);
12377}
12378#endif
12379
12408#if SU_HAVE_INLINE
12410#endif
12412 __attribute__((__malloc__));
12413
12414#if SU_HAVE_INLINE
12417{
12418 return (sip_min_se_t *)
12420}
12421#endif
12422
12438#if SU_HAVE_INLINE
12440#endif
12441sip_min_se_t *sip_min_se_make(su_home_t *home, char const *s)
12442 __attribute__((__malloc__));
12443
12444#if SU_HAVE_INLINE
12446{
12447 return (sip_min_se_t *)sip_header_make(home, sip_min_se_class, s);
12448}
12449#endif
12450
12469#if SU_HAVE_INLINE
12471#endif
12472sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
12473 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12474
12475#if SU_HAVE_INLINE
12477{
12478 sip_header_t *h;
12479 va_list ap;
12480
12481 va_start(ap, fmt);
12482 h = sip_header_vformat(home, sip_min_se_class, fmt, ap);
12483 va_end(ap);
12484
12485 return (sip_min_se_t *)h;
12486}
12487#endif
12488
12497 char *s, isize_t slen);
12498
12500SOFIAPUBFUN issize_t sip_path_e(char b[], isize_t bsiz,
12501 msg_header_t const *h, int flags);
12502
12507#define sip_path(sip) \
12508 ((sip_path_t *)msg_header_access((msg_pub_t*)(sip), sip_path_class))
12509
12524#define SIP_PATH_INIT() SIP_HDR_INIT(path)
12525
12541#if SU_HAVE_INLINE
12546#else
12547#define sip_path_init(x) \
12548 SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t))
12549#endif
12550
12563#if SU_HAVE_INLINE
12565{
12566 return header && header->sh_class->hc_hash == sip_path_hash;
12567}
12568#else
12569int sip_is_path(sip_header_t const *header);
12570#endif
12571
12572#define sip_path_p(h) sip_is_path((h))
12573
12574
12603#if SU_HAVE_INLINE
12605#endif
12606sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
12607 __attribute__((__malloc__));
12608
12609#if SU_HAVE_INLINE
12612{
12613 return (sip_path_t *)
12614 msg_header_dup_as(home, sip_path_class, (msg_header_t const *)hdr);
12615}
12616#endif
12617
12646#if SU_HAVE_INLINE
12648#endif
12649sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
12650 __attribute__((__malloc__));
12651
12652#if SU_HAVE_INLINE
12655{
12656 return (sip_path_t *)
12657 msg_header_copy_as(home, sip_path_class, (msg_header_t const *)hdr);
12658}
12659#endif
12660
12676#if SU_HAVE_INLINE
12678#endif
12679sip_path_t *sip_path_make(su_home_t *home, char const *s)
12680 __attribute__((__malloc__));
12681
12682#if SU_HAVE_INLINE
12684{
12685 return (sip_path_t *)sip_header_make(home, sip_path_class, s);
12686}
12687#endif
12688
12707#if SU_HAVE_INLINE
12709#endif
12710sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
12711 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12712
12713#if SU_HAVE_INLINE
12714su_inline sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
12715{
12716 sip_header_t *h;
12717 va_list ap;
12718
12719 va_start(ap, fmt);
12720 h = sip_header_vformat(home, sip_path_class, fmt, ap);
12721 va_end(ap);
12722
12723 return (sip_path_t *)h;
12724}
12725#endif
12726
12735 char *s, isize_t slen);
12736
12738SOFIAPUBFUN issize_t sip_service_route_e(char b[], isize_t bsiz,
12739 msg_header_t const *h, int flags);
12740
12745#define sip_service_route(sip) \
12746 ((sip_service_route_t *)msg_header_access((msg_pub_t*)(sip), sip_service_route_class))
12747
12762#define SIP_SERVICE_ROUTE_INIT() SIP_HDR_INIT(service_route)
12763
12779#if SU_HAVE_INLINE
12784#else
12785#define sip_service_route_init(x) \
12786 SIP_HEADER_INIT(x, sip_service_route_class, sizeof(sip_service_route_t))
12787#endif
12788
12801#if SU_HAVE_INLINE
12803{
12804 return header && header->sh_class->hc_hash == sip_service_route_hash;
12805}
12806#else
12807int sip_is_service_route(sip_header_t const *header);
12808#endif
12809
12810#define sip_service_route_p(h) sip_is_service_route((h))
12811
12812
12841#if SU_HAVE_INLINE
12843#endif
12845 __attribute__((__malloc__));
12846
12847#if SU_HAVE_INLINE
12854#endif
12855
12884#if SU_HAVE_INLINE
12886#endif
12888 __attribute__((__malloc__));
12889
12890#if SU_HAVE_INLINE
12897#endif
12898
12914#if SU_HAVE_INLINE
12916#endif
12918 __attribute__((__malloc__));
12919
12920#if SU_HAVE_INLINE
12922{
12923 return (sip_service_route_t *)sip_header_make(home, sip_service_route_class, s);
12924}
12925#endif
12926
12945#if SU_HAVE_INLINE
12947#endif
12948sip_service_route_t *sip_service_route_format(su_home_t *home, char const *fmt, ...)
12949 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12950
12951#if SU_HAVE_INLINE
12953{
12954 sip_header_t *h;
12955 va_list ap;
12956
12957 va_start(ap, fmt);
12958 h = sip_header_vformat(home, sip_service_route_class, fmt, ap);
12959 va_end(ap);
12960
12961 return (sip_service_route_t *)h;
12962}
12963#endif
12964
12973 char *s, isize_t slen);
12974
12976SOFIAPUBFUN issize_t sip_reason_e(char b[], isize_t bsiz,
12977 msg_header_t const *h, int flags);
12978
12983#define sip_reason(sip) \
12984 ((sip_reason_t *)msg_header_access((msg_pub_t*)(sip), sip_reason_class))
12985
13000#define SIP_REASON_INIT() SIP_HDR_INIT(reason)
13001
13017#if SU_HAVE_INLINE
13022#else
13023#define sip_reason_init(x) \
13024 SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t))
13025#endif
13026
13039#if SU_HAVE_INLINE
13041{
13042 return header && header->sh_class->hc_hash == sip_reason_hash;
13043}
13044#else
13045int sip_is_reason(sip_header_t const *header);
13046#endif
13047
13048#define sip_reason_p(h) sip_is_reason((h))
13049
13050
13079#if SU_HAVE_INLINE
13081#endif
13083 __attribute__((__malloc__));
13084
13085#if SU_HAVE_INLINE
13088{
13089 return (sip_reason_t *)
13090 msg_header_dup_as(home, sip_reason_class, (msg_header_t const *)hdr);
13091}
13092#endif
13093
13122#if SU_HAVE_INLINE
13124#endif
13126 __attribute__((__malloc__));
13127
13128#if SU_HAVE_INLINE
13131{
13132 return (sip_reason_t *)
13134}
13135#endif
13136
13152#if SU_HAVE_INLINE
13154#endif
13155sip_reason_t *sip_reason_make(su_home_t *home, char const *s)
13156 __attribute__((__malloc__));
13157
13158#if SU_HAVE_INLINE
13160{
13161 return (sip_reason_t *)sip_header_make(home, sip_reason_class, s);
13162}
13163#endif
13164
13183#if SU_HAVE_INLINE
13185#endif
13186sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
13187 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13188
13189#if SU_HAVE_INLINE
13191{
13192 sip_header_t *h;
13193 va_list ap;
13194
13195 va_start(ap, fmt);
13196 h = sip_header_vformat(home, sip_reason_class, fmt, ap);
13197 va_end(ap);
13198
13199 return (sip_reason_t *)h;
13200}
13201#endif
13202
13211 char *s, isize_t slen);
13212
13214SOFIAPUBFUN issize_t sip_security_client_e(char b[], isize_t bsiz,
13215 msg_header_t const *h, int flags);
13216
13221#define sip_security_client(sip) \
13222 ((sip_security_client_t *)msg_header_access((msg_pub_t*)(sip), sip_security_client_class))
13223
13238#define SIP_SECURITY_CLIENT_INIT() SIP_HDR_INIT(security_client)
13239
13255#if SU_HAVE_INLINE
13260#else
13261#define sip_security_client_init(x) \
13262 SIP_HEADER_INIT(x, sip_security_client_class, sizeof(sip_security_client_t))
13263#endif
13264
13277#if SU_HAVE_INLINE
13279{
13280 return header && header->sh_class->hc_hash == sip_security_client_hash;
13281}
13282#else
13283int sip_is_security_client(sip_header_t const *header);
13284#endif
13285
13286#define sip_security_client_p(h) sip_is_security_client((h))
13287
13288
13317#if SU_HAVE_INLINE
13319#endif
13321 __attribute__((__malloc__));
13322
13323#if SU_HAVE_INLINE
13330#endif
13331
13360#if SU_HAVE_INLINE
13362#endif
13364 __attribute__((__malloc__));
13365
13366#if SU_HAVE_INLINE
13373#endif
13374
13390#if SU_HAVE_INLINE
13392#endif
13394 __attribute__((__malloc__));
13395
13396#if SU_HAVE_INLINE
13398{
13399 return (sip_security_client_t *)sip_header_make(home, sip_security_client_class, s);
13400}
13401#endif
13402
13421#if SU_HAVE_INLINE
13423#endif
13425 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13426
13427#if SU_HAVE_INLINE
13429{
13430 sip_header_t *h;
13431 va_list ap;
13432
13433 va_start(ap, fmt);
13434 h = sip_header_vformat(home, sip_security_client_class, fmt, ap);
13435 va_end(ap);
13436
13437 return (sip_security_client_t *)h;
13438}
13439#endif
13440
13449 char *s, isize_t slen);
13450
13452SOFIAPUBFUN issize_t sip_security_server_e(char b[], isize_t bsiz,
13453 msg_header_t const *h, int flags);
13454
13459#define sip_security_server(sip) \
13460 ((sip_security_server_t *)msg_header_access((msg_pub_t*)(sip), sip_security_server_class))
13461
13476#define SIP_SECURITY_SERVER_INIT() SIP_HDR_INIT(security_server)
13477
13493#if SU_HAVE_INLINE
13498#else
13499#define sip_security_server_init(x) \
13500 SIP_HEADER_INIT(x, sip_security_server_class, sizeof(sip_security_server_t))
13501#endif
13502
13515#if SU_HAVE_INLINE
13517{
13518 return header && header->sh_class->hc_hash == sip_security_server_hash;
13519}
13520#else
13521int sip_is_security_server(sip_header_t const *header);
13522#endif
13523
13524#define sip_security_server_p(h) sip_is_security_server((h))
13525
13526
13555#if SU_HAVE_INLINE
13557#endif
13559 __attribute__((__malloc__));
13560
13561#if SU_HAVE_INLINE
13568#endif
13569
13598#if SU_HAVE_INLINE
13600#endif
13602 __attribute__((__malloc__));
13603
13604#if SU_HAVE_INLINE
13611#endif
13612
13628#if SU_HAVE_INLINE
13630#endif
13632 __attribute__((__malloc__));
13633
13634#if SU_HAVE_INLINE
13636{
13637 return (sip_security_server_t *)sip_header_make(home, sip_security_server_class, s);
13638}
13639#endif
13640
13659#if SU_HAVE_INLINE
13661#endif
13663 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13664
13665#if SU_HAVE_INLINE
13667{
13668 sip_header_t *h;
13669 va_list ap;
13670
13671 va_start(ap, fmt);
13672 h = sip_header_vformat(home, sip_security_server_class, fmt, ap);
13673 va_end(ap);
13674
13675 return (sip_security_server_t *)h;
13676}
13677#endif
13678
13687 char *s, isize_t slen);
13688
13690SOFIAPUBFUN issize_t sip_security_verify_e(char b[], isize_t bsiz,
13691 msg_header_t const *h, int flags);
13692
13697#define sip_security_verify(sip) \
13698 ((sip_security_verify_t *)msg_header_access((msg_pub_t*)(sip), sip_security_verify_class))
13699
13714#define SIP_SECURITY_VERIFY_INIT() SIP_HDR_INIT(security_verify)
13715
13731#if SU_HAVE_INLINE
13736#else
13737#define sip_security_verify_init(x) \
13738 SIP_HEADER_INIT(x, sip_security_verify_class, sizeof(sip_security_verify_t))
13739#endif
13740
13753#if SU_HAVE_INLINE
13755{
13756 return header && header->sh_class->hc_hash == sip_security_verify_hash;
13757}
13758#else
13759int sip_is_security_verify(sip_header_t const *header);
13760#endif
13761
13762#define sip_security_verify_p(h) sip_is_security_verify((h))
13763
13764
13793#if SU_HAVE_INLINE
13795#endif
13797 __attribute__((__malloc__));
13798
13799#if SU_HAVE_INLINE
13806#endif
13807
13836#if SU_HAVE_INLINE
13838#endif
13840 __attribute__((__malloc__));
13841
13842#if SU_HAVE_INLINE
13849#endif
13850
13866#if SU_HAVE_INLINE
13868#endif
13870 __attribute__((__malloc__));
13871
13872#if SU_HAVE_INLINE
13874{
13875 return (sip_security_verify_t *)sip_header_make(home, sip_security_verify_class, s);
13876}
13877#endif
13878
13897#if SU_HAVE_INLINE
13899#endif
13901 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13902
13903#if SU_HAVE_INLINE
13905{
13906 sip_header_t *h;
13907 va_list ap;
13908
13909 va_start(ap, fmt);
13910 h = sip_header_vformat(home, sip_security_verify_class, fmt, ap);
13911 va_end(ap);
13912
13913 return (sip_security_verify_t *)h;
13914}
13915#endif
13916
13925 char *s, isize_t slen);
13926
13928SOFIAPUBFUN issize_t sip_privacy_e(char b[], isize_t bsiz,
13929 msg_header_t const *h, int flags);
13930
13935#define sip_privacy(sip) \
13936 ((sip_privacy_t *)msg_header_access((msg_pub_t*)(sip), sip_privacy_class))
13937
13952#define SIP_PRIVACY_INIT() SIP_HDR_INIT(privacy)
13953
13969#if SU_HAVE_INLINE
13974#else
13975#define sip_privacy_init(x) \
13976 SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t))
13977#endif
13978
13991#if SU_HAVE_INLINE
13993{
13994 return header && header->sh_class->hc_hash == sip_privacy_hash;
13995}
13996#else
13997int sip_is_privacy(sip_header_t const *header);
13998#endif
13999
14000#define sip_privacy_p(h) sip_is_privacy((h))
14001
14002
14031#if SU_HAVE_INLINE
14033#endif
14035 __attribute__((__malloc__));
14036
14037#if SU_HAVE_INLINE
14040{
14041 return (sip_privacy_t *)
14043}
14044#endif
14045
14074#if SU_HAVE_INLINE
14076#endif
14078 __attribute__((__malloc__));
14079
14080#if SU_HAVE_INLINE
14083{
14084 return (sip_privacy_t *)
14086}
14087#endif
14088
14104#if SU_HAVE_INLINE
14106#endif
14107sip_privacy_t *sip_privacy_make(su_home_t *home, char const *s)
14108 __attribute__((__malloc__));
14109
14110#if SU_HAVE_INLINE
14112{
14113 return (sip_privacy_t *)sip_header_make(home, sip_privacy_class, s);
14114}
14115#endif
14116
14135#if SU_HAVE_INLINE
14137#endif
14138sip_privacy_t *sip_privacy_format(su_home_t *home, char const *fmt, ...)
14139 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14140
14141#if SU_HAVE_INLINE
14143{
14144 sip_header_t *h;
14145 va_list ap;
14146
14147 va_start(ap, fmt);
14148 h = sip_header_vformat(home, sip_privacy_class, fmt, ap);
14149 va_end(ap);
14150
14151 return (sip_privacy_t *)h;
14152}
14153#endif
14154
14163 char *s, isize_t slen);
14164
14166SOFIAPUBFUN issize_t sip_etag_e(char b[], isize_t bsiz,
14167 msg_header_t const *h, int flags);
14168
14173#define sip_etag(sip) \
14174 ((sip_etag_t *)msg_header_access((msg_pub_t*)(sip), sip_etag_class))
14175
14190#define SIP_ETAG_INIT() SIP_HDR_INIT(etag)
14191
14207#if SU_HAVE_INLINE
14212#else
14213#define sip_etag_init(x) \
14214 SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t))
14215#endif
14216
14229#if SU_HAVE_INLINE
14231{
14232 return header && header->sh_class->hc_hash == sip_etag_hash;
14233}
14234#else
14235int sip_is_etag(sip_header_t const *header);
14236#endif
14237
14238#define sip_etag_p(h) sip_is_etag((h))
14239
14240
14269#if SU_HAVE_INLINE
14271#endif
14272sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
14273 __attribute__((__malloc__));
14274
14275#if SU_HAVE_INLINE
14278{
14279 return (sip_etag_t *)
14280 msg_header_dup_as(home, sip_etag_class, (msg_header_t const *)hdr);
14281}
14282#endif
14283
14312#if SU_HAVE_INLINE
14314#endif
14315sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
14316 __attribute__((__malloc__));
14317
14318#if SU_HAVE_INLINE
14321{
14322 return (sip_etag_t *)
14323 msg_header_copy_as(home, sip_etag_class, (msg_header_t const *)hdr);
14324}
14325#endif
14326
14342#if SU_HAVE_INLINE
14344#endif
14345sip_etag_t *sip_etag_make(su_home_t *home, char const *s)
14346 __attribute__((__malloc__));
14347
14348#if SU_HAVE_INLINE
14350{
14351 return (sip_etag_t *)sip_header_make(home, sip_etag_class, s);
14352}
14353#endif
14354
14373#if SU_HAVE_INLINE
14375#endif
14376sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
14377 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14378
14379#if SU_HAVE_INLINE
14380su_inline sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
14381{
14382 sip_header_t *h;
14383 va_list ap;
14384
14385 va_start(ap, fmt);
14386 h = sip_header_vformat(home, sip_etag_class, fmt, ap);
14387 va_end(ap);
14388
14389 return (sip_etag_t *)h;
14390}
14391#endif
14392
14401 char *s, isize_t slen);
14402
14404SOFIAPUBFUN issize_t sip_if_match_e(char b[], isize_t bsiz,
14405 msg_header_t const *h, int flags);
14406
14411#define sip_if_match(sip) \
14412 ((sip_if_match_t *)msg_header_access((msg_pub_t*)(sip), sip_if_match_class))
14413
14428#define SIP_IF_MATCH_INIT() SIP_HDR_INIT(if_match)
14429
14445#if SU_HAVE_INLINE
14450#else
14451#define sip_if_match_init(x) \
14452 SIP_HEADER_INIT(x, sip_if_match_class, sizeof(sip_if_match_t))
14453#endif
14454
14467#if SU_HAVE_INLINE
14469{
14470 return header && header->sh_class->hc_hash == sip_if_match_hash;
14471}
14472#else
14473int sip_is_if_match(sip_header_t const *header);
14474#endif
14475
14476#define sip_if_match_p(h) sip_is_if_match((h))
14477
14478
14507#if SU_HAVE_INLINE
14509#endif
14511 __attribute__((__malloc__));
14512
14513#if SU_HAVE_INLINE
14516{
14517 return (sip_if_match_t *)
14519}
14520#endif
14521
14550#if SU_HAVE_INLINE
14552#endif
14554 __attribute__((__malloc__));
14555
14556#if SU_HAVE_INLINE
14559{
14560 return (sip_if_match_t *)
14562}
14563#endif
14564
14580#if SU_HAVE_INLINE
14582#endif
14583sip_if_match_t *sip_if_match_make(su_home_t *home, char const *s)
14584 __attribute__((__malloc__));
14585
14586#if SU_HAVE_INLINE
14588{
14589 return (sip_if_match_t *)sip_header_make(home, sip_if_match_class, s);
14590}
14591#endif
14592
14611#if SU_HAVE_INLINE
14613#endif
14614sip_if_match_t *sip_if_match_format(su_home_t *home, char const *fmt, ...)
14615 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14616
14617#if SU_HAVE_INLINE
14619{
14620 sip_header_t *h;
14621 va_list ap;
14622
14623 va_start(ap, fmt);
14624 h = sip_header_vformat(home, sip_if_match_class, fmt, ap);
14625 va_end(ap);
14626
14627 return (sip_if_match_t *)h;
14628}
14629#endif
14630
14639 char *s, isize_t slen);
14640
14642SOFIAPUBFUN issize_t sip_mime_version_e(char b[], isize_t bsiz,
14643 msg_header_t const *h, int flags);
14644
14649#define sip_mime_version(sip) \
14650 ((sip_mime_version_t *)msg_header_access((msg_pub_t*)(sip), sip_mime_version_class))
14651
14666#define SIP_MIME_VERSION_INIT() SIP_HDR_INIT(mime_version)
14667
14683#if SU_HAVE_INLINE
14688#else
14689#define sip_mime_version_init(x) \
14690 SIP_HEADER_INIT(x, sip_mime_version_class, sizeof(sip_mime_version_t))
14691#endif
14692
14705#if SU_HAVE_INLINE
14707{
14708 return header && header->sh_class->hc_hash == sip_mime_version_hash;
14709}
14710#else
14711int sip_is_mime_version(sip_header_t const *header);
14712#endif
14713
14714#define sip_mime_version_p(h) sip_is_mime_version((h))
14715
14716
14745#if SU_HAVE_INLINE
14747#endif
14749 __attribute__((__malloc__));
14750
14751#if SU_HAVE_INLINE
14758#endif
14759
14788#if SU_HAVE_INLINE
14790#endif
14792 __attribute__((__malloc__));
14793
14794#if SU_HAVE_INLINE
14801#endif
14802
14818#if SU_HAVE_INLINE
14820#endif
14822 __attribute__((__malloc__));
14823
14824#if SU_HAVE_INLINE
14826{
14827 return (sip_mime_version_t *)sip_header_make(home, sip_mime_version_class, s);
14828}
14829#endif
14830
14849#if SU_HAVE_INLINE
14851#endif
14852sip_mime_version_t *sip_mime_version_format(su_home_t *home, char const *fmt, ...)
14853 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14854
14855#if SU_HAVE_INLINE
14857{
14858 sip_header_t *h;
14859 va_list ap;
14860
14861 va_start(ap, fmt);
14862 h = sip_header_vformat(home, sip_mime_version_class, fmt, ap);
14863 va_end(ap);
14864
14865 return (sip_mime_version_t *)h;
14866}
14867#endif
14868
14877 char *s, isize_t slen);
14878
14880SOFIAPUBFUN issize_t sip_content_type_e(char b[], isize_t bsiz,
14881 msg_header_t const *h, int flags);
14882
14887#define sip_content_type(sip) \
14888 ((sip_content_type_t *)msg_header_access((msg_pub_t*)(sip), sip_content_type_class))
14889
14904#define SIP_CONTENT_TYPE_INIT() SIP_HDR_INIT(content_type)
14905
14921#if SU_HAVE_INLINE
14926#else
14927#define sip_content_type_init(x) \
14928 SIP_HEADER_INIT(x, sip_content_type_class, sizeof(sip_content_type_t))
14929#endif
14930
14943#if SU_HAVE_INLINE
14945{
14946 return header && header->sh_class->hc_hash == sip_content_type_hash;
14947}
14948#else
14949int sip_is_content_type(sip_header_t const *header);
14950#endif
14951
14952#define sip_content_type_p(h) sip_is_content_type((h))
14953
14954
14983#if SU_HAVE_INLINE
14985#endif
14987 __attribute__((__malloc__));
14988
14989#if SU_HAVE_INLINE
14996#endif
14997
15026#if SU_HAVE_INLINE
15028#endif
15030 __attribute__((__malloc__));
15031
15032#if SU_HAVE_INLINE
15039#endif
15040
15056#if SU_HAVE_INLINE
15058#endif
15060 __attribute__((__malloc__));
15061
15062#if SU_HAVE_INLINE
15064{
15065 return (sip_content_type_t *)sip_header_make(home, sip_content_type_class, s);
15066}
15067#endif
15068
15087#if SU_HAVE_INLINE
15089#endif
15090sip_content_type_t *sip_content_type_format(su_home_t *home, char const *fmt, ...)
15091 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15092
15093#if SU_HAVE_INLINE
15095{
15096 sip_header_t *h;
15097 va_list ap;
15098
15099 va_start(ap, fmt);
15100 h = sip_header_vformat(home, sip_content_type_class, fmt, ap);
15101 va_end(ap);
15102
15103 return (sip_content_type_t *)h;
15104}
15105#endif
15106
15115 char *s, isize_t slen);
15116
15118SOFIAPUBFUN issize_t sip_content_encoding_e(char b[], isize_t bsiz,
15119 msg_header_t const *h, int flags);
15120
15125#define sip_content_encoding(sip) \
15126 ((sip_content_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_content_encoding_class))
15127
15142#define SIP_CONTENT_ENCODING_INIT() SIP_HDR_INIT(content_encoding)
15143
15159#if SU_HAVE_INLINE
15164#else
15165#define sip_content_encoding_init(x) \
15166 SIP_HEADER_INIT(x, sip_content_encoding_class, sizeof(sip_content_encoding_t))
15167#endif
15168
15181#if SU_HAVE_INLINE
15183{
15184 return header && header->sh_class->hc_hash == sip_content_encoding_hash;
15185}
15186#else
15187int sip_is_content_encoding(sip_header_t const *header);
15188#endif
15189
15190#define sip_content_encoding_p(h) sip_is_content_encoding((h))
15191
15192
15221#if SU_HAVE_INLINE
15223#endif
15225 __attribute__((__malloc__));
15226
15227#if SU_HAVE_INLINE
15234#endif
15235
15264#if SU_HAVE_INLINE
15266#endif
15268 __attribute__((__malloc__));
15269
15270#if SU_HAVE_INLINE
15277#endif
15278
15294#if SU_HAVE_INLINE
15296#endif
15298 __attribute__((__malloc__));
15299
15300#if SU_HAVE_INLINE
15302{
15303 return (sip_content_encoding_t *)sip_header_make(home, sip_content_encoding_class, s);
15304}
15305#endif
15306
15325#if SU_HAVE_INLINE
15327#endif
15329 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15330
15331#if SU_HAVE_INLINE
15333{
15334 sip_header_t *h;
15335 va_list ap;
15336
15337 va_start(ap, fmt);
15338 h = sip_header_vformat(home, sip_content_encoding_class, fmt, ap);
15339 va_end(ap);
15340
15341 return (sip_content_encoding_t *)h;
15342}
15343#endif
15344
15353 char *s, isize_t slen);
15354
15356SOFIAPUBFUN issize_t sip_content_language_e(char b[], isize_t bsiz,
15357 msg_header_t const *h, int flags);
15358
15363#define sip_content_language(sip) \
15364 ((sip_content_language_t *)msg_header_access((msg_pub_t*)(sip), sip_content_language_class))
15365
15380#define SIP_CONTENT_LANGUAGE_INIT() SIP_HDR_INIT(content_language)
15381
15397#if SU_HAVE_INLINE
15402#else
15403#define sip_content_language_init(x) \
15404 SIP_HEADER_INIT(x, sip_content_language_class, sizeof(sip_content_language_t))
15405#endif
15406
15419#if SU_HAVE_INLINE
15421{
15422 return header && header->sh_class->hc_hash == sip_content_language_hash;
15423}
15424#else
15425int sip_is_content_language(sip_header_t const *header);
15426#endif
15427
15428#define sip_content_language_p(h) sip_is_content_language((h))
15429
15430
15459#if SU_HAVE_INLINE
15461#endif
15463 __attribute__((__malloc__));
15464
15465#if SU_HAVE_INLINE
15472#endif
15473
15502#if SU_HAVE_INLINE
15504#endif
15506 __attribute__((__malloc__));
15507
15508#if SU_HAVE_INLINE
15515#endif
15516
15532#if SU_HAVE_INLINE
15534#endif
15536 __attribute__((__malloc__));
15537
15538#if SU_HAVE_INLINE
15540{
15541 return (sip_content_language_t *)sip_header_make(home, sip_content_language_class, s);
15542}
15543#endif
15544
15563#if SU_HAVE_INLINE
15565#endif
15567 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15568
15569#if SU_HAVE_INLINE
15571{
15572 sip_header_t *h;
15573 va_list ap;
15574
15575 va_start(ap, fmt);
15576 h = sip_header_vformat(home, sip_content_language_class, fmt, ap);
15577 va_end(ap);
15578
15579 return (sip_content_language_t *)h;
15580}
15581#endif
15582
15591 char *s, isize_t slen);
15592
15594SOFIAPUBFUN issize_t sip_content_disposition_e(char b[], isize_t bsiz,
15595 msg_header_t const *h, int flags);
15596
15601#define sip_content_disposition(sip) \
15602 ((sip_content_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_content_disposition_class))
15603
15618#define SIP_CONTENT_DISPOSITION_INIT() SIP_HDR_INIT(content_disposition)
15619
15635#if SU_HAVE_INLINE
15636su_inline sip_content_disposition_t *sip_content_disposition_init(sip_content_disposition_t x[1])
15637{
15638 return SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t));
15639}
15640#else
15641#define sip_content_disposition_init(x) \
15642 SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t))
15643#endif
15644
15657#if SU_HAVE_INLINE
15659{
15660 return header && header->sh_class->hc_hash == sip_content_disposition_hash;
15661}
15662#else
15663int sip_is_content_disposition(sip_header_t const *header);
15664#endif
15665
15666#define sip_content_disposition_p(h) sip_is_content_disposition((h))
15667
15668
15697#if SU_HAVE_INLINE
15699#endif
15700sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
15701 __attribute__((__malloc__));
15702
15703#if SU_HAVE_INLINE
15705sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
15706{
15707 return (sip_content_disposition_t *)
15709}
15710#endif
15711
15740#if SU_HAVE_INLINE
15742#endif
15743sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
15744 __attribute__((__malloc__));
15745
15746#if SU_HAVE_INLINE
15748sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
15749{
15750 return (sip_content_disposition_t *)
15752}
15753#endif
15754
15770#if SU_HAVE_INLINE
15772#endif
15773sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
15774 __attribute__((__malloc__));
15775
15776#if SU_HAVE_INLINE
15777su_inline sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
15778{
15779 return (sip_content_disposition_t *)sip_header_make(home, sip_content_disposition_class, s);
15780}
15781#endif
15782
15801#if SU_HAVE_INLINE
15803#endif
15804sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
15805 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15806
15807#if SU_HAVE_INLINE
15808su_inline sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
15809{
15810 sip_header_t *h;
15811 va_list ap;
15812
15813 va_start(ap, fmt);
15814 h = sip_header_vformat(home, sip_content_disposition_class, fmt, ap);
15815 va_end(ap);
15816
15817 return (sip_content_disposition_t *)h;
15818}
15819#endif
15820
15829 char *s, isize_t slen);
15830
15832SOFIAPUBFUN issize_t sip_content_length_e(char b[], isize_t bsiz,
15833 msg_header_t const *h, int flags);
15834
15839#define sip_content_length(sip) \
15840 ((sip_content_length_t *)msg_header_access((msg_pub_t*)(sip), sip_content_length_class))
15841
15856#define SIP_CONTENT_LENGTH_INIT() SIP_HDR_INIT(content_length)
15857
15873#if SU_HAVE_INLINE
15878#else
15879#define sip_content_length_init(x) \
15880 SIP_HEADER_INIT(x, sip_content_length_class, sizeof(sip_content_length_t))
15881#endif
15882
15895#if SU_HAVE_INLINE
15897{
15898 return header && header->sh_class->hc_hash == sip_content_length_hash;
15899}
15900#else
15901int sip_is_content_length(sip_header_t const *header);
15902#endif
15903
15904#define sip_content_length_p(h) sip_is_content_length((h))
15905
15906
15935#if SU_HAVE_INLINE
15937#endif
15939 __attribute__((__malloc__));
15940
15941#if SU_HAVE_INLINE
15948#endif
15949
15978#if SU_HAVE_INLINE
15980#endif
15982 __attribute__((__malloc__));
15983
15984#if SU_HAVE_INLINE
15991#endif
15992
16008#if SU_HAVE_INLINE
16010#endif
16012 __attribute__((__malloc__));
16013
16014#if SU_HAVE_INLINE
16016{
16017 return (sip_content_length_t *)sip_header_make(home, sip_content_length_class, s);
16018}
16019#endif
16020
16039#if SU_HAVE_INLINE
16041#endif
16042sip_content_length_t *sip_content_length_format(su_home_t *home, char const *fmt, ...)
16043 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16044
16045#if SU_HAVE_INLINE
16047{
16048 sip_header_t *h;
16049 va_list ap;
16050
16051 va_start(ap, fmt);
16052 h = sip_header_vformat(home, sip_content_length_class, fmt, ap);
16053 va_end(ap);
16054
16055 return (sip_content_length_t *)h;
16056}
16057#endif
16058
16067 char *s, isize_t slen);
16068
16070SOFIAPUBFUN issize_t sip_unknown_e(char b[], isize_t bsiz,
16071 msg_header_t const *h, int flags);
16072
16077#define sip_unknown(sip) \
16078 ((sip_unknown_t *)msg_header_access((msg_pub_t*)(sip), sip_unknown_class))
16079
16094#define SIP_UNKNOWN_INIT() SIP_HDR_INIT(unknown)
16095
16111#if SU_HAVE_INLINE
16112su_inline sip_unknown_t *sip_unknown_init(sip_unknown_t x[1])
16113{
16114 return SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t));
16115}
16116#else
16117#define sip_unknown_init(x) \
16118 SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t))
16119#endif
16120
16133#if SU_HAVE_INLINE
16135{
16136 return header && header->sh_class->hc_hash == sip_unknown_hash;
16137}
16138#else
16139int sip_is_unknown(sip_header_t const *header);
16140#endif
16141
16142#define sip_unknown_p(h) sip_is_unknown((h))
16143
16144
16173#if SU_HAVE_INLINE
16175#endif
16176sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
16177 __attribute__((__malloc__));
16178
16179#if SU_HAVE_INLINE
16181sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
16182{
16183 return (sip_unknown_t *)
16185}
16186#endif
16187
16216#if SU_HAVE_INLINE
16218#endif
16219sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
16220 __attribute__((__malloc__));
16221
16222#if SU_HAVE_INLINE
16224sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
16225{
16226 return (sip_unknown_t *)
16228}
16229#endif
16230
16246#if SU_HAVE_INLINE
16248#endif
16249sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
16250 __attribute__((__malloc__));
16251
16252#if SU_HAVE_INLINE
16253su_inline sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
16254{
16255 return (sip_unknown_t *)sip_header_make(home, sip_unknown_class, s);
16256}
16257#endif
16258
16277#if SU_HAVE_INLINE
16279#endif
16280sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
16281 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16282
16283#if SU_HAVE_INLINE
16284su_inline sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
16285{
16286 sip_header_t *h;
16287 va_list ap;
16288
16289 va_start(ap, fmt);
16290 h = sip_header_vformat(home, sip_unknown_class, fmt, ap);
16291 va_end(ap);
16292
16293 return (sip_unknown_t *)h;
16294}
16295#endif
16296
16305 char *s, isize_t slen);
16306
16308SOFIAPUBFUN issize_t sip_error_e(char b[], isize_t bsiz,
16309 msg_header_t const *h, int flags);
16310
16315#define sip_error(sip) \
16316 ((sip_error_t *)msg_header_access((msg_pub_t*)(sip), sip_error_class))
16317
16332#define SIP_ERROR_INIT() SIP_HDR_INIT(error)
16333
16349#if SU_HAVE_INLINE
16350su_inline sip_error_t *sip_error_init(sip_error_t x[1])
16351{
16352 return SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t));
16353}
16354#else
16355#define sip_error_init(x) \
16356 SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t))
16357#endif
16358
16371#if SU_HAVE_INLINE
16373{
16374 return header && header->sh_class->hc_hash == sip_error_hash;
16375}
16376#else
16377int sip_is_error(sip_header_t const *header);
16378#endif
16379
16380#define sip_error_p(h) sip_is_error((h))
16381
16382
16411#if SU_HAVE_INLINE
16413#endif
16414sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
16415 __attribute__((__malloc__));
16416
16417#if SU_HAVE_INLINE
16419sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
16420{
16421 return (sip_error_t *)
16422 msg_header_dup_as(home, sip_error_class, (msg_header_t const *)hdr);
16423}
16424#endif
16425
16454#if SU_HAVE_INLINE
16456#endif
16457sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
16458 __attribute__((__malloc__));
16459
16460#if SU_HAVE_INLINE
16462sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
16463{
16464 return (sip_error_t *)
16465 msg_header_copy_as(home, sip_error_class, (msg_header_t const *)hdr);
16466}
16467#endif
16468
16484#if SU_HAVE_INLINE
16486#endif
16487sip_error_t *sip_error_make(su_home_t *home, char const *s)
16488 __attribute__((__malloc__));
16489
16490#if SU_HAVE_INLINE
16491su_inline sip_error_t *sip_error_make(su_home_t *home, char const *s)
16492{
16493 return (sip_error_t *)sip_header_make(home, sip_error_class, s);
16494}
16495#endif
16496
16515#if SU_HAVE_INLINE
16517#endif
16518sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
16519 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16520
16521#if SU_HAVE_INLINE
16522su_inline sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
16523{
16524 sip_header_t *h;
16525 va_list ap;
16526
16527 va_start(ap, fmt);
16528 h = sip_header_vformat(home, sip_error_class, fmt, ap);
16529 va_end(ap);
16530
16531 return (sip_error_t *)h;
16532}
16533#endif
16534
16542SOFIAPUBFUN issize_t sip_separator_d(su_home_t *, msg_header_t *,
16543 char *s, isize_t slen);
16544
16546SOFIAPUBFUN issize_t sip_separator_e(char b[], isize_t bsiz,
16547 msg_header_t const *h, int flags);
16548
16553#define sip_separator(sip) \
16554 ((sip_separator_t *)msg_header_access((msg_pub_t*)(sip), sip_separator_class))
16555
16570#define SIP_SEPARATOR_INIT() SIP_HDR_INIT(separator)
16571
16587#if SU_HAVE_INLINE
16588su_inline sip_separator_t *sip_separator_init(sip_separator_t x[1])
16589{
16590 return SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t));
16591}
16592#else
16593#define sip_separator_init(x) \
16594 SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t))
16595#endif
16596
16609#if SU_HAVE_INLINE
16611{
16612 return header && header->sh_class->hc_hash == sip_separator_hash;
16613}
16614#else
16615int sip_is_separator(sip_header_t const *header);
16616#endif
16617
16618#define sip_separator_p(h) sip_is_separator((h))
16619
16620
16649#if SU_HAVE_INLINE
16651#endif
16652sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
16653 __attribute__((__malloc__));
16654
16655#if SU_HAVE_INLINE
16657sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
16658{
16659 return (sip_separator_t *)
16661}
16662#endif
16663
16692#if SU_HAVE_INLINE
16694#endif
16695sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
16696 __attribute__((__malloc__));
16697
16698#if SU_HAVE_INLINE
16700sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
16701{
16702 return (sip_separator_t *)
16704}
16705#endif
16706
16722#if SU_HAVE_INLINE
16724#endif
16725sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
16726 __attribute__((__malloc__));
16727
16728#if SU_HAVE_INLINE
16729su_inline sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
16730{
16731 return (sip_separator_t *)sip_header_make(home, sip_separator_class, s);
16732}
16733#endif
16734
16753#if SU_HAVE_INLINE
16755#endif
16756sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
16757 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16758
16759#if SU_HAVE_INLINE
16760su_inline sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
16761{
16762 sip_header_t *h;
16763 va_list ap;
16764
16765 va_start(ap, fmt);
16766 h = sip_header_vformat(home, sip_separator_class, fmt, ap);
16767 va_end(ap);
16768
16769 return (sip_separator_t *)h;
16770}
16771#endif
16772
16780SOFIAPUBFUN issize_t sip_payload_d(su_home_t *, msg_header_t *,
16781 char *s, isize_t slen);
16782
16784SOFIAPUBFUN issize_t sip_payload_e(char b[], isize_t bsiz,
16785 msg_header_t const *h, int flags);
16786
16791#define sip_payload(sip) \
16792 ((sip_payload_t *)msg_header_access((msg_pub_t*)(sip), sip_payload_class))
16793
16808#define SIP_PAYLOAD_INIT() SIP_HDR_INIT(payload)
16809
16825#if SU_HAVE_INLINE
16826su_inline sip_payload_t *sip_payload_init(sip_payload_t x[1])
16827{
16828 return SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t));
16829}
16830#else
16831#define sip_payload_init(x) \
16832 SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t))
16833#endif
16834
16847#if SU_HAVE_INLINE
16849{
16850 return header && header->sh_class->hc_hash == sip_payload_hash;
16851}
16852#else
16853int sip_is_payload(sip_header_t const *header);
16854#endif
16855
16856#define sip_payload_p(h) sip_is_payload((h))
16857
16858
16887#if SU_HAVE_INLINE
16889#endif
16890sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
16891 __attribute__((__malloc__));
16892
16893#if SU_HAVE_INLINE
16895sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
16896{
16897 return (sip_payload_t *)
16899}
16900#endif
16901
16930#if SU_HAVE_INLINE
16932#endif
16933sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
16934 __attribute__((__malloc__));
16935
16936#if SU_HAVE_INLINE
16938sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
16939{
16940 return (sip_payload_t *)
16942}
16943#endif
16944
16960#if SU_HAVE_INLINE
16962#endif
16963sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
16964 __attribute__((__malloc__));
16965
16966#if SU_HAVE_INLINE
16967su_inline sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
16968{
16969 return (sip_payload_t *)sip_header_make(home, sip_payload_class, s);
16970}
16971#endif
16972
16991#if SU_HAVE_INLINE
16993#endif
16994sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
16995 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16996
16997#if SU_HAVE_INLINE
16998su_inline sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
16999{
17000 sip_header_t *h;
17001 va_list ap;
17002
17003 va_start(ap, fmt);
17004 h = sip_header_vformat(home, sip_payload_class, fmt, ap);
17005 va_end(ap);
17006
17007 return (sip_payload_t *)h;
17008}
17009#endif
17010
17013SOFIA_END_DECLS
17014#endif /* !defined(SIP_PROTOS_H) */
sip_accept_contact_t * sip_accept_contact_make(su_home_t *home, char const *s))
Make a Accept-Contact header structure sip_accept_contact_t.
Definition sip_protos.h:3877
sip_accept_contact_t * sip_accept_contact_dup(su_home_t *home, sip_accept_contact_t const *hdr))
Duplicate a list of Accept-Contact header header structures sip_accept_contact_t.
Definition sip_protos.h:3805
issize_t sip_accept_contact_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Accept-Contact header.
sip_accept_contact_t * sip_accept_contact_copy(su_home_t *home, sip_accept_contact_t const *hdr))
Copy a list of Accept-Contact header header structures sip_accept_contact_t.
Definition sip_protos.h:3848
sip_accept_contact_t * sip_accept_contact_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Contact header from formatting result.
Definition sip_protos.h:3908
msg_hclass_t sip_accept_contact_class[]
Header class for Accept-Contact header.
Definition sip_caller_prefs.c:323
@ sip_accept_contact_hash
@
Definition sip_hclasses.h:397
sip_accept_contact_t * sip_accept_contact_init(sip_accept_contact_t x[1])
Initialize a structure sip_accept_contact_t.
Definition sip_protos.h:3736
int sip_is_accept_contact(sip_header_t const *header)
Test if header object is instance of sip_accept_contact_t.
Definition sip_protos.h:3758
issize_t sip_accept_contact_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Accept-Contact header.
@ sip_accept_encoding_hash
@
Definition sip_hclasses.h:742
sip_accept_encoding_t * sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr))
Copy a list of Accept-Encoding header header structures sip_accept_encoding_t.
Definition sip_protos.h:7418
msg_hclass_t sip_accept_encoding_class[]
Header class for Accept-Encoding header.
Definition sip_mime.c:214
issize_t sip_accept_encoding_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Accept-Encoding header.
sip_accept_encoding_t * sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr))
Duplicate a list of Accept-Encoding header header structures sip_accept_encoding_t.
Definition sip_protos.h:7375
issize_t sip_accept_encoding_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Accept-Encoding header.
int sip_is_accept_encoding(sip_header_t const *header)
Test if header object is instance of sip_accept_encoding_t.
Definition sip_protos.h:7328
sip_accept_encoding_t * sip_accept_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Encoding header from formatting result.
Definition sip_protos.h:7478
sip_accept_encoding_t * sip_accept_encoding_make(su_home_t *home, char const *s))
Make a Accept-Encoding header structure sip_accept_encoding_t.
Definition sip_protos.h:7447
sip_accept_encoding_t * sip_accept_encoding_init(sip_accept_encoding_t x[1])
Initialize a structure sip_accept_encoding_t.
Definition sip_protos.h:7306
sip_accept_language_t * sip_accept_language_init(sip_accept_language_t x[1])
Initialize a structure sip_accept_language_t.
Definition sip_protos.h:7544
sip_accept_language_t * sip_accept_language_format(su_home_t *home, char const *fmt,...)))
Make a Accept-Language header from formatting result.
Definition sip_protos.h:7716
msg_hclass_t sip_accept_language_class[]
Header class for Accept-Language header.
Definition sip_mime.c:280
sip_accept_language_t * sip_accept_language_make(su_home_t *home, char const *s))
Make a Accept-Language header structure sip_accept_language_t.
Definition sip_protos.h:7685
sip_accept_language_t * sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr))
Copy a list of Accept-Language header header structures sip_accept_language_t.
Definition sip_protos.h:7656
sip_accept_language_t * sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr))
Duplicate a list of Accept-Language header header structures sip_accept_language_t.
Definition sip_protos.h:7613
issize_t sip_accept_language_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Accept-Language header.
issize_t sip_accept_language_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Accept-Language header.
int sip_is_accept_language(sip_header_t const *header)
Test if header object is instance of sip_accept_language_t.
Definition sip_protos.h:7566
@ sip_accept_language_hash
@
Definition sip_hclasses.h:765
issize_t sip_accept_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Accept header.
sip_accept_t * sip_accept_make(su_home_t *home, char const *s))
Make a Accept header structure sip_accept_t.
Definition sip_protos.h:7209
@ sip_accept_hash
@
Definition sip_hclasses.h:719
issize_t sip_accept_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Accept header.
sip_accept_t * sip_accept_init(sip_accept_t x[1])
Initialize a structure sip_accept_t.
Definition sip_protos.h:7068
sip_accept_t * sip_accept_dup(su_home_t *home, sip_accept_t const *hdr))
Duplicate a list of Accept header header structures sip_accept_t.
Definition sip_protos.h:7137
sip_accept_t * sip_accept_format(su_home_t *home, char const *fmt,...)))
Make a Accept header from formatting result.
Definition sip_protos.h:7240
msg_hclass_t sip_accept_class[]
Header class for Accept header.
Definition sip_mime.c:100
sip_accept_t * sip_accept_copy(su_home_t *home, sip_accept_t const *hdr))
Copy a list of Accept header header structures sip_accept_t.
Definition sip_protos.h:7180
int sip_is_accept(sip_header_t const *header)
Test if header object is instance of sip_accept_t.
Definition sip_protos.h:7090
sip_allow_events_t * sip_allow_events_copy(su_home_t *home, sip_allow_events_t const *hdr))
Copy a list of Allow-Events header header structures sip_allow_events_t.
Definition sip_protos.h:9084
sip_allow_events_t * sip_allow_events_format(su_home_t *home, char const *fmt,...)))
Make a Allow-Events header from formatting result.
Definition sip_protos.h:9144
int sip_is_allow_events(sip_header_t const *header)
Test if header object is instance of sip_allow_events_t.
Definition sip_protos.h:8994
sip_allow_events_t * sip_allow_events_make(su_home_t *home, char const *s))
Make a Allow-Events header structure sip_allow_events_t.
Definition sip_protos.h:9113
msg_hclass_t sip_allow_events_class[]
Header class for Allow-Events header.
Definition sip_event.c:209
sip_allow_events_t * sip_allow_events_dup(su_home_t *home, sip_allow_events_t const *hdr))
Duplicate a list of Allow-Events header header structures sip_allow_events_t.
Definition sip_protos.h:9041
sip_allow_events_t * sip_allow_events_init(sip_allow_events_t x[1])
Initialize a structure sip_allow_events_t.
Definition sip_protos.h:8972
issize_t sip_allow_events_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Allow-Events header.
@ sip_allow_events_hash
@
Definition sip_hclasses.h:903
issize_t sip_allow_events_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Allow-Events header.
@ sip_allow_hash
@
Definition sip_hclasses.h:788
int sip_is_allow(sip_header_t const *header)
Test if header object is instance of sip_allow_t.
Definition sip_protos.h:7804
msg_hclass_t sip_allow_class[]
Header class for Allow header.
Definition sip_feature.c:92
sip_allow_t * sip_allow_copy(su_home_t *home, sip_allow_t const *hdr))
Copy a list of Allow header header structures sip_allow_t.
Definition sip_protos.h:7894
issize_t sip_allow_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Allow header.
sip_allow_t * sip_allow_dup(su_home_t *home, sip_allow_t const *hdr))
Duplicate a list of Allow header header structures sip_allow_t.
Definition sip_protos.h:7851
sip_allow_t * sip_allow_format(su_home_t *home, char const *fmt,...)))
Make a Allow header from formatting result.
Definition sip_protos.h:7954
sip_allow_t * sip_allow_make(su_home_t *home, char const *s))
Make a Allow header structure sip_allow_t.
Definition sip_protos.h:7923
issize_t sip_allow_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Allow header.
sip_allow_t * sip_allow_init(sip_allow_t x[1])
Initialize a structure sip_allow_t.
Definition sip_protos.h:7782
issize_t sip_authentication_info_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Authentication-Info header.
issize_t sip_authentication_info_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Authentication-Info header.
msg_hclass_t sip_authentication_info_class[]
Header class for Authentication-Info header.
Definition sip_security.c:368
int sip_is_authentication_info(sip_header_t const *header)
Test if header object is instance of sip_authentication_info_t.
Definition sip_protos.h:10660
sip_authentication_info_t * sip_authentication_info_format(su_home_t *home, char const *fmt,...)))
Make a Authentication-Info header from formatting result.
Definition sip_protos.h:10810
sip_authentication_info_t * sip_authentication_info_dup(su_home_t *home, sip_authentication_info_t const *hdr))
Duplicate a list of Authentication-Info header header structures sip_authentication_info_t.
Definition sip_protos.h:10707
@ sip_authentication_info_hash
@
Definition sip_hclasses.h:1064
sip_authentication_info_t * sip_authentication_info_make(su_home_t *home, char const *s))
Make a Authentication-Info header structure sip_authentication_info_t.
Definition sip_protos.h:10779
sip_authentication_info_t * sip_authentication_info_copy(su_home_t *home, sip_authentication_info_t const *hdr))
Copy a list of Authentication-Info header header structures sip_authentication_info_t.
Definition sip_protos.h:10750
sip_authentication_info_t * sip_authentication_info_init(sip_authentication_info_t x[1])
Initialize a structure sip_authentication_info_t.
Definition sip_protos.h:10638
sip_authorization_t * sip_authorization_dup(su_home_t *home, sip_authorization_t const *hdr))
Duplicate a list of Authorization header header structures sip_authorization_t.
Definition sip_protos.h:10231
sip_authorization_t * sip_authorization_format(su_home_t *home, char const *fmt,...)))
Make a Authorization header from formatting result.
Definition sip_protos.h:10334
msg_hclass_t sip_authorization_class[]
Header class for Authorization header.
Definition sip_security.c:130
@ sip_authorization_hash
@
Definition sip_hclasses.h:1018
sip_authorization_t * sip_authorization_init(sip_authorization_t x[1])
Initialize a structure sip_authorization_t.
Definition sip_protos.h:10162
sip_authorization_t * sip_authorization_copy(su_home_t *home, sip_authorization_t const *hdr))
Copy a list of Authorization header header structures sip_authorization_t.
Definition sip_protos.h:10274
issize_t sip_authorization_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Authorization header.
int sip_is_authorization(sip_header_t const *header)
Test if header object is instance of sip_authorization_t.
Definition sip_protos.h:10184
sip_authorization_t * sip_authorization_make(su_home_t *home, char const *s))
Make a Authorization header structure sip_authorization_t.
Definition sip_protos.h:10303
issize_t sip_authorization_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Authorization header.
issize_t sip_call_id_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Call-ID header.
sip_call_id_t * sip_call_id_init(sip_call_id_t x[1])
Initialize a structure sip_call_id_t.
Definition sip_protos.h:2308
issize_t sip_call_id_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Call-ID header.
sip_call_id_t * sip_call_id_copy(su_home_t *home, sip_call_id_t const *hdr))
Copy a list of Call-ID header header structures sip_call_id_t.
Definition sip_protos.h:2420
sip_call_id_t * sip_call_id_format(su_home_t *home, char const *fmt,...)))
Make a Call-ID header from formatting result.
Definition sip_protos.h:2480
sip_call_id_t * sip_call_id_make(su_home_t *home, char const *s))
Make a Call-ID header structure sip_call_id_t.
Definition sip_protos.h:2449
msg_hclass_t sip_call_id_class[]
Header class for Call-ID header.
Definition sip_basic.c:1045
sip_call_id_t * sip_call_id_dup(su_home_t *home, sip_call_id_t const *hdr))
Duplicate a list of Call-ID header header structures sip_call_id_t.
Definition sip_protos.h:2377
int sip_is_call_id(sip_header_t const *header)
Test if header object is instance of sip_call_id_t.
Definition sip_protos.h:2330
@ sip_call_id_hash
@
Definition sip_hclasses.h:259
sip_call_info_t * sip_call_info_dup(su_home_t *home, sip_call_info_t const *hdr))
Duplicate a list of Call-Info header header structures sip_call_info_t.
Definition sip_protos.h:5947
sip_call_info_t * sip_call_info_make(su_home_t *home, char const *s))
Make a Call-Info header structure sip_call_info_t.
Definition sip_protos.h:6019
sip_call_info_t * sip_call_info_format(su_home_t *home, char const *fmt,...)))
Make a Call-Info header from formatting result.
Definition sip_protos.h:6050
issize_t sip_call_info_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Call-Info header.
msg_hclass_t sip_call_info_class[]
Header class for Call-Info header.
Definition sip_extra.c:107
issize_t sip_call_info_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Call-Info header.
@ sip_call_info_hash
@
Definition sip_hclasses.h:604
int sip_is_call_info(sip_header_t const *header)
Test if header object is instance of sip_call_info_t.
Definition sip_protos.h:5900
sip_call_info_t * sip_call_info_copy(su_home_t *home, sip_call_info_t const *hdr))
Copy a list of Call-Info header header structures sip_call_info_t.
Definition sip_protos.h:5990
sip_call_info_t * sip_call_info_init(sip_call_info_t x[1])
Initialize a structure sip_call_info_t.
Definition sip_protos.h:5878
sip_contact_t * sip_contact_copy(su_home_t *home, sip_contact_t const *hdr))
Copy a list of Contact header header structures sip_contact_t.
Definition sip_protos.h:2896
int sip_is_contact(sip_header_t const *header)
Test if header object is instance of sip_contact_t.
Definition sip_protos.h:2806
sip_contact_t * sip_contact_make(su_home_t *home, char const *s))
Make a Contact header structure sip_contact_t.
Definition sip_protos.h:2925
sip_contact_t * sip_contact_init(sip_contact_t x[1])
Initialize a structure sip_contact_t.
Definition sip_protos.h:2784
msg_hclass_t sip_contact_class[]
Header class for Contact header.
Definition sip_basic.c:1367
issize_t sip_contact_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Contact header.
issize_t sip_contact_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Contact header.
sip_contact_t * sip_contact_format(su_home_t *home, char const *fmt,...)))
Make a Contact header from formatting result.
Definition sip_protos.h:2956
@ sip_contact_hash
@
Definition sip_hclasses.h:305
sip_contact_t * sip_contact_dup(su_home_t *home, sip_contact_t const *hdr))
Duplicate a list of Contact header header structures sip_contact_t.
Definition sip_protos.h:2853
sip_content_disposition_t * sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr))
Copy a list of Content-Disposition header header structures sip_content_disposition_t.
Definition sip_protos.h:15748
issize_t sip_content_disposition_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Content-Disposition header.
issize_t sip_content_disposition_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Content-Disposition header.
sip_content_disposition_t * sip_content_disposition_init(sip_content_disposition_t x[1])
Initialize a structure sip_content_disposition_t.
Definition sip_protos.h:15636
msg_hclass_t sip_content_disposition_class[]
Header class for Content-Disposition header.
Definition sip_mime.c:369
@ sip_content_disposition_hash
@
Definition sip_hclasses.h:1547
sip_content_disposition_t * sip_content_disposition_make(su_home_t *home, char const *s))
Make a Content-Disposition header structure sip_content_disposition_t.
Definition sip_protos.h:15777
sip_content_disposition_t * sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr))
Duplicate a list of Content-Disposition header header structures sip_content_disposition_t.
Definition sip_protos.h:15705
int sip_is_content_disposition(sip_header_t const *header)
Test if header object is instance of sip_content_disposition_t.
Definition sip_protos.h:15658
sip_content_disposition_t * sip_content_disposition_format(su_home_t *home, char const *fmt,...)))
Make a Content-Disposition header from formatting result.
Definition sip_protos.h:15808
sip_content_encoding_t * sip_content_encoding_format(su_home_t *home, char const *fmt,...)))
Make a Content-Encoding header from formatting result.
Definition sip_protos.h:15332
issize_t sip_content_encoding_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Content-Encoding header.
issize_t sip_content_encoding_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Content-Encoding header.
sip_content_encoding_t * sip_content_encoding_make(su_home_t *home, char const *s))
Make a Content-Encoding header structure sip_content_encoding_t.
Definition sip_protos.h:15301
msg_hclass_t sip_content_encoding_class[]
Header class for Content-Encoding header.
Definition sip_mime.c:436
sip_content_encoding_t * sip_content_encoding_copy(su_home_t *home, sip_content_encoding_t const *hdr))
Copy a list of Content-Encoding header header structures sip_content_encoding_t.
Definition sip_protos.h:15272
@ sip_content_encoding_hash
@
Definition sip_hclasses.h:1501
sip_content_encoding_t * sip_content_encoding_dup(su_home_t *home, sip_content_encoding_t const *hdr))
Duplicate a list of Content-Encoding header header structures sip_content_encoding_t.
Definition sip_protos.h:15229
int sip_is_content_encoding(sip_header_t const *header)
Test if header object is instance of sip_content_encoding_t.
Definition sip_protos.h:15182
sip_content_encoding_t * sip_content_encoding_init(sip_content_encoding_t x[1])
Initialize a structure sip_content_encoding_t.
Definition sip_protos.h:15160
sip_content_language_t * sip_content_language_dup(su_home_t *home, sip_content_language_t const *hdr))
Duplicate a list of Content-Language header header structures sip_content_language_t.
Definition sip_protos.h:15467
sip_content_language_t * sip_content_language_format(su_home_t *home, char const *fmt,...)))
Make a Content-Language header from formatting result.
Definition sip_protos.h:15570
int sip_is_content_language(sip_header_t const *header)
Test if header object is instance of sip_content_language_t.
Definition sip_protos.h:15420
sip_content_language_t * sip_content_language_make(su_home_t *home, char const *s))
Make a Content-Language header structure sip_content_language_t.
Definition sip_protos.h:15539
issize_t sip_content_language_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Content-Language header.
msg_hclass_t sip_content_language_class[]
Header class for Content-Language header.
Definition sip_mime.c:486
issize_t sip_content_language_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Content-Language header.
sip_content_language_t * sip_content_language_copy(su_home_t *home, sip_content_language_t const *hdr))
Copy a list of Content-Language header header structures sip_content_language_t.
Definition sip_protos.h:15510
sip_content_language_t * sip_content_language_init(sip_content_language_t x[1])
Initialize a structure sip_content_language_t.
Definition sip_protos.h:15398
@ sip_content_language_hash
@
Definition sip_hclasses.h:1524
issize_t sip_content_length_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Content-Length header.
issize_t sip_content_length_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Content-Length header.
sip_content_length_t * sip_content_length_make(su_home_t *home, char const *s))
Make a Content-Length header structure sip_content_length_t.
Definition sip_protos.h:16015
@ sip_content_length_hash
@
Definition sip_hclasses.h:1570
sip_content_length_t * sip_content_length_dup(su_home_t *home, sip_content_length_t const *hdr))
Duplicate a list of Content-Length header header structures sip_content_length_t.
Definition sip_protos.h:15943
sip_content_length_t * sip_content_length_init(sip_content_length_t x[1])
Initialize a structure sip_content_length_t.
Definition sip_protos.h:15874
msg_hclass_t sip_content_length_class[]
Header class for Content-Length header.
Definition sip_basic.c:1527
int sip_is_content_length(sip_header_t const *header)
Test if header object is instance of sip_content_length_t.
Definition sip_protos.h:15896
sip_content_length_t * sip_content_length_copy(su_home_t *home, sip_content_length_t const *hdr))
Copy a list of Content-Length header header structures sip_content_length_t.
Definition sip_protos.h:15986
sip_content_length_t * sip_content_length_format(su_home_t *home, char const *fmt,...)))
Make a Content-Length header from formatting result.
Definition sip_protos.h:16046
sip_content_type_t * sip_content_type_format(su_home_t *home, char const *fmt,...)))
Make a Content-Type header from formatting result.
Definition sip_protos.h:15094
issize_t sip_content_type_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Content-Type header.
int sip_is_content_type(sip_header_t const *header)
Test if header object is instance of sip_content_type_t.
Definition sip_protos.h:14944
sip_content_type_t * sip_content_type_init(sip_content_type_t x[1])
Initialize a structure sip_content_type_t.
Definition sip_protos.h:14922
issize_t sip_content_type_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Content-Type header.
@ sip_content_type_hash
@
Definition sip_hclasses.h:1478
sip_content_type_t * sip_content_type_dup(su_home_t *home, sip_content_type_t const *hdr))
Duplicate a list of Content-Type header header structures sip_content_type_t.
Definition sip_protos.h:14991
sip_content_type_t * sip_content_type_copy(su_home_t *home, sip_content_type_t const *hdr))
Copy a list of Content-Type header header structures sip_content_type_t.
Definition sip_protos.h:15034
sip_content_type_t * sip_content_type_make(su_home_t *home, char const *s))
Make a Content-Type header structure sip_content_type_t.
Definition sip_protos.h:15063
msg_hclass_t sip_content_type_class[]
Header class for Content-Type header.
Definition sip_mime.c:551
sip_cseq_t * sip_cseq_init(sip_cseq_t x[1])
Initialize a structure sip_cseq_t.
Definition sip_protos.h:2546
sip_cseq_t * sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr))
Duplicate a list of CSeq header header structures sip_cseq_t.
Definition sip_protos.h:2615
msg_hclass_t sip_cseq_class[]
Header class for CSeq header.
Definition sip_basic.c:1198
sip_cseq_t * sip_cseq_make(su_home_t *home, char const *s))
Make a CSeq header structure sip_cseq_t.
Definition sip_protos.h:2687
sip_cseq_t * sip_cseq_format(su_home_t *home, char const *fmt,...)))
Make a CSeq header from formatting result.
Definition sip_protos.h:2718
issize_t sip_cseq_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP CSeq header.
sip_cseq_t * sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr))
Copy a list of CSeq header header structures sip_cseq_t.
Definition sip_protos.h:2658
issize_t sip_cseq_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP CSeq header.
@ sip_cseq_hash
@
Definition sip_hclasses.h:282
int sip_is_cseq(sip_header_t const *header)
Test if header object is instance of sip_cseq_t.
Definition sip_protos.h:2568
@ sip_date_hash
@
Definition sip_hclasses.h:466
sip_date_t * sip_date_copy(su_home_t *home, sip_date_t const *hdr))
Copy a list of Date header header structures sip_date_t.
Definition sip_protos.h:4562
issize_t sip_date_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Date header.
issize_t sip_date_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Date header.
sip_date_t * sip_date_dup(su_home_t *home, sip_date_t const *hdr))
Duplicate a list of Date header header structures sip_date_t.
Definition sip_protos.h:4519
int sip_is_date(sip_header_t const *header)
Test if header object is instance of sip_date_t.
Definition sip_protos.h:4472
sip_date_t * sip_date_init(sip_date_t x[1])
Initialize a structure sip_date_t.
Definition sip_protos.h:4450
sip_date_t * sip_date_make(su_home_t *home, char const *s))
Make a Date header structure sip_date_t.
Definition sip_protos.h:4591
msg_hclass_t sip_date_class[]
Header class for Date header.
Definition sip_basic.c:1617
sip_date_t * sip_date_format(su_home_t *home, char const *fmt,...)))
Make a Date header from formatting result.
Definition sip_protos.h:4622
sip_error_info_t * sip_error_info_init(sip_error_info_t x[1])
Initialize a structure sip_error_info_t.
Definition sip_protos.h:10876
issize_t sip_error_info_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Error-Info header.
@ sip_error_info_hash
@
Definition sip_hclasses.h:1087
issize_t sip_error_info_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Error-Info header.
sip_error_info_t * sip_error_info_copy(su_home_t *home, sip_error_info_t const *hdr))
Copy a list of Error-Info header header structures sip_error_info_t.
Definition sip_protos.h:10988
sip_error_info_t * sip_error_info_dup(su_home_t *home, sip_error_info_t const *hdr))
Duplicate a list of Error-Info header header structures sip_error_info_t.
Definition sip_protos.h:10945
sip_error_info_t * sip_error_info_make(su_home_t *home, char const *s))
Make a Error-Info header structure sip_error_info_t.
Definition sip_protos.h:11017
int sip_is_error_info(sip_header_t const *header)
Test if header object is instance of sip_error_info_t.
Definition sip_protos.h:10898
msg_hclass_t sip_error_info_class[]
Header class for Error-Info header.
Definition sip_extra.c:187
sip_error_info_t * sip_error_info_format(su_home_t *home, char const *fmt,...)))
Make a Error-Info header from formatting result.
Definition sip_protos.h:11048
@ sip_error_hash
@
Definition sip_hclasses.h:1616
sip_error_t * sip_error_format(su_home_t *home, char const *fmt,...)))
Make a erroneous headers from formatting result.
Definition sip_protos.h:16522
sip_error_t * sip_error_make(su_home_t *home, char const *s))
Make a erroneous headers structure sip_error_t.
Definition sip_protos.h:16491
sip_error_t * sip_error_init(sip_error_t x[1])
Initialize a structure sip_error_t.
Definition sip_protos.h:16350
int sip_is_error(sip_header_t const *header)
Test if header object is instance of sip_error_t.
Definition sip_protos.h:16372
issize_t sip_error_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP erroneous headers.
Definition sip_basic.c:601
msg_hclass_t sip_error_class[]
Header class for erroneous headers.
Definition sip_basic.c:598
sip_error_t * sip_error_copy(su_home_t *home, sip_error_t const *hdr))
Copy a list of erroneous headers header structures sip_error_t.
Definition sip_protos.h:16462
sip_error_t * sip_error_dup(su_home_t *home, sip_error_t const *hdr))
Duplicate a list of erroneous headers header structures sip_error_t.
Definition sip_protos.h:16419
issize_t sip_error_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP erroneous headers.
Definition sip_basic.c:606
sip_etag_t * sip_etag_copy(su_home_t *home, sip_etag_t const *hdr))
Copy a list of SIP-ETag header header structures sip_etag_t.
Definition sip_protos.h:14320
@ sip_etag_hash
@
Definition sip_hclasses.h:1409
sip_etag_t * sip_etag_init(sip_etag_t x[1])
Initialize a structure sip_etag_t.
Definition sip_protos.h:14208
issize_t sip_etag_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP SIP-ETag header.
msg_hclass_t sip_etag_class[]
Header class for SIP-ETag header.
Definition sip_extra.c:820
sip_etag_t * sip_etag_dup(su_home_t *home, sip_etag_t const *hdr))
Duplicate a list of SIP-ETag header header structures sip_etag_t.
Definition sip_protos.h:14277
int sip_is_etag(sip_header_t const *header)
Test if header object is instance of sip_etag_t.
Definition sip_protos.h:14230
sip_etag_t * sip_etag_format(su_home_t *home, char const *fmt,...)))
Make a SIP-ETag header from formatting result.
Definition sip_protos.h:14380
issize_t sip_etag_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP SIP-ETag header.
sip_etag_t * sip_etag_make(su_home_t *home, char const *s))
Make a SIP-ETag header structure sip_etag_t.
Definition sip_protos.h:14349
issize_t sip_event_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Event header.
sip_event_t * sip_event_copy(su_home_t *home, sip_event_t const *hdr))
Copy a list of Event header header structures sip_event_t.
Definition sip_protos.h:8846
sip_event_t * sip_event_init(sip_event_t x[1])
Initialize a structure sip_event_t.
Definition sip_protos.h:8734
sip_event_t * sip_event_format(su_home_t *home, char const *fmt,...)))
Make a Event header from formatting result.
Definition sip_protos.h:8906
int sip_is_event(sip_header_t const *header)
Test if header object is instance of sip_event_t.
Definition sip_protos.h:8756
msg_hclass_t sip_event_class[]
Header class for Event header.
Definition sip_event.c:96
sip_event_t * sip_event_dup(su_home_t *home, sip_event_t const *hdr))
Duplicate a list of Event header header structures sip_event_t.
Definition sip_protos.h:8803
@ sip_event_hash
@
Definition sip_hclasses.h:880
sip_event_t * sip_event_make(su_home_t *home, char const *s))
Make a Event header structure sip_event_t.
Definition sip_protos.h:8875
issize_t sip_event_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Event header.
issize_t sip_expires_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Expires header.
sip_expires_t * sip_expires_make(su_home_t *home, char const *s))
Make a Expires header structure sip_expires_t.
Definition sip_protos.h:4353
int sip_is_expires(sip_header_t const *header)
Test if header object is instance of sip_expires_t.
Definition sip_protos.h:4234
msg_hclass_t sip_expires_class[]
Header class for Expires header.
Definition sip_basic.c:1698
sip_expires_t * sip_expires_copy(su_home_t *home, sip_expires_t const *hdr))
Copy a list of Expires header header structures sip_expires_t.
Definition sip_protos.h:4324
sip_expires_t * sip_expires_dup(su_home_t *home, sip_expires_t const *hdr))
Duplicate a list of Expires header header structures sip_expires_t.
Definition sip_protos.h:4281
sip_expires_t * sip_expires_format(su_home_t *home, char const *fmt,...)))
Make a Expires header from formatting result.
Definition sip_protos.h:4384
sip_expires_t * sip_expires_init(sip_expires_t x[1])
Initialize a structure sip_expires_t.
Definition sip_protos.h:4212
@ sip_expires_hash
@
Definition sip_hclasses.h:443
issize_t sip_expires_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Expires header.
issize_t sip_from_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP From header.
sip_from_t * sip_from_dup(su_home_t *home, sip_from_t const *hdr))
Duplicate a list of From header header structures sip_from_t.
Definition sip_protos.h:1901
sip_from_t * sip_from_make(su_home_t *home, char const *s))
Make a From header structure sip_from_t.
Definition sip_protos.h:1973
sip_from_t * sip_from_format(su_home_t *home, char const *fmt,...)))
Make a From header from formatting result.
Definition sip_protos.h:2004
sip_from_t * sip_from_copy(su_home_t *home, sip_from_t const *hdr))
Copy a list of From header header structures sip_from_t.
Definition sip_protos.h:1944
issize_t sip_from_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP From header.
@ sip_from_hash
@
Definition sip_hclasses.h:213
sip_from_t * sip_from_init(sip_from_t x[1])
Initialize a structure sip_from_t.
Definition sip_protos.h:1832
msg_hclass_t sip_from_class[]
Header class for From header.
Definition sip_basic.c:1785
int sip_is_from(sip_header_t const *header)
Test if header object is instance of sip_from_t.
Definition sip_protos.h:1854
sip_if_match_t * sip_if_match_format(su_home_t *home, char const *fmt,...)))
Make a SIP-If-Match header from formatting result.
Definition sip_protos.h:14618
msg_hclass_t sip_if_match_class[]
Header class for SIP-If-Match header.
Definition sip_extra.c:868
sip_if_match_t * sip_if_match_make(su_home_t *home, char const *s))
Make a SIP-If-Match header structure sip_if_match_t.
Definition sip_protos.h:14587
sip_if_match_t * sip_if_match_init(sip_if_match_t x[1])
Initialize a structure sip_if_match_t.
Definition sip_protos.h:14446
@ sip_if_match_hash
@
Definition sip_hclasses.h:1432
issize_t sip_if_match_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP SIP-If-Match header.
sip_if_match_t * sip_if_match_copy(su_home_t *home, sip_if_match_t const *hdr))
Copy a list of SIP-If-Match header header structures sip_if_match_t.
Definition sip_protos.h:14558
sip_if_match_t * sip_if_match_dup(su_home_t *home, sip_if_match_t const *hdr))
Duplicate a list of SIP-If-Match header header structures sip_if_match_t.
Definition sip_protos.h:14515
int sip_is_if_match(sip_header_t const *header)
Test if header object is instance of sip_if_match_t.
Definition sip_protos.h:14468
issize_t sip_if_match_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP SIP-If-Match header.
sip_in_reply_to_t * sip_in_reply_to_dup(su_home_t *home, sip_in_reply_to_t const *hdr))
Duplicate a list of In-Reply-To header header structures sip_in_reply_to_t.
Definition sip_protos.h:6899
sip_in_reply_to_t * sip_in_reply_to_make(su_home_t *home, char const *s))
Make a In-Reply-To header structure sip_in_reply_to_t.
Definition sip_protos.h:6971
sip_in_reply_to_t * sip_in_reply_to_init(sip_in_reply_to_t x[1])
Initialize a structure sip_in_reply_to_t.
Definition sip_protos.h:6830
@ sip_in_reply_to_hash
@
Definition sip_hclasses.h:696
int sip_is_in_reply_to(sip_header_t const *header)
Test if header object is instance of sip_in_reply_to_t.
Definition sip_protos.h:6852
issize_t sip_in_reply_to_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP In-Reply-To header.
msg_hclass_t sip_in_reply_to_class[]
Header class for In-Reply-To header.
Definition sip_extra.c:409
sip_in_reply_to_t * sip_in_reply_to_copy(su_home_t *home, sip_in_reply_to_t const *hdr))
Copy a list of In-Reply-To header header structures sip_in_reply_to_t.
Definition sip_protos.h:6942
sip_in_reply_to_t * sip_in_reply_to_format(su_home_t *home, char const *fmt,...)))
Make a In-Reply-To header from formatting result.
Definition sip_protos.h:7002
issize_t sip_in_reply_to_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP In-Reply-To header.
sip_max_forwards_t * sip_max_forwards_make(su_home_t *home, char const *s))
Make a Max-Forwards header structure sip_max_forwards_t.
Definition sip_protos.h:1497
sip_max_forwards_t * sip_max_forwards_format(su_home_t *home, char const *fmt,...)))
Make a Max-Forwards header from formatting result.
Definition sip_protos.h:1528
sip_max_forwards_t * sip_max_forwards_dup(su_home_t *home, sip_max_forwards_t const *hdr))
Duplicate a list of Max-Forwards header header structures sip_max_forwards_t.
Definition sip_protos.h:1425
sip_max_forwards_t * sip_max_forwards_copy(su_home_t *home, sip_max_forwards_t const *hdr))
Copy a list of Max-Forwards header header structures sip_max_forwards_t.
Definition sip_protos.h:1468
issize_t sip_max_forwards_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Max-Forwards header.
issize_t sip_max_forwards_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Max-Forwards header.
msg_hclass_t sip_max_forwards_class[]
Header class for Max-Forwards header.
Definition sip_basic.c:1898
@ sip_max_forwards_hash
@
Definition sip_hclasses.h:167
int sip_is_max_forwards(sip_header_t const *header)
Test if header object is instance of sip_max_forwards_t.
Definition sip_protos.h:1378
sip_max_forwards_t * sip_max_forwards_init(sip_max_forwards_t x[1])
Initialize a structure sip_max_forwards_t.
Definition sip_protos.h:1356
issize_t sip_mime_version_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP MIME-Version header.
sip_mime_version_t * sip_mime_version_make(su_home_t *home, char const *s))
Make a MIME-Version header structure sip_mime_version_t.
Definition sip_protos.h:14825
sip_mime_version_t * sip_mime_version_init(sip_mime_version_t x[1])
Initialize a structure sip_mime_version_t.
Definition sip_protos.h:14684
int sip_is_mime_version(sip_header_t const *header)
Test if header object is instance of sip_mime_version_t.
Definition sip_protos.h:14706
issize_t sip_mime_version_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP MIME-Version header.
@ sip_mime_version_hash
@
Definition sip_hclasses.h:1455
msg_hclass_t sip_mime_version_class[]
Header class for MIME-Version header.
Definition sip_mime.c:613
sip_mime_version_t * sip_mime_version_copy(su_home_t *home, sip_mime_version_t const *hdr))
Copy a list of MIME-Version header header structures sip_mime_version_t.
Definition sip_protos.h:14796
sip_mime_version_t * sip_mime_version_format(su_home_t *home, char const *fmt,...)))
Make a MIME-Version header from formatting result.
Definition sip_protos.h:14856
sip_mime_version_t * sip_mime_version_dup(su_home_t *home, sip_mime_version_t const *hdr))
Duplicate a list of MIME-Version header header structures sip_mime_version_t.
Definition sip_protos.h:14753
@ sip_min_expires_hash
@
Definition sip_hclasses.h:535
issize_t sip_min_expires_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Min-Expires header.
sip_min_expires_t * sip_min_expires_init(sip_min_expires_t x[1])
Initialize a structure sip_min_expires_t.
Definition sip_protos.h:5164
int sip_is_min_expires(sip_header_t const *header)
Test if header object is instance of sip_min_expires_t.
Definition sip_protos.h:5186
sip_min_expires_t * sip_min_expires_dup(su_home_t *home, sip_min_expires_t const *hdr))
Duplicate a list of Min-Expires header header structures sip_min_expires_t.
Definition sip_protos.h:5233
issize_t sip_min_expires_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Min-Expires header.
msg_hclass_t sip_min_expires_class[]
Header class for Min-Expires header.
Definition sip_basic.c:1944
sip_min_expires_t * sip_min_expires_make(su_home_t *home, char const *s))
Make a Min-Expires header structure sip_min_expires_t.
Definition sip_protos.h:5305
sip_min_expires_t * sip_min_expires_format(su_home_t *home, char const *fmt,...)))
Make a Min-Expires header from formatting result.
Definition sip_protos.h:5336
sip_min_expires_t * sip_min_expires_copy(su_home_t *home, sip_min_expires_t const *hdr))
Copy a list of Min-Expires header header structures sip_min_expires_t.
Definition sip_protos.h:5276
sip_min_se_t * sip_min_se_format(su_home_t *home, char const *fmt,...)))
Make a Min-SE header from formatting result.
Definition sip_protos.h:12476
issize_t sip_min_se_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Min-SE header.
sip_min_se_t * sip_min_se_make(su_home_t *home, char const *s))
Make a Min-SE header structure sip_min_se_t.
Definition sip_protos.h:12445
issize_t sip_min_se_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Min-SE header.
msg_hclass_t sip_min_se_class[]
Header class for Min-SE header.
Definition sip_session.c:200
sip_min_se_t * sip_min_se_dup(su_home_t *home, sip_min_se_t const *hdr))
Duplicate a list of Min-SE header header structures sip_min_se_t.
Definition sip_protos.h:12373
int sip_is_min_se(sip_header_t const *header)
Test if header object is instance of sip_min_se_t.
Definition sip_protos.h:12326
sip_min_se_t * sip_min_se_copy(su_home_t *home, sip_min_se_t const *hdr))
Copy a list of Min-SE header header structures sip_min_se_t.
Definition sip_protos.h:12416
sip_min_se_t * sip_min_se_init(sip_min_se_t x[1])
Initialize a structure sip_min_se_t.
Definition sip_protos.h:12304
@ sip_min_se_hash
@
Definition sip_hclasses.h:1225
sip_organization_t * sip_organization_make(su_home_t *home, char const *s))
Make a Organization header structure sip_organization_t.
Definition sip_protos.h:6257
issize_t sip_organization_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Organization header.
msg_hclass_t sip_organization_class[]
Header class for Organization header.
Definition sip_extra.c:456
int sip_is_organization(sip_header_t const *header)
Test if header object is instance of sip_organization_t.
Definition sip_protos.h:6138
issize_t sip_organization_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Organization header.
sip_organization_t * sip_organization_copy(su_home_t *home, sip_organization_t const *hdr))
Copy a list of Organization header header structures sip_organization_t.
Definition sip_protos.h:6228
sip_organization_t * sip_organization_init(sip_organization_t x[1])
Initialize a structure sip_organization_t.
Definition sip_protos.h:6116
@ sip_organization_hash
@
Definition sip_hclasses.h:627
sip_organization_t * sip_organization_dup(su_home_t *home, sip_organization_t const *hdr))
Duplicate a list of Organization header header structures sip_organization_t.
Definition sip_protos.h:6185
sip_organization_t * sip_organization_format(su_home_t *home, char const *fmt,...)))
Make a Organization header from formatting result.
Definition sip_protos.h:6288
sip_path_t * sip_path_dup(su_home_t *home, sip_path_t const *hdr))
Duplicate a list of Path header header structures sip_path_t.
Definition sip_protos.h:12611
sip_path_t * sip_path_copy(su_home_t *home, sip_path_t const *hdr))
Copy a list of Path header header structures sip_path_t.
Definition sip_protos.h:12654
issize_t sip_path_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Path header.
@ sip_path_hash
@
Definition sip_hclasses.h:1248
issize_t sip_path_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Path header.
sip_path_t * sip_path_make(su_home_t *home, char const *s))
Make a Path header structure sip_path_t.
Definition sip_protos.h:12683
sip_path_t * sip_path_init(sip_path_t x[1])
Initialize a structure sip_path_t.
Definition sip_protos.h:12542
int sip_is_path(sip_header_t const *header)
Test if header object is instance of sip_path_t.
Definition sip_protos.h:12564
sip_path_t * sip_path_format(su_home_t *home, char const *fmt,...)))
Make a Path header from formatting result.
Definition sip_protos.h:12714
msg_hclass_t sip_path_class[]
Header class for Path header.
Definition sip_feature.c:528
sip_payload_t * sip_payload_dup(su_home_t *home, sip_payload_t const *hdr))
Duplicate a list of message payload header structures sip_payload_t.
Definition sip_protos.h:16895
msg_hclass_t sip_payload_class[]
Header class for message payload.
Definition sip_basic.c:433
sip_payload_t * sip_payload_make(su_home_t *home, char const *s))
Make a message payload structure sip_payload_t.
Definition sip_protos.h:16967
@ sip_payload_hash
@
Definition sip_hclasses.h:1662
sip_payload_t * sip_payload_format(su_home_t *home, char const *fmt,...)))
Make a message payload from formatting result.
Definition sip_protos.h:16998
int sip_is_payload(sip_header_t const *header)
Test if header object is instance of sip_payload_t.
Definition sip_protos.h:16848
sip_payload_t * sip_payload_copy(su_home_t *home, sip_payload_t const *hdr))
Copy a list of message payload header structures sip_payload_t.
Definition sip_protos.h:16938
sip_payload_t * sip_payload_init(sip_payload_t x[1])
Initialize a structure sip_payload_t.
Definition sip_protos.h:16826
issize_t sip_priority_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Priority header.
@ sip_priority_hash
@
Definition sip_hclasses.h:581
int sip_is_priority(sip_header_t const *header)
Test if header object is instance of sip_priority_t.
Definition sip_protos.h:5662
sip_priority_t * sip_priority_dup(su_home_t *home, sip_priority_t const *hdr))
Duplicate a list of Priority header header structures sip_priority_t.
Definition sip_protos.h:5709
sip_priority_t * sip_priority_init(sip_priority_t x[1])
Initialize a structure sip_priority_t.
Definition sip_protos.h:5640
issize_t sip_priority_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Priority header.
sip_priority_t * sip_priority_format(su_home_t *home, char const *fmt,...)))
Make a Priority header from formatting result.
Definition sip_protos.h:5812
sip_priority_t * sip_priority_make(su_home_t *home, char const *s))
Make a Priority header structure sip_priority_t.
Definition sip_protos.h:5781
msg_hclass_t sip_priority_class[]
Header class for Priority header.
Definition sip_extra.c:505
sip_priority_t * sip_priority_copy(su_home_t *home, sip_priority_t const *hdr))
Copy a list of Priority header header structures sip_priority_t.
Definition sip_protos.h:5752
sip_privacy_t * sip_privacy_format(su_home_t *home, char const *fmt,...)))
Make a Privacy header from formatting result.
Definition sip_protos.h:14142
sip_privacy_t * sip_privacy_init(sip_privacy_t x[1])
Initialize a structure sip_privacy_t.
Definition sip_protos.h:13970
sip_privacy_t * sip_privacy_dup(su_home_t *home, sip_privacy_t const *hdr))
Duplicate a list of Privacy header header structures sip_privacy_t.
Definition sip_protos.h:14039
sip_privacy_t * sip_privacy_copy(su_home_t *home, sip_privacy_t const *hdr))
Copy a list of Privacy header header structures sip_privacy_t.
Definition sip_protos.h:14082
int sip_is_privacy(sip_header_t const *header)
Test if header object is instance of sip_privacy_t.
Definition sip_protos.h:13992
sip_privacy_t * sip_privacy_make(su_home_t *home, char const *s))
Make a Privacy header structure sip_privacy_t.
Definition sip_protos.h:14111
issize_t sip_privacy_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Privacy header.
msg_hclass_t sip_privacy_class[]
Header class for Privacy header.
Definition sip_security.c:755
issize_t sip_privacy_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Privacy header.
@ sip_privacy_hash
@
Definition sip_hclasses.h:1386
sip_proxy_authenticate_t * sip_proxy_authenticate_copy(su_home_t *home, sip_proxy_authenticate_t const *hdr))
Copy a list of Proxy-Authenticate header header structures sip_proxy_authenticate_t.
Definition sip_protos.h:9560
sip_proxy_authenticate_t * sip_proxy_authenticate_make(su_home_t *home, char const *s))
Make a Proxy-Authenticate header structure sip_proxy_authenticate_t.
Definition sip_protos.h:9589
issize_t sip_proxy_authenticate_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Proxy-Authenticate header.
int sip_is_proxy_authenticate(sip_header_t const *header)
Test if header object is instance of sip_proxy_authenticate_t.
Definition sip_protos.h:9470
sip_proxy_authenticate_t * sip_proxy_authenticate_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Authenticate header from formatting result.
Definition sip_protos.h:9620
msg_hclass_t sip_proxy_authenticate_class[]
Header class for Proxy-Authenticate header.
Definition sip_security.c:200
sip_proxy_authenticate_t * sip_proxy_authenticate_dup(su_home_t *home, sip_proxy_authenticate_t const *hdr))
Duplicate a list of Proxy-Authenticate header header structures sip_proxy_authenticate_t.
Definition sip_protos.h:9517
sip_proxy_authenticate_t * sip_proxy_authenticate_init(sip_proxy_authenticate_t x[1])
Initialize a structure sip_proxy_authenticate_t.
Definition sip_protos.h:9448
issize_t sip_proxy_authenticate_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Proxy-Authenticate header.
@ sip_proxy_authenticate_hash
@
Definition sip_hclasses.h:949
sip_proxy_authentication_info_t * sip_proxy_authentication_info_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Authentication-Info header from formatting result.
Definition sip_protos.h:9858
sip_proxy_authentication_info_t * sip_proxy_authentication_info_init(sip_proxy_authentication_info_t x[1])
Initialize a structure sip_proxy_authentication_info_t.
Definition sip_protos.h:9686
sip_proxy_authentication_info_t * sip_proxy_authentication_info_copy(su_home_t *home, sip_proxy_authentication_info_t const *hdr))
Copy a list of Proxy-Authentication-Info header header structures sip_proxy_authentication_info_t.
Definition sip_protos.h:9798
sip_proxy_authentication_info_t * sip_proxy_authentication_info_make(su_home_t *home, char const *s))
Make a Proxy-Authentication-Info header structure sip_proxy_authentication_info_t.
Definition sip_protos.h:9827
sip_proxy_authentication_info_t * sip_proxy_authentication_info_dup(su_home_t *home, sip_proxy_authentication_info_t const *hdr))
Duplicate a list of Proxy-Authentication-Info header header structures sip_proxy_authentication_info_...
Definition sip_protos.h:9755
msg_hclass_t sip_proxy_authentication_info_class[]
Header class for Proxy-Authentication-Info header.
Definition sip_security.c:434
issize_t sip_proxy_authentication_info_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Proxy-Authentication-Info header.
int sip_is_proxy_authentication_info(sip_header_t const *header)
Test if header object is instance of sip_proxy_authentication_info_t.
Definition sip_protos.h:9708
@ sip_proxy_authentication_info_hash
@
Definition sip_hclasses.h:972
issize_t sip_proxy_authentication_info_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Proxy-Authentication-Info header.
sip_proxy_authorization_t * sip_proxy_authorization_dup(su_home_t *home, sip_proxy_authorization_t const *hdr))
Duplicate a list of Proxy-Authorization header header structures sip_proxy_authorization_t.
Definition sip_protos.h:9993
sip_proxy_authorization_t * sip_proxy_authorization_copy(su_home_t *home, sip_proxy_authorization_t const *hdr))
Copy a list of Proxy-Authorization header header structures sip_proxy_authorization_t.
Definition sip_protos.h:10036
sip_proxy_authorization_t * sip_proxy_authorization_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Authorization header from formatting result.
Definition sip_protos.h:10096
msg_hclass_t sip_proxy_authorization_class[]
Header class for Proxy-Authorization header.
Definition sip_security.c:256
int sip_is_proxy_authorization(sip_header_t const *header)
Test if header object is instance of sip_proxy_authorization_t.
Definition sip_protos.h:9946
issize_t sip_proxy_authorization_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Proxy-Authorization header.
sip_proxy_authorization_t * sip_proxy_authorization_make(su_home_t *home, char const *s))
Make a Proxy-Authorization header structure sip_proxy_authorization_t.
Definition sip_protos.h:10065
sip_proxy_authorization_t * sip_proxy_authorization_init(sip_proxy_authorization_t x[1])
Initialize a structure sip_proxy_authorization_t.
Definition sip_protos.h:9924
issize_t sip_proxy_authorization_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Proxy-Authorization header.
@ sip_proxy_authorization_hash
@
Definition sip_hclasses.h:995
issize_t sip_proxy_require_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Proxy-Require header.
sip_proxy_require_t * sip_proxy_require_format(su_home_t *home, char const *fmt,...)))
Make a Proxy-Require header from formatting result.
Definition sip_protos.h:1766
msg_hclass_t sip_proxy_require_class[]
Header class for Proxy-Require header.
Definition sip_feature.c:181
sip_proxy_require_t * sip_proxy_require_dup(su_home_t *home, sip_proxy_require_t const *hdr))
Duplicate a list of Proxy-Require header header structures sip_proxy_require_t.
Definition sip_protos.h:1663
sip_proxy_require_t * sip_proxy_require_init(sip_proxy_require_t x[1])
Initialize a structure sip_proxy_require_t.
Definition sip_protos.h:1594
issize_t sip_proxy_require_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Proxy-Require header.
sip_proxy_require_t * sip_proxy_require_make(su_home_t *home, char const *s))
Make a Proxy-Require header structure sip_proxy_require_t.
Definition sip_protos.h:1735
@ sip_proxy_require_hash
@
Definition sip_hclasses.h:190
sip_proxy_require_t * sip_proxy_require_copy(su_home_t *home, sip_proxy_require_t const *hdr))
Copy a list of Proxy-Require header header structures sip_proxy_require_t.
Definition sip_protos.h:1706
int sip_is_proxy_require(sip_header_t const *header)
Test if header object is instance of sip_proxy_require_t.
Definition sip_protos.h:1616
sip_rack_t * sip_rack_dup(su_home_t *home, sip_rack_t const *hdr))
Duplicate a list of RAck header header structures sip_rack_t.
Definition sip_protos.h:3329
issize_t sip_rack_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP RAck header.
@ sip_rack_hash
@
Definition sip_hclasses.h:351
sip_rack_t * sip_rack_format(su_home_t *home, char const *fmt,...)))
Make a RAck header from formatting result.
Definition sip_protos.h:3432
int sip_is_rack(sip_header_t const *header)
Test if header object is instance of sip_rack_t.
Definition sip_protos.h:3282
msg_hclass_t sip_rack_class[]
Header class for RAck header.
Definition sip_prack.c:94
sip_rack_t * sip_rack_copy(su_home_t *home, sip_rack_t const *hdr))
Copy a list of RAck header header structures sip_rack_t.
Definition sip_protos.h:3372
issize_t sip_rack_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP RAck header.
sip_rack_t * sip_rack_init(sip_rack_t x[1])
Initialize a structure sip_rack_t.
Definition sip_protos.h:3260
sip_rack_t * sip_rack_make(su_home_t *home, char const *s))
Make a RAck header structure sip_rack_t.
Definition sip_protos.h:3401
sip_reason_t * sip_reason_init(sip_reason_t x[1])
Initialize a structure sip_reason_t.
Definition sip_protos.h:13018
issize_t sip_reason_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Reason header.
sip_reason_t * sip_reason_copy(su_home_t *home, sip_reason_t const *hdr))
Copy a list of Reason header header structures sip_reason_t.
Definition sip_protos.h:13130
sip_reason_t * sip_reason_make(su_home_t *home, char const *s))
Make a Reason header structure sip_reason_t.
Definition sip_protos.h:13159
sip_reason_t * sip_reason_format(su_home_t *home, char const *fmt,...)))
Make a Reason header from formatting result.
Definition sip_protos.h:13190
msg_hclass_t sip_reason_class[]
Header class for Reason header.
Definition sip_reason.c:94
@ sip_reason_hash
@
Definition sip_hclasses.h:1294
int sip_is_reason(sip_header_t const *header)
Test if header object is instance of sip_reason_t.
Definition sip_protos.h:13040
sip_reason_t * sip_reason_dup(su_home_t *home, sip_reason_t const *hdr))
Duplicate a list of Reason header header structures sip_reason_t.
Definition sip_protos.h:13087
issize_t sip_reason_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Reason header.
sip_record_route_t * sip_record_route_make(su_home_t *home, char const *s))
Make a Record-Route header structure sip_record_route_t.
Definition sip_protos.h:1259
@ sip_record_route_hash
@
Definition sip_hclasses.h:144
sip_record_route_t * sip_record_route_init(sip_record_route_t x[1])
Initialize a structure sip_record_route_t.
Definition sip_protos.h:1118
msg_hclass_t sip_record_route_class[]
Header class for Record-Route header.
Definition sip_basic.c:2324
issize_t sip_record_route_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Record-Route header.
int sip_is_record_route(sip_header_t const *header)
Test if header object is instance of sip_record_route_t.
Definition sip_protos.h:1140
sip_record_route_t * sip_record_route_format(su_home_t *home, char const *fmt,...)))
Make a Record-Route header from formatting result.
Definition sip_protos.h:1290
issize_t sip_record_route_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Record-Route header.
sip_record_route_t * sip_record_route_copy(su_home_t *home, sip_record_route_t const *hdr))
Copy a list of Record-Route header header structures sip_record_route_t.
Definition sip_protos.h:1230
sip_record_route_t * sip_record_route_dup(su_home_t *home, sip_record_route_t const *hdr))
Duplicate a list of Record-Route header header structures sip_record_route_t.
Definition sip_protos.h:1187
int sip_is_refer_to(sip_header_t const *header)
Test if header object is instance of sip_refer_to_t.
Definition sip_protos.h:11374
sip_refer_to_t * sip_refer_to_make(su_home_t *home, char const *s))
Make a Refer-To header structure sip_refer_to_t.
Definition sip_protos.h:11493
msg_hclass_t sip_refer_to_class[]
Header class for Refer-To header.
Definition sip_refer.c:93
sip_refer_to_t * sip_refer_to_format(su_home_t *home, char const *fmt,...)))
Make a Refer-To header from formatting result.
Definition sip_protos.h:11524
issize_t sip_refer_to_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Refer-To header.
sip_refer_to_t * sip_refer_to_copy(su_home_t *home, sip_refer_to_t const *hdr))
Copy a list of Refer-To header header structures sip_refer_to_t.
Definition sip_protos.h:11464
sip_refer_to_t * sip_refer_to_init(sip_refer_to_t x[1])
Initialize a structure sip_refer_to_t.
Definition sip_protos.h:11352
sip_refer_to_t * sip_refer_to_dup(su_home_t *home, sip_refer_to_t const *hdr))
Duplicate a list of Refer-To header header structures sip_refer_to_t.
Definition sip_protos.h:11421
issize_t sip_refer_to_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Refer-To header.
@ sip_refer_to_hash
@
Definition sip_hclasses.h:1133
sip_referred_by_t * sip_referred_by_copy(su_home_t *home, sip_referred_by_t const *hdr))
Copy a list of Referred-By header header structures sip_referred_by_t.
Definition sip_protos.h:11702
msg_hclass_t sip_referred_by_class[]
Header class for Referred-By header.
Definition sip_refer.c:221
sip_referred_by_t * sip_referred_by_format(su_home_t *home, char const *fmt,...)))
Make a Referred-By header from formatting result.
Definition sip_protos.h:11762
sip_referred_by_t * sip_referred_by_dup(su_home_t *home, sip_referred_by_t const *hdr))
Duplicate a list of Referred-By header header structures sip_referred_by_t.
Definition sip_protos.h:11659
issize_t sip_referred_by_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Referred-By header.
sip_referred_by_t * sip_referred_by_init(sip_referred_by_t x[1])
Initialize a structure sip_referred_by_t.
Definition sip_protos.h:11590
sip_referred_by_t * sip_referred_by_make(su_home_t *home, char const *s))
Make a Referred-By header structure sip_referred_by_t.
Definition sip_protos.h:11731
int sip_is_referred_by(sip_header_t const *header)
Test if header object is instance of sip_referred_by_t.
Definition sip_protos.h:11612
issize_t sip_referred_by_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Referred-By header.
@ sip_referred_by_hash
@
Definition sip_hclasses.h:1156
issize_t sip_reject_contact_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Reject-Contact header.
sip_reject_contact_t * sip_reject_contact_format(su_home_t *home, char const *fmt,...)))
Make a Reject-Contact header from formatting result.
Definition sip_protos.h:4146
sip_reject_contact_t * sip_reject_contact_copy(su_home_t *home, sip_reject_contact_t const *hdr))
Copy a list of Reject-Contact header header structures sip_reject_contact_t.
Definition sip_protos.h:4086
sip_reject_contact_t * sip_reject_contact_make(su_home_t *home, char const *s))
Make a Reject-Contact header structure sip_reject_contact_t.
Definition sip_protos.h:4115
issize_t sip_reject_contact_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Reject-Contact header.
int sip_is_reject_contact(sip_header_t const *header)
Test if header object is instance of sip_reject_contact_t.
Definition sip_protos.h:3996
msg_hclass_t sip_reject_contact_class[]
Header class for Reject-Contact header.
Definition sip_caller_prefs.c:414
@ sip_reject_contact_hash
@
Definition sip_hclasses.h:420
sip_reject_contact_t * sip_reject_contact_init(sip_reject_contact_t x[1])
Initialize a structure sip_reject_contact_t.
Definition sip_protos.h:3974
sip_reject_contact_t * sip_reject_contact_dup(su_home_t *home, sip_reject_contact_t const *hdr))
Duplicate a list of Reject-Contact header header structures sip_reject_contact_t.
Definition sip_protos.h:4043
issize_t sip_replaces_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Replaces header.
sip_replaces_t * sip_replaces_init(sip_replaces_t x[1])
Initialize a structure sip_replaces_t.
Definition sip_protos.h:11828
sip_replaces_t * sip_replaces_copy(su_home_t *home, sip_replaces_t const *hdr))
Copy a list of Replaces header header structures sip_replaces_t.
Definition sip_protos.h:11940
sip_replaces_t * sip_replaces_make(su_home_t *home, char const *s))
Make a Replaces header structure sip_replaces_t.
Definition sip_protos.h:11969
issize_t sip_replaces_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Replaces header.
@ sip_replaces_hash
@
Definition sip_hclasses.h:1179
int sip_is_replaces(sip_header_t const *header)
Test if header object is instance of sip_replaces_t.
Definition sip_protos.h:11850
sip_replaces_t * sip_replaces_format(su_home_t *home, char const *fmt,...)))
Make a Replaces header from formatting result.
Definition sip_protos.h:12000
msg_hclass_t sip_replaces_class[]
Header class for Replaces header.
Definition sip_refer.c:354
sip_replaces_t * sip_replaces_dup(su_home_t *home, sip_replaces_t const *hdr))
Duplicate a list of Replaces header header structures sip_replaces_t.
Definition sip_protos.h:11897
sip_request_disposition_t * sip_request_disposition_dup(su_home_t *home, sip_request_disposition_t const *hdr))
Duplicate a list of Request-Disposition header header structures sip_request_disposition_t.
Definition sip_protos.h:3567
issize_t sip_request_disposition_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Request-Disposition header.
issize_t sip_request_disposition_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Request-Disposition header.
int sip_is_request_disposition(sip_header_t const *header)
Test if header object is instance of sip_request_disposition_t.
Definition sip_protos.h:3520
sip_request_disposition_t * sip_request_disposition_copy(su_home_t *home, sip_request_disposition_t const *hdr))
Copy a list of Request-Disposition header header structures sip_request_disposition_t.
Definition sip_protos.h:3610
sip_request_disposition_t * sip_request_disposition_format(su_home_t *home, char const *fmt,...)))
Make a Request-Disposition header from formatting result.
Definition sip_protos.h:3670
@ sip_request_disposition_hash
@
Definition sip_hclasses.h:374
sip_request_disposition_t * sip_request_disposition_init(sip_request_disposition_t x[1])
Initialize a structure sip_request_disposition_t.
Definition sip_protos.h:3498
msg_hclass_t sip_request_disposition_class[]
Header class for Request-Disposition header.
Definition sip_caller_prefs.c:98
sip_request_disposition_t * sip_request_disposition_make(su_home_t *home, char const *s))
Make a Request-Disposition header structure sip_request_disposition_t.
Definition sip_protos.h:3639
sip_request_t * sip_request_dup(su_home_t *home, sip_request_t const *hdr))
Duplicate a list of request line header structures sip_request_t.
Definition sip_protos.h:235
sip_request_t * sip_request_copy(su_home_t *home, sip_request_t const *hdr))
Copy a list of request line header structures sip_request_t.
Definition sip_protos.h:278
@ sip_request_hash
@
Definition sip_hclasses.h:52
sip_request_t * sip_request_make(su_home_t *home, char const *s))
Make a request line structure sip_request_t.
Definition sip_protos.h:307
issize_t sip_request_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP request line.
sip_request_t * sip_request_init(sip_request_t x[1])
Initialize a structure sip_request_t.
Definition sip_protos.h:166
sip_request_t * sip_request_format(su_home_t *home, char const *fmt,...)))
Make a request line from formatting result.
Definition sip_protos.h:338
int sip_is_request(sip_header_t const *header)
Test if header object is instance of sip_request_t.
Definition sip_protos.h:188
msg_hclass_t sip_request_class[]
Header class for request line.
Definition sip_basic.c:120
issize_t sip_request_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP request line.
sip_require_t * sip_require_format(su_home_t *home, char const *fmt,...)))
Make a Require header from formatting result.
Definition sip_protos.h:8192
msg_hclass_t sip_require_class[]
Header class for Require header.
Definition sip_feature.c:229
issize_t sip_require_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Require header.
sip_require_t * sip_require_dup(su_home_t *home, sip_require_t const *hdr))
Duplicate a list of Require header header structures sip_require_t.
Definition sip_protos.h:8089
sip_require_t * sip_require_init(sip_require_t x[1])
Initialize a structure sip_require_t.
Definition sip_protos.h:8020
@ sip_require_hash
@
Definition sip_hclasses.h:811
sip_require_t * sip_require_copy(su_home_t *home, sip_require_t const *hdr))
Copy a list of Require header header structures sip_require_t.
Definition sip_protos.h:8132
sip_require_t * sip_require_make(su_home_t *home, char const *s))
Make a Require header structure sip_require_t.
Definition sip_protos.h:8161
issize_t sip_require_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Require header.
int sip_is_require(sip_header_t const *header)
Test if header object is instance of sip_require_t.
Definition sip_protos.h:8042
issize_t sip_retry_after_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Retry-After header.
sip_retry_after_t * sip_retry_after_copy(su_home_t *home, sip_retry_after_t const *hdr))
Copy a list of Retry-After header header structures sip_retry_after_t.
Definition sip_protos.h:4800
sip_retry_after_t * sip_retry_after_dup(su_home_t *home, sip_retry_after_t const *hdr))
Duplicate a list of Retry-After header header structures sip_retry_after_t.
Definition sip_protos.h:4757
issize_t sip_retry_after_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Retry-After header.
int sip_is_retry_after(sip_header_t const *header)
Test if header object is instance of sip_retry_after_t.
Definition sip_protos.h:4710
msg_hclass_t sip_retry_after_class[]
Header class for Retry-After header.
Definition sip_basic.c:2002
@ sip_retry_after_hash
@
Definition sip_hclasses.h:489
sip_retry_after_t * sip_retry_after_init(sip_retry_after_t x[1])
Initialize a structure sip_retry_after_t.
Definition sip_protos.h:4688
sip_retry_after_t * sip_retry_after_make(su_home_t *home, char const *s))
Make a Retry-After header structure sip_retry_after_t.
Definition sip_protos.h:4829
sip_retry_after_t * sip_retry_after_format(su_home_t *home, char const *fmt,...)))
Make a Retry-After header from formatting result.
Definition sip_protos.h:4860
@ sip_route_hash
@
Definition sip_hclasses.h:121
msg_hclass_t sip_route_class[]
Header class for Route header.
Definition sip_basic.c:2251
sip_route_t * sip_route_format(su_home_t *home, char const *fmt,...)))
Make a Route header from formatting result.
Definition sip_protos.h:1052
sip_route_t * sip_route_init(sip_route_t x[1])
Initialize a structure sip_route_t.
Definition sip_protos.h:880
sip_route_t * sip_route_make(su_home_t *home, char const *s))
Make a Route header structure sip_route_t.
Definition sip_protos.h:1021
issize_t sip_route_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Route header.
int sip_is_route(sip_header_t const *header)
Test if header object is instance of sip_route_t.
Definition sip_protos.h:902
sip_route_t * sip_route_dup(su_home_t *home, sip_route_t const *hdr))
Duplicate a list of Route header header structures sip_route_t.
Definition sip_protos.h:949
sip_route_t * sip_route_copy(su_home_t *home, sip_route_t const *hdr))
Copy a list of Route header header structures sip_route_t.
Definition sip_protos.h:992
issize_t sip_route_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Route header.
sip_rseq_t * sip_rseq_format(su_home_t *home, char const *fmt,...)))
Make a RSeq header from formatting result.
Definition sip_protos.h:3194
@ sip_rseq_hash
@
Definition sip_hclasses.h:328
int sip_is_rseq(sip_header_t const *header)
Test if header object is instance of sip_rseq_t.
Definition sip_protos.h:3044
issize_t sip_rseq_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP RSeq header.
sip_rseq_t * sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr))
Duplicate a list of RSeq header header structures sip_rseq_t.
Definition sip_protos.h:3091
sip_rseq_t * sip_rseq_make(su_home_t *home, char const *s))
Make a RSeq header structure sip_rseq_t.
Definition sip_protos.h:3163
sip_rseq_t * sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr))
Copy a list of RSeq header header structures sip_rseq_t.
Definition sip_protos.h:3134
msg_hclass_t sip_rseq_class[]
Header class for RSeq header.
Definition sip_prack.c:192
issize_t sip_rseq_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP RSeq header.
sip_rseq_t * sip_rseq_init(sip_rseq_t x[1])
Initialize a structure sip_rseq_t.
Definition sip_protos.h:3022
issize_t sip_security_client_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Security-Client header.
int sip_is_security_client(sip_header_t const *header)
Test if header object is instance of sip_security_client_t.
Definition sip_protos.h:13278
sip_security_client_t * sip_security_client_copy(su_home_t *home, sip_security_client_t const *hdr))
Copy a list of Security-Client header header structures sip_security_client_t.
Definition sip_protos.h:13368
sip_security_client_t * sip_security_client_init(sip_security_client_t x[1])
Initialize a structure sip_security_client_t.
Definition sip_protos.h:13256
sip_security_client_t * sip_security_client_dup(su_home_t *home, sip_security_client_t const *hdr))
Duplicate a list of Security-Client header header structures sip_security_client_t.
Definition sip_protos.h:13325
@ sip_security_client_hash
@
Definition sip_hclasses.h:1317
issize_t sip_security_client_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Security-Client header.
msg_hclass_t sip_security_client_class[]
Header class for Security-Client header.
Definition sip_security.c:604
sip_security_client_t * sip_security_client_make(su_home_t *home, char const *s))
Make a Security-Client header structure sip_security_client_t.
Definition sip_protos.h:13397
sip_security_client_t * sip_security_client_format(su_home_t *home, char const *fmt,...)))
Make a Security-Client header from formatting result.
Definition sip_protos.h:13428
msg_hclass_t sip_security_server_class[]
Header class for Security-Server header.
Definition sip_security.c:653
sip_security_server_t * sip_security_server_init(sip_security_server_t x[1])
Initialize a structure sip_security_server_t.
Definition sip_protos.h:13494
int sip_is_security_server(sip_header_t const *header)
Test if header object is instance of sip_security_server_t.
Definition sip_protos.h:13516
sip_security_server_t * sip_security_server_copy(su_home_t *home, sip_security_server_t const *hdr))
Copy a list of Security-Server header header structures sip_security_server_t.
Definition sip_protos.h:13606
sip_security_server_t * sip_security_server_dup(su_home_t *home, sip_security_server_t const *hdr))
Duplicate a list of Security-Server header header structures sip_security_server_t.
Definition sip_protos.h:13563
sip_security_server_t * sip_security_server_make(su_home_t *home, char const *s))
Make a Security-Server header structure sip_security_server_t.
Definition sip_protos.h:13635
issize_t sip_security_server_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Security-Server header.
@ sip_security_server_hash
@
Definition sip_hclasses.h:1340
sip_security_server_t * sip_security_server_format(su_home_t *home, char const *fmt,...)))
Make a Security-Server header from formatting result.
Definition sip_protos.h:13666
issize_t sip_security_server_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Security-Server header.
issize_t sip_security_verify_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Security-Verify header.
msg_hclass_t sip_security_verify_class[]
Header class for Security-Verify header.
Definition sip_security.c:703
sip_security_verify_t * sip_security_verify_dup(su_home_t *home, sip_security_verify_t const *hdr))
Duplicate a list of Security-Verify header header structures sip_security_verify_t.
Definition sip_protos.h:13801
sip_security_verify_t * sip_security_verify_format(su_home_t *home, char const *fmt,...)))
Make a Security-Verify header from formatting result.
Definition sip_protos.h:13904
@ sip_security_verify_hash
@
Definition sip_hclasses.h:1363
sip_security_verify_t * sip_security_verify_init(sip_security_verify_t x[1])
Initialize a structure sip_security_verify_t.
Definition sip_protos.h:13732
sip_security_verify_t * sip_security_verify_copy(su_home_t *home, sip_security_verify_t const *hdr))
Copy a list of Security-Verify header header structures sip_security_verify_t.
Definition sip_protos.h:13844
sip_security_verify_t * sip_security_verify_make(su_home_t *home, char const *s))
Make a Security-Verify header structure sip_security_verify_t.
Definition sip_protos.h:13873
int sip_is_security_verify(sip_header_t const *header)
Test if header object is instance of sip_security_verify_t.
Definition sip_protos.h:13754
issize_t sip_security_verify_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Security-Verify header.
msg_hclass_t sip_separator_class[]
Header class for separator line between headers and body.
Definition sip_basic.c:507
sip_separator_t * sip_separator_format(su_home_t *home, char const *fmt,...)))
Make a separator line between headers and body from formatting result.
Definition sip_protos.h:16760
@ sip_separator_hash
@
Definition sip_hclasses.h:1639
sip_separator_t * sip_separator_dup(su_home_t *home, sip_separator_t const *hdr))
Duplicate a list of separator line between headers and body header structures sip_separator_t.
Definition sip_protos.h:16657
sip_separator_t * sip_separator_copy(su_home_t *home, sip_separator_t const *hdr))
Copy a list of separator line between headers and body header structures sip_separator_t.
Definition sip_protos.h:16700
int sip_is_separator(sip_header_t const *header)
Test if header object is instance of sip_separator_t.
Definition sip_protos.h:16610
sip_separator_t * sip_separator_make(su_home_t *home, char const *s))
Make a separator line between headers and body structure sip_separator_t.
Definition sip_protos.h:16729
sip_separator_t * sip_separator_init(sip_separator_t x[1])
Initialize a structure sip_separator_t.
Definition sip_protos.h:16588
@ sip_server_hash
@
Definition sip_hclasses.h:650
msg_hclass_t sip_server_class[]
Header class for Server header.
Definition sip_extra.c:562
sip_server_t * sip_server_copy(su_home_t *home, sip_server_t const *hdr))
Copy a list of Server header header structures sip_server_t.
Definition sip_protos.h:6466
sip_server_t * sip_server_make(su_home_t *home, char const *s))
Make a Server header structure sip_server_t.
Definition sip_protos.h:6495
int sip_is_server(sip_header_t const *header)
Test if header object is instance of sip_server_t.
Definition sip_protos.h:6376
sip_server_t * sip_server_dup(su_home_t *home, sip_server_t const *hdr))
Duplicate a list of Server header header structures sip_server_t.
Definition sip_protos.h:6423
sip_server_t * sip_server_init(sip_server_t x[1])
Initialize a structure sip_server_t.
Definition sip_protos.h:6354
issize_t sip_server_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Server header.
issize_t sip_server_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Server header.
sip_server_t * sip_server_format(su_home_t *home, char const *fmt,...)))
Make a Server header from formatting result.
Definition sip_protos.h:6526
sip_service_route_t * sip_service_route_copy(su_home_t *home, sip_service_route_t const *hdr))
Copy a list of Service-Route header header structures sip_service_route_t.
Definition sip_protos.h:12892
sip_service_route_t * sip_service_route_make(su_home_t *home, char const *s))
Make a Service-Route header structure sip_service_route_t.
Definition sip_protos.h:12921
msg_hclass_t sip_service_route_class[]
Header class for Service-Route header.
Definition sip_feature.c:583
sip_service_route_t * sip_service_route_format(su_home_t *home, char const *fmt,...)))
Make a Service-Route header from formatting result.
Definition sip_protos.h:12952
sip_service_route_t * sip_service_route_init(sip_service_route_t x[1])
Initialize a structure sip_service_route_t.
Definition sip_protos.h:12780
issize_t sip_service_route_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Service-Route header.
@ sip_service_route_hash
@
Definition sip_hclasses.h:1271
issize_t sip_service_route_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Service-Route header.
sip_service_route_t * sip_service_route_dup(su_home_t *home, sip_service_route_t const *hdr))
Duplicate a list of Service-Route header header structures sip_service_route_t.
Definition sip_protos.h:12849
int sip_is_service_route(sip_header_t const *header)
Test if header object is instance of sip_service_route_t.
Definition sip_protos.h:12802
int sip_is_session_expires(sip_header_t const *header)
Test if header object is instance of sip_session_expires_t.
Definition sip_protos.h:12088
sip_session_expires_t * sip_session_expires_copy(su_home_t *home, sip_session_expires_t const *hdr))
Copy a list of Session-Expires header header structures sip_session_expires_t.
Definition sip_protos.h:12178
issize_t sip_session_expires_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Session-Expires header.
issize_t sip_session_expires_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Session-Expires header.
@ sip_session_expires_hash
@
Definition sip_hclasses.h:1202
sip_session_expires_t * sip_session_expires_make(su_home_t *home, char const *s))
Make a Session-Expires header structure sip_session_expires_t.
Definition sip_protos.h:12207
msg_hclass_t sip_session_expires_class[]
Header class for Session-Expires header.
Definition sip_session.c:91
sip_session_expires_t * sip_session_expires_init(sip_session_expires_t x[1])
Initialize a structure sip_session_expires_t.
Definition sip_protos.h:12066
sip_session_expires_t * sip_session_expires_dup(su_home_t *home, sip_session_expires_t const *hdr))
Duplicate a list of Session-Expires header header structures sip_session_expires_t.
Definition sip_protos.h:12135
sip_session_expires_t * sip_session_expires_format(su_home_t *home, char const *fmt,...)))
Make a Session-Expires header from formatting result.
Definition sip_protos.h:12238
msg_hclass_t sip_status_class[]
Header class for status line.
Definition sip_basic.c:295
sip_status_t * sip_status_make(su_home_t *home, char const *s))
Make a status line structure sip_status_t.
Definition sip_protos.h:545
sip_status_t * sip_status_format(su_home_t *home, char const *fmt,...)))
Make a status line from formatting result.
Definition sip_protos.h:576
sip_status_t * sip_status_copy(su_home_t *home, sip_status_t const *hdr))
Copy a list of status line header structures sip_status_t.
Definition sip_protos.h:516
issize_t sip_status_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP status line.
int sip_is_status(sip_header_t const *header)
Test if header object is instance of sip_status_t.
Definition sip_protos.h:426
issize_t sip_status_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP status line.
@ sip_status_hash
@
Definition sip_hclasses.h:75
sip_status_t * sip_status_init(sip_status_t x[1])
Initialize a structure sip_status_t.
Definition sip_protos.h:404
sip_status_t * sip_status_dup(su_home_t *home, sip_status_t const *hdr))
Duplicate a list of status line header structures sip_status_t.
Definition sip_protos.h:473
sip_subject_t * sip_subject_init(sip_subject_t x[1])
Initialize a structure sip_subject_t.
Definition sip_protos.h:5402
sip_subject_t * sip_subject_copy(su_home_t *home, sip_subject_t const *hdr))
Copy a list of Subject header header structures sip_subject_t.
Definition sip_protos.h:5514
sip_subject_t * sip_subject_make(su_home_t *home, char const *s))
Make a Subject header structure sip_subject_t.
Definition sip_protos.h:5543
@ sip_subject_hash
@
Definition sip_hclasses.h:558
sip_subject_t * sip_subject_dup(su_home_t *home, sip_subject_t const *hdr))
Duplicate a list of Subject header header structures sip_subject_t.
Definition sip_protos.h:5471
issize_t sip_subject_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Subject header.
sip_subject_t * sip_subject_format(su_home_t *home, char const *fmt,...)))
Make a Subject header from formatting result.
Definition sip_protos.h:5574
msg_hclass_t sip_subject_class[]
Header class for Subject header.
Definition sip_extra.c:607
int sip_is_subject(sip_header_t const *header)
Test if header object is instance of sip_subject_t.
Definition sip_protos.h:5424
issize_t sip_subject_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Subject header.
sip_subscription_state_t * sip_subscription_state_dup(su_home_t *home, sip_subscription_state_t const *hdr))
Duplicate a list of Subscription-State header header structures sip_subscription_state_t.
Definition sip_protos.h:9279
issize_t sip_subscription_state_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Subscription-State header.
sip_subscription_state_t * sip_subscription_state_init(sip_subscription_state_t x[1])
Initialize a structure sip_subscription_state_t.
Definition sip_protos.h:9210
sip_subscription_state_t * sip_subscription_state_make(su_home_t *home, char const *s))
Make a Subscription-State header structure sip_subscription_state_t.
Definition sip_protos.h:9351
sip_subscription_state_t * sip_subscription_state_copy(su_home_t *home, sip_subscription_state_t const *hdr))
Copy a list of Subscription-State header header structures sip_subscription_state_t.
Definition sip_protos.h:9322
int sip_is_subscription_state(sip_header_t const *header)
Test if header object is instance of sip_subscription_state_t.
Definition sip_protos.h:9232
issize_t sip_subscription_state_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Subscription-State header.
sip_subscription_state_t * sip_subscription_state_format(su_home_t *home, char const *fmt,...)))
Make a Subscription-State header from formatting result.
Definition sip_protos.h:9382
@ sip_subscription_state_hash
@
Definition sip_hclasses.h:926
msg_hclass_t sip_subscription_state_class[]
Header class for Subscription-State header.
Definition sip_event.c:297
sip_supported_t * sip_supported_copy(su_home_t *home, sip_supported_t const *hdr))
Copy a list of Supported header header structures sip_supported_t.
Definition sip_protos.h:8370
@ sip_supported_hash
@
Definition sip_hclasses.h:834
issize_t sip_supported_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Supported header.
sip_supported_t * sip_supported_format(su_home_t *home, char const *fmt,...)))
Make a Supported header from formatting result.
Definition sip_protos.h:8430
sip_supported_t * sip_supported_make(su_home_t *home, char const *s))
Make a Supported header structure sip_supported_t.
Definition sip_protos.h:8399
sip_supported_t * sip_supported_dup(su_home_t *home, sip_supported_t const *hdr))
Duplicate a list of Supported header header structures sip_supported_t.
Definition sip_protos.h:8327
issize_t sip_supported_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Supported header.
sip_supported_t * sip_supported_init(sip_supported_t x[1])
Initialize a structure sip_supported_t.
Definition sip_protos.h:8258
msg_hclass_t sip_supported_class[]
Header class for Supported header.
Definition sip_feature.c:278
int sip_is_supported(sip_header_t const *header)
Test if header object is instance of sip_supported_t.
Definition sip_protos.h:8280
@ sip_timestamp_hash
@
Definition sip_hclasses.h:512
sip_timestamp_t * sip_timestamp_copy(su_home_t *home, sip_timestamp_t const *hdr))
Copy a list of Timestamp header header structures sip_timestamp_t.
Definition sip_protos.h:5038
sip_timestamp_t * sip_timestamp_make(su_home_t *home, char const *s))
Make a Timestamp header structure sip_timestamp_t.
Definition sip_protos.h:5067
sip_timestamp_t * sip_timestamp_format(su_home_t *home, char const *fmt,...)))
Make a Timestamp header from formatting result.
Definition sip_protos.h:5098
issize_t sip_timestamp_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Timestamp header.
msg_hclass_t sip_timestamp_class[]
Header class for Timestamp header.
Definition sip_extra.c:663
int sip_is_timestamp(sip_header_t const *header)
Test if header object is instance of sip_timestamp_t.
Definition sip_protos.h:4948
sip_timestamp_t * sip_timestamp_dup(su_home_t *home, sip_timestamp_t const *hdr))
Duplicate a list of Timestamp header header structures sip_timestamp_t.
Definition sip_protos.h:4995
issize_t sip_timestamp_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Timestamp header.
sip_timestamp_t * sip_timestamp_init(sip_timestamp_t x[1])
Initialize a structure sip_timestamp_t.
Definition sip_protos.h:4926
issize_t sip_to_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP To header.
sip_to_t * sip_to_make(su_home_t *home, char const *s))
Make a To header structure sip_to_t.
Definition sip_protos.h:2211
issize_t sip_to_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP To header.
sip_to_t * sip_to_dup(su_home_t *home, sip_to_t const *hdr))
Duplicate a list of To header header structures sip_to_t.
Definition sip_protos.h:2139
sip_to_t * sip_to_format(su_home_t *home, char const *fmt,...)))
Make a To header from formatting result.
Definition sip_protos.h:2242
int sip_is_to(sip_header_t const *header)
Test if header object is instance of sip_to_t.
Definition sip_protos.h:2092
msg_hclass_t sip_to_class[]
Header class for To header.
Definition sip_basic.c:2400
@ sip_to_hash
@
Definition sip_hclasses.h:236
sip_to_t * sip_to_copy(su_home_t *home, sip_to_t const *hdr))
Copy a list of To header header structures sip_to_t.
Definition sip_protos.h:2182
sip_to_t * sip_to_init(sip_to_t x[1])
Initialize a structure sip_to_t.
Definition sip_protos.h:2070
issize_t sip_unknown_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP unknown headers.
msg_hclass_t sip_unknown_class[]
Header class for unknown headers.
Definition sip_basic.c:559
sip_unknown_t * sip_unknown_format(su_home_t *home, char const *fmt,...)))
Make a unknown headers from formatting result.
Definition sip_protos.h:16284
sip_unknown_t * sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr))
Copy a list of unknown headers header structures sip_unknown_t.
Definition sip_protos.h:16224
sip_unknown_t * sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr))
Duplicate a list of unknown headers header structures sip_unknown_t.
Definition sip_protos.h:16181
sip_unknown_t * sip_unknown_init(sip_unknown_t x[1])
Initialize a structure sip_unknown_t.
Definition sip_protos.h:16112
@ sip_unknown_hash
@
Definition sip_hclasses.h:1593
int sip_is_unknown(sip_header_t const *header)
Test if header object is instance of sip_unknown_t.
Definition sip_protos.h:16134
sip_unknown_t * sip_unknown_make(su_home_t *home, char const *s))
Make a unknown headers structure sip_unknown_t.
Definition sip_protos.h:16253
issize_t sip_unknown_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP unknown headers.
msg_hclass_t sip_unsupported_class[]
Header class for Unsupported header.
Definition sip_feature.c:325
int sip_is_unsupported(sip_header_t const *header)
Test if header object is instance of sip_unsupported_t.
Definition sip_protos.h:8518
@ sip_unsupported_hash
@
Definition sip_hclasses.h:857
sip_unsupported_t * sip_unsupported_make(su_home_t *home, char const *s))
Make a Unsupported header structure sip_unsupported_t.
Definition sip_protos.h:8637
sip_unsupported_t * sip_unsupported_dup(su_home_t *home, sip_unsupported_t const *hdr))
Duplicate a list of Unsupported header header structures sip_unsupported_t.
Definition sip_protos.h:8565
sip_unsupported_t * sip_unsupported_copy(su_home_t *home, sip_unsupported_t const *hdr))
Copy a list of Unsupported header header structures sip_unsupported_t.
Definition sip_protos.h:8608
sip_unsupported_t * sip_unsupported_format(su_home_t *home, char const *fmt,...)))
Make a Unsupported header from formatting result.
Definition sip_protos.h:8668
issize_t sip_unsupported_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Unsupported header.
sip_unsupported_t * sip_unsupported_init(sip_unsupported_t x[1])
Initialize a structure sip_unsupported_t.
Definition sip_protos.h:8496
issize_t sip_unsupported_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Unsupported header.
sip_user_agent_t * sip_user_agent_format(su_home_t *home, char const *fmt,...)))
Make a User-Agent header from formatting result.
Definition sip_protos.h:6764
sip_user_agent_t * sip_user_agent_init(sip_user_agent_t x[1])
Initialize a structure sip_user_agent_t.
Definition sip_protos.h:6592
sip_user_agent_t * sip_user_agent_make(su_home_t *home, char const *s))
Make a User-Agent header structure sip_user_agent_t.
Definition sip_protos.h:6733
@ sip_user_agent_hash
@
Definition sip_hclasses.h:673
issize_t sip_user_agent_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP User-Agent header.
issize_t sip_user_agent_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP User-Agent header.
msg_hclass_t sip_user_agent_class[]
Header class for User-Agent header.
Definition sip_extra.c:774
sip_user_agent_t * sip_user_agent_dup(su_home_t *home, sip_user_agent_t const *hdr))
Duplicate a list of User-Agent header header structures sip_user_agent_t.
Definition sip_protos.h:6661
int sip_is_user_agent(sip_header_t const *header)
Test if header object is instance of sip_user_agent_t.
Definition sip_protos.h:6614
sip_user_agent_t * sip_user_agent_copy(su_home_t *home, sip_user_agent_t const *hdr))
Copy a list of User-Agent header header structures sip_user_agent_t.
Definition sip_protos.h:6704
sip_via_t * sip_via_copy(su_home_t *home, sip_via_t const *hdr))
Copy a list of Via header header structures sip_via_t.
Definition sip_protos.h:754
sip_via_t * sip_via_make(su_home_t *home, char const *s))
Make a Via header structure sip_via_t.
Definition sip_protos.h:783
sip_via_t * sip_via_init(sip_via_t x[1])
Initialize a structure sip_via_t.
Definition sip_protos.h:642
sip_via_t * sip_via_dup(su_home_t *home, sip_via_t const *hdr))
Duplicate a list of Via header header structures sip_via_t.
Definition sip_protos.h:711
issize_t sip_via_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Via header.
msg_hclass_t sip_via_class[]
Header class for Via header.
Definition sip_basic.c:2532
int sip_is_via(sip_header_t const *header)
Test if header object is instance of sip_via_t.
Definition sip_protos.h:664
issize_t sip_via_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Via header.
@ sip_via_hash
@
Definition sip_hclasses.h:98
sip_via_t * sip_via_format(su_home_t *home, char const *fmt,...)))
Make a Via header from formatting result.
Definition sip_protos.h:814
sip_warning_t * sip_warning_make(su_home_t *home, char const *s))
Make a Warning header structure sip_warning_t.
Definition sip_protos.h:11255
sip_warning_t * sip_warning_copy(su_home_t *home, sip_warning_t const *hdr))
Copy a list of Warning header header structures sip_warning_t.
Definition sip_protos.h:11226
sip_warning_t * sip_warning_format(su_home_t *home, char const *fmt,...)))
Make a Warning header from formatting result.
Definition sip_protos.h:11286
sip_warning_t * sip_warning_dup(su_home_t *home, sip_warning_t const *hdr))
Duplicate a list of Warning header header structures sip_warning_t.
Definition sip_protos.h:11183
int sip_is_warning(sip_header_t const *header)
Test if header object is instance of sip_warning_t.
Definition sip_protos.h:11136
sip_warning_t * sip_warning_init(sip_warning_t x[1])
Initialize a structure sip_warning_t.
Definition sip_protos.h:11114
@ sip_warning_hash
@
Definition sip_hclasses.h:1110
msg_hclass_t sip_warning_class[]
Header class for Warning header.
Definition sip_mime.c:672
issize_t sip_warning_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP Warning header.
issize_t sip_warning_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP Warning header.
int sip_is_www_authenticate(sip_header_t const *header)
Test if header object is instance of sip_www_authenticate_t.
Definition sip_protos.h:10422
sip_www_authenticate_t * sip_www_authenticate_init(sip_www_authenticate_t x[1])
Initialize a structure sip_www_authenticate_t.
Definition sip_protos.h:10400
sip_www_authenticate_t * sip_www_authenticate_copy(su_home_t *home, sip_www_authenticate_t const *hdr))
Copy a list of WWW-Authenticate header header structures sip_www_authenticate_t.
Definition sip_protos.h:10512
sip_www_authenticate_t * sip_www_authenticate_format(su_home_t *home, char const *fmt,...)))
Make a WWW-Authenticate header from formatting result.
Definition sip_protos.h:10572
issize_t sip_www_authenticate_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP WWW-Authenticate header.
sip_www_authenticate_t * sip_www_authenticate_dup(su_home_t *home, sip_www_authenticate_t const *hdr))
Duplicate a list of WWW-Authenticate header header structures sip_www_authenticate_t.
Definition sip_protos.h:10469
sip_www_authenticate_t * sip_www_authenticate_make(su_home_t *home, char const *s))
Make a WWW-Authenticate header structure sip_www_authenticate_t.
Definition sip_protos.h:10541
issize_t sip_www_authenticate_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP WWW-Authenticate header.
msg_hclass_t sip_www_authenticate_class[]
Header class for WWW-Authenticate header.
Definition sip_security.c:311
@ sip_www_authenticate_hash
@
Definition sip_hclasses.h:1041
msg_pub_t * msg_public(msg_t const *msg, void *tag)
int msg_header_insert(msg_t *msg, msg_pub_t *mo, msg_header_t *h)
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
int msg_header_remove(msg_t *msg, msg_pub_t *mo, msg_header_t *h)
msg_header_t * msg_header_dup_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
MSG_HDR_T msg_header_t
MSG_PUB_T msg_pub_t
#define SIP_NONE
Magic pointer value - never valid for SIP headers.
Definition sip.h:84
#define SIP_PROTOCOL_TAG
SIP protocol identifier.
Definition sip.h:87
union sip_header_u sip_header_t
Any SIP header - union of all possible SIP headers.
Definition sip.h:114
Declarations of SIP header classes.
SIP parser library prototypes.
#define SIP_HEADER_INIT(h, sip_class, size)
Initialize a SIP header structure.
Definition sip_header.h:73
int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h)
Insert a (list of) header(s) to the header structure and fragment chain.
Definition sip_protos.h:79
int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h)
Remove a header from a SIP message.
Definition sip_protos.h:86
void * sip_header_data(sip_header_t *h)
Return data after header structure.
Definition sip_protos.h:103
char const * sip_header_name(sip_header_t const *h, int compact)
Return name of the header.
Definition sip_protos.h:93
sip_t * sip_object(msg_t const *msg)
Get SIP structure from msg.
Definition sip_protos.h:55
Structure for Accept header field.
Definition sip.h:400
Structure for From and To headers.
Definition sip.h:382
Structure for Allow header field.
Definition sip.h:415
Structure for Call-ID (and In-Reply-To) header fields.
Definition sip.h:438
Structure for Call-Info header.
Definition sip.h:449
Structure for Accept-Contact and Reject-Contact header fields.
Definition sip.h:655
Structure for Contact header field.
Definition sip.h:473
Structure for Content-Length header.
Definition sip.h:489
Structure for CSeq header.
Definition sip.h:461
Structure for Date header.
Definition sip.h:514
Structure for Error-Info header.
Definition sip.h:524
Structure for Event header.
Definition sip.h:535
Structure for Expires header.
Definition sip.h:547
Structure for Max-Forwards header.
Definition sip.h:559
Structure for Min-Expires header.
Definition sip.h:569
Structure for Min-SE header.
Definition sip.h:716
Structure for Privacy header.
Definition sip.h:790
Structure for RAck header.
Definition sip.h:579
Structure for Reason header field.
Definition sip.h:668
Structure for Refer-To header.
Definition sip.h:592
Structure for Referred-By header.
Definition sip.h:604
Structure for Replaces header.
Definition sip.h:618
Structure for Request-Disposition header.
Definition sip.h:645
Structure for SIP request line.
Definition sip.h:357
Structure for Retry-After header.
Definition sip.h:632
Structure for Route and Record-Route header fields.
Definition sip.h:681
Structure for RSeq header.
Definition sip.h:693
SIP message object.
Definition sip.h:230
Structure for Security-Client, Security-Server, and Security-Verify headers.
Definition sip.h:774
Structure for Session-Expires header.
Definition sip.h:703
Structure for SIP status line.
Definition sip.h:370
Structure for Subscription-State header.
Definition sip.h:727
Structure for Timestamp header.
Definition sip.h:742
Structure for Via header field.
Definition sip.h:753
SU_HOME_T su_home_t
#define SOFIAPUBFUN
#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.