sip  1.12.11devel
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
43 #include <sofia-sip/sip_header.h>
44 #endif
45 
46 #ifndef SIP_HCLASSES_H
47 #include <sofia-sip/sip_hclasses.h>
48 #endif
49 
50 SOFIA_BEGIN_DECLS
51 
52 #if SU_HAVE_INLINE
55 sip_t *sip_object(msg_t const *msg)
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 
93 char 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 
102 su_inline
104 {
105  return h && h != SIP_NONE ? h->sh_class->hc_size + (char *)h : NULL;
106 }
107 #else
108 sip_t *sip_object(msg_t *msg);
109 int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h);
110 int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h);
111 char const *sip_header_name(sip_header_t const *h, int compact);
112 void *sip_header_data(sip_header_t *h);
113 #endif
114 
121  char *s, isize_t slen);
122 
124 SOFIAPUBFUN 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
167 {
168  return SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t));
169 }
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
193 int 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
228 su_inline
229 #endif
231  __attribute__((__malloc__));
232 
233 #if SU_HAVE_INLINE
234 su_inline
236 {
237  return (sip_request_t *)
238  msg_header_dup_as(home, sip_request_class, (msg_header_t const *)hdr);
239 }
240 #endif
241 
270 #if SU_HAVE_INLINE
271 su_inline
272 #endif
274  __attribute__((__malloc__));
275 
276 #if SU_HAVE_INLINE
277 su_inline
279 {
280  return (sip_request_t *)
282 }
283 #endif
284 
300 #if SU_HAVE_INLINE
301 su_inline
302 #endif
303 sip_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
332 su_inline
333 #endif
334 sip_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 
362 SOFIAPUBFUN 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
405 {
406  return SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t));
407 }
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
431 int 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
466 su_inline
467 #endif
469  __attribute__((__malloc__));
470 
471 #if SU_HAVE_INLINE
472 su_inline
474 {
475  return (sip_status_t *)
476  msg_header_dup_as(home, sip_status_class, (msg_header_t const *)hdr);
477 }
478 #endif
479 
508 #if SU_HAVE_INLINE
509 su_inline
510 #endif
512  __attribute__((__malloc__));
513 
514 #if SU_HAVE_INLINE
515 su_inline
517 {
518  return (sip_status_t *)
519  msg_header_copy_as(home, sip_status_class, (msg_header_t const *)hdr);
520 }
521 #endif
522 
538 #if SU_HAVE_INLINE
539 su_inline
540 #endif
541 sip_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
570 su_inline
571 #endif
572 sip_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
576 su_inline sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
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 
600 SOFIAPUBFUN 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
643 {
644  return SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t));
645 }
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
669 int 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
704 su_inline
705 #endif
706 sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
707  __attribute__((__malloc__));
708 
709 #if SU_HAVE_INLINE
710 su_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
747 su_inline
748 #endif
749 sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
750  __attribute__((__malloc__));
751 
752 #if SU_HAVE_INLINE
753 su_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
777 su_inline
778 #endif
779 sip_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
808 su_inline
809 #endif
810 sip_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
814 su_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 
838 SOFIAPUBFUN 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
881 {
882  return SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t));
883 }
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
907 int 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
942 su_inline
943 #endif
945  __attribute__((__malloc__));
946 
947 #if SU_HAVE_INLINE
948 su_inline
950 {
951  return (sip_route_t *)
952  msg_header_dup_as(home, sip_route_class, (msg_header_t const *)hdr);
953 }
954 #endif
955 
984 #if SU_HAVE_INLINE
985 su_inline
986 #endif
988  __attribute__((__malloc__));
989 
990 #if SU_HAVE_INLINE
991 su_inline
993 {
994  return (sip_route_t *)
995  msg_header_copy_as(home, sip_route_class, (msg_header_t const *)hdr);
996 }
997 #endif
998 
1014 #if SU_HAVE_INLINE
1015 su_inline
1016 #endif
1017 sip_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
1046 su_inline
1047 #endif
1048 sip_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
1052 su_inline sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
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 
1076 SOFIAPUBFUN 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
1119 {
1121 }
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
1145 int 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
1180 su_inline
1181 #endif
1183  __attribute__((__malloc__));
1184 
1185 #if SU_HAVE_INLINE
1186 su_inline
1188 {
1189  return (sip_record_route_t *)
1191 }
1192 #endif
1193 
1222 #if SU_HAVE_INLINE
1223 su_inline
1224 #endif
1226  __attribute__((__malloc__));
1227 
1228 #if SU_HAVE_INLINE
1229 su_inline
1231 {
1232  return (sip_record_route_t *)
1234 }
1235 #endif
1236 
1252 #if SU_HAVE_INLINE
1253 su_inline
1254 #endif
1255 sip_record_route_t *sip_record_route_make(su_home_t *home, char const *s)
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
1284 su_inline
1285 #endif
1286 sip_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 
1314 SOFIAPUBFUN 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
1357 {
1359 }
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
1383 int 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
1418 su_inline
1419 #endif
1421  __attribute__((__malloc__));
1422 
1423 #if SU_HAVE_INLINE
1424 su_inline
1426 {
1427  return (sip_max_forwards_t *)
1429 }
1430 #endif
1431 
1460 #if SU_HAVE_INLINE
1461 su_inline
1462 #endif
1464  __attribute__((__malloc__));
1465 
1466 #if SU_HAVE_INLINE
1467 su_inline
1469 {
1470  return (sip_max_forwards_t *)
1472 }
1473 #endif
1474 
1490 #if SU_HAVE_INLINE
1491 su_inline
1492 #endif
1493 sip_max_forwards_t *sip_max_forwards_make(su_home_t *home, char const *s)
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
1522 su_inline
1523 #endif
1524 sip_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 
1552 SOFIAPUBFUN 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
1595 {
1597 }
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
1621 int 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
1656 su_inline
1657 #endif
1659  __attribute__((__malloc__));
1660 
1661 #if SU_HAVE_INLINE
1662 su_inline
1664 {
1665  return (sip_proxy_require_t *)
1667 }
1668 #endif
1669 
1698 #if SU_HAVE_INLINE
1699 su_inline
1700 #endif
1702  __attribute__((__malloc__));
1703 
1704 #if SU_HAVE_INLINE
1705 su_inline
1707 {
1708  return (sip_proxy_require_t *)
1710 }
1711 #endif
1712 
1728 #if SU_HAVE_INLINE
1729 su_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
1760 su_inline
1761 #endif
1762 sip_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 
1790 SOFIAPUBFUN 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
1833 {
1834  return SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t));
1835 }
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
1859 int 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
1894 su_inline
1895 #endif
1896 sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
1897  __attribute__((__malloc__));
1898 
1899 #if SU_HAVE_INLINE
1900 su_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
1937 su_inline
1938 #endif
1939 sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
1940  __attribute__((__malloc__));
1941 
1942 #if SU_HAVE_INLINE
1943 su_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
1967 su_inline
1968 #endif
1969 sip_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
1998 su_inline
1999 #endif
2000 sip_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
2004 su_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 
2028 SOFIAPUBFUN 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
2097 int 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
2132 su_inline
2133 #endif
2134 sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
2135  __attribute__((__malloc__));
2136 
2137 #if SU_HAVE_INLINE
2138 su_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
2175 su_inline
2176 #endif
2177 sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
2178  __attribute__((__malloc__));
2179 
2180 #if SU_HAVE_INLINE
2181 su_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
2205 su_inline
2206 #endif
2207 sip_to_t *sip_to_make(su_home_t *home, char const *s)
2208  __attribute__((__malloc__));
2209 
2210 #if SU_HAVE_INLINE
2211 su_inline sip_to_t *sip_to_make(su_home_t *home, char const *s)
2212 {
2213  return (sip_to_t *)sip_header_make(home, sip_to_class, s);
2214 }
2215 #endif
2216 
2235 #if SU_HAVE_INLINE
2236 su_inline
2237 #endif
2238 sip_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
2242 su_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 
2266 SOFIAPUBFUN 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
2309 {
2310  return SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t));
2311 }
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
2335 int 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
2370 su_inline
2371 #endif
2373  __attribute__((__malloc__));
2374 
2375 #if SU_HAVE_INLINE
2376 su_inline
2378 {
2379  return (sip_call_id_t *)
2380  msg_header_dup_as(home, sip_call_id_class, (msg_header_t const *)hdr);
2381 }
2382 #endif
2383 
2412 #if SU_HAVE_INLINE
2413 su_inline
2414 #endif
2416  __attribute__((__malloc__));
2417 
2418 #if SU_HAVE_INLINE
2419 su_inline
2421 {
2422  return (sip_call_id_t *)
2423  msg_header_copy_as(home, sip_call_id_class, (msg_header_t const *)hdr);
2424 }
2425 #endif
2426 
2442 #if SU_HAVE_INLINE
2443 su_inline
2444 #endif
2445 sip_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
2474 su_inline
2475 #endif
2476 sip_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 
2504 SOFIAPUBFUN 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
2547 {
2548  return SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t));
2549 }
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
2573 int 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
2608 su_inline
2609 #endif
2610 sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
2611  __attribute__((__malloc__));
2612 
2613 #if SU_HAVE_INLINE
2614 su_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
2651 su_inline
2652 #endif
2653 sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
2654  __attribute__((__malloc__));
2655 
2656 #if SU_HAVE_INLINE
2657 su_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
2681 su_inline
2682 #endif
2683 sip_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
2712 su_inline
2713 #endif
2714 sip_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
2718 su_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 
2742 SOFIAPUBFUN 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
2785 {
2786  return SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t));
2787 }
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
2811 int 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
2846 su_inline
2847 #endif
2849  __attribute__((__malloc__));
2850 
2851 #if SU_HAVE_INLINE
2852 su_inline
2854 {
2855  return (sip_contact_t *)
2856  msg_header_dup_as(home, sip_contact_class, (msg_header_t const *)hdr);
2857 }
2858 #endif
2859 
2888 #if SU_HAVE_INLINE
2889 su_inline
2890 #endif
2892  __attribute__((__malloc__));
2893 
2894 #if SU_HAVE_INLINE
2895 su_inline
2897 {
2898  return (sip_contact_t *)
2899  msg_header_copy_as(home, sip_contact_class, (msg_header_t const *)hdr);
2900 }
2901 #endif
2902 
2918 #if SU_HAVE_INLINE
2919 su_inline
2920 #endif
2921 sip_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
2950 su_inline
2951 #endif
2952 sip_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 
2980 SOFIAPUBFUN 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
3023 {
3024  return SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t));
3025 }
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
3049 int 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
3084 su_inline
3085 #endif
3086 sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
3087  __attribute__((__malloc__));
3088 
3089 #if SU_HAVE_INLINE
3090 su_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
3127 su_inline
3128 #endif
3129 sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
3130  __attribute__((__malloc__));
3131 
3132 #if SU_HAVE_INLINE
3133 su_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
3157 su_inline
3158 #endif
3159 sip_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
3188 su_inline
3189 #endif
3190 sip_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
3194 su_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 
3218 SOFIAPUBFUN 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
3261 {
3262  return SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t));
3263 }
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
3287 int 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
3322 su_inline
3323 #endif
3324 sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
3325  __attribute__((__malloc__));
3326 
3327 #if SU_HAVE_INLINE
3328 su_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
3365 su_inline
3366 #endif
3367 sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
3368  __attribute__((__malloc__));
3369 
3370 #if SU_HAVE_INLINE
3371 su_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
3395 su_inline
3396 #endif
3397 sip_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
3426 su_inline
3427 #endif
3428 sip_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
3432 su_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 
3456 SOFIAPUBFUN 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
3499 {
3501 }
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
3525 int 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
3560 su_inline
3561 #endif
3563  __attribute__((__malloc__));
3564 
3565 #if SU_HAVE_INLINE
3566 su_inline
3568 {
3569  return (sip_request_disposition_t *)
3571 }
3572 #endif
3573 
3602 #if SU_HAVE_INLINE
3603 su_inline
3604 #endif
3606  __attribute__((__malloc__));
3607 
3608 #if SU_HAVE_INLINE
3609 su_inline
3611 {
3612  return (sip_request_disposition_t *)
3614 }
3615 #endif
3616 
3632 #if SU_HAVE_INLINE
3633 su_inline
3634 #endif
3636  __attribute__((__malloc__));
3637 
3638 #if SU_HAVE_INLINE
3640 {
3641  return (sip_request_disposition_t *)sip_header_make(home, sip_request_disposition_class, s);
3642 }
3643 #endif
3644 
3663 #if SU_HAVE_INLINE
3664 su_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 
3694 SOFIAPUBFUN 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
3737 {
3739 }
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
3763 int 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
3798 su_inline
3799 #endif
3801  __attribute__((__malloc__));
3802 
3803 #if SU_HAVE_INLINE
3804 su_inline
3806 {
3807  return (sip_accept_contact_t *)
3809 }
3810 #endif
3811 
3840 #if SU_HAVE_INLINE
3841 su_inline
3842 #endif
3844  __attribute__((__malloc__));
3845 
3846 #if SU_HAVE_INLINE
3847 su_inline
3849 {
3850  return (sip_accept_contact_t *)
3852 }
3853 #endif
3854 
3870 #if SU_HAVE_INLINE
3871 su_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
3902 su_inline
3903 #endif
3904 sip_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 
3932 SOFIAPUBFUN 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
3975 {
3977 }
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
4001 int 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
4036 su_inline
4037 #endif
4039  __attribute__((__malloc__));
4040 
4041 #if SU_HAVE_INLINE
4042 su_inline
4044 {
4045  return (sip_reject_contact_t *)
4047 }
4048 #endif
4049 
4078 #if SU_HAVE_INLINE
4079 su_inline
4080 #endif
4082  __attribute__((__malloc__));
4083 
4084 #if SU_HAVE_INLINE
4085 su_inline
4087 {
4088  return (sip_reject_contact_t *)
4090 }
4091 #endif
4092 
4108 #if SU_HAVE_INLINE
4109 su_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
4140 su_inline
4141 #endif
4142 sip_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 
4170 SOFIAPUBFUN 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
4213 {
4214  return SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t));
4215 }
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
4239 int 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
4274 su_inline
4275 #endif
4277  __attribute__((__malloc__));
4278 
4279 #if SU_HAVE_INLINE
4280 su_inline
4282 {
4283  return (sip_expires_t *)
4284  msg_header_dup_as(home, sip_expires_class, (msg_header_t const *)hdr);
4285 }
4286 #endif
4287 
4316 #if SU_HAVE_INLINE
4317 su_inline
4318 #endif
4320  __attribute__((__malloc__));
4321 
4322 #if SU_HAVE_INLINE
4323 su_inline
4325 {
4326  return (sip_expires_t *)
4327  msg_header_copy_as(home, sip_expires_class, (msg_header_t const *)hdr);
4328 }
4329 #endif
4330 
4346 #if SU_HAVE_INLINE
4347 su_inline
4348 #endif
4349 sip_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
4378 su_inline
4379 #endif
4380 sip_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 
4408 SOFIAPUBFUN 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
4451 {
4452  return SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t));
4453 }
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
4477 int 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
4512 su_inline
4513 #endif
4514 sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
4515  __attribute__((__malloc__));
4516 
4517 #if SU_HAVE_INLINE
4518 su_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
4555 su_inline
4556 #endif
4557 sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
4558  __attribute__((__malloc__));
4559 
4560 #if SU_HAVE_INLINE
4561 su_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
4585 su_inline
4586 #endif
4587 sip_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
4616 su_inline
4617 #endif
4618 sip_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
4622 su_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 
4646 SOFIAPUBFUN 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
4689 {
4691 }
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
4715 int 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
4750 su_inline
4751 #endif
4753  __attribute__((__malloc__));
4754 
4755 #if SU_HAVE_INLINE
4756 su_inline
4758 {
4759  return (sip_retry_after_t *)
4761 }
4762 #endif
4763 
4792 #if SU_HAVE_INLINE
4793 su_inline
4794 #endif
4796  __attribute__((__malloc__));
4797 
4798 #if SU_HAVE_INLINE
4799 su_inline
4801 {
4802  return (sip_retry_after_t *)
4804 }
4805 #endif
4806 
4822 #if SU_HAVE_INLINE
4823 su_inline
4824 #endif
4825 sip_retry_after_t *sip_retry_after_make(su_home_t *home, char const *s)
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
4854 su_inline
4855 #endif
4856 sip_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 
4884 SOFIAPUBFUN 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
4927 {
4929 }
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
4953 int 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
4988 su_inline
4989 #endif
4991  __attribute__((__malloc__));
4992 
4993 #if SU_HAVE_INLINE
4994 su_inline
4996 {
4997  return (sip_timestamp_t *)
4998  msg_header_dup_as(home, sip_timestamp_class, (msg_header_t const *)hdr);
4999 }
5000 #endif
5001 
5030 #if SU_HAVE_INLINE
5031 su_inline
5032 #endif
5034  __attribute__((__malloc__));
5035 
5036 #if SU_HAVE_INLINE
5037 su_inline
5039 {
5040  return (sip_timestamp_t *)
5042 }
5043 #endif
5044 
5060 #if SU_HAVE_INLINE
5061 su_inline
5062 #endif
5063 sip_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
5092 su_inline
5093 #endif
5094 sip_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 
5122 SOFIAPUBFUN 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
5165 {
5167 }
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
5191 int 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
5226 su_inline
5227 #endif
5229  __attribute__((__malloc__));
5230 
5231 #if SU_HAVE_INLINE
5232 su_inline
5234 {
5235  return (sip_min_expires_t *)
5237 }
5238 #endif
5239 
5268 #if SU_HAVE_INLINE
5269 su_inline
5270 #endif
5272  __attribute__((__malloc__));
5273 
5274 #if SU_HAVE_INLINE
5275 su_inline
5277 {
5278  return (sip_min_expires_t *)
5280 }
5281 #endif
5282 
5298 #if SU_HAVE_INLINE
5299 su_inline
5300 #endif
5301 sip_min_expires_t *sip_min_expires_make(su_home_t *home, char const *s)
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
5330 su_inline
5331 #endif
5332 sip_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 
5360 SOFIAPUBFUN 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
5403 {
5404  return SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t));
5405 }
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
5429 int 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
5464 su_inline
5465 #endif
5467  __attribute__((__malloc__));
5468 
5469 #if SU_HAVE_INLINE
5470 su_inline
5472 {
5473  return (sip_subject_t *)
5474  msg_header_dup_as(home, sip_subject_class, (msg_header_t const *)hdr);
5475 }
5476 #endif
5477 
5506 #if SU_HAVE_INLINE
5507 su_inline
5508 #endif
5510  __attribute__((__malloc__));
5511 
5512 #if SU_HAVE_INLINE
5513 su_inline
5515 {
5516  return (sip_subject_t *)
5517  msg_header_copy_as(home, sip_subject_class, (msg_header_t const *)hdr);
5518 }
5519 #endif
5520 
5536 #if SU_HAVE_INLINE
5537 su_inline
5538 #endif
5539 sip_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
5568 su_inline
5569 #endif
5570 sip_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 
5598 SOFIAPUBFUN 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
5641 {
5643 }
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
5667 int 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
5702 su_inline
5703 #endif
5705  __attribute__((__malloc__));
5706 
5707 #if SU_HAVE_INLINE
5708 su_inline
5710 {
5711  return (sip_priority_t *)
5712  msg_header_dup_as(home, sip_priority_class, (msg_header_t const *)hdr);
5713 }
5714 #endif
5715 
5744 #if SU_HAVE_INLINE
5745 su_inline
5746 #endif
5748  __attribute__((__malloc__));
5749 
5750 #if SU_HAVE_INLINE
5751 su_inline
5753 {
5754  return (sip_priority_t *)
5755  msg_header_copy_as(home, sip_priority_class, (msg_header_t const *)hdr);
5756 }
5757 #endif
5758 
5774 #if SU_HAVE_INLINE
5775 su_inline
5776 #endif
5777 sip_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
5806 su_inline
5807 #endif
5808 sip_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 
5836 SOFIAPUBFUN 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
5879 {
5881 }
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
5905 int 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
5940 su_inline
5941 #endif
5943  __attribute__((__malloc__));
5944 
5945 #if SU_HAVE_INLINE
5946 su_inline
5948 {
5949  return (sip_call_info_t *)
5950  msg_header_dup_as(home, sip_call_info_class, (msg_header_t const *)hdr);
5951 }
5952 #endif
5953 
5982 #if SU_HAVE_INLINE
5983 su_inline
5984 #endif
5986  __attribute__((__malloc__));
5987 
5988 #if SU_HAVE_INLINE
5989 su_inline
5991 {
5992  return (sip_call_info_t *)
5994 }
5995 #endif
5996 
6012 #if SU_HAVE_INLINE
6013 su_inline
6014 #endif
6015 sip_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
6044 su_inline
6045 #endif
6046 sip_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 
6074 SOFIAPUBFUN 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
6117 {
6119 }
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
6143 int 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
6178 su_inline
6179 #endif
6181  __attribute__((__malloc__));
6182 
6183 #if SU_HAVE_INLINE
6184 su_inline
6186 {
6187  return (sip_organization_t *)
6189 }
6190 #endif
6191 
6220 #if SU_HAVE_INLINE
6221 su_inline
6222 #endif
6224  __attribute__((__malloc__));
6225 
6226 #if SU_HAVE_INLINE
6227 su_inline
6229 {
6230  return (sip_organization_t *)
6232 }
6233 #endif
6234 
6250 #if SU_HAVE_INLINE
6251 su_inline
6252 #endif
6253 sip_organization_t *sip_organization_make(su_home_t *home, char const *s)
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
6282 su_inline
6283 #endif
6284 sip_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 
6312 SOFIAPUBFUN 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
6355 {
6356  return SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t));
6357 }
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
6381 int 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
6416 su_inline
6417 #endif
6419  __attribute__((__malloc__));
6420 
6421 #if SU_HAVE_INLINE
6422 su_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
6459 su_inline
6460 #endif
6462  __attribute__((__malloc__));
6463 
6464 #if SU_HAVE_INLINE
6465 su_inline
6467 {
6468  return (sip_server_t *)
6469  msg_header_copy_as(home, sip_server_class, (msg_header_t const *)hdr);
6470 }
6471 #endif
6472 
6488 #if SU_HAVE_INLINE
6489 su_inline
6490 #endif
6491 sip_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
6520 su_inline
6521 #endif
6522 sip_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
6526 su_inline sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
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 
6550 SOFIAPUBFUN 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
6593 {
6595 }
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
6619 int 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
6654 su_inline
6655 #endif
6657  __attribute__((__malloc__));
6658 
6659 #if SU_HAVE_INLINE
6660 su_inline
6662 {
6663  return (sip_user_agent_t *)
6665 }
6666 #endif
6667 
6696 #if SU_HAVE_INLINE
6697 su_inline
6698 #endif
6700  __attribute__((__malloc__));
6701 
6702 #if SU_HAVE_INLINE
6703 su_inline
6705 {
6706  return (sip_user_agent_t *)
6708 }
6709 #endif
6710 
6726 #if SU_HAVE_INLINE
6727 su_inline
6728 #endif
6729 sip_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
6758 su_inline
6759 #endif
6760 sip_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 
6788 SOFIAPUBFUN 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
6831 {
6833 }
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
6857 int 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
6892 su_inline
6893 #endif
6895  __attribute__((__malloc__));
6896 
6897 #if SU_HAVE_INLINE
6898 su_inline
6900 {
6901  return (sip_in_reply_to_t *)
6903 }
6904 #endif
6905 
6934 #if SU_HAVE_INLINE
6935 su_inline
6936 #endif
6938  __attribute__((__malloc__));
6939 
6940 #if SU_HAVE_INLINE
6941 su_inline
6943 {
6944  return (sip_in_reply_to_t *)
6946 }
6947 #endif
6948 
6964 #if SU_HAVE_INLINE
6965 su_inline
6966 #endif
6967 sip_in_reply_to_t *sip_in_reply_to_make(su_home_t *home, char const *s)
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
6996 su_inline
6997 #endif
6998 sip_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 
7026 SOFIAPUBFUN 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
7069 {
7070  return SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t));
7071 }
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
7095 int 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
7130 su_inline
7131 #endif
7133  __attribute__((__malloc__));
7134 
7135 #if SU_HAVE_INLINE
7136 su_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
7173 su_inline
7174 #endif
7176  __attribute__((__malloc__));
7177 
7178 #if SU_HAVE_INLINE
7179 su_inline
7181 {
7182  return (sip_accept_t *)
7183  msg_header_copy_as(home, sip_accept_class, (msg_header_t const *)hdr);
7184 }
7185 #endif
7186 
7202 #if SU_HAVE_INLINE
7203 su_inline
7204 #endif
7205 sip_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
7234 su_inline
7235 #endif
7236 sip_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
7240 su_inline sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
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 
7264 SOFIAPUBFUN 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
7307 {
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
7333 int 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
7368 su_inline
7369 #endif
7371  __attribute__((__malloc__));
7372 
7373 #if SU_HAVE_INLINE
7374 su_inline
7376 {
7377  return (sip_accept_encoding_t *)
7379 }
7380 #endif
7381 
7410 #if SU_HAVE_INLINE
7411 su_inline
7412 #endif
7414  __attribute__((__malloc__));
7415 
7416 #if SU_HAVE_INLINE
7417 su_inline
7419 {
7420  return (sip_accept_encoding_t *)
7422 }
7423 #endif
7424 
7440 #if SU_HAVE_INLINE
7441 su_inline
7442 #endif
7444  __attribute__((__malloc__));
7445 
7446 #if SU_HAVE_INLINE
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
7472 su_inline
7473 #endif
7474 sip_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
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 
7502 SOFIAPUBFUN 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
7545 {
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
7571 int 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
7606 su_inline
7607 #endif
7609  __attribute__((__malloc__));
7610 
7611 #if SU_HAVE_INLINE
7612 su_inline
7614 {
7615  return (sip_accept_language_t *)
7617 }
7618 #endif
7619 
7648 #if SU_HAVE_INLINE
7649 su_inline
7650 #endif
7652  __attribute__((__malloc__));
7653 
7654 #if SU_HAVE_INLINE
7655 su_inline
7657 {
7658  return (sip_accept_language_t *)
7660 }
7661 #endif
7662 
7678 #if SU_HAVE_INLINE
7679 su_inline
7680 #endif
7682  __attribute__((__malloc__));
7683 
7684 #if SU_HAVE_INLINE
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
7710 su_inline
7711 #endif
7712 sip_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
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 
7740 SOFIAPUBFUN 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
7783 {
7784  return SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t));
7785 }
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
7809 int 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
7844 su_inline
7845 #endif
7846 sip_allow_t *sip_allow_dup(su_home_t *home, sip_allow_t const *hdr)
7847  __attribute__((__malloc__));
7848 
7849 #if SU_HAVE_INLINE
7850 su_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
7887 su_inline
7888 #endif
7889 sip_allow_t *sip_allow_copy(su_home_t *home, sip_allow_t const *hdr)
7890  __attribute__((__malloc__));
7891 
7892 #if SU_HAVE_INLINE
7893 su_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
7917 su_inline
7918 #endif
7919 sip_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
7948 su_inline
7949 #endif
7950 sip_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
7954 su_inline sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
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 
7978 SOFIAPUBFUN 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
8021 {
8022  return SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t));
8023 }
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
8047 int 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
8082 su_inline
8083 #endif
8085  __attribute__((__malloc__));
8086 
8087 #if SU_HAVE_INLINE
8088 su_inline
8090 {
8091  return (sip_require_t *)
8092  msg_header_dup_as(home, sip_require_class, (msg_header_t const *)hdr);
8093 }
8094 #endif
8095 
8124 #if SU_HAVE_INLINE
8125 su_inline
8126 #endif
8128  __attribute__((__malloc__));
8129 
8130 #if SU_HAVE_INLINE
8131 su_inline
8133 {
8134  return (sip_require_t *)
8135  msg_header_copy_as(home, sip_require_class, (msg_header_t const *)hdr);
8136 }
8137 #endif
8138 
8154 #if SU_HAVE_INLINE
8155 su_inline
8156 #endif
8157 sip_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
8186 su_inline
8187 #endif
8188 sip_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 
8216 SOFIAPUBFUN 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
8259 {
8261 }
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
8285 int 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
8320 su_inline
8321 #endif
8323  __attribute__((__malloc__));
8324 
8325 #if SU_HAVE_INLINE
8326 su_inline
8328 {
8329  return (sip_supported_t *)
8330  msg_header_dup_as(home, sip_supported_class, (msg_header_t const *)hdr);
8331 }
8332 #endif
8333 
8362 #if SU_HAVE_INLINE
8363 su_inline
8364 #endif
8366  __attribute__((__malloc__));
8367 
8368 #if SU_HAVE_INLINE
8369 su_inline
8371 {
8372  return (sip_supported_t *)
8374 }
8375 #endif
8376 
8392 #if SU_HAVE_INLINE
8393 su_inline
8394 #endif
8395 sip_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
8424 su_inline
8425 #endif
8426 sip_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 
8454 SOFIAPUBFUN 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
8497 {
8499 }
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
8523 int 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
8558 su_inline
8559 #endif
8561  __attribute__((__malloc__));
8562 
8563 #if SU_HAVE_INLINE
8564 su_inline
8566 {
8567  return (sip_unsupported_t *)
8569 }
8570 #endif
8571 
8600 #if SU_HAVE_INLINE
8601 su_inline
8602 #endif
8604  __attribute__((__malloc__));
8605 
8606 #if SU_HAVE_INLINE
8607 su_inline
8609 {
8610  return (sip_unsupported_t *)
8612 }
8613 #endif
8614 
8630 #if SU_HAVE_INLINE
8631 su_inline
8632 #endif
8633 sip_unsupported_t *sip_unsupported_make(su_home_t *home, char const *s)
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
8662 su_inline
8663 #endif
8664 sip_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 
8692 SOFIAPUBFUN 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
8735 {
8736  return SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t));
8737 }
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
8761 int 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
8796 su_inline
8797 #endif
8798 sip_event_t *sip_event_dup(su_home_t *home, sip_event_t const *hdr)
8799  __attribute__((__malloc__));
8800 
8801 #if SU_HAVE_INLINE
8802 su_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
8839 su_inline
8840 #endif
8841 sip_event_t *sip_event_copy(su_home_t *home, sip_event_t const *hdr)
8842  __attribute__((__malloc__));
8843 
8844 #if SU_HAVE_INLINE
8845 su_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
8869 su_inline
8870 #endif
8871 sip_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
8900 su_inline
8901 #endif
8902 sip_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
8906 su_inline sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
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 
8930 SOFIAPUBFUN 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
8973 {
8975 }
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
8999 int 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
9034 su_inline
9035 #endif
9037  __attribute__((__malloc__));
9038 
9039 #if SU_HAVE_INLINE
9040 su_inline
9042 {
9043  return (sip_allow_events_t *)
9045 }
9046 #endif
9047 
9076 #if SU_HAVE_INLINE
9077 su_inline
9078 #endif
9080  __attribute__((__malloc__));
9081 
9082 #if SU_HAVE_INLINE
9083 su_inline
9085 {
9086  return (sip_allow_events_t *)
9088 }
9089 #endif
9090 
9106 #if SU_HAVE_INLINE
9107 su_inline
9108 #endif
9109 sip_allow_events_t *sip_allow_events_make(su_home_t *home, char const *s)
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
9138 su_inline
9139 #endif
9140 sip_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 
9168 SOFIAPUBFUN 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
9211 {
9213 }
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
9237 int 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
9272 su_inline
9273 #endif
9275  __attribute__((__malloc__));
9276 
9277 #if SU_HAVE_INLINE
9278 su_inline
9280 {
9281  return (sip_subscription_state_t *)
9283 }
9284 #endif
9285 
9314 #if SU_HAVE_INLINE
9315 su_inline
9316 #endif
9318  __attribute__((__malloc__));
9319 
9320 #if SU_HAVE_INLINE
9321 su_inline
9323 {
9324  return (sip_subscription_state_t *)
9326 }
9327 #endif
9328 
9344 #if SU_HAVE_INLINE
9345 su_inline
9346 #endif
9348  __attribute__((__malloc__));
9349 
9350 #if SU_HAVE_INLINE
9352 {
9353  return (sip_subscription_state_t *)sip_header_make(home, sip_subscription_state_class, s);
9354 }
9355 #endif
9356 
9375 #if SU_HAVE_INLINE
9376 su_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 
9406 SOFIAPUBFUN 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
9449 {
9451 }
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
9475 int 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
9510 su_inline
9511 #endif
9513  __attribute__((__malloc__));
9514 
9515 #if SU_HAVE_INLINE
9516 su_inline
9518 {
9519  return (sip_proxy_authenticate_t *)
9521 }
9522 #endif
9523 
9552 #if SU_HAVE_INLINE
9553 su_inline
9554 #endif
9556  __attribute__((__malloc__));
9557 
9558 #if SU_HAVE_INLINE
9559 su_inline
9561 {
9562  return (sip_proxy_authenticate_t *)
9564 }
9565 #endif
9566 
9582 #if SU_HAVE_INLINE
9583 su_inline
9584 #endif
9586  __attribute__((__malloc__));
9587 
9588 #if SU_HAVE_INLINE
9590 {
9591  return (sip_proxy_authenticate_t *)sip_header_make(home, sip_proxy_authenticate_class, s);
9592 }
9593 #endif
9594 
9613 #if SU_HAVE_INLINE
9614 su_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 
9644 SOFIAPUBFUN 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
9687 {
9689 }
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
9748 su_inline
9749 #endif
9751  __attribute__((__malloc__));
9752 
9753 #if SU_HAVE_INLINE
9754 su_inline
9756 {
9759 }
9760 #endif
9761 
9790 #if SU_HAVE_INLINE
9791 su_inline
9792 #endif
9794  __attribute__((__malloc__));
9795 
9796 #if SU_HAVE_INLINE
9797 su_inline
9799 {
9802 }
9803 #endif
9804 
9820 #if SU_HAVE_INLINE
9821 su_inline
9822 #endif
9824  __attribute__((__malloc__));
9825 
9826 #if SU_HAVE_INLINE
9828 {
9829  return (sip_proxy_authentication_info_t *)sip_header_make(home, sip_proxy_authentication_info_class, s);
9830 }
9831 #endif
9832 
9851 #if SU_HAVE_INLINE
9852 su_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 
9867  return (sip_proxy_authentication_info_t *)h;
9868 }
9869 #endif
9870 
9879  char *s, isize_t slen);
9880 
9882 SOFIAPUBFUN 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
9925 {
9927 }
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
9951 int 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
9986 su_inline
9987 #endif
9989  __attribute__((__malloc__));
9990 
9991 #if SU_HAVE_INLINE
9992 su_inline
9994 {
9995  return (sip_proxy_authorization_t *)
9997 }
9998 #endif
9999 
10028 #if SU_HAVE_INLINE
10029 su_inline
10030 #endif
10032  __attribute__((__malloc__));
10033 
10034 #if SU_HAVE_INLINE
10035 su_inline
10037 {
10038  return (sip_proxy_authorization_t *)
10040 }
10041 #endif
10042 
10058 #if SU_HAVE_INLINE
10059 su_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
10090 su_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 
10120 SOFIAPUBFUN 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
10163 {
10165 }
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
10189 int 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
10224 su_inline
10225 #endif
10227  __attribute__((__malloc__));
10228 
10229 #if SU_HAVE_INLINE
10230 su_inline
10232 {
10233  return (sip_authorization_t *)
10235 }
10236 #endif
10237 
10266 #if SU_HAVE_INLINE
10267 su_inline
10268 #endif
10270  __attribute__((__malloc__));
10271 
10272 #if SU_HAVE_INLINE
10273 su_inline
10275 {
10276  return (sip_authorization_t *)
10278 }
10279 #endif
10280 
10296 #if SU_HAVE_INLINE
10297 su_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
10328 su_inline
10329 #endif
10330 sip_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 
10358 SOFIAPUBFUN 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
10401 {
10403 }
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
10427 int 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
10462 su_inline
10463 #endif
10465  __attribute__((__malloc__));
10466 
10467 #if SU_HAVE_INLINE
10468 su_inline
10470 {
10471  return (sip_www_authenticate_t *)
10473 }
10474 #endif
10475 
10504 #if SU_HAVE_INLINE
10505 su_inline
10506 #endif
10508  __attribute__((__malloc__));
10509 
10510 #if SU_HAVE_INLINE
10511 su_inline
10513 {
10514  return (sip_www_authenticate_t *)
10516 }
10517 #endif
10518 
10534 #if SU_HAVE_INLINE
10535 su_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
10566 su_inline
10567 #endif
10568 sip_www_authenticate_t *sip_www_authenticate_format(su_home_t *home, char const *fmt, ...)
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 
10596 SOFIAPUBFUN 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
10639 {
10641 }
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
10665 int 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
10700 su_inline
10701 #endif
10703  __attribute__((__malloc__));
10704 
10705 #if SU_HAVE_INLINE
10706 su_inline
10708 {
10709  return (sip_authentication_info_t *)
10711 }
10712 #endif
10713 
10742 #if SU_HAVE_INLINE
10743 su_inline
10744 #endif
10746  __attribute__((__malloc__));
10747 
10748 #if SU_HAVE_INLINE
10749 su_inline
10751 {
10752  return (sip_authentication_info_t *)
10754 }
10755 #endif
10756 
10772 #if SU_HAVE_INLINE
10773 su_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
10804 su_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 
10834 SOFIAPUBFUN 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
10877 {
10879 }
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
10903 int 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
10938 su_inline
10939 #endif
10941  __attribute__((__malloc__));
10942 
10943 #if SU_HAVE_INLINE
10944 su_inline
10946 {
10947  return (sip_error_info_t *)
10949 }
10950 #endif
10951 
10980 #if SU_HAVE_INLINE
10981 su_inline
10982 #endif
10984  __attribute__((__malloc__));
10985 
10986 #if SU_HAVE_INLINE
10987 su_inline
10989 {
10990  return (sip_error_info_t *)
10992 }
10993 #endif
10994 
11010 #if SU_HAVE_INLINE
11011 su_inline
11012 #endif
11013 sip_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
11042 su_inline
11043 #endif
11044 sip_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 
11072 SOFIAPUBFUN 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
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
11141 int 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
11176 su_inline
11177 #endif
11179  __attribute__((__malloc__));
11180 
11181 #if SU_HAVE_INLINE
11182 su_inline
11184 {
11185  return (sip_warning_t *)
11186  msg_header_dup_as(home, sip_warning_class, (msg_header_t const *)hdr);
11187 }
11188 #endif
11189 
11218 #if SU_HAVE_INLINE
11219 su_inline
11220 #endif
11222  __attribute__((__malloc__));
11223 
11224 #if SU_HAVE_INLINE
11225 su_inline
11227 {
11228  return (sip_warning_t *)
11229  msg_header_copy_as(home, sip_warning_class, (msg_header_t const *)hdr);
11230 }
11231 #endif
11232 
11248 #if SU_HAVE_INLINE
11249 su_inline
11250 #endif
11251 sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
11252  __attribute__((__malloc__));
11253 
11254 #if SU_HAVE_INLINE
11256 {
11257  return (sip_warning_t *)sip_header_make(home, sip_warning_class, s);
11258 }
11259 #endif
11260 
11279 #if SU_HAVE_INLINE
11280 su_inline
11281 #endif
11282 sip_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
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 
11310 SOFIAPUBFUN 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
11353 {
11355 }
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
11379 int 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
11414 su_inline
11415 #endif
11417  __attribute__((__malloc__));
11418 
11419 #if SU_HAVE_INLINE
11420 su_inline
11422 {
11423  return (sip_refer_to_t *)
11424  msg_header_dup_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
11425 }
11426 #endif
11427 
11456 #if SU_HAVE_INLINE
11457 su_inline
11458 #endif
11460  __attribute__((__malloc__));
11461 
11462 #if SU_HAVE_INLINE
11463 su_inline
11465 {
11466  return (sip_refer_to_t *)
11467  msg_header_copy_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
11468 }
11469 #endif
11470 
11486 #if SU_HAVE_INLINE
11487 su_inline
11488 #endif
11489 sip_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
11518 su_inline
11519 #endif
11520 sip_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 
11548 SOFIAPUBFUN 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
11591 {
11593 }
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
11617 int 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
11652 su_inline
11653 #endif
11655  __attribute__((__malloc__));
11656 
11657 #if SU_HAVE_INLINE
11658 su_inline
11660 {
11661  return (sip_referred_by_t *)
11663 }
11664 #endif
11665 
11694 #if SU_HAVE_INLINE
11695 su_inline
11696 #endif
11698  __attribute__((__malloc__));
11699 
11700 #if SU_HAVE_INLINE
11701 su_inline
11703 {
11704  return (sip_referred_by_t *)
11706 }
11707 #endif
11708 
11724 #if SU_HAVE_INLINE
11725 su_inline
11726 #endif
11727 sip_referred_by_t *sip_referred_by_make(su_home_t *home, char const *s)
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
11756 su_inline
11757 #endif
11758 sip_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 
11786 SOFIAPUBFUN 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
11829 {
11831 }
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
11855 int 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
11890 su_inline
11891 #endif
11893  __attribute__((__malloc__));
11894 
11895 #if SU_HAVE_INLINE
11896 su_inline
11898 {
11899  return (sip_replaces_t *)
11900  msg_header_dup_as(home, sip_replaces_class, (msg_header_t const *)hdr);
11901 }
11902 #endif
11903 
11932 #if SU_HAVE_INLINE
11933 su_inline
11934 #endif
11936  __attribute__((__malloc__));
11937 
11938 #if SU_HAVE_INLINE
11939 su_inline
11941 {
11942  return (sip_replaces_t *)
11943  msg_header_copy_as(home, sip_replaces_class, (msg_header_t const *)hdr);
11944 }
11945 #endif
11946 
11962 #if SU_HAVE_INLINE
11963 su_inline
11964 #endif
11965 sip_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
11994 su_inline
11995 #endif
11996 sip_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 
12024 SOFIAPUBFUN 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
12067 {
12069 }
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
12093 int 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
12128 su_inline
12129 #endif
12131  __attribute__((__malloc__));
12132 
12133 #if SU_HAVE_INLINE
12134 su_inline
12136 {
12137  return (sip_session_expires_t *)
12139 }
12140 #endif
12141 
12170 #if SU_HAVE_INLINE
12171 su_inline
12172 #endif
12174  __attribute__((__malloc__));
12175 
12176 #if SU_HAVE_INLINE
12177 su_inline
12179 {
12180  return (sip_session_expires_t *)
12182 }
12183 #endif
12184 
12200 #if SU_HAVE_INLINE
12201 su_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
12232 su_inline
12233 #endif
12234 sip_session_expires_t *sip_session_expires_format(su_home_t *home, char const *fmt, ...)
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 
12262 SOFIAPUBFUN 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
12305 {
12306  return SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t));
12307 }
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
12331 int 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
12366 su_inline
12367 #endif
12369  __attribute__((__malloc__));
12370 
12371 #if SU_HAVE_INLINE
12372 su_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
12409 su_inline
12410 #endif
12412  __attribute__((__malloc__));
12413 
12414 #if SU_HAVE_INLINE
12415 su_inline
12417 {
12418  return (sip_min_se_t *)
12419  msg_header_copy_as(home, sip_min_se_class, (msg_header_t const *)hdr);
12420 }
12421 #endif
12422 
12438 #if SU_HAVE_INLINE
12439 su_inline
12440 #endif
12441 sip_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
12470 su_inline
12471 #endif
12472 sip_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
12476 su_inline sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
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 
12500 SOFIAPUBFUN 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
12543 {
12544  return SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t));
12545 }
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
12569 int 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
12604 su_inline
12605 #endif
12606 sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
12607  __attribute__((__malloc__));
12608 
12609 #if SU_HAVE_INLINE
12610 su_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
12647 su_inline
12648 #endif
12649 sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
12650  __attribute__((__malloc__));
12651 
12652 #if SU_HAVE_INLINE
12653 su_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
12677 su_inline
12678 #endif
12679 sip_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
12708 su_inline
12709 #endif
12710 sip_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
12714 su_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 
12738 SOFIAPUBFUN 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
12781 {
12783 }
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
12807 int 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
12842 su_inline
12843 #endif
12845  __attribute__((__malloc__));
12846 
12847 #if SU_HAVE_INLINE
12848 su_inline
12850 {
12851  return (sip_service_route_t *)
12853 }
12854 #endif
12855 
12884 #if SU_HAVE_INLINE
12885 su_inline
12886 #endif
12888  __attribute__((__malloc__));
12889 
12890 #if SU_HAVE_INLINE
12891 su_inline
12893 {
12894  return (sip_service_route_t *)
12896 }
12897 #endif
12898 
12914 #if SU_HAVE_INLINE
12915 su_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
12946 su_inline
12947 #endif
12948 sip_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 
12976 SOFIAPUBFUN 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
13019 {
13020  return SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t));
13021 }
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
13045 int 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
13080 su_inline
13081 #endif
13083  __attribute__((__malloc__));
13084 
13085 #if SU_HAVE_INLINE
13086 su_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
13123 su_inline
13124 #endif
13126  __attribute__((__malloc__));
13127 
13128 #if SU_HAVE_INLINE
13129 su_inline
13131 {
13132  return (sip_reason_t *)
13133  msg_header_copy_as(home, sip_reason_class, (msg_header_t const *)hdr);
13134 }
13135 #endif
13136 
13152 #if SU_HAVE_INLINE
13153 su_inline
13154 #endif
13155 sip_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
13184 su_inline
13185 #endif
13186 sip_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
13190 su_inline sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
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 
13214 SOFIAPUBFUN 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
13257 {
13259 }
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
13283 int 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
13318 su_inline
13319 #endif
13321  __attribute__((__malloc__));
13322 
13323 #if SU_HAVE_INLINE
13324 su_inline
13326 {
13327  return (sip_security_client_t *)
13329 }
13330 #endif
13331 
13360 #if SU_HAVE_INLINE
13361 su_inline
13362 #endif
13364  __attribute__((__malloc__));
13365 
13366 #if SU_HAVE_INLINE
13367 su_inline
13369 {
13370  return (sip_security_client_t *)
13372 }
13373 #endif
13374 
13390 #if SU_HAVE_INLINE
13391 su_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
13422 su_inline
13423 #endif
13424 sip_security_client_t *sip_security_client_format(su_home_t *home, char const *fmt, ...)
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 
13452 SOFIAPUBFUN 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
13495 {
13497 }
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
13521 int 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
13556 su_inline
13557 #endif
13559  __attribute__((__malloc__));
13560 
13561 #if SU_HAVE_INLINE
13562 su_inline
13564 {
13565  return (sip_security_server_t *)
13567 }
13568 #endif
13569 
13598 #if SU_HAVE_INLINE
13599 su_inline
13600 #endif
13602  __attribute__((__malloc__));
13603 
13604 #if SU_HAVE_INLINE
13605 su_inline
13607 {
13608  return (sip_security_server_t *)
13610 }
13611 #endif
13612 
13628 #if SU_HAVE_INLINE
13629 su_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
13660 su_inline
13661 #endif
13662 sip_security_server_t *sip_security_server_format(su_home_t *home, char const *fmt, ...)
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 
13690 SOFIAPUBFUN 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
13733 {
13735 }
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
13759 int 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
13794 su_inline
13795 #endif
13797  __attribute__((__malloc__));
13798 
13799 #if SU_HAVE_INLINE
13800 su_inline
13802 {
13803  return (sip_security_verify_t *)
13805 }
13806 #endif
13807 
13836 #if SU_HAVE_INLINE
13837 su_inline
13838 #endif
13840  __attribute__((__malloc__));
13841 
13842 #if SU_HAVE_INLINE
13843 su_inline
13845 {
13846  return (sip_security_verify_t *)
13848 }
13849 #endif
13850 
13866 #if SU_HAVE_INLINE
13867 su_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
13898 su_inline
13899 #endif
13900 sip_security_verify_t *sip_security_verify_format(su_home_t *home, char const *fmt, ...)
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 
13928 SOFIAPUBFUN 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
13971 {
13972  return SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t));
13973 }
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
13997 int 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
14032 su_inline
14033 #endif
14035  __attribute__((__malloc__));
14036 
14037 #if SU_HAVE_INLINE
14038 su_inline
14040 {
14041  return (sip_privacy_t *)
14042  msg_header_dup_as(home, sip_privacy_class, (msg_header_t const *)hdr);
14043 }
14044 #endif
14045 
14074 #if SU_HAVE_INLINE
14075 su_inline
14076 #endif
14078  __attribute__((__malloc__));
14079 
14080 #if SU_HAVE_INLINE
14081 su_inline
14083 {
14084  return (sip_privacy_t *)
14085  msg_header_copy_as(home, sip_privacy_class, (msg_header_t const *)hdr);
14086 }
14087 #endif
14088 
14104 #if SU_HAVE_INLINE
14105 su_inline
14106 #endif
14107 sip_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
14136 su_inline
14137 #endif
14138 sip_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 
14166 SOFIAPUBFUN 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
14209 {
14210  return SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t));
14211 }
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
14235 int 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
14270 su_inline
14271 #endif
14272 sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
14273  __attribute__((__malloc__));
14274 
14275 #if SU_HAVE_INLINE
14276 su_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
14313 su_inline
14314 #endif
14315 sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
14316  __attribute__((__malloc__));
14317 
14318 #if SU_HAVE_INLINE
14319 su_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
14343 su_inline
14344 #endif
14345 sip_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
14374 su_inline
14375 #endif
14376 sip_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
14380 su_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 
14404 SOFIAPUBFUN 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
14447 {
14449 }
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
14473 int 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
14508 su_inline
14509 #endif
14511  __attribute__((__malloc__));
14512 
14513 #if SU_HAVE_INLINE
14514 su_inline
14516 {
14517  return (sip_if_match_t *)
14518  msg_header_dup_as(home, sip_if_match_class, (msg_header_t const *)hdr);
14519 }
14520 #endif
14521 
14550 #if SU_HAVE_INLINE
14551 su_inline
14552 #endif
14554  __attribute__((__malloc__));
14555 
14556 #if SU_HAVE_INLINE
14557 su_inline
14559 {
14560  return (sip_if_match_t *)
14561  msg_header_copy_as(home, sip_if_match_class, (msg_header_t const *)hdr);
14562 }
14563 #endif
14564 
14580 #if SU_HAVE_INLINE
14581 su_inline
14582 #endif
14583 sip_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
14612 su_inline
14613 #endif
14614 sip_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 
14642 SOFIAPUBFUN 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
14685 {
14687 }
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
14711 int 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
14746 su_inline
14747 #endif
14749  __attribute__((__malloc__));
14750 
14751 #if SU_HAVE_INLINE
14752 su_inline
14754 {
14755  return (sip_mime_version_t *)
14757 }
14758 #endif
14759 
14788 #if SU_HAVE_INLINE
14789 su_inline
14790 #endif
14792  __attribute__((__malloc__));
14793 
14794 #if SU_HAVE_INLINE
14795 su_inline
14797 {
14798  return (sip_mime_version_t *)
14800 }
14801 #endif
14802 
14818 #if SU_HAVE_INLINE
14819 su_inline
14820 #endif
14821 sip_mime_version_t *sip_mime_version_make(su_home_t *home, char const *s)
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
14850 su_inline
14851 #endif
14852 sip_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 
14880 SOFIAPUBFUN 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
14923 {
14925 }
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
14949 int 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
14984 su_inline
14985 #endif
14987  __attribute__((__malloc__));
14988 
14989 #if SU_HAVE_INLINE
14990 su_inline
14992 {
14993  return (sip_content_type_t *)
14995 }
14996 #endif
14997 
15026 #if SU_HAVE_INLINE
15027 su_inline
15028 #endif
15030  __attribute__((__malloc__));
15031 
15032 #if SU_HAVE_INLINE
15033 su_inline
15035 {
15036  return (sip_content_type_t *)
15038 }
15039 #endif
15040 
15056 #if SU_HAVE_INLINE
15057 su_inline
15058 #endif
15059 sip_content_type_t *sip_content_type_make(su_home_t *home, char const *s)
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
15088 su_inline
15089 #endif
15090 sip_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 
15118 SOFIAPUBFUN 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
15161 {
15163 }
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
15187 int 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
15222 su_inline
15223 #endif
15225  __attribute__((__malloc__));
15226 
15227 #if SU_HAVE_INLINE
15228 su_inline
15230 {
15231  return (sip_content_encoding_t *)
15233 }
15234 #endif
15235 
15264 #if SU_HAVE_INLINE
15265 su_inline
15266 #endif
15268  __attribute__((__malloc__));
15269 
15270 #if SU_HAVE_INLINE
15271 su_inline
15273 {
15274  return (sip_content_encoding_t *)
15276 }
15277 #endif
15278 
15294 #if SU_HAVE_INLINE
15295 su_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
15326 su_inline
15327 #endif
15328 sip_content_encoding_t *sip_content_encoding_format(su_home_t *home, char const *fmt, ...)
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 
15356 SOFIAPUBFUN 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
15399 {
15401 }
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
15425 int 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
15460 su_inline
15461 #endif
15463  __attribute__((__malloc__));
15464 
15465 #if SU_HAVE_INLINE
15466 su_inline
15468 {
15469  return (sip_content_language_t *)
15471 }
15472 #endif
15473 
15502 #if SU_HAVE_INLINE
15503 su_inline
15504 #endif
15506  __attribute__((__malloc__));
15507 
15508 #if SU_HAVE_INLINE
15509 su_inline
15511 {
15512  return (sip_content_language_t *)
15514 }
15515 #endif
15516 
15532 #if SU_HAVE_INLINE
15533 su_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
15564 su_inline
15565 #endif
15566 sip_content_language_t *sip_content_language_format(su_home_t *home, char const *fmt, ...)
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 
15594 SOFIAPUBFUN 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
15637 {
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
15663 int 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
15698 su_inline
15699 #endif
15701  __attribute__((__malloc__));
15702 
15703 #if SU_HAVE_INLINE
15704 su_inline
15706 {
15707  return (sip_content_disposition_t *)
15709 }
15710 #endif
15711 
15740 #if SU_HAVE_INLINE
15741 su_inline
15742 #endif
15744  __attribute__((__malloc__));
15745 
15746 #if SU_HAVE_INLINE
15747 su_inline
15749 {
15750  return (sip_content_disposition_t *)
15752 }
15753 #endif
15754 
15770 #if SU_HAVE_INLINE
15771 su_inline
15772 #endif
15774  __attribute__((__malloc__));
15775 
15776 #if SU_HAVE_INLINE
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
15802 su_inline
15803 #endif
15805  __attribute__((__malloc__, __format__ (printf, 2, 3)));
15806 
15807 #if SU_HAVE_INLINE
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 
15832 SOFIAPUBFUN 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
15875 {
15877 }
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
15901 int 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
15936 su_inline
15937 #endif
15939  __attribute__((__malloc__));
15940 
15941 #if SU_HAVE_INLINE
15942 su_inline
15944 {
15945  return (sip_content_length_t *)
15947 }
15948 #endif
15949 
15978 #if SU_HAVE_INLINE
15979 su_inline
15980 #endif
15982  __attribute__((__malloc__));
15983 
15984 #if SU_HAVE_INLINE
15985 su_inline
15987 {
15988  return (sip_content_length_t *)
15990 }
15991 #endif
15992 
16008 #if SU_HAVE_INLINE
16009 su_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
16040 su_inline
16041 #endif
16042 sip_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 
16070 SOFIAPUBFUN 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
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
16139 int 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
16174 su_inline
16175 #endif
16177  __attribute__((__malloc__));
16178 
16179 #if SU_HAVE_INLINE
16180 su_inline
16182 {
16183  return (sip_unknown_t *)
16184  msg_header_dup_as(home, sip_unknown_class, (msg_header_t const *)hdr);
16185 }
16186 #endif
16187 
16216 #if SU_HAVE_INLINE
16217 su_inline
16218 #endif
16220  __attribute__((__malloc__));
16221 
16222 #if SU_HAVE_INLINE
16223 su_inline
16225 {
16226  return (sip_unknown_t *)
16227  msg_header_copy_as(home, sip_unknown_class, (msg_header_t const *)hdr);
16228 }
16229 #endif
16230 
16246 #if SU_HAVE_INLINE
16247 su_inline
16248 #endif
16249 sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
16250  __attribute__((__malloc__));
16251 
16252 #if SU_HAVE_INLINE
16254 {
16255  return (sip_unknown_t *)sip_header_make(home, sip_unknown_class, s);
16256 }
16257 #endif
16258 
16277 #if SU_HAVE_INLINE
16278 su_inline
16279 #endif
16280 sip_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
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 
16308 SOFIAPUBFUN 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
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
16377 int 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
16412 su_inline
16413 #endif
16414 sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
16415  __attribute__((__malloc__));
16416 
16417 #if SU_HAVE_INLINE
16418 su_inline
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
16455 su_inline
16456 #endif
16457 sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
16458  __attribute__((__malloc__));
16459 
16460 #if SU_HAVE_INLINE
16461 su_inline
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
16485 su_inline
16486 #endif
16487 sip_error_t *sip_error_make(su_home_t *home, char const *s)
16488  __attribute__((__malloc__));
16489 
16490 #if SU_HAVE_INLINE
16492 {
16493  return (sip_error_t *)sip_header_make(home, sip_error_class, s);
16494 }
16495 #endif
16496 
16515 #if SU_HAVE_INLINE
16516 su_inline
16517 #endif
16518 sip_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
16522 su_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 
16543  char *s, isize_t slen);
16544 
16546 SOFIAPUBFUN 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
16589 {
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
16615 int 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
16650 su_inline
16651 #endif
16653  __attribute__((__malloc__));
16654 
16655 #if SU_HAVE_INLINE
16656 su_inline
16658 {
16659  return (sip_separator_t *)
16660  msg_header_dup_as(home, sip_separator_class, (msg_header_t const *)hdr);
16661 }
16662 #endif
16663 
16692 #if SU_HAVE_INLINE
16693 su_inline
16694 #endif
16696  __attribute__((__malloc__));
16697 
16698 #if SU_HAVE_INLINE
16699 su_inline
16701 {
16702  return (sip_separator_t *)
16704 }
16705 #endif
16706 
16722 #if SU_HAVE_INLINE
16723 su_inline
16724 #endif
16725 sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
16726  __attribute__((__malloc__));
16727 
16728 #if SU_HAVE_INLINE
16730 {
16731  return (sip_separator_t *)sip_header_make(home, sip_separator_class, s);
16732 }
16733 #endif
16734 
16753 #if SU_HAVE_INLINE
16754 su_inline
16755 #endif
16756 sip_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
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 
16781  char *s, isize_t slen);
16782 
16784 SOFIAPUBFUN 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
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
16853 int 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
16888 su_inline
16889 #endif
16891  __attribute__((__malloc__));
16892 
16893 #if SU_HAVE_INLINE
16894 su_inline
16896 {
16897  return (sip_payload_t *)
16898  msg_header_dup_as(home, sip_payload_class, (msg_header_t const *)hdr);
16899 }
16900 #endif
16901 
16930 #if SU_HAVE_INLINE
16931 su_inline
16932 #endif
16934  __attribute__((__malloc__));
16935 
16936 #if SU_HAVE_INLINE
16937 su_inline
16939 {
16940  return (sip_payload_t *)
16941  msg_header_copy_as(home, sip_payload_class, (msg_header_t const *)hdr);
16942 }
16943 #endif
16944 
16960 #if SU_HAVE_INLINE
16961 su_inline
16962 #endif
16963 sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
16964  __attribute__((__malloc__));
16965 
16966 #if SU_HAVE_INLINE
16968 {
16969  return (sip_payload_t *)sip_header_make(home, sip_payload_class, s);
16970 }
16971 #endif
16972 
16991 #if SU_HAVE_INLINE
16992 su_inline
16993 #endif
16994 sip_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
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 
17013 SOFIA_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_init(sip_accept_contact_t x[1])
Initialize a structure sip_accept_contact_t.
Definition: sip_protos.h:3736
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
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
msg_accept_any_t sip_accept_encoding_t
@
Definition: sip.h:140
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_init(sip_accept_encoding_t x[1])
Initialize a structure sip_accept_encoding_t.
Definition: sip_protos.h:7306
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_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_accept_any_t sip_accept_language_t
@
Definition: sip.h:141
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
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_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_accept_t * sip_accept_init(sip_accept_t x[1])
Initialize a structure sip_accept_t.
Definition: sip_protos.h:7068
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_init(sip_allow_events_t x[1])
Initialize a structure sip_allow_events_t.
Definition: sip_protos.h:8972
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
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_t * sip_allow_init(sip_allow_t x[1])
Initialize a structure sip_allow_t.
Definition: sip_protos.h:7782
@ 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.
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_init(sip_authentication_info_t x[1])
Initialize a structure sip_authentication_info_t.
Definition: sip_protos.h:10638
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_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_init(sip_authorization_t x[1])
Initialize a structure sip_authorization_t.
Definition: sip_protos.h:10162
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_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.
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_id_t * sip_call_id_init(sip_call_id_t x[1])
Initialize a structure sip_call_id_t.
Definition: sip_protos.h:2308
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
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
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_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
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_init(sip_contact_t x[1])
Initialize a structure sip_contact_t.
Definition: sip_protos.h:2784
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.
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_init(sip_content_disposition_t x[1])
Initialize a structure sip_content_disposition_t.
Definition: sip_protos.h:15636
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_init(sip_content_language_t x[1])
Initialize a structure sip_content_language_t.
Definition: sip_protos.h:15398
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_hash
@
Definition: sip_hclasses.h:1524
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
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
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
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_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
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_cseq_t * sip_cseq_init(sip_cseq_t x[1])
Initialize a structure sip_cseq_t.
Definition: sip_protos.h:2546
@ 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
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_init(sip_error_info_t x[1])
Initialize a structure sip_error_info_t.
Definition: sip_protos.h:10876
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
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
sip_error_t * sip_error_init(sip_error_t x[1])
Initialize a structure sip_error_t.
Definition: sip_protos.h:16350
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
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
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_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_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
sip_event_t * sip_event_init(sip_event_t x[1])
Initialize a structure sip_event_t.
Definition: sip_protos.h:8734
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
sip_expires_t * sip_expires_init(sip_expires_t x[1])
Initialize a structure sip_expires_t.
Definition: sip_protos.h:4212
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_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
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_from_t * sip_from_init(sip_from_t x[1])
Initialize a structure sip_from_t.
Definition: sip_protos.h:1832
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_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_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_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_init(sip_max_forwards_t x[1])
Initialize a structure sip_max_forwards_t.
Definition: sip_protos.h:1356
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
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
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_t * sip_mime_version_init(sip_mime_version_t x[1])
Initialize a structure sip_mime_version_t.
Definition: sip_protos.h:14684
@ 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.
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
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
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_init(sip_min_se_t x[1])
Initialize a structure sip_min_se_t.
Definition: sip_protos.h:12304
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_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_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_organization_t * sip_organization_init(sip_organization_t x[1])
Initialize a structure sip_organization_t.
Definition: sip_protos.h:6116
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
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_init(sip_path_t x[1])
Initialize a structure sip_path_t.
Definition: sip_protos.h:12542
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
issize_t sip_payload_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP message payload.
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_init(sip_payload_t x[1])
Initialize a structure sip_payload_t.
Definition: sip_protos.h:16826
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
issize_t sip_payload_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP message payload.
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_init(sip_priority_t x[1])
Initialize a structure sip_priority_t.
Definition: sip_protos.h:5640
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
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_init(sip_proxy_authenticate_t x[1])
Initialize a structure sip_proxy_authenticate_t.
Definition: sip_protos.h:9448
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
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_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_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_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
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
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
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
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_init(sip_proxy_require_t x[1])
Initialize a structure sip_proxy_require_t.
Definition: sip_protos.h:1594
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
sip_rack_t * sip_rack_init(sip_rack_t x[1])
Initialize a structure sip_rack_t.
Definition: sip_protos.h:3260
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_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
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
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
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_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_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_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_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_hash
@
Definition: sip_hclasses.h:420
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_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
sip_replaces_t * sip_replaces_init(sip_replaces_t x[1])
Initialize a structure sip_replaces_t.
Definition: sip_protos.h:11828
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.
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
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
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_format(su_home_t *home, char const *fmt,...)))
Make a request line from formatting result.
Definition: sip_protos.h:338
sip_request_t * sip_request_init(sip_request_t x[1])
Initialize a structure sip_request_t.
Definition: sip_protos.h:166
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
sip_require_t * sip_require_init(sip_require_t x[1])
Initialize a structure sip_require_t.
Definition: sip_protos.h:8020
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_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_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
sip_route_t * sip_route_init(sip_route_t x[1])
Initialize a structure sip_route_t.
Definition: sip_protos.h:880
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
sip_rseq_t * sip_rseq_init(sip_rseq_t x[1])
Initialize a structure sip_rseq_t.
Definition: sip_protos.h:3022
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.
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_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_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_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
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_init(sip_security_server_t x[1])
Initialize a structure sip_security_server_t.
Definition: sip_protos.h:13494
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_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
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
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
issize_t sip_separator_e(char b[], isize_t bsiz, msg_header_t const *h, int flags)
Print a SIP separator line between headers and body.
sip_separator_t * sip_separator_init(sip_separator_t x[1])
Initialize a structure sip_separator_t.
Definition: sip_protos.h:16588
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
issize_t sip_separator_d(su_home_t *, msg_header_t *, char *s, isize_t slen)
Parse a SIP separator line between headers and body.
sip_server_t * sip_server_init(sip_server_t x[1])
Initialize a structure sip_server_t.
Definition: sip_protos.h:6354
@ 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
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
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
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
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
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
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_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_init(sip_status_t x[1])
Initialize a structure sip_status_t.
Definition: sip_protos.h:404
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_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_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
sip_subject_t * sip_subject_init(sip_subject_t x[1])
Initialize a structure sip_subject_t.
Definition: sip_protos.h:5402
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_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
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
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_init(sip_timestamp_t x[1])
Initialize a structure sip_timestamp_t.
Definition: sip_protos.h:4926
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.
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_t * sip_to_init(sip_to_t x[1])
Initialize a structure sip_to_t.
Definition: sip_protos.h:2070
@ 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
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_init(sip_unsupported_t x[1])
Initialize a structure sip_unsupported_t.
Definition: sip_protos.h:8496
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.
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_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.
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
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_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.
sip_via_t * sip_via_init(sip_via_t x[1])
Initialize a structure sip_via_t.
Definition: sip_protos.h:642
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_init(sip_warning_t x[1])
Initialize a structure sip_warning_t.
Definition: sip_protos.h:11114
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_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_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
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
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)
msg_header_t * msg_header_copy_as(su_home_t *home, msg_hclass_t *hc, msg_header_t const *o))
int msg_header_insert(msg_t *msg, msg_pub_t *mo, msg_header_t *h)
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
void * sip_header_data(sip_header_t *h)
Return data after header structure.
Definition: sip_protos.h:103
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
char const * sip_header_name(sip_header_t const *h, int compact)
Return name of the header.
Definition: sip_protos.h:93
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
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.