00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026 #ifndef SIP_PROTOS_H
00027
00028 #define SIP_PROTOS_H
00029
00040 #include <sofia-sip/su_config.h>
00041
00042 #ifndef SIP_HEADER_H
00043 #include <sofia-sip/sip_header.h>
00044 #endif
00045
00046 #ifndef SIP_HCLASSES_H
00047 #include <sofia-sip/sip_hclasses.h>
00048 #endif
00049
00050 SOFIA_BEGIN_DECLS
00051
00052 #if SU_HAVE_INLINE
00053
00054 su_inline
00055 sip_t *sip_object(msg_t const *msg)
00056 {
00057 return (sip_t *)msg_public(msg, SIP_PROTOCOL_TAG);
00058 }
00059
00078 su_inline
00079 int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h)
00080 {
00081 return msg_header_insert(msg, (msg_pub_t *)sip, (msg_header_t *)h);
00082 }
00083
00085 su_inline
00086 int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h)
00087 {
00088 return msg_header_remove(msg, (msg_pub_t *)sip, (msg_header_t *)h);
00089 }
00090
00092 su_inline
00093 char const *sip_header_name(sip_header_t const *h, int compact)
00094 {
00095 if (compact && h->sh_class->hc_short[0])
00096 return h->sh_class->hc_short;
00097 else
00098 return h->sh_class->hc_name;
00099 }
00100
00102 su_inline
00103 void *sip_header_data(sip_header_t *h)
00104 {
00105 return h && h != SIP_NONE ? h->sh_class->hc_size + (char *)h : NULL;
00106 }
00107 #else
00108 sip_t *sip_object(msg_t *msg);
00109 int sip_header_insert(msg_t *msg, sip_t *sip, sip_header_t *h);
00110 int sip_header_remove(msg_t *msg, sip_t *sip, sip_header_t *h);
00111 char const *sip_header_name(sip_header_t const *h, int compact);
00112 void *sip_header_data(sip_header_t *h);
00113 #endif
00114
00120 SOFIAPUBFUN issize_t sip_request_d(su_home_t *, msg_header_t *,
00121 char *s, isize_t slen);
00122
00124 SOFIAPUBFUN issize_t sip_request_e(char b[], isize_t bsiz,
00125 msg_header_t const *h, int flags);
00126
00131 #define sip_request(sip) \
00132 ((sip_request_t *)msg_header_access((msg_pub_t*)(sip), sip_request_class))
00133
00147 #define SIP_REQUEST_INIT() SIP_HDR_INIT(request)
00148
00163 #if SU_HAVE_INLINE
00164 su_inline sip_request_t *sip_request_init(sip_request_t x[1])
00165 {
00166 return SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t));
00167 }
00168 #else
00169 #define sip_request_init(x) \
00170 SIP_HEADER_INIT(x, sip_request_class, sizeof(sip_request_t))
00171 #endif
00172
00184 #if SU_HAVE_INLINE
00185 su_inline int sip_is_request(sip_header_t const *header)
00186 {
00187 return header && header->sh_class->hc_hash == sip_request_hash;
00188 }
00189 #else
00190 int sip_is_request(sip_header_t const *header);
00191 #endif
00192
00193 #define sip_request_p(h) sip_is_request((h))
00194
00195
00223 #if SU_HAVE_INLINE
00224 su_inline
00225 #endif
00226 sip_request_t *sip_request_dup(su_home_t *home, sip_request_t const *hdr)
00227 __attribute__((__malloc__));
00228
00229 #if SU_HAVE_INLINE
00230 su_inline
00231 sip_request_t *sip_request_dup(su_home_t *home, sip_request_t const *hdr)
00232 {
00233 return (sip_request_t *)
00234 msg_header_dup_as(home, sip_request_class, (msg_header_t const *)hdr);
00235 }
00236 #endif
00237
00265 #if SU_HAVE_INLINE
00266 su_inline
00267 #endif
00268 sip_request_t *sip_request_copy(su_home_t *home, sip_request_t const *hdr)
00269 __attribute__((__malloc__));
00270
00271 #if SU_HAVE_INLINE
00272 su_inline
00273 sip_request_t *sip_request_copy(su_home_t *home, sip_request_t const *hdr)
00274 {
00275 return (sip_request_t *)
00276 msg_header_copy_as(home, sip_request_class, (msg_header_t const *)hdr);
00277 }
00278 #endif
00279
00294 #if SU_HAVE_INLINE
00295 su_inline
00296 #endif
00297 sip_request_t *sip_request_make(su_home_t *home, char const *s)
00298 __attribute__((__malloc__));
00299
00300 #if SU_HAVE_INLINE
00301 su_inline sip_request_t *sip_request_make(su_home_t *home, char const *s)
00302 {
00303 return (sip_request_t *)sip_header_make(home, sip_request_class, s);
00304 }
00305 #endif
00306
00324 #if SU_HAVE_INLINE
00325 su_inline
00326 #endif
00327 sip_request_t *sip_request_format(su_home_t *home, char const *fmt, ...)
00328 __attribute__((__malloc__, __format__ (printf, 2, 3)));
00329
00330 #if SU_HAVE_INLINE
00331 su_inline sip_request_t *sip_request_format(su_home_t *home, char const *fmt, ...)
00332 {
00333 sip_header_t *h;
00334 va_list ap;
00335
00336 va_start(ap, fmt);
00337 h = sip_header_vformat(home, sip_request_class, fmt, ap);
00338 va_end(ap);
00339
00340 return (sip_request_t *)h;
00341 }
00342 #endif
00343
00351 SOFIAPUBFUN issize_t sip_status_d(su_home_t *, msg_header_t *,
00352 char *s, isize_t slen);
00353
00355 SOFIAPUBFUN issize_t sip_status_e(char b[], isize_t bsiz,
00356 msg_header_t const *h, int flags);
00357
00362 #define sip_status(sip) \
00363 ((sip_status_t *)msg_header_access((msg_pub_t*)(sip), sip_status_class))
00364
00378 #define SIP_STATUS_INIT() SIP_HDR_INIT(status)
00379
00394 #if SU_HAVE_INLINE
00395 su_inline sip_status_t *sip_status_init(sip_status_t x[1])
00396 {
00397 return SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t));
00398 }
00399 #else
00400 #define sip_status_init(x) \
00401 SIP_HEADER_INIT(x, sip_status_class, sizeof(sip_status_t))
00402 #endif
00403
00415 #if SU_HAVE_INLINE
00416 su_inline int sip_is_status(sip_header_t const *header)
00417 {
00418 return header && header->sh_class->hc_hash == sip_status_hash;
00419 }
00420 #else
00421 int sip_is_status(sip_header_t const *header);
00422 #endif
00423
00424 #define sip_status_p(h) sip_is_status((h))
00425
00426
00454 #if SU_HAVE_INLINE
00455 su_inline
00456 #endif
00457 sip_status_t *sip_status_dup(su_home_t *home, sip_status_t const *hdr)
00458 __attribute__((__malloc__));
00459
00460 #if SU_HAVE_INLINE
00461 su_inline
00462 sip_status_t *sip_status_dup(su_home_t *home, sip_status_t const *hdr)
00463 {
00464 return (sip_status_t *)
00465 msg_header_dup_as(home, sip_status_class, (msg_header_t const *)hdr);
00466 }
00467 #endif
00468
00496 #if SU_HAVE_INLINE
00497 su_inline
00498 #endif
00499 sip_status_t *sip_status_copy(su_home_t *home, sip_status_t const *hdr)
00500 __attribute__((__malloc__));
00501
00502 #if SU_HAVE_INLINE
00503 su_inline
00504 sip_status_t *sip_status_copy(su_home_t *home, sip_status_t const *hdr)
00505 {
00506 return (sip_status_t *)
00507 msg_header_copy_as(home, sip_status_class, (msg_header_t const *)hdr);
00508 }
00509 #endif
00510
00525 #if SU_HAVE_INLINE
00526 su_inline
00527 #endif
00528 sip_status_t *sip_status_make(su_home_t *home, char const *s)
00529 __attribute__((__malloc__));
00530
00531 #if SU_HAVE_INLINE
00532 su_inline sip_status_t *sip_status_make(su_home_t *home, char const *s)
00533 {
00534 return (sip_status_t *)sip_header_make(home, sip_status_class, s);
00535 }
00536 #endif
00537
00555 #if SU_HAVE_INLINE
00556 su_inline
00557 #endif
00558 sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
00559 __attribute__((__malloc__, __format__ (printf, 2, 3)));
00560
00561 #if SU_HAVE_INLINE
00562 su_inline sip_status_t *sip_status_format(su_home_t *home, char const *fmt, ...)
00563 {
00564 sip_header_t *h;
00565 va_list ap;
00566
00567 va_start(ap, fmt);
00568 h = sip_header_vformat(home, sip_status_class, fmt, ap);
00569 va_end(ap);
00570
00571 return (sip_status_t *)h;
00572 }
00573 #endif
00574
00582 SOFIAPUBFUN issize_t sip_via_d(su_home_t *, msg_header_t *,
00583 char *s, isize_t slen);
00584
00586 SOFIAPUBFUN issize_t sip_via_e(char b[], isize_t bsiz,
00587 msg_header_t const *h, int flags);
00588
00593 #define sip_via(sip) \
00594 ((sip_via_t *)msg_header_access((msg_pub_t*)(sip), sip_via_class))
00595
00609 #define SIP_VIA_INIT() SIP_HDR_INIT(via)
00610
00625 #if SU_HAVE_INLINE
00626 su_inline sip_via_t *sip_via_init(sip_via_t x[1])
00627 {
00628 return SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t));
00629 }
00630 #else
00631 #define sip_via_init(x) \
00632 SIP_HEADER_INIT(x, sip_via_class, sizeof(sip_via_t))
00633 #endif
00634
00646 #if SU_HAVE_INLINE
00647 su_inline int sip_is_via(sip_header_t const *header)
00648 {
00649 return header && header->sh_class->hc_hash == sip_via_hash;
00650 }
00651 #else
00652 int sip_is_via(sip_header_t const *header);
00653 #endif
00654
00655 #define sip_via_p(h) sip_is_via((h))
00656
00657
00685 #if SU_HAVE_INLINE
00686 su_inline
00687 #endif
00688 sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
00689 __attribute__((__malloc__));
00690
00691 #if SU_HAVE_INLINE
00692 su_inline
00693 sip_via_t *sip_via_dup(su_home_t *home, sip_via_t const *hdr)
00694 {
00695 return (sip_via_t *)
00696 msg_header_dup_as(home, sip_via_class, (msg_header_t const *)hdr);
00697 }
00698 #endif
00699
00727 #if SU_HAVE_INLINE
00728 su_inline
00729 #endif
00730 sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
00731 __attribute__((__malloc__));
00732
00733 #if SU_HAVE_INLINE
00734 su_inline
00735 sip_via_t *sip_via_copy(su_home_t *home, sip_via_t const *hdr)
00736 {
00737 return (sip_via_t *)
00738 msg_header_copy_as(home, sip_via_class, (msg_header_t const *)hdr);
00739 }
00740 #endif
00741
00756 #if SU_HAVE_INLINE
00757 su_inline
00758 #endif
00759 sip_via_t *sip_via_make(su_home_t *home, char const *s)
00760 __attribute__((__malloc__));
00761
00762 #if SU_HAVE_INLINE
00763 su_inline sip_via_t *sip_via_make(su_home_t *home, char const *s)
00764 {
00765 return (sip_via_t *)sip_header_make(home, sip_via_class, s);
00766 }
00767 #endif
00768
00786 #if SU_HAVE_INLINE
00787 su_inline
00788 #endif
00789 sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
00790 __attribute__((__malloc__, __format__ (printf, 2, 3)));
00791
00792 #if SU_HAVE_INLINE
00793 su_inline sip_via_t *sip_via_format(su_home_t *home, char const *fmt, ...)
00794 {
00795 sip_header_t *h;
00796 va_list ap;
00797
00798 va_start(ap, fmt);
00799 h = sip_header_vformat(home, sip_via_class, fmt, ap);
00800 va_end(ap);
00801
00802 return (sip_via_t *)h;
00803 }
00804 #endif
00805
00813 SOFIAPUBFUN issize_t sip_route_d(su_home_t *, msg_header_t *,
00814 char *s, isize_t slen);
00815
00817 SOFIAPUBFUN issize_t sip_route_e(char b[], isize_t bsiz,
00818 msg_header_t const *h, int flags);
00819
00824 #define sip_route(sip) \
00825 ((sip_route_t *)msg_header_access((msg_pub_t*)(sip), sip_route_class))
00826
00840 #define SIP_ROUTE_INIT() SIP_HDR_INIT(route)
00841
00856 #if SU_HAVE_INLINE
00857 su_inline sip_route_t *sip_route_init(sip_route_t x[1])
00858 {
00859 return SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t));
00860 }
00861 #else
00862 #define sip_route_init(x) \
00863 SIP_HEADER_INIT(x, sip_route_class, sizeof(sip_route_t))
00864 #endif
00865
00877 #if SU_HAVE_INLINE
00878 su_inline int sip_is_route(sip_header_t const *header)
00879 {
00880 return header && header->sh_class->hc_hash == sip_route_hash;
00881 }
00882 #else
00883 int sip_is_route(sip_header_t const *header);
00884 #endif
00885
00886 #define sip_route_p(h) sip_is_route((h))
00887
00888
00916 #if SU_HAVE_INLINE
00917 su_inline
00918 #endif
00919 sip_route_t *sip_route_dup(su_home_t *home, sip_route_t const *hdr)
00920 __attribute__((__malloc__));
00921
00922 #if SU_HAVE_INLINE
00923 su_inline
00924 sip_route_t *sip_route_dup(su_home_t *home, sip_route_t const *hdr)
00925 {
00926 return (sip_route_t *)
00927 msg_header_dup_as(home, sip_route_class, (msg_header_t const *)hdr);
00928 }
00929 #endif
00930
00958 #if SU_HAVE_INLINE
00959 su_inline
00960 #endif
00961 sip_route_t *sip_route_copy(su_home_t *home, sip_route_t const *hdr)
00962 __attribute__((__malloc__));
00963
00964 #if SU_HAVE_INLINE
00965 su_inline
00966 sip_route_t *sip_route_copy(su_home_t *home, sip_route_t const *hdr)
00967 {
00968 return (sip_route_t *)
00969 msg_header_copy_as(home, sip_route_class, (msg_header_t const *)hdr);
00970 }
00971 #endif
00972
00987 #if SU_HAVE_INLINE
00988 su_inline
00989 #endif
00990 sip_route_t *sip_route_make(su_home_t *home, char const *s)
00991 __attribute__((__malloc__));
00992
00993 #if SU_HAVE_INLINE
00994 su_inline sip_route_t *sip_route_make(su_home_t *home, char const *s)
00995 {
00996 return (sip_route_t *)sip_header_make(home, sip_route_class, s);
00997 }
00998 #endif
00999
01017 #if SU_HAVE_INLINE
01018 su_inline
01019 #endif
01020 sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
01021 __attribute__((__malloc__, __format__ (printf, 2, 3)));
01022
01023 #if SU_HAVE_INLINE
01024 su_inline sip_route_t *sip_route_format(su_home_t *home, char const *fmt, ...)
01025 {
01026 sip_header_t *h;
01027 va_list ap;
01028
01029 va_start(ap, fmt);
01030 h = sip_header_vformat(home, sip_route_class, fmt, ap);
01031 va_end(ap);
01032
01033 return (sip_route_t *)h;
01034 }
01035 #endif
01036
01044 SOFIAPUBFUN issize_t sip_record_route_d(su_home_t *, msg_header_t *,
01045 char *s, isize_t slen);
01046
01048 SOFIAPUBFUN issize_t sip_record_route_e(char b[], isize_t bsiz,
01049 msg_header_t const *h, int flags);
01050
01055 #define sip_record_route(sip) \
01056 ((sip_record_route_t *)msg_header_access((msg_pub_t*)(sip), sip_record_route_class))
01057
01071 #define SIP_RECORD_ROUTE_INIT() SIP_HDR_INIT(record_route)
01072
01087 #if SU_HAVE_INLINE
01088 su_inline sip_record_route_t *sip_record_route_init(sip_record_route_t x[1])
01089 {
01090 return SIP_HEADER_INIT(x, sip_record_route_class, sizeof(sip_record_route_t));
01091 }
01092 #else
01093 #define sip_record_route_init(x) \
01094 SIP_HEADER_INIT(x, sip_record_route_class, sizeof(sip_record_route_t))
01095 #endif
01096
01108 #if SU_HAVE_INLINE
01109 su_inline int sip_is_record_route(sip_header_t const *header)
01110 {
01111 return header && header->sh_class->hc_hash == sip_record_route_hash;
01112 }
01113 #else
01114 int sip_is_record_route(sip_header_t const *header);
01115 #endif
01116
01117 #define sip_record_route_p(h) sip_is_record_route((h))
01118
01119
01147 #if SU_HAVE_INLINE
01148 su_inline
01149 #endif
01150 sip_record_route_t *sip_record_route_dup(su_home_t *home, sip_record_route_t const *hdr)
01151 __attribute__((__malloc__));
01152
01153 #if SU_HAVE_INLINE
01154 su_inline
01155 sip_record_route_t *sip_record_route_dup(su_home_t *home, sip_record_route_t const *hdr)
01156 {
01157 return (sip_record_route_t *)
01158 msg_header_dup_as(home, sip_record_route_class, (msg_header_t const *)hdr);
01159 }
01160 #endif
01161
01189 #if SU_HAVE_INLINE
01190 su_inline
01191 #endif
01192 sip_record_route_t *sip_record_route_copy(su_home_t *home, sip_record_route_t const *hdr)
01193 __attribute__((__malloc__));
01194
01195 #if SU_HAVE_INLINE
01196 su_inline
01197 sip_record_route_t *sip_record_route_copy(su_home_t *home, sip_record_route_t const *hdr)
01198 {
01199 return (sip_record_route_t *)
01200 msg_header_copy_as(home, sip_record_route_class, (msg_header_t const *)hdr);
01201 }
01202 #endif
01203
01218 #if SU_HAVE_INLINE
01219 su_inline
01220 #endif
01221 sip_record_route_t *sip_record_route_make(su_home_t *home, char const *s)
01222 __attribute__((__malloc__));
01223
01224 #if SU_HAVE_INLINE
01225 su_inline sip_record_route_t *sip_record_route_make(su_home_t *home, char const *s)
01226 {
01227 return (sip_record_route_t *)sip_header_make(home, sip_record_route_class, s);
01228 }
01229 #endif
01230
01248 #if SU_HAVE_INLINE
01249 su_inline
01250 #endif
01251 sip_record_route_t *sip_record_route_format(su_home_t *home, char const *fmt, ...)
01252 __attribute__((__malloc__, __format__ (printf, 2, 3)));
01253
01254 #if SU_HAVE_INLINE
01255 su_inline sip_record_route_t *sip_record_route_format(su_home_t *home, char const *fmt, ...)
01256 {
01257 sip_header_t *h;
01258 va_list ap;
01259
01260 va_start(ap, fmt);
01261 h = sip_header_vformat(home, sip_record_route_class, fmt, ap);
01262 va_end(ap);
01263
01264 return (sip_record_route_t *)h;
01265 }
01266 #endif
01267
01275 SOFIAPUBFUN issize_t sip_max_forwards_d(su_home_t *, msg_header_t *,
01276 char *s, isize_t slen);
01277
01279 SOFIAPUBFUN issize_t sip_max_forwards_e(char b[], isize_t bsiz,
01280 msg_header_t const *h, int flags);
01281
01286 #define sip_max_forwards(sip) \
01287 ((sip_max_forwards_t *)msg_header_access((msg_pub_t*)(sip), sip_max_forwards_class))
01288
01302 #define SIP_MAX_FORWARDS_INIT() SIP_HDR_INIT(max_forwards)
01303
01318 #if SU_HAVE_INLINE
01319 su_inline sip_max_forwards_t *sip_max_forwards_init(sip_max_forwards_t x[1])
01320 {
01321 return SIP_HEADER_INIT(x, sip_max_forwards_class, sizeof(sip_max_forwards_t));
01322 }
01323 #else
01324 #define sip_max_forwards_init(x) \
01325 SIP_HEADER_INIT(x, sip_max_forwards_class, sizeof(sip_max_forwards_t))
01326 #endif
01327
01339 #if SU_HAVE_INLINE
01340 su_inline int sip_is_max_forwards(sip_header_t const *header)
01341 {
01342 return header && header->sh_class->hc_hash == sip_max_forwards_hash;
01343 }
01344 #else
01345 int sip_is_max_forwards(sip_header_t const *header);
01346 #endif
01347
01348 #define sip_max_forwards_p(h) sip_is_max_forwards((h))
01349
01350
01378 #if SU_HAVE_INLINE
01379 su_inline
01380 #endif
01381 sip_max_forwards_t *sip_max_forwards_dup(su_home_t *home, sip_max_forwards_t const *hdr)
01382 __attribute__((__malloc__));
01383
01384 #if SU_HAVE_INLINE
01385 su_inline
01386 sip_max_forwards_t *sip_max_forwards_dup(su_home_t *home, sip_max_forwards_t const *hdr)
01387 {
01388 return (sip_max_forwards_t *)
01389 msg_header_dup_as(home, sip_max_forwards_class, (msg_header_t const *)hdr);
01390 }
01391 #endif
01392
01420 #if SU_HAVE_INLINE
01421 su_inline
01422 #endif
01423 sip_max_forwards_t *sip_max_forwards_copy(su_home_t *home, sip_max_forwards_t const *hdr)
01424 __attribute__((__malloc__));
01425
01426 #if SU_HAVE_INLINE
01427 su_inline
01428 sip_max_forwards_t *sip_max_forwards_copy(su_home_t *home, sip_max_forwards_t const *hdr)
01429 {
01430 return (sip_max_forwards_t *)
01431 msg_header_copy_as(home, sip_max_forwards_class, (msg_header_t const *)hdr);
01432 }
01433 #endif
01434
01449 #if SU_HAVE_INLINE
01450 su_inline
01451 #endif
01452 sip_max_forwards_t *sip_max_forwards_make(su_home_t *home, char const *s)
01453 __attribute__((__malloc__));
01454
01455 #if SU_HAVE_INLINE
01456 su_inline sip_max_forwards_t *sip_max_forwards_make(su_home_t *home, char const *s)
01457 {
01458 return (sip_max_forwards_t *)sip_header_make(home, sip_max_forwards_class, s);
01459 }
01460 #endif
01461
01479 #if SU_HAVE_INLINE
01480 su_inline
01481 #endif
01482 sip_max_forwards_t *sip_max_forwards_format(su_home_t *home, char const *fmt, ...)
01483 __attribute__((__malloc__, __format__ (printf, 2, 3)));
01484
01485 #if SU_HAVE_INLINE
01486 su_inline sip_max_forwards_t *sip_max_forwards_format(su_home_t *home, char const *fmt, ...)
01487 {
01488 sip_header_t *h;
01489 va_list ap;
01490
01491 va_start(ap, fmt);
01492 h = sip_header_vformat(home, sip_max_forwards_class, fmt, ap);
01493 va_end(ap);
01494
01495 return (sip_max_forwards_t *)h;
01496 }
01497 #endif
01498
01506 SOFIAPUBFUN issize_t sip_proxy_require_d(su_home_t *, msg_header_t *,
01507 char *s, isize_t slen);
01508
01510 SOFIAPUBFUN issize_t sip_proxy_require_e(char b[], isize_t bsiz,
01511 msg_header_t const *h, int flags);
01512
01517 #define sip_proxy_require(sip) \
01518 ((sip_proxy_require_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_require_class))
01519
01533 #define SIP_PROXY_REQUIRE_INIT() SIP_HDR_INIT(proxy_require)
01534
01549 #if SU_HAVE_INLINE
01550 su_inline sip_proxy_require_t *sip_proxy_require_init(sip_proxy_require_t x[1])
01551 {
01552 return SIP_HEADER_INIT(x, sip_proxy_require_class, sizeof(sip_proxy_require_t));
01553 }
01554 #else
01555 #define sip_proxy_require_init(x) \
01556 SIP_HEADER_INIT(x, sip_proxy_require_class, sizeof(sip_proxy_require_t))
01557 #endif
01558
01570 #if SU_HAVE_INLINE
01571 su_inline int sip_is_proxy_require(sip_header_t const *header)
01572 {
01573 return header && header->sh_class->hc_hash == sip_proxy_require_hash;
01574 }
01575 #else
01576 int sip_is_proxy_require(sip_header_t const *header);
01577 #endif
01578
01579 #define sip_proxy_require_p(h) sip_is_proxy_require((h))
01580
01581
01609 #if SU_HAVE_INLINE
01610 su_inline
01611 #endif
01612 sip_proxy_require_t *sip_proxy_require_dup(su_home_t *home, sip_proxy_require_t const *hdr)
01613 __attribute__((__malloc__));
01614
01615 #if SU_HAVE_INLINE
01616 su_inline
01617 sip_proxy_require_t *sip_proxy_require_dup(su_home_t *home, sip_proxy_require_t const *hdr)
01618 {
01619 return (sip_proxy_require_t *)
01620 msg_header_dup_as(home, sip_proxy_require_class, (msg_header_t const *)hdr);
01621 }
01622 #endif
01623
01651 #if SU_HAVE_INLINE
01652 su_inline
01653 #endif
01654 sip_proxy_require_t *sip_proxy_require_copy(su_home_t *home, sip_proxy_require_t const *hdr)
01655 __attribute__((__malloc__));
01656
01657 #if SU_HAVE_INLINE
01658 su_inline
01659 sip_proxy_require_t *sip_proxy_require_copy(su_home_t *home, sip_proxy_require_t const *hdr)
01660 {
01661 return (sip_proxy_require_t *)
01662 msg_header_copy_as(home, sip_proxy_require_class, (msg_header_t const *)hdr);
01663 }
01664 #endif
01665
01680 #if SU_HAVE_INLINE
01681 su_inline
01682 #endif
01683 sip_proxy_require_t *sip_proxy_require_make(su_home_t *home, char const *s)
01684 __attribute__((__malloc__));
01685
01686 #if SU_HAVE_INLINE
01687 su_inline sip_proxy_require_t *sip_proxy_require_make(su_home_t *home, char const *s)
01688 {
01689 return (sip_proxy_require_t *)sip_header_make(home, sip_proxy_require_class, s);
01690 }
01691 #endif
01692
01710 #if SU_HAVE_INLINE
01711 su_inline
01712 #endif
01713 sip_proxy_require_t *sip_proxy_require_format(su_home_t *home, char const *fmt, ...)
01714 __attribute__((__malloc__, __format__ (printf, 2, 3)));
01715
01716 #if SU_HAVE_INLINE
01717 su_inline sip_proxy_require_t *sip_proxy_require_format(su_home_t *home, char const *fmt, ...)
01718 {
01719 sip_header_t *h;
01720 va_list ap;
01721
01722 va_start(ap, fmt);
01723 h = sip_header_vformat(home, sip_proxy_require_class, fmt, ap);
01724 va_end(ap);
01725
01726 return (sip_proxy_require_t *)h;
01727 }
01728 #endif
01729
01737 SOFIAPUBFUN issize_t sip_from_d(su_home_t *, msg_header_t *,
01738 char *s, isize_t slen);
01739
01741 SOFIAPUBFUN issize_t sip_from_e(char b[], isize_t bsiz,
01742 msg_header_t const *h, int flags);
01743
01748 #define sip_from(sip) \
01749 ((sip_from_t *)msg_header_access((msg_pub_t*)(sip), sip_from_class))
01750
01764 #define SIP_FROM_INIT() SIP_HDR_INIT(from)
01765
01780 #if SU_HAVE_INLINE
01781 su_inline sip_from_t *sip_from_init(sip_from_t x[1])
01782 {
01783 return SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t));
01784 }
01785 #else
01786 #define sip_from_init(x) \
01787 SIP_HEADER_INIT(x, sip_from_class, sizeof(sip_from_t))
01788 #endif
01789
01801 #if SU_HAVE_INLINE
01802 su_inline int sip_is_from(sip_header_t const *header)
01803 {
01804 return header && header->sh_class->hc_hash == sip_from_hash;
01805 }
01806 #else
01807 int sip_is_from(sip_header_t const *header);
01808 #endif
01809
01810 #define sip_from_p(h) sip_is_from((h))
01811
01812
01840 #if SU_HAVE_INLINE
01841 su_inline
01842 #endif
01843 sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
01844 __attribute__((__malloc__));
01845
01846 #if SU_HAVE_INLINE
01847 su_inline
01848 sip_from_t *sip_from_dup(su_home_t *home, sip_from_t const *hdr)
01849 {
01850 return (sip_from_t *)
01851 msg_header_dup_as(home, sip_from_class, (msg_header_t const *)hdr);
01852 }
01853 #endif
01854
01882 #if SU_HAVE_INLINE
01883 su_inline
01884 #endif
01885 sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
01886 __attribute__((__malloc__));
01887
01888 #if SU_HAVE_INLINE
01889 su_inline
01890 sip_from_t *sip_from_copy(su_home_t *home, sip_from_t const *hdr)
01891 {
01892 return (sip_from_t *)
01893 msg_header_copy_as(home, sip_from_class, (msg_header_t const *)hdr);
01894 }
01895 #endif
01896
01911 #if SU_HAVE_INLINE
01912 su_inline
01913 #endif
01914 sip_from_t *sip_from_make(su_home_t *home, char const *s)
01915 __attribute__((__malloc__));
01916
01917 #if SU_HAVE_INLINE
01918 su_inline sip_from_t *sip_from_make(su_home_t *home, char const *s)
01919 {
01920 return (sip_from_t *)sip_header_make(home, sip_from_class, s);
01921 }
01922 #endif
01923
01941 #if SU_HAVE_INLINE
01942 su_inline
01943 #endif
01944 sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
01945 __attribute__((__malloc__, __format__ (printf, 2, 3)));
01946
01947 #if SU_HAVE_INLINE
01948 su_inline sip_from_t *sip_from_format(su_home_t *home, char const *fmt, ...)
01949 {
01950 sip_header_t *h;
01951 va_list ap;
01952
01953 va_start(ap, fmt);
01954 h = sip_header_vformat(home, sip_from_class, fmt, ap);
01955 va_end(ap);
01956
01957 return (sip_from_t *)h;
01958 }
01959 #endif
01960
01968 SOFIAPUBFUN issize_t sip_to_d(su_home_t *, msg_header_t *,
01969 char *s, isize_t slen);
01970
01972 SOFIAPUBFUN issize_t sip_to_e(char b[], isize_t bsiz,
01973 msg_header_t const *h, int flags);
01974
01979 #define sip_to(sip) \
01980 ((sip_to_t *)msg_header_access((msg_pub_t*)(sip), sip_to_class))
01981
01995 #define SIP_TO_INIT() SIP_HDR_INIT(to)
01996
02011 #if SU_HAVE_INLINE
02012 su_inline sip_to_t *sip_to_init(sip_to_t x[1])
02013 {
02014 return SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t));
02015 }
02016 #else
02017 #define sip_to_init(x) \
02018 SIP_HEADER_INIT(x, sip_to_class, sizeof(sip_to_t))
02019 #endif
02020
02032 #if SU_HAVE_INLINE
02033 su_inline int sip_is_to(sip_header_t const *header)
02034 {
02035 return header && header->sh_class->hc_hash == sip_to_hash;
02036 }
02037 #else
02038 int sip_is_to(sip_header_t const *header);
02039 #endif
02040
02041 #define sip_to_p(h) sip_is_to((h))
02042
02043
02071 #if SU_HAVE_INLINE
02072 su_inline
02073 #endif
02074 sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
02075 __attribute__((__malloc__));
02076
02077 #if SU_HAVE_INLINE
02078 su_inline
02079 sip_to_t *sip_to_dup(su_home_t *home, sip_to_t const *hdr)
02080 {
02081 return (sip_to_t *)
02082 msg_header_dup_as(home, sip_to_class, (msg_header_t const *)hdr);
02083 }
02084 #endif
02085
02113 #if SU_HAVE_INLINE
02114 su_inline
02115 #endif
02116 sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
02117 __attribute__((__malloc__));
02118
02119 #if SU_HAVE_INLINE
02120 su_inline
02121 sip_to_t *sip_to_copy(su_home_t *home, sip_to_t const *hdr)
02122 {
02123 return (sip_to_t *)
02124 msg_header_copy_as(home, sip_to_class, (msg_header_t const *)hdr);
02125 }
02126 #endif
02127
02142 #if SU_HAVE_INLINE
02143 su_inline
02144 #endif
02145 sip_to_t *sip_to_make(su_home_t *home, char const *s)
02146 __attribute__((__malloc__));
02147
02148 #if SU_HAVE_INLINE
02149 su_inline sip_to_t *sip_to_make(su_home_t *home, char const *s)
02150 {
02151 return (sip_to_t *)sip_header_make(home, sip_to_class, s);
02152 }
02153 #endif
02154
02172 #if SU_HAVE_INLINE
02173 su_inline
02174 #endif
02175 sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
02176 __attribute__((__malloc__, __format__ (printf, 2, 3)));
02177
02178 #if SU_HAVE_INLINE
02179 su_inline sip_to_t *sip_to_format(su_home_t *home, char const *fmt, ...)
02180 {
02181 sip_header_t *h;
02182 va_list ap;
02183
02184 va_start(ap, fmt);
02185 h = sip_header_vformat(home, sip_to_class, fmt, ap);
02186 va_end(ap);
02187
02188 return (sip_to_t *)h;
02189 }
02190 #endif
02191
02199 SOFIAPUBFUN issize_t sip_call_id_d(su_home_t *, msg_header_t *,
02200 char *s, isize_t slen);
02201
02203 SOFIAPUBFUN issize_t sip_call_id_e(char b[], isize_t bsiz,
02204 msg_header_t const *h, int flags);
02205
02210 #define sip_call_id(sip) \
02211 ((sip_call_id_t *)msg_header_access((msg_pub_t*)(sip), sip_call_id_class))
02212
02226 #define SIP_CALL_ID_INIT() SIP_HDR_INIT(call_id)
02227
02242 #if SU_HAVE_INLINE
02243 su_inline sip_call_id_t *sip_call_id_init(sip_call_id_t x[1])
02244 {
02245 return SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t));
02246 }
02247 #else
02248 #define sip_call_id_init(x) \
02249 SIP_HEADER_INIT(x, sip_call_id_class, sizeof(sip_call_id_t))
02250 #endif
02251
02263 #if SU_HAVE_INLINE
02264 su_inline int sip_is_call_id(sip_header_t const *header)
02265 {
02266 return header && header->sh_class->hc_hash == sip_call_id_hash;
02267 }
02268 #else
02269 int sip_is_call_id(sip_header_t const *header);
02270 #endif
02271
02272 #define sip_call_id_p(h) sip_is_call_id((h))
02273
02274
02302 #if SU_HAVE_INLINE
02303 su_inline
02304 #endif
02305 sip_call_id_t *sip_call_id_dup(su_home_t *home, sip_call_id_t const *hdr)
02306 __attribute__((__malloc__));
02307
02308 #if SU_HAVE_INLINE
02309 su_inline
02310 sip_call_id_t *sip_call_id_dup(su_home_t *home, sip_call_id_t const *hdr)
02311 {
02312 return (sip_call_id_t *)
02313 msg_header_dup_as(home, sip_call_id_class, (msg_header_t const *)hdr);
02314 }
02315 #endif
02316
02344 #if SU_HAVE_INLINE
02345 su_inline
02346 #endif
02347 sip_call_id_t *sip_call_id_copy(su_home_t *home, sip_call_id_t const *hdr)
02348 __attribute__((__malloc__));
02349
02350 #if SU_HAVE_INLINE
02351 su_inline
02352 sip_call_id_t *sip_call_id_copy(su_home_t *home, sip_call_id_t const *hdr)
02353 {
02354 return (sip_call_id_t *)
02355 msg_header_copy_as(home, sip_call_id_class, (msg_header_t const *)hdr);
02356 }
02357 #endif
02358
02373 #if SU_HAVE_INLINE
02374 su_inline
02375 #endif
02376 sip_call_id_t *sip_call_id_make(su_home_t *home, char const *s)
02377 __attribute__((__malloc__));
02378
02379 #if SU_HAVE_INLINE
02380 su_inline sip_call_id_t *sip_call_id_make(su_home_t *home, char const *s)
02381 {
02382 return (sip_call_id_t *)sip_header_make(home, sip_call_id_class, s);
02383 }
02384 #endif
02385
02403 #if SU_HAVE_INLINE
02404 su_inline
02405 #endif
02406 sip_call_id_t *sip_call_id_format(su_home_t *home, char const *fmt, ...)
02407 __attribute__((__malloc__, __format__ (printf, 2, 3)));
02408
02409 #if SU_HAVE_INLINE
02410 su_inline sip_call_id_t *sip_call_id_format(su_home_t *home, char const *fmt, ...)
02411 {
02412 sip_header_t *h;
02413 va_list ap;
02414
02415 va_start(ap, fmt);
02416 h = sip_header_vformat(home, sip_call_id_class, fmt, ap);
02417 va_end(ap);
02418
02419 return (sip_call_id_t *)h;
02420 }
02421 #endif
02422
02430 SOFIAPUBFUN issize_t sip_cseq_d(su_home_t *, msg_header_t *,
02431 char *s, isize_t slen);
02432
02434 SOFIAPUBFUN issize_t sip_cseq_e(char b[], isize_t bsiz,
02435 msg_header_t const *h, int flags);
02436
02441 #define sip_cseq(sip) \
02442 ((sip_cseq_t *)msg_header_access((msg_pub_t*)(sip), sip_cseq_class))
02443
02457 #define SIP_CSEQ_INIT() SIP_HDR_INIT(cseq)
02458
02473 #if SU_HAVE_INLINE
02474 su_inline sip_cseq_t *sip_cseq_init(sip_cseq_t x[1])
02475 {
02476 return SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t));
02477 }
02478 #else
02479 #define sip_cseq_init(x) \
02480 SIP_HEADER_INIT(x, sip_cseq_class, sizeof(sip_cseq_t))
02481 #endif
02482
02494 #if SU_HAVE_INLINE
02495 su_inline int sip_is_cseq(sip_header_t const *header)
02496 {
02497 return header && header->sh_class->hc_hash == sip_cseq_hash;
02498 }
02499 #else
02500 int sip_is_cseq(sip_header_t const *header);
02501 #endif
02502
02503 #define sip_cseq_p(h) sip_is_cseq((h))
02504
02505
02533 #if SU_HAVE_INLINE
02534 su_inline
02535 #endif
02536 sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
02537 __attribute__((__malloc__));
02538
02539 #if SU_HAVE_INLINE
02540 su_inline
02541 sip_cseq_t *sip_cseq_dup(su_home_t *home, sip_cseq_t const *hdr)
02542 {
02543 return (sip_cseq_t *)
02544 msg_header_dup_as(home, sip_cseq_class, (msg_header_t const *)hdr);
02545 }
02546 #endif
02547
02575 #if SU_HAVE_INLINE
02576 su_inline
02577 #endif
02578 sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
02579 __attribute__((__malloc__));
02580
02581 #if SU_HAVE_INLINE
02582 su_inline
02583 sip_cseq_t *sip_cseq_copy(su_home_t *home, sip_cseq_t const *hdr)
02584 {
02585 return (sip_cseq_t *)
02586 msg_header_copy_as(home, sip_cseq_class, (msg_header_t const *)hdr);
02587 }
02588 #endif
02589
02604 #if SU_HAVE_INLINE
02605 su_inline
02606 #endif
02607 sip_cseq_t *sip_cseq_make(su_home_t *home, char const *s)
02608 __attribute__((__malloc__));
02609
02610 #if SU_HAVE_INLINE
02611 su_inline sip_cseq_t *sip_cseq_make(su_home_t *home, char const *s)
02612 {
02613 return (sip_cseq_t *)sip_header_make(home, sip_cseq_class, s);
02614 }
02615 #endif
02616
02634 #if SU_HAVE_INLINE
02635 su_inline
02636 #endif
02637 sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
02638 __attribute__((__malloc__, __format__ (printf, 2, 3)));
02639
02640 #if SU_HAVE_INLINE
02641 su_inline sip_cseq_t *sip_cseq_format(su_home_t *home, char const *fmt, ...)
02642 {
02643 sip_header_t *h;
02644 va_list ap;
02645
02646 va_start(ap, fmt);
02647 h = sip_header_vformat(home, sip_cseq_class, fmt, ap);
02648 va_end(ap);
02649
02650 return (sip_cseq_t *)h;
02651 }
02652 #endif
02653
02661 SOFIAPUBFUN issize_t sip_contact_d(su_home_t *, msg_header_t *,
02662 char *s, isize_t slen);
02663
02665 SOFIAPUBFUN issize_t sip_contact_e(char b[], isize_t bsiz,
02666 msg_header_t const *h, int flags);
02667
02672 #define sip_contact(sip) \
02673 ((sip_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_contact_class))
02674
02688 #define SIP_CONTACT_INIT() SIP_HDR_INIT(contact)
02689
02704 #if SU_HAVE_INLINE
02705 su_inline sip_contact_t *sip_contact_init(sip_contact_t x[1])
02706 {
02707 return SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t));
02708 }
02709 #else
02710 #define sip_contact_init(x) \
02711 SIP_HEADER_INIT(x, sip_contact_class, sizeof(sip_contact_t))
02712 #endif
02713
02725 #if SU_HAVE_INLINE
02726 su_inline int sip_is_contact(sip_header_t const *header)
02727 {
02728 return header && header->sh_class->hc_hash == sip_contact_hash;
02729 }
02730 #else
02731 int sip_is_contact(sip_header_t const *header);
02732 #endif
02733
02734 #define sip_contact_p(h) sip_is_contact((h))
02735
02736
02764 #if SU_HAVE_INLINE
02765 su_inline
02766 #endif
02767 sip_contact_t *sip_contact_dup(su_home_t *home, sip_contact_t const *hdr)
02768 __attribute__((__malloc__));
02769
02770 #if SU_HAVE_INLINE
02771 su_inline
02772 sip_contact_t *sip_contact_dup(su_home_t *home, sip_contact_t const *hdr)
02773 {
02774 return (sip_contact_t *)
02775 msg_header_dup_as(home, sip_contact_class, (msg_header_t const *)hdr);
02776 }
02777 #endif
02778
02806 #if SU_HAVE_INLINE
02807 su_inline
02808 #endif
02809 sip_contact_t *sip_contact_copy(su_home_t *home, sip_contact_t const *hdr)
02810 __attribute__((__malloc__));
02811
02812 #if SU_HAVE_INLINE
02813 su_inline
02814 sip_contact_t *sip_contact_copy(su_home_t *home, sip_contact_t const *hdr)
02815 {
02816 return (sip_contact_t *)
02817 msg_header_copy_as(home, sip_contact_class, (msg_header_t const *)hdr);
02818 }
02819 #endif
02820
02835 #if SU_HAVE_INLINE
02836 su_inline
02837 #endif
02838 sip_contact_t *sip_contact_make(su_home_t *home, char const *s)
02839 __attribute__((__malloc__));
02840
02841 #if SU_HAVE_INLINE
02842 su_inline sip_contact_t *sip_contact_make(su_home_t *home, char const *s)
02843 {
02844 return (sip_contact_t *)sip_header_make(home, sip_contact_class, s);
02845 }
02846 #endif
02847
02865 #if SU_HAVE_INLINE
02866 su_inline
02867 #endif
02868 sip_contact_t *sip_contact_format(su_home_t *home, char const *fmt, ...)
02869 __attribute__((__malloc__, __format__ (printf, 2, 3)));
02870
02871 #if SU_HAVE_INLINE
02872 su_inline sip_contact_t *sip_contact_format(su_home_t *home, char const *fmt, ...)
02873 {
02874 sip_header_t *h;
02875 va_list ap;
02876
02877 va_start(ap, fmt);
02878 h = sip_header_vformat(home, sip_contact_class, fmt, ap);
02879 va_end(ap);
02880
02881 return (sip_contact_t *)h;
02882 }
02883 #endif
02884
02892 SOFIAPUBFUN issize_t sip_rseq_d(su_home_t *, msg_header_t *,
02893 char *s, isize_t slen);
02894
02896 SOFIAPUBFUN issize_t sip_rseq_e(char b[], isize_t bsiz,
02897 msg_header_t const *h, int flags);
02898
02903 #define sip_rseq(sip) \
02904 ((sip_rseq_t *)msg_header_access((msg_pub_t*)(sip), sip_rseq_class))
02905
02919 #define SIP_RSEQ_INIT() SIP_HDR_INIT(rseq)
02920
02935 #if SU_HAVE_INLINE
02936 su_inline sip_rseq_t *sip_rseq_init(sip_rseq_t x[1])
02937 {
02938 return SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t));
02939 }
02940 #else
02941 #define sip_rseq_init(x) \
02942 SIP_HEADER_INIT(x, sip_rseq_class, sizeof(sip_rseq_t))
02943 #endif
02944
02956 #if SU_HAVE_INLINE
02957 su_inline int sip_is_rseq(sip_header_t const *header)
02958 {
02959 return header && header->sh_class->hc_hash == sip_rseq_hash;
02960 }
02961 #else
02962 int sip_is_rseq(sip_header_t const *header);
02963 #endif
02964
02965 #define sip_rseq_p(h) sip_is_rseq((h))
02966
02967
02995 #if SU_HAVE_INLINE
02996 su_inline
02997 #endif
02998 sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
02999 __attribute__((__malloc__));
03000
03001 #if SU_HAVE_INLINE
03002 su_inline
03003 sip_rseq_t *sip_rseq_dup(su_home_t *home, sip_rseq_t const *hdr)
03004 {
03005 return (sip_rseq_t *)
03006 msg_header_dup_as(home, sip_rseq_class, (msg_header_t const *)hdr);
03007 }
03008 #endif
03009
03037 #if SU_HAVE_INLINE
03038 su_inline
03039 #endif
03040 sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
03041 __attribute__((__malloc__));
03042
03043 #if SU_HAVE_INLINE
03044 su_inline
03045 sip_rseq_t *sip_rseq_copy(su_home_t *home, sip_rseq_t const *hdr)
03046 {
03047 return (sip_rseq_t *)
03048 msg_header_copy_as(home, sip_rseq_class, (msg_header_t const *)hdr);
03049 }
03050 #endif
03051
03066 #if SU_HAVE_INLINE
03067 su_inline
03068 #endif
03069 sip_rseq_t *sip_rseq_make(su_home_t *home, char const *s)
03070 __attribute__((__malloc__));
03071
03072 #if SU_HAVE_INLINE
03073 su_inline sip_rseq_t *sip_rseq_make(su_home_t *home, char const *s)
03074 {
03075 return (sip_rseq_t *)sip_header_make(home, sip_rseq_class, s);
03076 }
03077 #endif
03078
03096 #if SU_HAVE_INLINE
03097 su_inline
03098 #endif
03099 sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
03100 __attribute__((__malloc__, __format__ (printf, 2, 3)));
03101
03102 #if SU_HAVE_INLINE
03103 su_inline sip_rseq_t *sip_rseq_format(su_home_t *home, char const *fmt, ...)
03104 {
03105 sip_header_t *h;
03106 va_list ap;
03107
03108 va_start(ap, fmt);
03109 h = sip_header_vformat(home, sip_rseq_class, fmt, ap);
03110 va_end(ap);
03111
03112 return (sip_rseq_t *)h;
03113 }
03114 #endif
03115
03123 SOFIAPUBFUN issize_t sip_rack_d(su_home_t *, msg_header_t *,
03124 char *s, isize_t slen);
03125
03127 SOFIAPUBFUN issize_t sip_rack_e(char b[], isize_t bsiz,
03128 msg_header_t const *h, int flags);
03129
03134 #define sip_rack(sip) \
03135 ((sip_rack_t *)msg_header_access((msg_pub_t*)(sip), sip_rack_class))
03136
03150 #define SIP_RACK_INIT() SIP_HDR_INIT(rack)
03151
03166 #if SU_HAVE_INLINE
03167 su_inline sip_rack_t *sip_rack_init(sip_rack_t x[1])
03168 {
03169 return SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t));
03170 }
03171 #else
03172 #define sip_rack_init(x) \
03173 SIP_HEADER_INIT(x, sip_rack_class, sizeof(sip_rack_t))
03174 #endif
03175
03187 #if SU_HAVE_INLINE
03188 su_inline int sip_is_rack(sip_header_t const *header)
03189 {
03190 return header && header->sh_class->hc_hash == sip_rack_hash;
03191 }
03192 #else
03193 int sip_is_rack(sip_header_t const *header);
03194 #endif
03195
03196 #define sip_rack_p(h) sip_is_rack((h))
03197
03198
03226 #if SU_HAVE_INLINE
03227 su_inline
03228 #endif
03229 sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
03230 __attribute__((__malloc__));
03231
03232 #if SU_HAVE_INLINE
03233 su_inline
03234 sip_rack_t *sip_rack_dup(su_home_t *home, sip_rack_t const *hdr)
03235 {
03236 return (sip_rack_t *)
03237 msg_header_dup_as(home, sip_rack_class, (msg_header_t const *)hdr);
03238 }
03239 #endif
03240
03268 #if SU_HAVE_INLINE
03269 su_inline
03270 #endif
03271 sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
03272 __attribute__((__malloc__));
03273
03274 #if SU_HAVE_INLINE
03275 su_inline
03276 sip_rack_t *sip_rack_copy(su_home_t *home, sip_rack_t const *hdr)
03277 {
03278 return (sip_rack_t *)
03279 msg_header_copy_as(home, sip_rack_class, (msg_header_t const *)hdr);
03280 }
03281 #endif
03282
03297 #if SU_HAVE_INLINE
03298 su_inline
03299 #endif
03300 sip_rack_t *sip_rack_make(su_home_t *home, char const *s)
03301 __attribute__((__malloc__));
03302
03303 #if SU_HAVE_INLINE
03304 su_inline sip_rack_t *sip_rack_make(su_home_t *home, char const *s)
03305 {
03306 return (sip_rack_t *)sip_header_make(home, sip_rack_class, s);
03307 }
03308 #endif
03309
03327 #if SU_HAVE_INLINE
03328 su_inline
03329 #endif
03330 sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
03331 __attribute__((__malloc__, __format__ (printf, 2, 3)));
03332
03333 #if SU_HAVE_INLINE
03334 su_inline sip_rack_t *sip_rack_format(su_home_t *home, char const *fmt, ...)
03335 {
03336 sip_header_t *h;
03337 va_list ap;
03338
03339 va_start(ap, fmt);
03340 h = sip_header_vformat(home, sip_rack_class, fmt, ap);
03341 va_end(ap);
03342
03343 return (sip_rack_t *)h;
03344 }
03345 #endif
03346
03354 SOFIAPUBFUN issize_t sip_request_disposition_d(su_home_t *, msg_header_t *,
03355 char *s, isize_t slen);
03356
03358 SOFIAPUBFUN issize_t sip_request_disposition_e(char b[], isize_t bsiz,
03359 msg_header_t const *h, int flags);
03360
03365 #define sip_request_disposition(sip) \
03366 ((sip_request_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_request_disposition_class))
03367
03381 #define SIP_REQUEST_DISPOSITION_INIT() SIP_HDR_INIT(request_disposition)
03382
03397 #if SU_HAVE_INLINE
03398 su_inline sip_request_disposition_t *sip_request_disposition_init(sip_request_disposition_t x[1])
03399 {
03400 return SIP_HEADER_INIT(x, sip_request_disposition_class, sizeof(sip_request_disposition_t));
03401 }
03402 #else
03403 #define sip_request_disposition_init(x) \
03404 SIP_HEADER_INIT(x, sip_request_disposition_class, sizeof(sip_request_disposition_t))
03405 #endif
03406
03418 #if SU_HAVE_INLINE
03419 su_inline int sip_is_request_disposition(sip_header_t const *header)
03420 {
03421 return header && header->sh_class->hc_hash == sip_request_disposition_hash;
03422 }
03423 #else
03424 int sip_is_request_disposition(sip_header_t const *header);
03425 #endif
03426
03427 #define sip_request_disposition_p(h) sip_is_request_disposition((h))
03428
03429
03457 #if SU_HAVE_INLINE
03458 su_inline
03459 #endif
03460 sip_request_disposition_t *sip_request_disposition_dup(su_home_t *home, sip_request_disposition_t const *hdr)
03461 __attribute__((__malloc__));
03462
03463 #if SU_HAVE_INLINE
03464 su_inline
03465 sip_request_disposition_t *sip_request_disposition_dup(su_home_t *home, sip_request_disposition_t const *hdr)
03466 {
03467 return (sip_request_disposition_t *)
03468 msg_header_dup_as(home, sip_request_disposition_class, (msg_header_t const *)hdr);
03469 }
03470 #endif
03471
03499 #if SU_HAVE_INLINE
03500 su_inline
03501 #endif
03502 sip_request_disposition_t *sip_request_disposition_copy(su_home_t *home, sip_request_disposition_t const *hdr)
03503 __attribute__((__malloc__));
03504
03505 #if SU_HAVE_INLINE
03506 su_inline
03507 sip_request_disposition_t *sip_request_disposition_copy(su_home_t *home, sip_request_disposition_t const *hdr)
03508 {
03509 return (sip_request_disposition_t *)
03510 msg_header_copy_as(home, sip_request_disposition_class, (msg_header_t const *)hdr);
03511 }
03512 #endif
03513
03528 #if SU_HAVE_INLINE
03529 su_inline
03530 #endif
03531 sip_request_disposition_t *sip_request_disposition_make(su_home_t *home, char const *s)
03532 __attribute__((__malloc__));
03533
03534 #if SU_HAVE_INLINE
03535 su_inline sip_request_disposition_t *sip_request_disposition_make(su_home_t *home, char const *s)
03536 {
03537 return (sip_request_disposition_t *)sip_header_make(home, sip_request_disposition_class, s);
03538 }
03539 #endif
03540
03558 #if SU_HAVE_INLINE
03559 su_inline
03560 #endif
03561 sip_request_disposition_t *sip_request_disposition_format(su_home_t *home, char const *fmt, ...)
03562 __attribute__((__malloc__, __format__ (printf, 2, 3)));
03563
03564 #if SU_HAVE_INLINE
03565 su_inline sip_request_disposition_t *sip_request_disposition_format(su_home_t *home, char const *fmt, ...)
03566 {
03567 sip_header_t *h;
03568 va_list ap;
03569
03570 va_start(ap, fmt);
03571 h = sip_header_vformat(home, sip_request_disposition_class, fmt, ap);
03572 va_end(ap);
03573
03574 return (sip_request_disposition_t *)h;
03575 }
03576 #endif
03577
03585 SOFIAPUBFUN issize_t sip_accept_contact_d(su_home_t *, msg_header_t *,
03586 char *s, isize_t slen);
03587
03589 SOFIAPUBFUN issize_t sip_accept_contact_e(char b[], isize_t bsiz,
03590 msg_header_t const *h, int flags);
03591
03596 #define sip_accept_contact(sip) \
03597 ((sip_accept_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_contact_class))
03598
03612 #define SIP_ACCEPT_CONTACT_INIT() SIP_HDR_INIT(accept_contact)
03613
03628 #if SU_HAVE_INLINE
03629 su_inline sip_accept_contact_t *sip_accept_contact_init(sip_accept_contact_t x[1])
03630 {
03631 return SIP_HEADER_INIT(x, sip_accept_contact_class, sizeof(sip_accept_contact_t));
03632 }
03633 #else
03634 #define sip_accept_contact_init(x) \
03635 SIP_HEADER_INIT(x, sip_accept_contact_class, sizeof(sip_accept_contact_t))
03636 #endif
03637
03649 #if SU_HAVE_INLINE
03650 su_inline int sip_is_accept_contact(sip_header_t const *header)
03651 {
03652 return header && header->sh_class->hc_hash == sip_accept_contact_hash;
03653 }
03654 #else
03655 int sip_is_accept_contact(sip_header_t const *header);
03656 #endif
03657
03658 #define sip_accept_contact_p(h) sip_is_accept_contact((h))
03659
03660
03688 #if SU_HAVE_INLINE
03689 su_inline
03690 #endif
03691 sip_accept_contact_t *sip_accept_contact_dup(su_home_t *home, sip_accept_contact_t const *hdr)
03692 __attribute__((__malloc__));
03693
03694 #if SU_HAVE_INLINE
03695 su_inline
03696 sip_accept_contact_t *sip_accept_contact_dup(su_home_t *home, sip_accept_contact_t const *hdr)
03697 {
03698 return (sip_accept_contact_t *)
03699 msg_header_dup_as(home, sip_accept_contact_class, (msg_header_t const *)hdr);
03700 }
03701 #endif
03702
03730 #if SU_HAVE_INLINE
03731 su_inline
03732 #endif
03733 sip_accept_contact_t *sip_accept_contact_copy(su_home_t *home, sip_accept_contact_t const *hdr)
03734 __attribute__((__malloc__));
03735
03736 #if SU_HAVE_INLINE
03737 su_inline
03738 sip_accept_contact_t *sip_accept_contact_copy(su_home_t *home, sip_accept_contact_t const *hdr)
03739 {
03740 return (sip_accept_contact_t *)
03741 msg_header_copy_as(home, sip_accept_contact_class, (msg_header_t const *)hdr);
03742 }
03743 #endif
03744
03759 #if SU_HAVE_INLINE
03760 su_inline
03761 #endif
03762 sip_accept_contact_t *sip_accept_contact_make(su_home_t *home, char const *s)
03763 __attribute__((__malloc__));
03764
03765 #if SU_HAVE_INLINE
03766 su_inline sip_accept_contact_t *sip_accept_contact_make(su_home_t *home, char const *s)
03767 {
03768 return (sip_accept_contact_t *)sip_header_make(home, sip_accept_contact_class, s);
03769 }
03770 #endif
03771
03789 #if SU_HAVE_INLINE
03790 su_inline
03791 #endif
03792 sip_accept_contact_t *sip_accept_contact_format(su_home_t *home, char const *fmt, ...)
03793 __attribute__((__malloc__, __format__ (printf, 2, 3)));
03794
03795 #if SU_HAVE_INLINE
03796 su_inline sip_accept_contact_t *sip_accept_contact_format(su_home_t *home, char const *fmt, ...)
03797 {
03798 sip_header_t *h;
03799 va_list ap;
03800
03801 va_start(ap, fmt);
03802 h = sip_header_vformat(home, sip_accept_contact_class, fmt, ap);
03803 va_end(ap);
03804
03805 return (sip_accept_contact_t *)h;
03806 }
03807 #endif
03808
03816 SOFIAPUBFUN issize_t sip_reject_contact_d(su_home_t *, msg_header_t *,
03817 char *s, isize_t slen);
03818
03820 SOFIAPUBFUN issize_t sip_reject_contact_e(char b[], isize_t bsiz,
03821 msg_header_t const *h, int flags);
03822
03827 #define sip_reject_contact(sip) \
03828 ((sip_reject_contact_t *)msg_header_access((msg_pub_t*)(sip), sip_reject_contact_class))
03829
03843 #define SIP_REJECT_CONTACT_INIT() SIP_HDR_INIT(reject_contact)
03844
03859 #if SU_HAVE_INLINE
03860 su_inline sip_reject_contact_t *sip_reject_contact_init(sip_reject_contact_t x[1])
03861 {
03862 return SIP_HEADER_INIT(x, sip_reject_contact_class, sizeof(sip_reject_contact_t));
03863 }
03864 #else
03865 #define sip_reject_contact_init(x) \
03866 SIP_HEADER_INIT(x, sip_reject_contact_class, sizeof(sip_reject_contact_t))
03867 #endif
03868
03880 #if SU_HAVE_INLINE
03881 su_inline int sip_is_reject_contact(sip_header_t const *header)
03882 {
03883 return header && header->sh_class->hc_hash == sip_reject_contact_hash;
03884 }
03885 #else
03886 int sip_is_reject_contact(sip_header_t const *header);
03887 #endif
03888
03889 #define sip_reject_contact_p(h) sip_is_reject_contact((h))
03890
03891
03919 #if SU_HAVE_INLINE
03920 su_inline
03921 #endif
03922 sip_reject_contact_t *sip_reject_contact_dup(su_home_t *home, sip_reject_contact_t const *hdr)
03923 __attribute__((__malloc__));
03924
03925 #if SU_HAVE_INLINE
03926 su_inline
03927 sip_reject_contact_t *sip_reject_contact_dup(su_home_t *home, sip_reject_contact_t const *hdr)
03928 {
03929 return (sip_reject_contact_t *)
03930 msg_header_dup_as(home, sip_reject_contact_class, (msg_header_t const *)hdr);
03931 }
03932 #endif
03933
03961 #if SU_HAVE_INLINE
03962 su_inline
03963 #endif
03964 sip_reject_contact_t *sip_reject_contact_copy(su_home_t *home, sip_reject_contact_t const *hdr)
03965 __attribute__((__malloc__));
03966
03967 #if SU_HAVE_INLINE
03968 su_inline
03969 sip_reject_contact_t *sip_reject_contact_copy(su_home_t *home, sip_reject_contact_t const *hdr)
03970 {
03971 return (sip_reject_contact_t *)
03972 msg_header_copy_as(home, sip_reject_contact_class, (msg_header_t const *)hdr);
03973 }
03974 #endif
03975
03990 #if SU_HAVE_INLINE
03991 su_inline
03992 #endif
03993 sip_reject_contact_t *sip_reject_contact_make(su_home_t *home, char const *s)
03994 __attribute__((__malloc__));
03995
03996 #if SU_HAVE_INLINE
03997 su_inline sip_reject_contact_t *sip_reject_contact_make(su_home_t *home, char const *s)
03998 {
03999 return (sip_reject_contact_t *)sip_header_make(home, sip_reject_contact_class, s);
04000 }
04001 #endif
04002
04020 #if SU_HAVE_INLINE
04021 su_inline
04022 #endif
04023 sip_reject_contact_t *sip_reject_contact_format(su_home_t *home, char const *fmt, ...)
04024 __attribute__((__malloc__, __format__ (printf, 2, 3)));
04025
04026 #if SU_HAVE_INLINE
04027 su_inline sip_reject_contact_t *sip_reject_contact_format(su_home_t *home, char const *fmt, ...)
04028 {
04029 sip_header_t *h;
04030 va_list ap;
04031
04032 va_start(ap, fmt);
04033 h = sip_header_vformat(home, sip_reject_contact_class, fmt, ap);
04034 va_end(ap);
04035
04036 return (sip_reject_contact_t *)h;
04037 }
04038 #endif
04039
04047 SOFIAPUBFUN issize_t sip_expires_d(su_home_t *, msg_header_t *,
04048 char *s, isize_t slen);
04049
04051 SOFIAPUBFUN issize_t sip_expires_e(char b[], isize_t bsiz,
04052 msg_header_t const *h, int flags);
04053
04058 #define sip_expires(sip) \
04059 ((sip_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_expires_class))
04060
04074 #define SIP_EXPIRES_INIT() SIP_HDR_INIT(expires)
04075
04090 #if SU_HAVE_INLINE
04091 su_inline sip_expires_t *sip_expires_init(sip_expires_t x[1])
04092 {
04093 return SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t));
04094 }
04095 #else
04096 #define sip_expires_init(x) \
04097 SIP_HEADER_INIT(x, sip_expires_class, sizeof(sip_expires_t))
04098 #endif
04099
04111 #if SU_HAVE_INLINE
04112 su_inline int sip_is_expires(sip_header_t const *header)
04113 {
04114 return header && header->sh_class->hc_hash == sip_expires_hash;
04115 }
04116 #else
04117 int sip_is_expires(sip_header_t const *header);
04118 #endif
04119
04120 #define sip_expires_p(h) sip_is_expires((h))
04121
04122
04150 #if SU_HAVE_INLINE
04151 su_inline
04152 #endif
04153 sip_expires_t *sip_expires_dup(su_home_t *home, sip_expires_t const *hdr)
04154 __attribute__((__malloc__));
04155
04156 #if SU_HAVE_INLINE
04157 su_inline
04158 sip_expires_t *sip_expires_dup(su_home_t *home, sip_expires_t const *hdr)
04159 {
04160 return (sip_expires_t *)
04161 msg_header_dup_as(home, sip_expires_class, (msg_header_t const *)hdr);
04162 }
04163 #endif
04164
04192 #if SU_HAVE_INLINE
04193 su_inline
04194 #endif
04195 sip_expires_t *sip_expires_copy(su_home_t *home, sip_expires_t const *hdr)
04196 __attribute__((__malloc__));
04197
04198 #if SU_HAVE_INLINE
04199 su_inline
04200 sip_expires_t *sip_expires_copy(su_home_t *home, sip_expires_t const *hdr)
04201 {
04202 return (sip_expires_t *)
04203 msg_header_copy_as(home, sip_expires_class, (msg_header_t const *)hdr);
04204 }
04205 #endif
04206
04221 #if SU_HAVE_INLINE
04222 su_inline
04223 #endif
04224 sip_expires_t *sip_expires_make(su_home_t *home, char const *s)
04225 __attribute__((__malloc__));
04226
04227 #if SU_HAVE_INLINE
04228 su_inline sip_expires_t *sip_expires_make(su_home_t *home, char const *s)
04229 {
04230 return (sip_expires_t *)sip_header_make(home, sip_expires_class, s);
04231 }
04232 #endif
04233
04251 #if SU_HAVE_INLINE
04252 su_inline
04253 #endif
04254 sip_expires_t *sip_expires_format(su_home_t *home, char const *fmt, ...)
04255 __attribute__((__malloc__, __format__ (printf, 2, 3)));
04256
04257 #if SU_HAVE_INLINE
04258 su_inline sip_expires_t *sip_expires_format(su_home_t *home, char const *fmt, ...)
04259 {
04260 sip_header_t *h;
04261 va_list ap;
04262
04263 va_start(ap, fmt);
04264 h = sip_header_vformat(home, sip_expires_class, fmt, ap);
04265 va_end(ap);
04266
04267 return (sip_expires_t *)h;
04268 }
04269 #endif
04270
04278 SOFIAPUBFUN issize_t sip_date_d(su_home_t *, msg_header_t *,
04279 char *s, isize_t slen);
04280
04282 SOFIAPUBFUN issize_t sip_date_e(char b[], isize_t bsiz,
04283 msg_header_t const *h, int flags);
04284
04289 #define sip_date(sip) \
04290 ((sip_date_t *)msg_header_access((msg_pub_t*)(sip), sip_date_class))
04291
04305 #define SIP_DATE_INIT() SIP_HDR_INIT(date)
04306
04321 #if SU_HAVE_INLINE
04322 su_inline sip_date_t *sip_date_init(sip_date_t x[1])
04323 {
04324 return SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t));
04325 }
04326 #else
04327 #define sip_date_init(x) \
04328 SIP_HEADER_INIT(x, sip_date_class, sizeof(sip_date_t))
04329 #endif
04330
04342 #if SU_HAVE_INLINE
04343 su_inline int sip_is_date(sip_header_t const *header)
04344 {
04345 return header && header->sh_class->hc_hash == sip_date_hash;
04346 }
04347 #else
04348 int sip_is_date(sip_header_t const *header);
04349 #endif
04350
04351 #define sip_date_p(h) sip_is_date((h))
04352
04353
04381 #if SU_HAVE_INLINE
04382 su_inline
04383 #endif
04384 sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
04385 __attribute__((__malloc__));
04386
04387 #if SU_HAVE_INLINE
04388 su_inline
04389 sip_date_t *sip_date_dup(su_home_t *home, sip_date_t const *hdr)
04390 {
04391 return (sip_date_t *)
04392 msg_header_dup_as(home, sip_date_class, (msg_header_t const *)hdr);
04393 }
04394 #endif
04395
04423 #if SU_HAVE_INLINE
04424 su_inline
04425 #endif
04426 sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
04427 __attribute__((__malloc__));
04428
04429 #if SU_HAVE_INLINE
04430 su_inline
04431 sip_date_t *sip_date_copy(su_home_t *home, sip_date_t const *hdr)
04432 {
04433 return (sip_date_t *)
04434 msg_header_copy_as(home, sip_date_class, (msg_header_t const *)hdr);
04435 }
04436 #endif
04437
04452 #if SU_HAVE_INLINE
04453 su_inline
04454 #endif
04455 sip_date_t *sip_date_make(su_home_t *home, char const *s)
04456 __attribute__((__malloc__));
04457
04458 #if SU_HAVE_INLINE
04459 su_inline sip_date_t *sip_date_make(su_home_t *home, char const *s)
04460 {
04461 return (sip_date_t *)sip_header_make(home, sip_date_class, s);
04462 }
04463 #endif
04464
04482 #if SU_HAVE_INLINE
04483 su_inline
04484 #endif
04485 sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
04486 __attribute__((__malloc__, __format__ (printf, 2, 3)));
04487
04488 #if SU_HAVE_INLINE
04489 su_inline sip_date_t *sip_date_format(su_home_t *home, char const *fmt, ...)
04490 {
04491 sip_header_t *h;
04492 va_list ap;
04493
04494 va_start(ap, fmt);
04495 h = sip_header_vformat(home, sip_date_class, fmt, ap);
04496 va_end(ap);
04497
04498 return (sip_date_t *)h;
04499 }
04500 #endif
04501
04509 SOFIAPUBFUN issize_t sip_retry_after_d(su_home_t *, msg_header_t *,
04510 char *s, isize_t slen);
04511
04513 SOFIAPUBFUN issize_t sip_retry_after_e(char b[], isize_t bsiz,
04514 msg_header_t const *h, int flags);
04515
04520 #define sip_retry_after(sip) \
04521 ((sip_retry_after_t *)msg_header_access((msg_pub_t*)(sip), sip_retry_after_class))
04522
04536 #define SIP_RETRY_AFTER_INIT() SIP_HDR_INIT(retry_after)
04537
04552 #if SU_HAVE_INLINE
04553 su_inline sip_retry_after_t *sip_retry_after_init(sip_retry_after_t x[1])
04554 {
04555 return SIP_HEADER_INIT(x, sip_retry_after_class, sizeof(sip_retry_after_t));
04556 }
04557 #else
04558 #define sip_retry_after_init(x) \
04559 SIP_HEADER_INIT(x, sip_retry_after_class, sizeof(sip_retry_after_t))
04560 #endif
04561
04573 #if SU_HAVE_INLINE
04574 su_inline int sip_is_retry_after(sip_header_t const *header)
04575 {
04576 return header && header->sh_class->hc_hash == sip_retry_after_hash;
04577 }
04578 #else
04579 int sip_is_retry_after(sip_header_t const *header);
04580 #endif
04581
04582 #define sip_retry_after_p(h) sip_is_retry_after((h))
04583
04584
04612 #if SU_HAVE_INLINE
04613 su_inline
04614 #endif
04615 sip_retry_after_t *sip_retry_after_dup(su_home_t *home, sip_retry_after_t const *hdr)
04616 __attribute__((__malloc__));
04617
04618 #if SU_HAVE_INLINE
04619 su_inline
04620 sip_retry_after_t *sip_retry_after_dup(su_home_t *home, sip_retry_after_t const *hdr)
04621 {
04622 return (sip_retry_after_t *)
04623 msg_header_dup_as(home, sip_retry_after_class, (msg_header_t const *)hdr);
04624 }
04625 #endif
04626
04654 #if SU_HAVE_INLINE
04655 su_inline
04656 #endif
04657 sip_retry_after_t *sip_retry_after_copy(su_home_t *home, sip_retry_after_t const *hdr)
04658 __attribute__((__malloc__));
04659
04660 #if SU_HAVE_INLINE
04661 su_inline
04662 sip_retry_after_t *sip_retry_after_copy(su_home_t *home, sip_retry_after_t const *hdr)
04663 {
04664 return (sip_retry_after_t *)
04665 msg_header_copy_as(home, sip_retry_after_class, (msg_header_t const *)hdr);
04666 }
04667 #endif
04668
04683 #if SU_HAVE_INLINE
04684 su_inline
04685 #endif
04686 sip_retry_after_t *sip_retry_after_make(su_home_t *home, char const *s)
04687 __attribute__((__malloc__));
04688
04689 #if SU_HAVE_INLINE
04690 su_inline sip_retry_after_t *sip_retry_after_make(su_home_t *home, char const *s)
04691 {
04692 return (sip_retry_after_t *)sip_header_make(home, sip_retry_after_class, s);
04693 }
04694 #endif
04695
04713 #if SU_HAVE_INLINE
04714 su_inline
04715 #endif
04716 sip_retry_after_t *sip_retry_after_format(su_home_t *home, char const *fmt, ...)
04717 __attribute__((__malloc__, __format__ (printf, 2, 3)));
04718
04719 #if SU_HAVE_INLINE
04720 su_inline sip_retry_after_t *sip_retry_after_format(su_home_t *home, char const *fmt, ...)
04721 {
04722 sip_header_t *h;
04723 va_list ap;
04724
04725 va_start(ap, fmt);
04726 h = sip_header_vformat(home, sip_retry_after_class, fmt, ap);
04727 va_end(ap);
04728
04729 return (sip_retry_after_t *)h;
04730 }
04731 #endif
04732
04740 SOFIAPUBFUN issize_t sip_timestamp_d(su_home_t *, msg_header_t *,
04741 char *s, isize_t slen);
04742
04744 SOFIAPUBFUN issize_t sip_timestamp_e(char b[], isize_t bsiz,
04745 msg_header_t const *h, int flags);
04746
04751 #define sip_timestamp(sip) \
04752 ((sip_timestamp_t *)msg_header_access((msg_pub_t*)(sip), sip_timestamp_class))
04753
04767 #define SIP_TIMESTAMP_INIT() SIP_HDR_INIT(timestamp)
04768
04783 #if SU_HAVE_INLINE
04784 su_inline sip_timestamp_t *sip_timestamp_init(sip_timestamp_t x[1])
04785 {
04786 return SIP_HEADER_INIT(x, sip_timestamp_class, sizeof(sip_timestamp_t));
04787 }
04788 #else
04789 #define sip_timestamp_init(x) \
04790 SIP_HEADER_INIT(x, sip_timestamp_class, sizeof(sip_timestamp_t))
04791 #endif
04792
04804 #if SU_HAVE_INLINE
04805 su_inline int sip_is_timestamp(sip_header_t const *header)
04806 {
04807 return header && header->sh_class->hc_hash == sip_timestamp_hash;
04808 }
04809 #else
04810 int sip_is_timestamp(sip_header_t const *header);
04811 #endif
04812
04813 #define sip_timestamp_p(h) sip_is_timestamp((h))
04814
04815
04843 #if SU_HAVE_INLINE
04844 su_inline
04845 #endif
04846 sip_timestamp_t *sip_timestamp_dup(su_home_t *home, sip_timestamp_t const *hdr)
04847 __attribute__((__malloc__));
04848
04849 #if SU_HAVE_INLINE
04850 su_inline
04851 sip_timestamp_t *sip_timestamp_dup(su_home_t *home, sip_timestamp_t const *hdr)
04852 {
04853 return (sip_timestamp_t *)
04854 msg_header_dup_as(home, sip_timestamp_class, (msg_header_t const *)hdr);
04855 }
04856 #endif
04857
04885 #if SU_HAVE_INLINE
04886 su_inline
04887 #endif
04888 sip_timestamp_t *sip_timestamp_copy(su_home_t *home, sip_timestamp_t const *hdr)
04889 __attribute__((__malloc__));
04890
04891 #if SU_HAVE_INLINE
04892 su_inline
04893 sip_timestamp_t *sip_timestamp_copy(su_home_t *home, sip_timestamp_t const *hdr)
04894 {
04895 return (sip_timestamp_t *)
04896 msg_header_copy_as(home, sip_timestamp_class, (msg_header_t const *)hdr);
04897 }
04898 #endif
04899
04914 #if SU_HAVE_INLINE
04915 su_inline
04916 #endif
04917 sip_timestamp_t *sip_timestamp_make(su_home_t *home, char const *s)
04918 __attribute__((__malloc__));
04919
04920 #if SU_HAVE_INLINE
04921 su_inline sip_timestamp_t *sip_timestamp_make(su_home_t *home, char const *s)
04922 {
04923 return (sip_timestamp_t *)sip_header_make(home, sip_timestamp_class, s);
04924 }
04925 #endif
04926
04944 #if SU_HAVE_INLINE
04945 su_inline
04946 #endif
04947 sip_timestamp_t *sip_timestamp_format(su_home_t *home, char const *fmt, ...)
04948 __attribute__((__malloc__, __format__ (printf, 2, 3)));
04949
04950 #if SU_HAVE_INLINE
04951 su_inline sip_timestamp_t *sip_timestamp_format(su_home_t *home, char const *fmt, ...)
04952 {
04953 sip_header_t *h;
04954 va_list ap;
04955
04956 va_start(ap, fmt);
04957 h = sip_header_vformat(home, sip_timestamp_class, fmt, ap);
04958 va_end(ap);
04959
04960 return (sip_timestamp_t *)h;
04961 }
04962 #endif
04963
04971 SOFIAPUBFUN issize_t sip_min_expires_d(su_home_t *, msg_header_t *,
04972 char *s, isize_t slen);
04973
04975 SOFIAPUBFUN issize_t sip_min_expires_e(char b[], isize_t bsiz,
04976 msg_header_t const *h, int flags);
04977
04982 #define sip_min_expires(sip) \
04983 ((sip_min_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_min_expires_class))
04984
04998 #define SIP_MIN_EXPIRES_INIT() SIP_HDR_INIT(min_expires)
04999
05014 #if SU_HAVE_INLINE
05015 su_inline sip_min_expires_t *sip_min_expires_init(sip_min_expires_t x[1])
05016 {
05017 return SIP_HEADER_INIT(x, sip_min_expires_class, sizeof(sip_min_expires_t));
05018 }
05019 #else
05020 #define sip_min_expires_init(x) \
05021 SIP_HEADER_INIT(x, sip_min_expires_class, sizeof(sip_min_expires_t))
05022 #endif
05023
05035 #if SU_HAVE_INLINE
05036 su_inline int sip_is_min_expires(sip_header_t const *header)
05037 {
05038 return header && header->sh_class->hc_hash == sip_min_expires_hash;
05039 }
05040 #else
05041 int sip_is_min_expires(sip_header_t const *header);
05042 #endif
05043
05044 #define sip_min_expires_p(h) sip_is_min_expires((h))
05045
05046
05074 #if SU_HAVE_INLINE
05075 su_inline
05076 #endif
05077 sip_min_expires_t *sip_min_expires_dup(su_home_t *home, sip_min_expires_t const *hdr)
05078 __attribute__((__malloc__));
05079
05080 #if SU_HAVE_INLINE
05081 su_inline
05082 sip_min_expires_t *sip_min_expires_dup(su_home_t *home, sip_min_expires_t const *hdr)
05083 {
05084 return (sip_min_expires_t *)
05085 msg_header_dup_as(home, sip_min_expires_class, (msg_header_t const *)hdr);
05086 }
05087 #endif
05088
05116 #if SU_HAVE_INLINE
05117 su_inline
05118 #endif
05119 sip_min_expires_t *sip_min_expires_copy(su_home_t *home, sip_min_expires_t const *hdr)
05120 __attribute__((__malloc__));
05121
05122 #if SU_HAVE_INLINE
05123 su_inline
05124 sip_min_expires_t *sip_min_expires_copy(su_home_t *home, sip_min_expires_t const *hdr)
05125 {
05126 return (sip_min_expires_t *)
05127 msg_header_copy_as(home, sip_min_expires_class, (msg_header_t const *)hdr);
05128 }
05129 #endif
05130
05145 #if SU_HAVE_INLINE
05146 su_inline
05147 #endif
05148 sip_min_expires_t *sip_min_expires_make(su_home_t *home, char const *s)
05149 __attribute__((__malloc__));
05150
05151 #if SU_HAVE_INLINE
05152 su_inline sip_min_expires_t *sip_min_expires_make(su_home_t *home, char const *s)
05153 {
05154 return (sip_min_expires_t *)sip_header_make(home, sip_min_expires_class, s);
05155 }
05156 #endif
05157
05175 #if SU_HAVE_INLINE
05176 su_inline
05177 #endif
05178 sip_min_expires_t *sip_min_expires_format(su_home_t *home, char const *fmt, ...)
05179 __attribute__((__malloc__, __format__ (printf, 2, 3)));
05180
05181 #if SU_HAVE_INLINE
05182 su_inline sip_min_expires_t *sip_min_expires_format(su_home_t *home, char const *fmt, ...)
05183 {
05184 sip_header_t *h;
05185 va_list ap;
05186
05187 va_start(ap, fmt);
05188 h = sip_header_vformat(home, sip_min_expires_class, fmt, ap);
05189 va_end(ap);
05190
05191 return (sip_min_expires_t *)h;
05192 }
05193 #endif
05194
05202 SOFIAPUBFUN issize_t sip_subject_d(su_home_t *, msg_header_t *,
05203 char *s, isize_t slen);
05204
05206 SOFIAPUBFUN issize_t sip_subject_e(char b[], isize_t bsiz,
05207 msg_header_t const *h, int flags);
05208
05213 #define sip_subject(sip) \
05214 ((sip_subject_t *)msg_header_access((msg_pub_t*)(sip), sip_subject_class))
05215
05229 #define SIP_SUBJECT_INIT() SIP_HDR_INIT(subject)
05230
05245 #if SU_HAVE_INLINE
05246 su_inline sip_subject_t *sip_subject_init(sip_subject_t x[1])
05247 {
05248 return SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t));
05249 }
05250 #else
05251 #define sip_subject_init(x) \
05252 SIP_HEADER_INIT(x, sip_subject_class, sizeof(sip_subject_t))
05253 #endif
05254
05266 #if SU_HAVE_INLINE
05267 su_inline int sip_is_subject(sip_header_t const *header)
05268 {
05269 return header && header->sh_class->hc_hash == sip_subject_hash;
05270 }
05271 #else
05272 int sip_is_subject(sip_header_t const *header);
05273 #endif
05274
05275 #define sip_subject_p(h) sip_is_subject((h))
05276
05277
05305 #if SU_HAVE_INLINE
05306 su_inline
05307 #endif
05308 sip_subject_t *sip_subject_dup(su_home_t *home, sip_subject_t const *hdr)
05309 __attribute__((__malloc__));
05310
05311 #if SU_HAVE_INLINE
05312 su_inline
05313 sip_subject_t *sip_subject_dup(su_home_t *home, sip_subject_t const *hdr)
05314 {
05315 return (sip_subject_t *)
05316 msg_header_dup_as(home, sip_subject_class, (msg_header_t const *)hdr);
05317 }
05318 #endif
05319
05347 #if SU_HAVE_INLINE
05348 su_inline
05349 #endif
05350 sip_subject_t *sip_subject_copy(su_home_t *home, sip_subject_t const *hdr)
05351 __attribute__((__malloc__));
05352
05353 #if SU_HAVE_INLINE
05354 su_inline
05355 sip_subject_t *sip_subject_copy(su_home_t *home, sip_subject_t const *hdr)
05356 {
05357 return (sip_subject_t *)
05358 msg_header_copy_as(home, sip_subject_class, (msg_header_t const *)hdr);
05359 }
05360 #endif
05361
05376 #if SU_HAVE_INLINE
05377 su_inline
05378 #endif
05379 sip_subject_t *sip_subject_make(su_home_t *home, char const *s)
05380 __attribute__((__malloc__));
05381
05382 #if SU_HAVE_INLINE
05383 su_inline sip_subject_t *sip_subject_make(su_home_t *home, char const *s)
05384 {
05385 return (sip_subject_t *)sip_header_make(home, sip_subject_class, s);
05386 }
05387 #endif
05388
05406 #if SU_HAVE_INLINE
05407 su_inline
05408 #endif
05409 sip_subject_t *sip_subject_format(su_home_t *home, char const *fmt, ...)
05410 __attribute__((__malloc__, __format__ (printf, 2, 3)));
05411
05412 #if SU_HAVE_INLINE
05413 su_inline sip_subject_t *sip_subject_format(su_home_t *home, char const *fmt, ...)
05414 {
05415 sip_header_t *h;
05416 va_list ap;
05417
05418 va_start(ap, fmt);
05419 h = sip_header_vformat(home, sip_subject_class, fmt, ap);
05420 va_end(ap);
05421
05422 return (sip_subject_t *)h;
05423 }
05424 #endif
05425
05433 SOFIAPUBFUN issize_t sip_priority_d(su_home_t *, msg_header_t *,
05434 char *s, isize_t slen);
05435
05437 SOFIAPUBFUN issize_t sip_priority_e(char b[], isize_t bsiz,
05438 msg_header_t const *h, int flags);
05439
05444 #define sip_priority(sip) \
05445 ((sip_priority_t *)msg_header_access((msg_pub_t*)(sip), sip_priority_class))
05446
05460 #define SIP_PRIORITY_INIT() SIP_HDR_INIT(priority)
05461
05476 #if SU_HAVE_INLINE
05477 su_inline sip_priority_t *sip_priority_init(sip_priority_t x[1])
05478 {
05479 return SIP_HEADER_INIT(x, sip_priority_class, sizeof(sip_priority_t));
05480 }
05481 #else
05482 #define sip_priority_init(x) \
05483 SIP_HEADER_INIT(x, sip_priority_class, sizeof(sip_priority_t))
05484 #endif
05485
05497 #if SU_HAVE_INLINE
05498 su_inline int sip_is_priority(sip_header_t const *header)
05499 {
05500 return header && header->sh_class->hc_hash == sip_priority_hash;
05501 }
05502 #else
05503 int sip_is_priority(sip_header_t const *header);
05504 #endif
05505
05506 #define sip_priority_p(h) sip_is_priority((h))
05507
05508
05536 #if SU_HAVE_INLINE
05537 su_inline
05538 #endif
05539 sip_priority_t *sip_priority_dup(su_home_t *home, sip_priority_t const *hdr)
05540 __attribute__((__malloc__));
05541
05542 #if SU_HAVE_INLINE
05543 su_inline
05544 sip_priority_t *sip_priority_dup(su_home_t *home, sip_priority_t const *hdr)
05545 {
05546 return (sip_priority_t *)
05547 msg_header_dup_as(home, sip_priority_class, (msg_header_t const *)hdr);
05548 }
05549 #endif
05550
05578 #if SU_HAVE_INLINE
05579 su_inline
05580 #endif
05581 sip_priority_t *sip_priority_copy(su_home_t *home, sip_priority_t const *hdr)
05582 __attribute__((__malloc__));
05583
05584 #if SU_HAVE_INLINE
05585 su_inline
05586 sip_priority_t *sip_priority_copy(su_home_t *home, sip_priority_t const *hdr)
05587 {
05588 return (sip_priority_t *)
05589 msg_header_copy_as(home, sip_priority_class, (msg_header_t const *)hdr);
05590 }
05591 #endif
05592
05607 #if SU_HAVE_INLINE
05608 su_inline
05609 #endif
05610 sip_priority_t *sip_priority_make(su_home_t *home, char const *s)
05611 __attribute__((__malloc__));
05612
05613 #if SU_HAVE_INLINE
05614 su_inline sip_priority_t *sip_priority_make(su_home_t *home, char const *s)
05615 {
05616 return (sip_priority_t *)sip_header_make(home, sip_priority_class, s);
05617 }
05618 #endif
05619
05637 #if SU_HAVE_INLINE
05638 su_inline
05639 #endif
05640 sip_priority_t *sip_priority_format(su_home_t *home, char const *fmt, ...)
05641 __attribute__((__malloc__, __format__ (printf, 2, 3)));
05642
05643 #if SU_HAVE_INLINE
05644 su_inline sip_priority_t *sip_priority_format(su_home_t *home, char const *fmt, ...)
05645 {
05646 sip_header_t *h;
05647 va_list ap;
05648
05649 va_start(ap, fmt);
05650 h = sip_header_vformat(home, sip_priority_class, fmt, ap);
05651 va_end(ap);
05652
05653 return (sip_priority_t *)h;
05654 }
05655 #endif
05656
05664 SOFIAPUBFUN issize_t sip_call_info_d(su_home_t *, msg_header_t *,
05665 char *s, isize_t slen);
05666
05668 SOFIAPUBFUN issize_t sip_call_info_e(char b[], isize_t bsiz,
05669 msg_header_t const *h, int flags);
05670
05675 #define sip_call_info(sip) \
05676 ((sip_call_info_t *)msg_header_access((msg_pub_t*)(sip), sip_call_info_class))
05677
05691 #define SIP_CALL_INFO_INIT() SIP_HDR_INIT(call_info)
05692
05707 #if SU_HAVE_INLINE
05708 su_inline sip_call_info_t *sip_call_info_init(sip_call_info_t x[1])
05709 {
05710 return SIP_HEADER_INIT(x, sip_call_info_class, sizeof(sip_call_info_t));
05711 }
05712 #else
05713 #define sip_call_info_init(x) \
05714 SIP_HEADER_INIT(x, sip_call_info_class, sizeof(sip_call_info_t))
05715 #endif
05716
05728 #if SU_HAVE_INLINE
05729 su_inline int sip_is_call_info(sip_header_t const *header)
05730 {
05731 return header && header->sh_class->hc_hash == sip_call_info_hash;
05732 }
05733 #else
05734 int sip_is_call_info(sip_header_t const *header);
05735 #endif
05736
05737 #define sip_call_info_p(h) sip_is_call_info((h))
05738
05739
05767 #if SU_HAVE_INLINE
05768 su_inline
05769 #endif
05770 sip_call_info_t *sip_call_info_dup(su_home_t *home, sip_call_info_t const *hdr)
05771 __attribute__((__malloc__));
05772
05773 #if SU_HAVE_INLINE
05774 su_inline
05775 sip_call_info_t *sip_call_info_dup(su_home_t *home, sip_call_info_t const *hdr)
05776 {
05777 return (sip_call_info_t *)
05778 msg_header_dup_as(home, sip_call_info_class, (msg_header_t const *)hdr);
05779 }
05780 #endif
05781
05809 #if SU_HAVE_INLINE
05810 su_inline
05811 #endif
05812 sip_call_info_t *sip_call_info_copy(su_home_t *home, sip_call_info_t const *hdr)
05813 __attribute__((__malloc__));
05814
05815 #if SU_HAVE_INLINE
05816 su_inline
05817 sip_call_info_t *sip_call_info_copy(su_home_t *home, sip_call_info_t const *hdr)
05818 {
05819 return (sip_call_info_t *)
05820 msg_header_copy_as(home, sip_call_info_class, (msg_header_t const *)hdr);
05821 }
05822 #endif
05823
05838 #if SU_HAVE_INLINE
05839 su_inline
05840 #endif
05841 sip_call_info_t *sip_call_info_make(su_home_t *home, char const *s)
05842 __attribute__((__malloc__));
05843
05844 #if SU_HAVE_INLINE
05845 su_inline sip_call_info_t *sip_call_info_make(su_home_t *home, char const *s)
05846 {
05847 return (sip_call_info_t *)sip_header_make(home, sip_call_info_class, s);
05848 }
05849 #endif
05850
05868 #if SU_HAVE_INLINE
05869 su_inline
05870 #endif
05871 sip_call_info_t *sip_call_info_format(su_home_t *home, char const *fmt, ...)
05872 __attribute__((__malloc__, __format__ (printf, 2, 3)));
05873
05874 #if SU_HAVE_INLINE
05875 su_inline sip_call_info_t *sip_call_info_format(su_home_t *home, char const *fmt, ...)
05876 {
05877 sip_header_t *h;
05878 va_list ap;
05879
05880 va_start(ap, fmt);
05881 h = sip_header_vformat(home, sip_call_info_class, fmt, ap);
05882 va_end(ap);
05883
05884 return (sip_call_info_t *)h;
05885 }
05886 #endif
05887
05895 SOFIAPUBFUN issize_t sip_organization_d(su_home_t *, msg_header_t *,
05896 char *s, isize_t slen);
05897
05899 SOFIAPUBFUN issize_t sip_organization_e(char b[], isize_t bsiz,
05900 msg_header_t const *h, int flags);
05901
05906 #define sip_organization(sip) \
05907 ((sip_organization_t *)msg_header_access((msg_pub_t*)(sip), sip_organization_class))
05908
05922 #define SIP_ORGANIZATION_INIT() SIP_HDR_INIT(organization)
05923
05938 #if SU_HAVE_INLINE
05939 su_inline sip_organization_t *sip_organization_init(sip_organization_t x[1])
05940 {
05941 return SIP_HEADER_INIT(x, sip_organization_class, sizeof(sip_organization_t));
05942 }
05943 #else
05944 #define sip_organization_init(x) \
05945 SIP_HEADER_INIT(x, sip_organization_class, sizeof(sip_organization_t))
05946 #endif
05947
05959 #if SU_HAVE_INLINE
05960 su_inline int sip_is_organization(sip_header_t const *header)
05961 {
05962 return header && header->sh_class->hc_hash == sip_organization_hash;
05963 }
05964 #else
05965 int sip_is_organization(sip_header_t const *header);
05966 #endif
05967
05968 #define sip_organization_p(h) sip_is_organization((h))
05969
05970
05998 #if SU_HAVE_INLINE
05999 su_inline
06000 #endif
06001 sip_organization_t *sip_organization_dup(su_home_t *home, sip_organization_t const *hdr)
06002 __attribute__((__malloc__));
06003
06004 #if SU_HAVE_INLINE
06005 su_inline
06006 sip_organization_t *sip_organization_dup(su_home_t *home, sip_organization_t const *hdr)
06007 {
06008 return (sip_organization_t *)
06009 msg_header_dup_as(home, sip_organization_class, (msg_header_t const *)hdr);
06010 }
06011 #endif
06012
06040 #if SU_HAVE_INLINE
06041 su_inline
06042 #endif
06043 sip_organization_t *sip_organization_copy(su_home_t *home, sip_organization_t const *hdr)
06044 __attribute__((__malloc__));
06045
06046 #if SU_HAVE_INLINE
06047 su_inline
06048 sip_organization_t *sip_organization_copy(su_home_t *home, sip_organization_t const *hdr)
06049 {
06050 return (sip_organization_t *)
06051 msg_header_copy_as(home, sip_organization_class, (msg_header_t const *)hdr);
06052 }
06053 #endif
06054
06069 #if SU_HAVE_INLINE
06070 su_inline
06071 #endif
06072 sip_organization_t *sip_organization_make(su_home_t *home, char const *s)
06073 __attribute__((__malloc__));
06074
06075 #if SU_HAVE_INLINE
06076 su_inline sip_organization_t *sip_organization_make(su_home_t *home, char const *s)
06077 {
06078 return (sip_organization_t *)sip_header_make(home, sip_organization_class, s);
06079 }
06080 #endif
06081
06099 #if SU_HAVE_INLINE
06100 su_inline
06101 #endif
06102 sip_organization_t *sip_organization_format(su_home_t *home, char const *fmt, ...)
06103 __attribute__((__malloc__, __format__ (printf, 2, 3)));
06104
06105 #if SU_HAVE_INLINE
06106 su_inline sip_organization_t *sip_organization_format(su_home_t *home, char const *fmt, ...)
06107 {
06108 sip_header_t *h;
06109 va_list ap;
06110
06111 va_start(ap, fmt);
06112 h = sip_header_vformat(home, sip_organization_class, fmt, ap);
06113 va_end(ap);
06114
06115 return (sip_organization_t *)h;
06116 }
06117 #endif
06118
06126 SOFIAPUBFUN issize_t sip_server_d(su_home_t *, msg_header_t *,
06127 char *s, isize_t slen);
06128
06130 SOFIAPUBFUN issize_t sip_server_e(char b[], isize_t bsiz,
06131 msg_header_t const *h, int flags);
06132
06137 #define sip_server(sip) \
06138 ((sip_server_t *)msg_header_access((msg_pub_t*)(sip), sip_server_class))
06139
06153 #define SIP_SERVER_INIT() SIP_HDR_INIT(server)
06154
06169 #if SU_HAVE_INLINE
06170 su_inline sip_server_t *sip_server_init(sip_server_t x[1])
06171 {
06172 return SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t));
06173 }
06174 #else
06175 #define sip_server_init(x) \
06176 SIP_HEADER_INIT(x, sip_server_class, sizeof(sip_server_t))
06177 #endif
06178
06190 #if SU_HAVE_INLINE
06191 su_inline int sip_is_server(sip_header_t const *header)
06192 {
06193 return header && header->sh_class->hc_hash == sip_server_hash;
06194 }
06195 #else
06196 int sip_is_server(sip_header_t const *header);
06197 #endif
06198
06199 #define sip_server_p(h) sip_is_server((h))
06200
06201
06229 #if SU_HAVE_INLINE
06230 su_inline
06231 #endif
06232 sip_server_t *sip_server_dup(su_home_t *home, sip_server_t const *hdr)
06233 __attribute__((__malloc__));
06234
06235 #if SU_HAVE_INLINE
06236 su_inline
06237 sip_server_t *sip_server_dup(su_home_t *home, sip_server_t const *hdr)
06238 {
06239 return (sip_server_t *)
06240 msg_header_dup_as(home, sip_server_class, (msg_header_t const *)hdr);
06241 }
06242 #endif
06243
06271 #if SU_HAVE_INLINE
06272 su_inline
06273 #endif
06274 sip_server_t *sip_server_copy(su_home_t *home, sip_server_t const *hdr)
06275 __attribute__((__malloc__));
06276
06277 #if SU_HAVE_INLINE
06278 su_inline
06279 sip_server_t *sip_server_copy(su_home_t *home, sip_server_t const *hdr)
06280 {
06281 return (sip_server_t *)
06282 msg_header_copy_as(home, sip_server_class, (msg_header_t const *)hdr);
06283 }
06284 #endif
06285
06300 #if SU_HAVE_INLINE
06301 su_inline
06302 #endif
06303 sip_server_t *sip_server_make(su_home_t *home, char const *s)
06304 __attribute__((__malloc__));
06305
06306 #if SU_HAVE_INLINE
06307 su_inline sip_server_t *sip_server_make(su_home_t *home, char const *s)
06308 {
06309 return (sip_server_t *)sip_header_make(home, sip_server_class, s);
06310 }
06311 #endif
06312
06330 #if SU_HAVE_INLINE
06331 su_inline
06332 #endif
06333 sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
06334 __attribute__((__malloc__, __format__ (printf, 2, 3)));
06335
06336 #if SU_HAVE_INLINE
06337 su_inline sip_server_t *sip_server_format(su_home_t *home, char const *fmt, ...)
06338 {
06339 sip_header_t *h;
06340 va_list ap;
06341
06342 va_start(ap, fmt);
06343 h = sip_header_vformat(home, sip_server_class, fmt, ap);
06344 va_end(ap);
06345
06346 return (sip_server_t *)h;
06347 }
06348 #endif
06349
06357 SOFIAPUBFUN issize_t sip_user_agent_d(su_home_t *, msg_header_t *,
06358 char *s, isize_t slen);
06359
06361 SOFIAPUBFUN issize_t sip_user_agent_e(char b[], isize_t bsiz,
06362 msg_header_t const *h, int flags);
06363
06368 #define sip_user_agent(sip) \
06369 ((sip_user_agent_t *)msg_header_access((msg_pub_t*)(sip), sip_user_agent_class))
06370
06384 #define SIP_USER_AGENT_INIT() SIP_HDR_INIT(user_agent)
06385
06400 #if SU_HAVE_INLINE
06401 su_inline sip_user_agent_t *sip_user_agent_init(sip_user_agent_t x[1])
06402 {
06403 return SIP_HEADER_INIT(x, sip_user_agent_class, sizeof(sip_user_agent_t));
06404 }
06405 #else
06406 #define sip_user_agent_init(x) \
06407 SIP_HEADER_INIT(x, sip_user_agent_class, sizeof(sip_user_agent_t))
06408 #endif
06409
06421 #if SU_HAVE_INLINE
06422 su_inline int sip_is_user_agent(sip_header_t const *header)
06423 {
06424 return header && header->sh_class->hc_hash == sip_user_agent_hash;
06425 }
06426 #else
06427 int sip_is_user_agent(sip_header_t const *header);
06428 #endif
06429
06430 #define sip_user_agent_p(h) sip_is_user_agent((h))
06431
06432
06460 #if SU_HAVE_INLINE
06461 su_inline
06462 #endif
06463 sip_user_agent_t *sip_user_agent_dup(su_home_t *home, sip_user_agent_t const *hdr)
06464 __attribute__((__malloc__));
06465
06466 #if SU_HAVE_INLINE
06467 su_inline
06468 sip_user_agent_t *sip_user_agent_dup(su_home_t *home, sip_user_agent_t const *hdr)
06469 {
06470 return (sip_user_agent_t *)
06471 msg_header_dup_as(home, sip_user_agent_class, (msg_header_t const *)hdr);
06472 }
06473 #endif
06474
06502 #if SU_HAVE_INLINE
06503 su_inline
06504 #endif
06505 sip_user_agent_t *sip_user_agent_copy(su_home_t *home, sip_user_agent_t const *hdr)
06506 __attribute__((__malloc__));
06507
06508 #if SU_HAVE_INLINE
06509 su_inline
06510 sip_user_agent_t *sip_user_agent_copy(su_home_t *home, sip_user_agent_t const *hdr)
06511 {
06512 return (sip_user_agent_t *)
06513 msg_header_copy_as(home, sip_user_agent_class, (msg_header_t const *)hdr);
06514 }
06515 #endif
06516
06531 #if SU_HAVE_INLINE
06532 su_inline
06533 #endif
06534 sip_user_agent_t *sip_user_agent_make(su_home_t *home, char const *s)
06535 __attribute__((__malloc__));
06536
06537 #if SU_HAVE_INLINE
06538 su_inline sip_user_agent_t *sip_user_agent_make(su_home_t *home, char const *s)
06539 {
06540 return (sip_user_agent_t *)sip_header_make(home, sip_user_agent_class, s);
06541 }
06542 #endif
06543
06561 #if SU_HAVE_INLINE
06562 su_inline
06563 #endif
06564 sip_user_agent_t *sip_user_agent_format(su_home_t *home, char const *fmt, ...)
06565 __attribute__((__malloc__, __format__ (printf, 2, 3)));
06566
06567 #if SU_HAVE_INLINE
06568 su_inline sip_user_agent_t *sip_user_agent_format(su_home_t *home, char const *fmt, ...)
06569 {
06570 sip_header_t *h;
06571 va_list ap;
06572
06573 va_start(ap, fmt);
06574 h = sip_header_vformat(home, sip_user_agent_class, fmt, ap);
06575 va_end(ap);
06576
06577 return (sip_user_agent_t *)h;
06578 }
06579 #endif
06580
06588 SOFIAPUBFUN issize_t sip_in_reply_to_d(su_home_t *, msg_header_t *,
06589 char *s, isize_t slen);
06590
06592 SOFIAPUBFUN issize_t sip_in_reply_to_e(char b[], isize_t bsiz,
06593 msg_header_t const *h, int flags);
06594
06599 #define sip_in_reply_to(sip) \
06600 ((sip_in_reply_to_t *)msg_header_access((msg_pub_t*)(sip), sip_in_reply_to_class))
06601
06615 #define SIP_IN_REPLY_TO_INIT() SIP_HDR_INIT(in_reply_to)
06616
06631 #if SU_HAVE_INLINE
06632 su_inline sip_in_reply_to_t *sip_in_reply_to_init(sip_in_reply_to_t x[1])
06633 {
06634 return SIP_HEADER_INIT(x, sip_in_reply_to_class, sizeof(sip_in_reply_to_t));
06635 }
06636 #else
06637 #define sip_in_reply_to_init(x) \
06638 SIP_HEADER_INIT(x, sip_in_reply_to_class, sizeof(sip_in_reply_to_t))
06639 #endif
06640
06652 #if SU_HAVE_INLINE
06653 su_inline int sip_is_in_reply_to(sip_header_t const *header)
06654 {
06655 return header && header->sh_class->hc_hash == sip_in_reply_to_hash;
06656 }
06657 #else
06658 int sip_is_in_reply_to(sip_header_t const *header);
06659 #endif
06660
06661 #define sip_in_reply_to_p(h) sip_is_in_reply_to((h))
06662
06663
06691 #if SU_HAVE_INLINE
06692 su_inline
06693 #endif
06694 sip_in_reply_to_t *sip_in_reply_to_dup(su_home_t *home, sip_in_reply_to_t const *hdr)
06695 __attribute__((__malloc__));
06696
06697 #if SU_HAVE_INLINE
06698 su_inline
06699 sip_in_reply_to_t *sip_in_reply_to_dup(su_home_t *home, sip_in_reply_to_t const *hdr)
06700 {
06701 return (sip_in_reply_to_t *)
06702 msg_header_dup_as(home, sip_in_reply_to_class, (msg_header_t const *)hdr);
06703 }
06704 #endif
06705
06733 #if SU_HAVE_INLINE
06734 su_inline
06735 #endif
06736 sip_in_reply_to_t *sip_in_reply_to_copy(su_home_t *home, sip_in_reply_to_t const *hdr)
06737 __attribute__((__malloc__));
06738
06739 #if SU_HAVE_INLINE
06740 su_inline
06741 sip_in_reply_to_t *sip_in_reply_to_copy(su_home_t *home, sip_in_reply_to_t const *hdr)
06742 {
06743 return (sip_in_reply_to_t *)
06744 msg_header_copy_as(home, sip_in_reply_to_class, (msg_header_t const *)hdr);
06745 }
06746 #endif
06747
06762 #if SU_HAVE_INLINE
06763 su_inline
06764 #endif
06765 sip_in_reply_to_t *sip_in_reply_to_make(su_home_t *home, char const *s)
06766 __attribute__((__malloc__));
06767
06768 #if SU_HAVE_INLINE
06769 su_inline sip_in_reply_to_t *sip_in_reply_to_make(su_home_t *home, char const *s)
06770 {
06771 return (sip_in_reply_to_t *)sip_header_make(home, sip_in_reply_to_class, s);
06772 }
06773 #endif
06774
06792 #if SU_HAVE_INLINE
06793 su_inline
06794 #endif
06795 sip_in_reply_to_t *sip_in_reply_to_format(su_home_t *home, char const *fmt, ...)
06796 __attribute__((__malloc__, __format__ (printf, 2, 3)));
06797
06798 #if SU_HAVE_INLINE
06799 su_inline sip_in_reply_to_t *sip_in_reply_to_format(su_home_t *home, char const *fmt, ...)
06800 {
06801 sip_header_t *h;
06802 va_list ap;
06803
06804 va_start(ap, fmt);
06805 h = sip_header_vformat(home, sip_in_reply_to_class, fmt, ap);
06806 va_end(ap);
06807
06808 return (sip_in_reply_to_t *)h;
06809 }
06810 #endif
06811
06819 SOFIAPUBFUN issize_t sip_accept_d(su_home_t *, msg_header_t *,
06820 char *s, isize_t slen);
06821
06823 SOFIAPUBFUN issize_t sip_accept_e(char b[], isize_t bsiz,
06824 msg_header_t const *h, int flags);
06825
06830 #define sip_accept(sip) \
06831 ((sip_accept_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_class))
06832
06846 #define SIP_ACCEPT_INIT() SIP_HDR_INIT(accept)
06847
06862 #if SU_HAVE_INLINE
06863 su_inline sip_accept_t *sip_accept_init(sip_accept_t x[1])
06864 {
06865 return SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t));
06866 }
06867 #else
06868 #define sip_accept_init(x) \
06869 SIP_HEADER_INIT(x, sip_accept_class, sizeof(sip_accept_t))
06870 #endif
06871
06883 #if SU_HAVE_INLINE
06884 su_inline int sip_is_accept(sip_header_t const *header)
06885 {
06886 return header && header->sh_class->hc_hash == sip_accept_hash;
06887 }
06888 #else
06889 int sip_is_accept(sip_header_t const *header);
06890 #endif
06891
06892 #define sip_accept_p(h) sip_is_accept((h))
06893
06894
06922 #if SU_HAVE_INLINE
06923 su_inline
06924 #endif
06925 sip_accept_t *sip_accept_dup(su_home_t *home, sip_accept_t const *hdr)
06926 __attribute__((__malloc__));
06927
06928 #if SU_HAVE_INLINE
06929 su_inline
06930 sip_accept_t *sip_accept_dup(su_home_t *home, sip_accept_t const *hdr)
06931 {
06932 return (sip_accept_t *)
06933 msg_header_dup_as(home, sip_accept_class, (msg_header_t const *)hdr);
06934 }
06935 #endif
06936
06964 #if SU_HAVE_INLINE
06965 su_inline
06966 #endif
06967 sip_accept_t *sip_accept_copy(su_home_t *home, sip_accept_t const *hdr)
06968 __attribute__((__malloc__));
06969
06970 #if SU_HAVE_INLINE
06971 su_inline
06972 sip_accept_t *sip_accept_copy(su_home_t *home, sip_accept_t const *hdr)
06973 {
06974 return (sip_accept_t *)
06975 msg_header_copy_as(home, sip_accept_class, (msg_header_t const *)hdr);
06976 }
06977 #endif
06978
06993 #if SU_HAVE_INLINE
06994 su_inline
06995 #endif
06996 sip_accept_t *sip_accept_make(su_home_t *home, char const *s)
06997 __attribute__((__malloc__));
06998
06999 #if SU_HAVE_INLINE
07000 su_inline sip_accept_t *sip_accept_make(su_home_t *home, char const *s)
07001 {
07002 return (sip_accept_t *)sip_header_make(home, sip_accept_class, s);
07003 }
07004 #endif
07005
07023 #if SU_HAVE_INLINE
07024 su_inline
07025 #endif
07026 sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
07027 __attribute__((__malloc__, __format__ (printf, 2, 3)));
07028
07029 #if SU_HAVE_INLINE
07030 su_inline sip_accept_t *sip_accept_format(su_home_t *home, char const *fmt, ...)
07031 {
07032 sip_header_t *h;
07033 va_list ap;
07034
07035 va_start(ap, fmt);
07036 h = sip_header_vformat(home, sip_accept_class, fmt, ap);
07037 va_end(ap);
07038
07039 return (sip_accept_t *)h;
07040 }
07041 #endif
07042
07050 SOFIAPUBFUN issize_t sip_accept_encoding_d(su_home_t *, msg_header_t *,
07051 char *s, isize_t slen);
07052
07054 SOFIAPUBFUN issize_t sip_accept_encoding_e(char b[], isize_t bsiz,
07055 msg_header_t const *h, int flags);
07056
07061 #define sip_accept_encoding(sip) \
07062 ((sip_accept_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_encoding_class))
07063
07077 #define SIP_ACCEPT_ENCODING_INIT() SIP_HDR_INIT(accept_encoding)
07078
07093 #if SU_HAVE_INLINE
07094 su_inline sip_accept_encoding_t *sip_accept_encoding_init(sip_accept_encoding_t x[1])
07095 {
07096 return SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t));
07097 }
07098 #else
07099 #define sip_accept_encoding_init(x) \
07100 SIP_HEADER_INIT(x, sip_accept_encoding_class, sizeof(sip_accept_encoding_t))
07101 #endif
07102
07114 #if SU_HAVE_INLINE
07115 su_inline int sip_is_accept_encoding(sip_header_t const *header)
07116 {
07117 return header && header->sh_class->hc_hash == sip_accept_encoding_hash;
07118 }
07119 #else
07120 int sip_is_accept_encoding(sip_header_t const *header);
07121 #endif
07122
07123 #define sip_accept_encoding_p(h) sip_is_accept_encoding((h))
07124
07125
07153 #if SU_HAVE_INLINE
07154 su_inline
07155 #endif
07156 sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
07157 __attribute__((__malloc__));
07158
07159 #if SU_HAVE_INLINE
07160 su_inline
07161 sip_accept_encoding_t *sip_accept_encoding_dup(su_home_t *home, sip_accept_encoding_t const *hdr)
07162 {
07163 return (sip_accept_encoding_t *)
07164 msg_header_dup_as(home, sip_accept_encoding_class, (msg_header_t const *)hdr);
07165 }
07166 #endif
07167
07195 #if SU_HAVE_INLINE
07196 su_inline
07197 #endif
07198 sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
07199 __attribute__((__malloc__));
07200
07201 #if SU_HAVE_INLINE
07202 su_inline
07203 sip_accept_encoding_t *sip_accept_encoding_copy(su_home_t *home, sip_accept_encoding_t const *hdr)
07204 {
07205 return (sip_accept_encoding_t *)
07206 msg_header_copy_as(home, sip_accept_encoding_class, (msg_header_t const *)hdr);
07207 }
07208 #endif
07209
07224 #if SU_HAVE_INLINE
07225 su_inline
07226 #endif
07227 sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
07228 __attribute__((__malloc__));
07229
07230 #if SU_HAVE_INLINE
07231 su_inline sip_accept_encoding_t *sip_accept_encoding_make(su_home_t *home, char const *s)
07232 {
07233 return (sip_accept_encoding_t *)sip_header_make(home, sip_accept_encoding_class, s);
07234 }
07235 #endif
07236
07254 #if SU_HAVE_INLINE
07255 su_inline
07256 #endif
07257 sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
07258 __attribute__((__malloc__, __format__ (printf, 2, 3)));
07259
07260 #if SU_HAVE_INLINE
07261 su_inline sip_accept_encoding_t *sip_accept_encoding_format(su_home_t *home, char const *fmt, ...)
07262 {
07263 sip_header_t *h;
07264 va_list ap;
07265
07266 va_start(ap, fmt);
07267 h = sip_header_vformat(home, sip_accept_encoding_class, fmt, ap);
07268 va_end(ap);
07269
07270 return (sip_accept_encoding_t *)h;
07271 }
07272 #endif
07273
07281 SOFIAPUBFUN issize_t sip_accept_language_d(su_home_t *, msg_header_t *,
07282 char *s, isize_t slen);
07283
07285 SOFIAPUBFUN issize_t sip_accept_language_e(char b[], isize_t bsiz,
07286 msg_header_t const *h, int flags);
07287
07292 #define sip_accept_language(sip) \
07293 ((sip_accept_language_t *)msg_header_access((msg_pub_t*)(sip), sip_accept_language_class))
07294
07308 #define SIP_ACCEPT_LANGUAGE_INIT() SIP_HDR_INIT(accept_language)
07309
07324 #if SU_HAVE_INLINE
07325 su_inline sip_accept_language_t *sip_accept_language_init(sip_accept_language_t x[1])
07326 {
07327 return SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t));
07328 }
07329 #else
07330 #define sip_accept_language_init(x) \
07331 SIP_HEADER_INIT(x, sip_accept_language_class, sizeof(sip_accept_language_t))
07332 #endif
07333
07345 #if SU_HAVE_INLINE
07346 su_inline int sip_is_accept_language(sip_header_t const *header)
07347 {
07348 return header && header->sh_class->hc_hash == sip_accept_language_hash;
07349 }
07350 #else
07351 int sip_is_accept_language(sip_header_t const *header);
07352 #endif
07353
07354 #define sip_accept_language_p(h) sip_is_accept_language((h))
07355
07356
07384 #if SU_HAVE_INLINE
07385 su_inline
07386 #endif
07387 sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
07388 __attribute__((__malloc__));
07389
07390 #if SU_HAVE_INLINE
07391 su_inline
07392 sip_accept_language_t *sip_accept_language_dup(su_home_t *home, sip_accept_language_t const *hdr)
07393 {
07394 return (sip_accept_language_t *)
07395 msg_header_dup_as(home, sip_accept_language_class, (msg_header_t const *)hdr);
07396 }
07397 #endif
07398
07426 #if SU_HAVE_INLINE
07427 su_inline
07428 #endif
07429 sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
07430 __attribute__((__malloc__));
07431
07432 #if SU_HAVE_INLINE
07433 su_inline
07434 sip_accept_language_t *sip_accept_language_copy(su_home_t *home, sip_accept_language_t const *hdr)
07435 {
07436 return (sip_accept_language_t *)
07437 msg_header_copy_as(home, sip_accept_language_class, (msg_header_t const *)hdr);
07438 }
07439 #endif
07440
07455 #if SU_HAVE_INLINE
07456 su_inline
07457 #endif
07458 sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
07459 __attribute__((__malloc__));
07460
07461 #if SU_HAVE_INLINE
07462 su_inline sip_accept_language_t *sip_accept_language_make(su_home_t *home, char const *s)
07463 {
07464 return (sip_accept_language_t *)sip_header_make(home, sip_accept_language_class, s);
07465 }
07466 #endif
07467
07485 #if SU_HAVE_INLINE
07486 su_inline
07487 #endif
07488 sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
07489 __attribute__((__malloc__, __format__ (printf, 2, 3)));
07490
07491 #if SU_HAVE_INLINE
07492 su_inline sip_accept_language_t *sip_accept_language_format(su_home_t *home, char const *fmt, ...)
07493 {
07494 sip_header_t *h;
07495 va_list ap;
07496
07497 va_start(ap, fmt);
07498 h = sip_header_vformat(home, sip_accept_language_class, fmt, ap);
07499 va_end(ap);
07500
07501 return (sip_accept_language_t *)h;
07502 }
07503 #endif
07504
07512 SOFIAPUBFUN issize_t sip_allow_d(su_home_t *, msg_header_t *,
07513 char *s, isize_t slen);
07514
07516 SOFIAPUBFUN issize_t sip_allow_e(char b[], isize_t bsiz,
07517 msg_header_t const *h, int flags);
07518
07523 #define sip_allow(sip) \
07524 ((sip_allow_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_class))
07525
07539 #define SIP_ALLOW_INIT() SIP_HDR_INIT(allow)
07540
07555 #if SU_HAVE_INLINE
07556 su_inline sip_allow_t *sip_allow_init(sip_allow_t x[1])
07557 {
07558 return SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t));
07559 }
07560 #else
07561 #define sip_allow_init(x) \
07562 SIP_HEADER_INIT(x, sip_allow_class, sizeof(sip_allow_t))
07563 #endif
07564
07576 #if SU_HAVE_INLINE
07577 su_inline int sip_is_allow(sip_header_t const *header)
07578 {
07579 return header && header->sh_class->hc_hash == sip_allow_hash;
07580 }
07581 #else
07582 int sip_is_allow(sip_header_t const *header);
07583 #endif
07584
07585 #define sip_allow_p(h) sip_is_allow((h))
07586
07587
07615 #if SU_HAVE_INLINE
07616 su_inline
07617 #endif
07618 sip_allow_t *sip_allow_dup(su_home_t *home, sip_allow_t const *hdr)
07619 __attribute__((__malloc__));
07620
07621 #if SU_HAVE_INLINE
07622 su_inline
07623 sip_allow_t *sip_allow_dup(su_home_t *home, sip_allow_t const *hdr)
07624 {
07625 return (sip_allow_t *)
07626 msg_header_dup_as(home, sip_allow_class, (msg_header_t const *)hdr);
07627 }
07628 #endif
07629
07657 #if SU_HAVE_INLINE
07658 su_inline
07659 #endif
07660 sip_allow_t *sip_allow_copy(su_home_t *home, sip_allow_t const *hdr)
07661 __attribute__((__malloc__));
07662
07663 #if SU_HAVE_INLINE
07664 su_inline
07665 sip_allow_t *sip_allow_copy(su_home_t *home, sip_allow_t const *hdr)
07666 {
07667 return (sip_allow_t *)
07668 msg_header_copy_as(home, sip_allow_class, (msg_header_t const *)hdr);
07669 }
07670 #endif
07671
07686 #if SU_HAVE_INLINE
07687 su_inline
07688 #endif
07689 sip_allow_t *sip_allow_make(su_home_t *home, char const *s)
07690 __attribute__((__malloc__));
07691
07692 #if SU_HAVE_INLINE
07693 su_inline sip_allow_t *sip_allow_make(su_home_t *home, char const *s)
07694 {
07695 return (sip_allow_t *)sip_header_make(home, sip_allow_class, s);
07696 }
07697 #endif
07698
07716 #if SU_HAVE_INLINE
07717 su_inline
07718 #endif
07719 sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
07720 __attribute__((__malloc__, __format__ (printf, 2, 3)));
07721
07722 #if SU_HAVE_INLINE
07723 su_inline sip_allow_t *sip_allow_format(su_home_t *home, char const *fmt, ...)
07724 {
07725 sip_header_t *h;
07726 va_list ap;
07727
07728 va_start(ap, fmt);
07729 h = sip_header_vformat(home, sip_allow_class, fmt, ap);
07730 va_end(ap);
07731
07732 return (sip_allow_t *)h;
07733 }
07734 #endif
07735
07743 SOFIAPUBFUN issize_t sip_require_d(su_home_t *, msg_header_t *,
07744 char *s, isize_t slen);
07745
07747 SOFIAPUBFUN issize_t sip_require_e(char b[], isize_t bsiz,
07748 msg_header_t const *h, int flags);
07749
07754 #define sip_require(sip) \
07755 ((sip_require_t *)msg_header_access((msg_pub_t*)(sip), sip_require_class))
07756
07770 #define SIP_REQUIRE_INIT() SIP_HDR_INIT(require)
07771
07786 #if SU_HAVE_INLINE
07787 su_inline sip_require_t *sip_require_init(sip_require_t x[1])
07788 {
07789 return SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t));
07790 }
07791 #else
07792 #define sip_require_init(x) \
07793 SIP_HEADER_INIT(x, sip_require_class, sizeof(sip_require_t))
07794 #endif
07795
07807 #if SU_HAVE_INLINE
07808 su_inline int sip_is_require(sip_header_t const *header)
07809 {
07810 return header && header->sh_class->hc_hash == sip_require_hash;
07811 }
07812 #else
07813 int sip_is_require(sip_header_t const *header);
07814 #endif
07815
07816 #define sip_require_p(h) sip_is_require((h))
07817
07818
07846 #if SU_HAVE_INLINE
07847 su_inline
07848 #endif
07849 sip_require_t *sip_require_dup(su_home_t *home, sip_require_t const *hdr)
07850 __attribute__((__malloc__));
07851
07852 #if SU_HAVE_INLINE
07853 su_inline
07854 sip_require_t *sip_require_dup(su_home_t *home, sip_require_t const *hdr)
07855 {
07856 return (sip_require_t *)
07857 msg_header_dup_as(home, sip_require_class, (msg_header_t const *)hdr);
07858 }
07859 #endif
07860
07888 #if SU_HAVE_INLINE
07889 su_inline
07890 #endif
07891 sip_require_t *sip_require_copy(su_home_t *home, sip_require_t const *hdr)
07892 __attribute__((__malloc__));
07893
07894 #if SU_HAVE_INLINE
07895 su_inline
07896 sip_require_t *sip_require_copy(su_home_t *home, sip_require_t const *hdr)
07897 {
07898 return (sip_require_t *)
07899 msg_header_copy_as(home, sip_require_class, (msg_header_t const *)hdr);
07900 }
07901 #endif
07902
07917 #if SU_HAVE_INLINE
07918 su_inline
07919 #endif
07920 sip_require_t *sip_require_make(su_home_t *home, char const *s)
07921 __attribute__((__malloc__));
07922
07923 #if SU_HAVE_INLINE
07924 su_inline sip_require_t *sip_require_make(su_home_t *home, char const *s)
07925 {
07926 return (sip_require_t *)sip_header_make(home, sip_require_class, s);
07927 }
07928 #endif
07929
07947 #if SU_HAVE_INLINE
07948 su_inline
07949 #endif
07950 sip_require_t *sip_require_format(su_home_t *home, char const *fmt, ...)
07951 __attribute__((__malloc__, __format__ (printf, 2, 3)));
07952
07953 #if SU_HAVE_INLINE
07954 su_inline sip_require_t *sip_require_format(su_home_t *home, char const *fmt, ...)
07955 {
07956 sip_header_t *h;
07957 va_list ap;
07958
07959 va_start(ap, fmt);
07960 h = sip_header_vformat(home, sip_require_class, fmt, ap);
07961 va_end(ap);
07962
07963 return (sip_require_t *)h;
07964 }
07965 #endif
07966
07974 SOFIAPUBFUN issize_t sip_supported_d(su_home_t *, msg_header_t *,
07975 char *s, isize_t slen);
07976
07978 SOFIAPUBFUN issize_t sip_supported_e(char b[], isize_t bsiz,
07979 msg_header_t const *h, int flags);
07980
07985 #define sip_supported(sip) \
07986 ((sip_supported_t *)msg_header_access((msg_pub_t*)(sip), sip_supported_class))
07987
08001 #define SIP_SUPPORTED_INIT() SIP_HDR_INIT(supported)
08002
08017 #if SU_HAVE_INLINE
08018 su_inline sip_supported_t *sip_supported_init(sip_supported_t x[1])
08019 {
08020 return SIP_HEADER_INIT(x, sip_supported_class, sizeof(sip_supported_t));
08021 }
08022 #else
08023 #define sip_supported_init(x) \
08024 SIP_HEADER_INIT(x, sip_supported_class, sizeof(sip_supported_t))
08025 #endif
08026
08038 #if SU_HAVE_INLINE
08039 su_inline int sip_is_supported(sip_header_t const *header)
08040 {
08041 return header && header->sh_class->hc_hash == sip_supported_hash;
08042 }
08043 #else
08044 int sip_is_supported(sip_header_t const *header);
08045 #endif
08046
08047 #define sip_supported_p(h) sip_is_supported((h))
08048
08049
08077 #if SU_HAVE_INLINE
08078 su_inline
08079 #endif
08080 sip_supported_t *sip_supported_dup(su_home_t *home, sip_supported_t const *hdr)
08081 __attribute__((__malloc__));
08082
08083 #if SU_HAVE_INLINE
08084 su_inline
08085 sip_supported_t *sip_supported_dup(su_home_t *home, sip_supported_t const *hdr)
08086 {
08087 return (sip_supported_t *)
08088 msg_header_dup_as(home, sip_supported_class, (msg_header_t const *)hdr);
08089 }
08090 #endif
08091
08119 #if SU_HAVE_INLINE
08120 su_inline
08121 #endif
08122 sip_supported_t *sip_supported_copy(su_home_t *home, sip_supported_t const *hdr)
08123 __attribute__((__malloc__));
08124
08125 #if SU_HAVE_INLINE
08126 su_inline
08127 sip_supported_t *sip_supported_copy(su_home_t *home, sip_supported_t const *hdr)
08128 {
08129 return (sip_supported_t *)
08130 msg_header_copy_as(home, sip_supported_class, (msg_header_t const *)hdr);
08131 }
08132 #endif
08133
08148 #if SU_HAVE_INLINE
08149 su_inline
08150 #endif
08151 sip_supported_t *sip_supported_make(su_home_t *home, char const *s)
08152 __attribute__((__malloc__));
08153
08154 #if SU_HAVE_INLINE
08155 su_inline sip_supported_t *sip_supported_make(su_home_t *home, char const *s)
08156 {
08157 return (sip_supported_t *)sip_header_make(home, sip_supported_class, s);
08158 }
08159 #endif
08160
08178 #if SU_HAVE_INLINE
08179 su_inline
08180 #endif
08181 sip_supported_t *sip_supported_format(su_home_t *home, char const *fmt, ...)
08182 __attribute__((__malloc__, __format__ (printf, 2, 3)));
08183
08184 #if SU_HAVE_INLINE
08185 su_inline sip_supported_t *sip_supported_format(su_home_t *home, char const *fmt, ...)
08186 {
08187 sip_header_t *h;
08188 va_list ap;
08189
08190 va_start(ap, fmt);
08191 h = sip_header_vformat(home, sip_supported_class, fmt, ap);
08192 va_end(ap);
08193
08194 return (sip_supported_t *)h;
08195 }
08196 #endif
08197
08205 SOFIAPUBFUN issize_t sip_unsupported_d(su_home_t *, msg_header_t *,
08206 char *s, isize_t slen);
08207
08209 SOFIAPUBFUN issize_t sip_unsupported_e(char b[], isize_t bsiz,
08210 msg_header_t const *h, int flags);
08211
08216 #define sip_unsupported(sip) \
08217 ((sip_unsupported_t *)msg_header_access((msg_pub_t*)(sip), sip_unsupported_class))
08218
08232 #define SIP_UNSUPPORTED_INIT() SIP_HDR_INIT(unsupported)
08233
08248 #if SU_HAVE_INLINE
08249 su_inline sip_unsupported_t *sip_unsupported_init(sip_unsupported_t x[1])
08250 {
08251 return SIP_HEADER_INIT(x, sip_unsupported_class, sizeof(sip_unsupported_t));
08252 }
08253 #else
08254 #define sip_unsupported_init(x) \
08255 SIP_HEADER_INIT(x, sip_unsupported_class, sizeof(sip_unsupported_t))
08256 #endif
08257
08269 #if SU_HAVE_INLINE
08270 su_inline int sip_is_unsupported(sip_header_t const *header)
08271 {
08272 return header && header->sh_class->hc_hash == sip_unsupported_hash;
08273 }
08274 #else
08275 int sip_is_unsupported(sip_header_t const *header);
08276 #endif
08277
08278 #define sip_unsupported_p(h) sip_is_unsupported((h))
08279
08280
08308 #if SU_HAVE_INLINE
08309 su_inline
08310 #endif
08311 sip_unsupported_t *sip_unsupported_dup(su_home_t *home, sip_unsupported_t const *hdr)
08312 __attribute__((__malloc__));
08313
08314 #if SU_HAVE_INLINE
08315 su_inline
08316 sip_unsupported_t *sip_unsupported_dup(su_home_t *home, sip_unsupported_t const *hdr)
08317 {
08318 return (sip_unsupported_t *)
08319 msg_header_dup_as(home, sip_unsupported_class, (msg_header_t const *)hdr);
08320 }
08321 #endif
08322
08350 #if SU_HAVE_INLINE
08351 su_inline
08352 #endif
08353 sip_unsupported_t *sip_unsupported_copy(su_home_t *home, sip_unsupported_t const *hdr)
08354 __attribute__((__malloc__));
08355
08356 #if SU_HAVE_INLINE
08357 su_inline
08358 sip_unsupported_t *sip_unsupported_copy(su_home_t *home, sip_unsupported_t const *hdr)
08359 {
08360 return (sip_unsupported_t *)
08361 msg_header_copy_as(home, sip_unsupported_class, (msg_header_t const *)hdr);
08362 }
08363 #endif
08364
08379 #if SU_HAVE_INLINE
08380 su_inline
08381 #endif
08382 sip_unsupported_t *sip_unsupported_make(su_home_t *home, char const *s)
08383 __attribute__((__malloc__));
08384
08385 #if SU_HAVE_INLINE
08386 su_inline sip_unsupported_t *sip_unsupported_make(su_home_t *home, char const *s)
08387 {
08388 return (sip_unsupported_t *)sip_header_make(home, sip_unsupported_class, s);
08389 }
08390 #endif
08391
08409 #if SU_HAVE_INLINE
08410 su_inline
08411 #endif
08412 sip_unsupported_t *sip_unsupported_format(su_home_t *home, char const *fmt, ...)
08413 __attribute__((__malloc__, __format__ (printf, 2, 3)));
08414
08415 #if SU_HAVE_INLINE
08416 su_inline sip_unsupported_t *sip_unsupported_format(su_home_t *home, char const *fmt, ...)
08417 {
08418 sip_header_t *h;
08419 va_list ap;
08420
08421 va_start(ap, fmt);
08422 h = sip_header_vformat(home, sip_unsupported_class, fmt, ap);
08423 va_end(ap);
08424
08425 return (sip_unsupported_t *)h;
08426 }
08427 #endif
08428
08436 SOFIAPUBFUN issize_t sip_event_d(su_home_t *, msg_header_t *,
08437 char *s, isize_t slen);
08438
08440 SOFIAPUBFUN issize_t sip_event_e(char b[], isize_t bsiz,
08441 msg_header_t const *h, int flags);
08442
08447 #define sip_event(sip) \
08448 ((sip_event_t *)msg_header_access((msg_pub_t*)(sip), sip_event_class))
08449
08463 #define SIP_EVENT_INIT() SIP_HDR_INIT(event)
08464
08479 #if SU_HAVE_INLINE
08480 su_inline sip_event_t *sip_event_init(sip_event_t x[1])
08481 {
08482 return SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t));
08483 }
08484 #else
08485 #define sip_event_init(x) \
08486 SIP_HEADER_INIT(x, sip_event_class, sizeof(sip_event_t))
08487 #endif
08488
08500 #if SU_HAVE_INLINE
08501 su_inline int sip_is_event(sip_header_t const *header)
08502 {
08503 return header && header->sh_class->hc_hash == sip_event_hash;
08504 }
08505 #else
08506 int sip_is_event(sip_header_t const *header);
08507 #endif
08508
08509 #define sip_event_p(h) sip_is_event((h))
08510
08511
08539 #if SU_HAVE_INLINE
08540 su_inline
08541 #endif
08542 sip_event_t *sip_event_dup(su_home_t *home, sip_event_t const *hdr)
08543 __attribute__((__malloc__));
08544
08545 #if SU_HAVE_INLINE
08546 su_inline
08547 sip_event_t *sip_event_dup(su_home_t *home, sip_event_t const *hdr)
08548 {
08549 return (sip_event_t *)
08550 msg_header_dup_as(home, sip_event_class, (msg_header_t const *)hdr);
08551 }
08552 #endif
08553
08581 #if SU_HAVE_INLINE
08582 su_inline
08583 #endif
08584 sip_event_t *sip_event_copy(su_home_t *home, sip_event_t const *hdr)
08585 __attribute__((__malloc__));
08586
08587 #if SU_HAVE_INLINE
08588 su_inline
08589 sip_event_t *sip_event_copy(su_home_t *home, sip_event_t const *hdr)
08590 {
08591 return (sip_event_t *)
08592 msg_header_copy_as(home, sip_event_class, (msg_header_t const *)hdr);
08593 }
08594 #endif
08595
08610 #if SU_HAVE_INLINE
08611 su_inline
08612 #endif
08613 sip_event_t *sip_event_make(su_home_t *home, char const *s)
08614 __attribute__((__malloc__));
08615
08616 #if SU_HAVE_INLINE
08617 su_inline sip_event_t *sip_event_make(su_home_t *home, char const *s)
08618 {
08619 return (sip_event_t *)sip_header_make(home, sip_event_class, s);
08620 }
08621 #endif
08622
08640 #if SU_HAVE_INLINE
08641 su_inline
08642 #endif
08643 sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
08644 __attribute__((__malloc__, __format__ (printf, 2, 3)));
08645
08646 #if SU_HAVE_INLINE
08647 su_inline sip_event_t *sip_event_format(su_home_t *home, char const *fmt, ...)
08648 {
08649 sip_header_t *h;
08650 va_list ap;
08651
08652 va_start(ap, fmt);
08653 h = sip_header_vformat(home, sip_event_class, fmt, ap);
08654 va_end(ap);
08655
08656 return (sip_event_t *)h;
08657 }
08658 #endif
08659
08667 SOFIAPUBFUN issize_t sip_allow_events_d(su_home_t *, msg_header_t *,
08668 char *s, isize_t slen);
08669
08671 SOFIAPUBFUN issize_t sip_allow_events_e(char b[], isize_t bsiz,
08672 msg_header_t const *h, int flags);
08673
08678 #define sip_allow_events(sip) \
08679 ((sip_allow_events_t *)msg_header_access((msg_pub_t*)(sip), sip_allow_events_class))
08680
08694 #define SIP_ALLOW_EVENTS_INIT() SIP_HDR_INIT(allow_events)
08695
08710 #if SU_HAVE_INLINE
08711 su_inline sip_allow_events_t *sip_allow_events_init(sip_allow_events_t x[1])
08712 {
08713 return SIP_HEADER_INIT(x, sip_allow_events_class, sizeof(sip_allow_events_t));
08714 }
08715 #else
08716 #define sip_allow_events_init(x) \
08717 SIP_HEADER_INIT(x, sip_allow_events_class, sizeof(sip_allow_events_t))
08718 #endif
08719
08731 #if SU_HAVE_INLINE
08732 su_inline int sip_is_allow_events(sip_header_t const *header)
08733 {
08734 return header && header->sh_class->hc_hash == sip_allow_events_hash;
08735 }
08736 #else
08737 int sip_is_allow_events(sip_header_t const *header);
08738 #endif
08739
08740 #define sip_allow_events_p(h) sip_is_allow_events((h))
08741
08742
08770 #if SU_HAVE_INLINE
08771 su_inline
08772 #endif
08773 sip_allow_events_t *sip_allow_events_dup(su_home_t *home, sip_allow_events_t const *hdr)
08774 __attribute__((__malloc__));
08775
08776 #if SU_HAVE_INLINE
08777 su_inline
08778 sip_allow_events_t *sip_allow_events_dup(su_home_t *home, sip_allow_events_t const *hdr)
08779 {
08780 return (sip_allow_events_t *)
08781 msg_header_dup_as(home, sip_allow_events_class, (msg_header_t const *)hdr);
08782 }
08783 #endif
08784
08812 #if SU_HAVE_INLINE
08813 su_inline
08814 #endif
08815 sip_allow_events_t *sip_allow_events_copy(su_home_t *home, sip_allow_events_t const *hdr)
08816 __attribute__((__malloc__));
08817
08818 #if SU_HAVE_INLINE
08819 su_inline
08820 sip_allow_events_t *sip_allow_events_copy(su_home_t *home, sip_allow_events_t const *hdr)
08821 {
08822 return (sip_allow_events_t *)
08823 msg_header_copy_as(home, sip_allow_events_class, (msg_header_t const *)hdr);
08824 }
08825 #endif
08826
08841 #if SU_HAVE_INLINE
08842 su_inline
08843 #endif
08844 sip_allow_events_t *sip_allow_events_make(su_home_t *home, char const *s)
08845 __attribute__((__malloc__));
08846
08847 #if SU_HAVE_INLINE
08848 su_inline sip_allow_events_t *sip_allow_events_make(su_home_t *home, char const *s)
08849 {
08850 return (sip_allow_events_t *)sip_header_make(home, sip_allow_events_class, s);
08851 }
08852 #endif
08853
08871 #if SU_HAVE_INLINE
08872 su_inline
08873 #endif
08874 sip_allow_events_t *sip_allow_events_format(su_home_t *home, char const *fmt, ...)
08875 __attribute__((__malloc__, __format__ (printf, 2, 3)));
08876
08877 #if SU_HAVE_INLINE
08878 su_inline sip_allow_events_t *sip_allow_events_format(su_home_t *home, char const *fmt, ...)
08879 {
08880 sip_header_t *h;
08881 va_list ap;
08882
08883 va_start(ap, fmt);
08884 h = sip_header_vformat(home, sip_allow_events_class, fmt, ap);
08885 va_end(ap);
08886
08887 return (sip_allow_events_t *)h;
08888 }
08889 #endif
08890
08898 SOFIAPUBFUN issize_t sip_subscription_state_d(su_home_t *, msg_header_t *,
08899 char *s, isize_t slen);
08900
08902 SOFIAPUBFUN issize_t sip_subscription_state_e(char b[], isize_t bsiz,
08903 msg_header_t const *h, int flags);
08904
08909 #define sip_subscription_state(sip) \
08910 ((sip_subscription_state_t *)msg_header_access((msg_pub_t*)(sip), sip_subscription_state_class))
08911
08925 #define SIP_SUBSCRIPTION_STATE_INIT() SIP_HDR_INIT(subscription_state)
08926
08941 #if SU_HAVE_INLINE
08942 su_inline sip_subscription_state_t *sip_subscription_state_init(sip_subscription_state_t x[1])
08943 {
08944 return SIP_HEADER_INIT(x, sip_subscription_state_class, sizeof(sip_subscription_state_t));
08945 }
08946 #else
08947 #define sip_subscription_state_init(x) \
08948 SIP_HEADER_INIT(x, sip_subscription_state_class, sizeof(sip_subscription_state_t))
08949 #endif
08950
08962 #if SU_HAVE_INLINE
08963 su_inline int sip_is_subscription_state(sip_header_t const *header)
08964 {
08965 return header && header->sh_class->hc_hash == sip_subscription_state_hash;
08966 }
08967 #else
08968 int sip_is_subscription_state(sip_header_t const *header);
08969 #endif
08970
08971 #define sip_subscription_state_p(h) sip_is_subscription_state((h))
08972
08973
09001 #if SU_HAVE_INLINE
09002 su_inline
09003 #endif
09004 sip_subscription_state_t *sip_subscription_state_dup(su_home_t *home, sip_subscription_state_t const *hdr)
09005 __attribute__((__malloc__));
09006
09007 #if SU_HAVE_INLINE
09008 su_inline
09009 sip_subscription_state_t *sip_subscription_state_dup(su_home_t *home, sip_subscription_state_t const *hdr)
09010 {
09011 return (sip_subscription_state_t *)
09012 msg_header_dup_as(home, sip_subscription_state_class, (msg_header_t const *)hdr);
09013 }
09014 #endif
09015
09043 #if SU_HAVE_INLINE
09044 su_inline
09045 #endif
09046 sip_subscription_state_t *sip_subscription_state_copy(su_home_t *home, sip_subscription_state_t const *hdr)
09047 __attribute__((__malloc__));
09048
09049 #if SU_HAVE_INLINE
09050 su_inline
09051 sip_subscription_state_t *sip_subscription_state_copy(su_home_t *home, sip_subscription_state_t const *hdr)
09052 {
09053 return (sip_subscription_state_t *)
09054 msg_header_copy_as(home, sip_subscription_state_class, (msg_header_t const *)hdr);
09055 }
09056 #endif
09057
09072 #if SU_HAVE_INLINE
09073 su_inline
09074 #endif
09075 sip_subscription_state_t *sip_subscription_state_make(su_home_t *home, char const *s)
09076 __attribute__((__malloc__));
09077
09078 #if SU_HAVE_INLINE
09079 su_inline sip_subscription_state_t *sip_subscription_state_make(su_home_t *home, char const *s)
09080 {
09081 return (sip_subscription_state_t *)sip_header_make(home, sip_subscription_state_class, s);
09082 }
09083 #endif
09084
09102 #if SU_HAVE_INLINE
09103 su_inline
09104 #endif
09105 sip_subscription_state_t *sip_subscription_state_format(su_home_t *home, char const *fmt, ...)
09106 __attribute__((__malloc__, __format__ (printf, 2, 3)));
09107
09108 #if SU_HAVE_INLINE
09109 su_inline sip_subscription_state_t *sip_subscription_state_format(su_home_t *home, char const *fmt, ...)
09110 {
09111 sip_header_t *h;
09112 va_list ap;
09113
09114 va_start(ap, fmt);
09115 h = sip_header_vformat(home, sip_subscription_state_class, fmt, ap);
09116 va_end(ap);
09117
09118 return (sip_subscription_state_t *)h;
09119 }
09120 #endif
09121
09129 SOFIAPUBFUN issize_t sip_proxy_authenticate_d(su_home_t *, msg_header_t *,
09130 char *s, isize_t slen);
09131
09133 SOFIAPUBFUN issize_t sip_proxy_authenticate_e(char b[], isize_t bsiz,
09134 msg_header_t const *h, int flags);
09135
09140 #define sip_proxy_authenticate(sip) \
09141 ((sip_proxy_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authenticate_class))
09142
09156 #define SIP_PROXY_AUTHENTICATE_INIT() SIP_HDR_INIT(proxy_authenticate)
09157
09172 #if SU_HAVE_INLINE
09173 su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_init(sip_proxy_authenticate_t x[1])
09174 {
09175 return SIP_HEADER_INIT(x, sip_proxy_authenticate_class, sizeof(sip_proxy_authenticate_t));
09176 }
09177 #else
09178 #define sip_proxy_authenticate_init(x) \
09179 SIP_HEADER_INIT(x, sip_proxy_authenticate_class, sizeof(sip_proxy_authenticate_t))
09180 #endif
09181
09193 #if SU_HAVE_INLINE
09194 su_inline int sip_is_proxy_authenticate(sip_header_t const *header)
09195 {
09196 return header && header->sh_class->hc_hash == sip_proxy_authenticate_hash;
09197 }
09198 #else
09199 int sip_is_proxy_authenticate(sip_header_t const *header);
09200 #endif
09201
09202 #define sip_proxy_authenticate_p(h) sip_is_proxy_authenticate((h))
09203
09204
09232 #if SU_HAVE_INLINE
09233 su_inline
09234 #endif
09235 sip_proxy_authenticate_t *sip_proxy_authenticate_dup(su_home_t *home, sip_proxy_authenticate_t const *hdr)
09236 __attribute__((__malloc__));
09237
09238 #if SU_HAVE_INLINE
09239 su_inline
09240 sip_proxy_authenticate_t *sip_proxy_authenticate_dup(su_home_t *home, sip_proxy_authenticate_t const *hdr)
09241 {
09242 return (sip_proxy_authenticate_t *)
09243 msg_header_dup_as(home, sip_proxy_authenticate_class, (msg_header_t const *)hdr);
09244 }
09245 #endif
09246
09274 #if SU_HAVE_INLINE
09275 su_inline
09276 #endif
09277 sip_proxy_authenticate_t *sip_proxy_authenticate_copy(su_home_t *home, sip_proxy_authenticate_t const *hdr)
09278 __attribute__((__malloc__));
09279
09280 #if SU_HAVE_INLINE
09281 su_inline
09282 sip_proxy_authenticate_t *sip_proxy_authenticate_copy(su_home_t *home, sip_proxy_authenticate_t const *hdr)
09283 {
09284 return (sip_proxy_authenticate_t *)
09285 msg_header_copy_as(home, sip_proxy_authenticate_class, (msg_header_t const *)hdr);
09286 }
09287 #endif
09288
09303 #if SU_HAVE_INLINE
09304 su_inline
09305 #endif
09306 sip_proxy_authenticate_t *sip_proxy_authenticate_make(su_home_t *home, char const *s)
09307 __attribute__((__malloc__));
09308
09309 #if SU_HAVE_INLINE
09310 su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_make(su_home_t *home, char const *s)
09311 {
09312 return (sip_proxy_authenticate_t *)sip_header_make(home, sip_proxy_authenticate_class, s);
09313 }
09314 #endif
09315
09333 #if SU_HAVE_INLINE
09334 su_inline
09335 #endif
09336 sip_proxy_authenticate_t *sip_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
09337 __attribute__((__malloc__, __format__ (printf, 2, 3)));
09338
09339 #if SU_HAVE_INLINE
09340 su_inline sip_proxy_authenticate_t *sip_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
09341 {
09342 sip_header_t *h;
09343 va_list ap;
09344
09345 va_start(ap, fmt);
09346 h = sip_header_vformat(home, sip_proxy_authenticate_class, fmt, ap);
09347 va_end(ap);
09348
09349 return (sip_proxy_authenticate_t *)h;
09350 }
09351 #endif
09352
09360 SOFIAPUBFUN issize_t sip_proxy_authentication_info_d(su_home_t *, msg_header_t *,
09361 char *s, isize_t slen);
09362
09364 SOFIAPUBFUN issize_t sip_proxy_authentication_info_e(char b[], isize_t bsiz,
09365 msg_header_t const *h, int flags);
09366
09371 #define sip_proxy_authentication_info(sip) \
09372 ((sip_proxy_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authentication_info_class))
09373
09387 #define SIP_PROXY_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(proxy_authentication_info)
09388
09403 #if SU_HAVE_INLINE
09404 su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_init(sip_proxy_authentication_info_t x[1])
09405 {
09406 return SIP_HEADER_INIT(x, sip_proxy_authentication_info_class, sizeof(sip_proxy_authentication_info_t));
09407 }
09408 #else
09409 #define sip_proxy_authentication_info_init(x) \
09410 SIP_HEADER_INIT(x, sip_proxy_authentication_info_class, sizeof(sip_proxy_authentication_info_t))
09411 #endif
09412
09424 #if SU_HAVE_INLINE
09425 su_inline int sip_is_proxy_authentication_info(sip_header_t const *header)
09426 {
09427 return header && header->sh_class->hc_hash == sip_proxy_authentication_info_hash;
09428 }
09429 #else
09430 int sip_is_proxy_authentication_info(sip_header_t const *header);
09431 #endif
09432
09433 #define sip_proxy_authentication_info_p(h) sip_is_proxy_authentication_info((h))
09434
09435
09463 #if SU_HAVE_INLINE
09464 su_inline
09465 #endif
09466 sip_proxy_authentication_info_t *sip_proxy_authentication_info_dup(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
09467 __attribute__((__malloc__));
09468
09469 #if SU_HAVE_INLINE
09470 su_inline
09471 sip_proxy_authentication_info_t *sip_proxy_authentication_info_dup(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
09472 {
09473 return (sip_proxy_authentication_info_t *)
09474 msg_header_dup_as(home, sip_proxy_authentication_info_class, (msg_header_t const *)hdr);
09475 }
09476 #endif
09477
09505 #if SU_HAVE_INLINE
09506 su_inline
09507 #endif
09508 sip_proxy_authentication_info_t *sip_proxy_authentication_info_copy(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
09509 __attribute__((__malloc__));
09510
09511 #if SU_HAVE_INLINE
09512 su_inline
09513 sip_proxy_authentication_info_t *sip_proxy_authentication_info_copy(su_home_t *home, sip_proxy_authentication_info_t const *hdr)
09514 {
09515 return (sip_proxy_authentication_info_t *)
09516 msg_header_copy_as(home, sip_proxy_authentication_info_class, (msg_header_t const *)hdr);
09517 }
09518 #endif
09519
09534 #if SU_HAVE_INLINE
09535 su_inline
09536 #endif
09537 sip_proxy_authentication_info_t *sip_proxy_authentication_info_make(su_home_t *home, char const *s)
09538 __attribute__((__malloc__));
09539
09540 #if SU_HAVE_INLINE
09541 su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_make(su_home_t *home, char const *s)
09542 {
09543 return (sip_proxy_authentication_info_t *)sip_header_make(home, sip_proxy_authentication_info_class, s);
09544 }
09545 #endif
09546
09564 #if SU_HAVE_INLINE
09565 su_inline
09566 #endif
09567 sip_proxy_authentication_info_t *sip_proxy_authentication_info_format(su_home_t *home, char const *fmt, ...)
09568 __attribute__((__malloc__, __format__ (printf, 2, 3)));
09569
09570 #if SU_HAVE_INLINE
09571 su_inline sip_proxy_authentication_info_t *sip_proxy_authentication_info_format(su_home_t *home, char const *fmt, ...)
09572 {
09573 sip_header_t *h;
09574 va_list ap;
09575
09576 va_start(ap, fmt);
09577 h = sip_header_vformat(home, sip_proxy_authentication_info_class, fmt, ap);
09578 va_end(ap);
09579
09580 return (sip_proxy_authentication_info_t *)h;
09581 }
09582 #endif
09583
09591 SOFIAPUBFUN issize_t sip_proxy_authorization_d(su_home_t *, msg_header_t *,
09592 char *s, isize_t slen);
09593
09595 SOFIAPUBFUN issize_t sip_proxy_authorization_e(char b[], isize_t bsiz,
09596 msg_header_t const *h, int flags);
09597
09602 #define sip_proxy_authorization(sip) \
09603 ((sip_proxy_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_proxy_authorization_class))
09604
09618 #define SIP_PROXY_AUTHORIZATION_INIT() SIP_HDR_INIT(proxy_authorization)
09619
09634 #if SU_HAVE_INLINE
09635 su_inline sip_proxy_authorization_t *sip_proxy_authorization_init(sip_proxy_authorization_t x[1])
09636 {
09637 return SIP_HEADER_INIT(x, sip_proxy_authorization_class, sizeof(sip_proxy_authorization_t));
09638 }
09639 #else
09640 #define sip_proxy_authorization_init(x) \
09641 SIP_HEADER_INIT(x, sip_proxy_authorization_class, sizeof(sip_proxy_authorization_t))
09642 #endif
09643
09655 #if SU_HAVE_INLINE
09656 su_inline int sip_is_proxy_authorization(sip_header_t const *header)
09657 {
09658 return header && header->sh_class->hc_hash == sip_proxy_authorization_hash;
09659 }
09660 #else
09661 int sip_is_proxy_authorization(sip_header_t const *header);
09662 #endif
09663
09664 #define sip_proxy_authorization_p(h) sip_is_proxy_authorization((h))
09665
09666
09694 #if SU_HAVE_INLINE
09695 su_inline
09696 #endif
09697 sip_proxy_authorization_t *sip_proxy_authorization_dup(su_home_t *home, sip_proxy_authorization_t const *hdr)
09698 __attribute__((__malloc__));
09699
09700 #if SU_HAVE_INLINE
09701 su_inline
09702 sip_proxy_authorization_t *sip_proxy_authorization_dup(su_home_t *home, sip_proxy_authorization_t const *hdr)
09703 {
09704 return (sip_proxy_authorization_t *)
09705 msg_header_dup_as(home, sip_proxy_authorization_class, (msg_header_t const *)hdr);
09706 }
09707 #endif
09708
09736 #if SU_HAVE_INLINE
09737 su_inline
09738 #endif
09739 sip_proxy_authorization_t *sip_proxy_authorization_copy(su_home_t *home, sip_proxy_authorization_t const *hdr)
09740 __attribute__((__malloc__));
09741
09742 #if SU_HAVE_INLINE
09743 su_inline
09744 sip_proxy_authorization_t *sip_proxy_authorization_copy(su_home_t *home, sip_proxy_authorization_t const *hdr)
09745 {
09746 return (sip_proxy_authorization_t *)
09747 msg_header_copy_as(home, sip_proxy_authorization_class, (msg_header_t const *)hdr);
09748 }
09749 #endif
09750
09765 #if SU_HAVE_INLINE
09766 su_inline
09767 #endif
09768 sip_proxy_authorization_t *sip_proxy_authorization_make(su_home_t *home, char const *s)
09769 __attribute__((__malloc__));
09770
09771 #if SU_HAVE_INLINE
09772 su_inline sip_proxy_authorization_t *sip_proxy_authorization_make(su_home_t *home, char const *s)
09773 {
09774 return (sip_proxy_authorization_t *)sip_header_make(home, sip_proxy_authorization_class, s);
09775 }
09776 #endif
09777
09795 #if SU_HAVE_INLINE
09796 su_inline
09797 #endif
09798 sip_proxy_authorization_t *sip_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
09799 __attribute__((__malloc__, __format__ (printf, 2, 3)));
09800
09801 #if SU_HAVE_INLINE
09802 su_inline sip_proxy_authorization_t *sip_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
09803 {
09804 sip_header_t *h;
09805 va_list ap;
09806
09807 va_start(ap, fmt);
09808 h = sip_header_vformat(home, sip_proxy_authorization_class, fmt, ap);
09809 va_end(ap);
09810
09811 return (sip_proxy_authorization_t *)h;
09812 }
09813 #endif
09814
09822 SOFIAPUBFUN issize_t sip_authorization_d(su_home_t *, msg_header_t *,
09823 char *s, isize_t slen);
09824
09826 SOFIAPUBFUN issize_t sip_authorization_e(char b[], isize_t bsiz,
09827 msg_header_t const *h, int flags);
09828
09833 #define sip_authorization(sip) \
09834 ((sip_authorization_t *)msg_header_access((msg_pub_t*)(sip), sip_authorization_class))
09835
09849 #define SIP_AUTHORIZATION_INIT() SIP_HDR_INIT(authorization)
09850
09865 #if SU_HAVE_INLINE
09866 su_inline sip_authorization_t *sip_authorization_init(sip_authorization_t x[1])
09867 {
09868 return SIP_HEADER_INIT(x, sip_authorization_class, sizeof(sip_authorization_t));
09869 }
09870 #else
09871 #define sip_authorization_init(x) \
09872 SIP_HEADER_INIT(x, sip_authorization_class, sizeof(sip_authorization_t))
09873 #endif
09874
09886 #if SU_HAVE_INLINE
09887 su_inline int sip_is_authorization(sip_header_t const *header)
09888 {
09889 return header && header->sh_class->hc_hash == sip_authorization_hash;
09890 }
09891 #else
09892 int sip_is_authorization(sip_header_t const *header);
09893 #endif
09894
09895 #define sip_authorization_p(h) sip_is_authorization((h))
09896
09897
09925 #if SU_HAVE_INLINE
09926 su_inline
09927 #endif
09928 sip_authorization_t *sip_authorization_dup(su_home_t *home, sip_authorization_t const *hdr)
09929 __attribute__((__malloc__));
09930
09931 #if SU_HAVE_INLINE
09932 su_inline
09933 sip_authorization_t *sip_authorization_dup(su_home_t *home, sip_authorization_t const *hdr)
09934 {
09935 return (sip_authorization_t *)
09936 msg_header_dup_as(home, sip_authorization_class, (msg_header_t const *)hdr);
09937 }
09938 #endif
09939
09967 #if SU_HAVE_INLINE
09968 su_inline
09969 #endif
09970 sip_authorization_t *sip_authorization_copy(su_home_t *home, sip_authorization_t const *hdr)
09971 __attribute__((__malloc__));
09972
09973 #if SU_HAVE_INLINE
09974 su_inline
09975 sip_authorization_t *sip_authorization_copy(su_home_t *home, sip_authorization_t const *hdr)
09976 {
09977 return (sip_authorization_t *)
09978 msg_header_copy_as(home, sip_authorization_class, (msg_header_t const *)hdr);
09979 }
09980 #endif
09981
09996 #if SU_HAVE_INLINE
09997 su_inline
09998 #endif
09999 sip_authorization_t *sip_authorization_make(su_home_t *home, char const *s)
10000 __attribute__((__malloc__));
10001
10002 #if SU_HAVE_INLINE
10003 su_inline sip_authorization_t *sip_authorization_make(su_home_t *home, char const *s)
10004 {
10005 return (sip_authorization_t *)sip_header_make(home, sip_authorization_class, s);
10006 }
10007 #endif
10008
10026 #if SU_HAVE_INLINE
10027 su_inline
10028 #endif
10029 sip_authorization_t *sip_authorization_format(su_home_t *home, char const *fmt, ...)
10030 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10031
10032 #if SU_HAVE_INLINE
10033 su_inline sip_authorization_t *sip_authorization_format(su_home_t *home, char const *fmt, ...)
10034 {
10035 sip_header_t *h;
10036 va_list ap;
10037
10038 va_start(ap, fmt);
10039 h = sip_header_vformat(home, sip_authorization_class, fmt, ap);
10040 va_end(ap);
10041
10042 return (sip_authorization_t *)h;
10043 }
10044 #endif
10045
10053 SOFIAPUBFUN issize_t sip_www_authenticate_d(su_home_t *, msg_header_t *,
10054 char *s, isize_t slen);
10055
10057 SOFIAPUBFUN issize_t sip_www_authenticate_e(char b[], isize_t bsiz,
10058 msg_header_t const *h, int flags);
10059
10064 #define sip_www_authenticate(sip) \
10065 ((sip_www_authenticate_t *)msg_header_access((msg_pub_t*)(sip), sip_www_authenticate_class))
10066
10080 #define SIP_WWW_AUTHENTICATE_INIT() SIP_HDR_INIT(www_authenticate)
10081
10096 #if SU_HAVE_INLINE
10097 su_inline sip_www_authenticate_t *sip_www_authenticate_init(sip_www_authenticate_t x[1])
10098 {
10099 return SIP_HEADER_INIT(x, sip_www_authenticate_class, sizeof(sip_www_authenticate_t));
10100 }
10101 #else
10102 #define sip_www_authenticate_init(x) \
10103 SIP_HEADER_INIT(x, sip_www_authenticate_class, sizeof(sip_www_authenticate_t))
10104 #endif
10105
10117 #if SU_HAVE_INLINE
10118 su_inline int sip_is_www_authenticate(sip_header_t const *header)
10119 {
10120 return header && header->sh_class->hc_hash == sip_www_authenticate_hash;
10121 }
10122 #else
10123 int sip_is_www_authenticate(sip_header_t const *header);
10124 #endif
10125
10126 #define sip_www_authenticate_p(h) sip_is_www_authenticate((h))
10127
10128
10156 #if SU_HAVE_INLINE
10157 su_inline
10158 #endif
10159 sip_www_authenticate_t *sip_www_authenticate_dup(su_home_t *home, sip_www_authenticate_t const *hdr)
10160 __attribute__((__malloc__));
10161
10162 #if SU_HAVE_INLINE
10163 su_inline
10164 sip_www_authenticate_t *sip_www_authenticate_dup(su_home_t *home, sip_www_authenticate_t const *hdr)
10165 {
10166 return (sip_www_authenticate_t *)
10167 msg_header_dup_as(home, sip_www_authenticate_class, (msg_header_t const *)hdr);
10168 }
10169 #endif
10170
10198 #if SU_HAVE_INLINE
10199 su_inline
10200 #endif
10201 sip_www_authenticate_t *sip_www_authenticate_copy(su_home_t *home, sip_www_authenticate_t const *hdr)
10202 __attribute__((__malloc__));
10203
10204 #if SU_HAVE_INLINE
10205 su_inline
10206 sip_www_authenticate_t *sip_www_authenticate_copy(su_home_t *home, sip_www_authenticate_t const *hdr)
10207 {
10208 return (sip_www_authenticate_t *)
10209 msg_header_copy_as(home, sip_www_authenticate_class, (msg_header_t const *)hdr);
10210 }
10211 #endif
10212
10227 #if SU_HAVE_INLINE
10228 su_inline
10229 #endif
10230 sip_www_authenticate_t *sip_www_authenticate_make(su_home_t *home, char const *s)
10231 __attribute__((__malloc__));
10232
10233 #if SU_HAVE_INLINE
10234 su_inline sip_www_authenticate_t *sip_www_authenticate_make(su_home_t *home, char const *s)
10235 {
10236 return (sip_www_authenticate_t *)sip_header_make(home, sip_www_authenticate_class, s);
10237 }
10238 #endif
10239
10257 #if SU_HAVE_INLINE
10258 su_inline
10259 #endif
10260 sip_www_authenticate_t *sip_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10261 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10262
10263 #if SU_HAVE_INLINE
10264 su_inline sip_www_authenticate_t *sip_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10265 {
10266 sip_header_t *h;
10267 va_list ap;
10268
10269 va_start(ap, fmt);
10270 h = sip_header_vformat(home, sip_www_authenticate_class, fmt, ap);
10271 va_end(ap);
10272
10273 return (sip_www_authenticate_t *)h;
10274 }
10275 #endif
10276
10284 SOFIAPUBFUN issize_t sip_authentication_info_d(su_home_t *, msg_header_t *,
10285 char *s, isize_t slen);
10286
10288 SOFIAPUBFUN issize_t sip_authentication_info_e(char b[], isize_t bsiz,
10289 msg_header_t const *h, int flags);
10290
10295 #define sip_authentication_info(sip) \
10296 ((sip_authentication_info_t *)msg_header_access((msg_pub_t*)(sip), sip_authentication_info_class))
10297
10311 #define SIP_AUTHENTICATION_INFO_INIT() SIP_HDR_INIT(authentication_info)
10312
10327 #if SU_HAVE_INLINE
10328 su_inline sip_authentication_info_t *sip_authentication_info_init(sip_authentication_info_t x[1])
10329 {
10330 return SIP_HEADER_INIT(x, sip_authentication_info_class, sizeof(sip_authentication_info_t));
10331 }
10332 #else
10333 #define sip_authentication_info_init(x) \
10334 SIP_HEADER_INIT(x, sip_authentication_info_class, sizeof(sip_authentication_info_t))
10335 #endif
10336
10348 #if SU_HAVE_INLINE
10349 su_inline int sip_is_authentication_info(sip_header_t const *header)
10350 {
10351 return header && header->sh_class->hc_hash == sip_authentication_info_hash;
10352 }
10353 #else
10354 int sip_is_authentication_info(sip_header_t const *header);
10355 #endif
10356
10357 #define sip_authentication_info_p(h) sip_is_authentication_info((h))
10358
10359
10387 #if SU_HAVE_INLINE
10388 su_inline
10389 #endif
10390 sip_authentication_info_t *sip_authentication_info_dup(su_home_t *home, sip_authentication_info_t const *hdr)
10391 __attribute__((__malloc__));
10392
10393 #if SU_HAVE_INLINE
10394 su_inline
10395 sip_authentication_info_t *sip_authentication_info_dup(su_home_t *home, sip_authentication_info_t const *hdr)
10396 {
10397 return (sip_authentication_info_t *)
10398 msg_header_dup_as(home, sip_authentication_info_class, (msg_header_t const *)hdr);
10399 }
10400 #endif
10401
10429 #if SU_HAVE_INLINE
10430 su_inline
10431 #endif
10432 sip_authentication_info_t *sip_authentication_info_copy(su_home_t *home, sip_authentication_info_t const *hdr)
10433 __attribute__((__malloc__));
10434
10435 #if SU_HAVE_INLINE
10436 su_inline
10437 sip_authentication_info_t *sip_authentication_info_copy(su_home_t *home, sip_authentication_info_t const *hdr)
10438 {
10439 return (sip_authentication_info_t *)
10440 msg_header_copy_as(home, sip_authentication_info_class, (msg_header_t const *)hdr);
10441 }
10442 #endif
10443
10458 #if SU_HAVE_INLINE
10459 su_inline
10460 #endif
10461 sip_authentication_info_t *sip_authentication_info_make(su_home_t *home, char const *s)
10462 __attribute__((__malloc__));
10463
10464 #if SU_HAVE_INLINE
10465 su_inline sip_authentication_info_t *sip_authentication_info_make(su_home_t *home, char const *s)
10466 {
10467 return (sip_authentication_info_t *)sip_header_make(home, sip_authentication_info_class, s);
10468 }
10469 #endif
10470
10488 #if SU_HAVE_INLINE
10489 su_inline
10490 #endif
10491 sip_authentication_info_t *sip_authentication_info_format(su_home_t *home, char const *fmt, ...)
10492 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10493
10494 #if SU_HAVE_INLINE
10495 su_inline sip_authentication_info_t *sip_authentication_info_format(su_home_t *home, char const *fmt, ...)
10496 {
10497 sip_header_t *h;
10498 va_list ap;
10499
10500 va_start(ap, fmt);
10501 h = sip_header_vformat(home, sip_authentication_info_class, fmt, ap);
10502 va_end(ap);
10503
10504 return (sip_authentication_info_t *)h;
10505 }
10506 #endif
10507
10515 SOFIAPUBFUN issize_t sip_error_info_d(su_home_t *, msg_header_t *,
10516 char *s, isize_t slen);
10517
10519 SOFIAPUBFUN issize_t sip_error_info_e(char b[], isize_t bsiz,
10520 msg_header_t const *h, int flags);
10521
10526 #define sip_error_info(sip) \
10527 ((sip_error_info_t *)msg_header_access((msg_pub_t*)(sip), sip_error_info_class))
10528
10542 #define SIP_ERROR_INFO_INIT() SIP_HDR_INIT(error_info)
10543
10558 #if SU_HAVE_INLINE
10559 su_inline sip_error_info_t *sip_error_info_init(sip_error_info_t x[1])
10560 {
10561 return SIP_HEADER_INIT(x, sip_error_info_class, sizeof(sip_error_info_t));
10562 }
10563 #else
10564 #define sip_error_info_init(x) \
10565 SIP_HEADER_INIT(x, sip_error_info_class, sizeof(sip_error_info_t))
10566 #endif
10567
10579 #if SU_HAVE_INLINE
10580 su_inline int sip_is_error_info(sip_header_t const *header)
10581 {
10582 return header && header->sh_class->hc_hash == sip_error_info_hash;
10583 }
10584 #else
10585 int sip_is_error_info(sip_header_t const *header);
10586 #endif
10587
10588 #define sip_error_info_p(h) sip_is_error_info((h))
10589
10590
10618 #if SU_HAVE_INLINE
10619 su_inline
10620 #endif
10621 sip_error_info_t *sip_error_info_dup(su_home_t *home, sip_error_info_t const *hdr)
10622 __attribute__((__malloc__));
10623
10624 #if SU_HAVE_INLINE
10625 su_inline
10626 sip_error_info_t *sip_error_info_dup(su_home_t *home, sip_error_info_t const *hdr)
10627 {
10628 return (sip_error_info_t *)
10629 msg_header_dup_as(home, sip_error_info_class, (msg_header_t const *)hdr);
10630 }
10631 #endif
10632
10660 #if SU_HAVE_INLINE
10661 su_inline
10662 #endif
10663 sip_error_info_t *sip_error_info_copy(su_home_t *home, sip_error_info_t const *hdr)
10664 __attribute__((__malloc__));
10665
10666 #if SU_HAVE_INLINE
10667 su_inline
10668 sip_error_info_t *sip_error_info_copy(su_home_t *home, sip_error_info_t const *hdr)
10669 {
10670 return (sip_error_info_t *)
10671 msg_header_copy_as(home, sip_error_info_class, (msg_header_t const *)hdr);
10672 }
10673 #endif
10674
10689 #if SU_HAVE_INLINE
10690 su_inline
10691 #endif
10692 sip_error_info_t *sip_error_info_make(su_home_t *home, char const *s)
10693 __attribute__((__malloc__));
10694
10695 #if SU_HAVE_INLINE
10696 su_inline sip_error_info_t *sip_error_info_make(su_home_t *home, char const *s)
10697 {
10698 return (sip_error_info_t *)sip_header_make(home, sip_error_info_class, s);
10699 }
10700 #endif
10701
10719 #if SU_HAVE_INLINE
10720 su_inline
10721 #endif
10722 sip_error_info_t *sip_error_info_format(su_home_t *home, char const *fmt, ...)
10723 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10724
10725 #if SU_HAVE_INLINE
10726 su_inline sip_error_info_t *sip_error_info_format(su_home_t *home, char const *fmt, ...)
10727 {
10728 sip_header_t *h;
10729 va_list ap;
10730
10731 va_start(ap, fmt);
10732 h = sip_header_vformat(home, sip_error_info_class, fmt, ap);
10733 va_end(ap);
10734
10735 return (sip_error_info_t *)h;
10736 }
10737 #endif
10738
10746 SOFIAPUBFUN issize_t sip_warning_d(su_home_t *, msg_header_t *,
10747 char *s, isize_t slen);
10748
10750 SOFIAPUBFUN issize_t sip_warning_e(char b[], isize_t bsiz,
10751 msg_header_t const *h, int flags);
10752
10757 #define sip_warning(sip) \
10758 ((sip_warning_t *)msg_header_access((msg_pub_t*)(sip), sip_warning_class))
10759
10773 #define SIP_WARNING_INIT() SIP_HDR_INIT(warning)
10774
10789 #if SU_HAVE_INLINE
10790 su_inline sip_warning_t *sip_warning_init(sip_warning_t x[1])
10791 {
10792 return SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t));
10793 }
10794 #else
10795 #define sip_warning_init(x) \
10796 SIP_HEADER_INIT(x, sip_warning_class, sizeof(sip_warning_t))
10797 #endif
10798
10810 #if SU_HAVE_INLINE
10811 su_inline int sip_is_warning(sip_header_t const *header)
10812 {
10813 return header && header->sh_class->hc_hash == sip_warning_hash;
10814 }
10815 #else
10816 int sip_is_warning(sip_header_t const *header);
10817 #endif
10818
10819 #define sip_warning_p(h) sip_is_warning((h))
10820
10821
10849 #if SU_HAVE_INLINE
10850 su_inline
10851 #endif
10852 sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
10853 __attribute__((__malloc__));
10854
10855 #if SU_HAVE_INLINE
10856 su_inline
10857 sip_warning_t *sip_warning_dup(su_home_t *home, sip_warning_t const *hdr)
10858 {
10859 return (sip_warning_t *)
10860 msg_header_dup_as(home, sip_warning_class, (msg_header_t const *)hdr);
10861 }
10862 #endif
10863
10891 #if SU_HAVE_INLINE
10892 su_inline
10893 #endif
10894 sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
10895 __attribute__((__malloc__));
10896
10897 #if SU_HAVE_INLINE
10898 su_inline
10899 sip_warning_t *sip_warning_copy(su_home_t *home, sip_warning_t const *hdr)
10900 {
10901 return (sip_warning_t *)
10902 msg_header_copy_as(home, sip_warning_class, (msg_header_t const *)hdr);
10903 }
10904 #endif
10905
10920 #if SU_HAVE_INLINE
10921 su_inline
10922 #endif
10923 sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
10924 __attribute__((__malloc__));
10925
10926 #if SU_HAVE_INLINE
10927 su_inline sip_warning_t *sip_warning_make(su_home_t *home, char const *s)
10928 {
10929 return (sip_warning_t *)sip_header_make(home, sip_warning_class, s);
10930 }
10931 #endif
10932
10950 #if SU_HAVE_INLINE
10951 su_inline
10952 #endif
10953 sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
10954 __attribute__((__malloc__, __format__ (printf, 2, 3)));
10955
10956 #if SU_HAVE_INLINE
10957 su_inline sip_warning_t *sip_warning_format(su_home_t *home, char const *fmt, ...)
10958 {
10959 sip_header_t *h;
10960 va_list ap;
10961
10962 va_start(ap, fmt);
10963 h = sip_header_vformat(home, sip_warning_class, fmt, ap);
10964 va_end(ap);
10965
10966 return (sip_warning_t *)h;
10967 }
10968 #endif
10969
10977 SOFIAPUBFUN issize_t sip_refer_to_d(su_home_t *, msg_header_t *,
10978 char *s, isize_t slen);
10979
10981 SOFIAPUBFUN issize_t sip_refer_to_e(char b[], isize_t bsiz,
10982 msg_header_t const *h, int flags);
10983
10988 #define sip_refer_to(sip) \
10989 ((sip_refer_to_t *)msg_header_access((msg_pub_t*)(sip), sip_refer_to_class))
10990
11004 #define SIP_REFER_TO_INIT() SIP_HDR_INIT(refer_to)
11005
11020 #if SU_HAVE_INLINE
11021 su_inline sip_refer_to_t *sip_refer_to_init(sip_refer_to_t x[1])
11022 {
11023 return SIP_HEADER_INIT(x, sip_refer_to_class, sizeof(sip_refer_to_t));
11024 }
11025 #else
11026 #define sip_refer_to_init(x) \
11027 SIP_HEADER_INIT(x, sip_refer_to_class, sizeof(sip_refer_to_t))
11028 #endif
11029
11041 #if SU_HAVE_INLINE
11042 su_inline int sip_is_refer_to(sip_header_t const *header)
11043 {
11044 return header && header->sh_class->hc_hash == sip_refer_to_hash;
11045 }
11046 #else
11047 int sip_is_refer_to(sip_header_t const *header);
11048 #endif
11049
11050 #define sip_refer_to_p(h) sip_is_refer_to((h))
11051
11052
11080 #if SU_HAVE_INLINE
11081 su_inline
11082 #endif
11083 sip_refer_to_t *sip_refer_to_dup(su_home_t *home, sip_refer_to_t const *hdr)
11084 __attribute__((__malloc__));
11085
11086 #if SU_HAVE_INLINE
11087 su_inline
11088 sip_refer_to_t *sip_refer_to_dup(su_home_t *home, sip_refer_to_t const *hdr)
11089 {
11090 return (sip_refer_to_t *)
11091 msg_header_dup_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
11092 }
11093 #endif
11094
11122 #if SU_HAVE_INLINE
11123 su_inline
11124 #endif
11125 sip_refer_to_t *sip_refer_to_copy(su_home_t *home, sip_refer_to_t const *hdr)
11126 __attribute__((__malloc__));
11127
11128 #if SU_HAVE_INLINE
11129 su_inline
11130 sip_refer_to_t *sip_refer_to_copy(su_home_t *home, sip_refer_to_t const *hdr)
11131 {
11132 return (sip_refer_to_t *)
11133 msg_header_copy_as(home, sip_refer_to_class, (msg_header_t const *)hdr);
11134 }
11135 #endif
11136
11151 #if SU_HAVE_INLINE
11152 su_inline
11153 #endif
11154 sip_refer_to_t *sip_refer_to_make(su_home_t *home, char const *s)
11155 __attribute__((__malloc__));
11156
11157 #if SU_HAVE_INLINE
11158 su_inline sip_refer_to_t *sip_refer_to_make(su_home_t *home, char const *s)
11159 {
11160 return (sip_refer_to_t *)sip_header_make(home, sip_refer_to_class, s);
11161 }
11162 #endif
11163
11181 #if SU_HAVE_INLINE
11182 su_inline
11183 #endif
11184 sip_refer_to_t *sip_refer_to_format(su_home_t *home, char const *fmt, ...)
11185 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11186
11187 #if SU_HAVE_INLINE
11188 su_inline sip_refer_to_t *sip_refer_to_format(su_home_t *home, char const *fmt, ...)
11189 {
11190 sip_header_t *h;
11191 va_list ap;
11192
11193 va_start(ap, fmt);
11194 h = sip_header_vformat(home, sip_refer_to_class, fmt, ap);
11195 va_end(ap);
11196
11197 return (sip_refer_to_t *)h;
11198 }
11199 #endif
11200
11208 SOFIAPUBFUN issize_t sip_referred_by_d(su_home_t *, msg_header_t *,
11209 char *s, isize_t slen);
11210
11212 SOFIAPUBFUN issize_t sip_referred_by_e(char b[], isize_t bsiz,
11213 msg_header_t const *h, int flags);
11214
11219 #define sip_referred_by(sip) \
11220 ((sip_referred_by_t *)msg_header_access((msg_pub_t*)(sip), sip_referred_by_class))
11221
11235 #define SIP_REFERRED_BY_INIT() SIP_HDR_INIT(referred_by)
11236
11251 #if SU_HAVE_INLINE
11252 su_inline sip_referred_by_t *sip_referred_by_init(sip_referred_by_t x[1])
11253 {
11254 return SIP_HEADER_INIT(x, sip_referred_by_class, sizeof(sip_referred_by_t));
11255 }
11256 #else
11257 #define sip_referred_by_init(x) \
11258 SIP_HEADER_INIT(x, sip_referred_by_class, sizeof(sip_referred_by_t))
11259 #endif
11260
11272 #if SU_HAVE_INLINE
11273 su_inline int sip_is_referred_by(sip_header_t const *header)
11274 {
11275 return header && header->sh_class->hc_hash == sip_referred_by_hash;
11276 }
11277 #else
11278 int sip_is_referred_by(sip_header_t const *header);
11279 #endif
11280
11281 #define sip_referred_by_p(h) sip_is_referred_by((h))
11282
11283
11311 #if SU_HAVE_INLINE
11312 su_inline
11313 #endif
11314 sip_referred_by_t *sip_referred_by_dup(su_home_t *home, sip_referred_by_t const *hdr)
11315 __attribute__((__malloc__));
11316
11317 #if SU_HAVE_INLINE
11318 su_inline
11319 sip_referred_by_t *sip_referred_by_dup(su_home_t *home, sip_referred_by_t const *hdr)
11320 {
11321 return (sip_referred_by_t *)
11322 msg_header_dup_as(home, sip_referred_by_class, (msg_header_t const *)hdr);
11323 }
11324 #endif
11325
11353 #if SU_HAVE_INLINE
11354 su_inline
11355 #endif
11356 sip_referred_by_t *sip_referred_by_copy(su_home_t *home, sip_referred_by_t const *hdr)
11357 __attribute__((__malloc__));
11358
11359 #if SU_HAVE_INLINE
11360 su_inline
11361 sip_referred_by_t *sip_referred_by_copy(su_home_t *home, sip_referred_by_t const *hdr)
11362 {
11363 return (sip_referred_by_t *)
11364 msg_header_copy_as(home, sip_referred_by_class, (msg_header_t const *)hdr);
11365 }
11366 #endif
11367
11382 #if SU_HAVE_INLINE
11383 su_inline
11384 #endif
11385 sip_referred_by_t *sip_referred_by_make(su_home_t *home, char const *s)
11386 __attribute__((__malloc__));
11387
11388 #if SU_HAVE_INLINE
11389 su_inline sip_referred_by_t *sip_referred_by_make(su_home_t *home, char const *s)
11390 {
11391 return (sip_referred_by_t *)sip_header_make(home, sip_referred_by_class, s);
11392 }
11393 #endif
11394
11412 #if SU_HAVE_INLINE
11413 su_inline
11414 #endif
11415 sip_referred_by_t *sip_referred_by_format(su_home_t *home, char const *fmt, ...)
11416 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11417
11418 #if SU_HAVE_INLINE
11419 su_inline sip_referred_by_t *sip_referred_by_format(su_home_t *home, char const *fmt, ...)
11420 {
11421 sip_header_t *h;
11422 va_list ap;
11423
11424 va_start(ap, fmt);
11425 h = sip_header_vformat(home, sip_referred_by_class, fmt, ap);
11426 va_end(ap);
11427
11428 return (sip_referred_by_t *)h;
11429 }
11430 #endif
11431
11439 SOFIAPUBFUN issize_t sip_replaces_d(su_home_t *, msg_header_t *,
11440 char *s, isize_t slen);
11441
11443 SOFIAPUBFUN issize_t sip_replaces_e(char b[], isize_t bsiz,
11444 msg_header_t const *h, int flags);
11445
11450 #define sip_replaces(sip) \
11451 ((sip_replaces_t *)msg_header_access((msg_pub_t*)(sip), sip_replaces_class))
11452
11466 #define SIP_REPLACES_INIT() SIP_HDR_INIT(replaces)
11467
11482 #if SU_HAVE_INLINE
11483 su_inline sip_replaces_t *sip_replaces_init(sip_replaces_t x[1])
11484 {
11485 return SIP_HEADER_INIT(x, sip_replaces_class, sizeof(sip_replaces_t));
11486 }
11487 #else
11488 #define sip_replaces_init(x) \
11489 SIP_HEADER_INIT(x, sip_replaces_class, sizeof(sip_replaces_t))
11490 #endif
11491
11503 #if SU_HAVE_INLINE
11504 su_inline int sip_is_replaces(sip_header_t const *header)
11505 {
11506 return header && header->sh_class->hc_hash == sip_replaces_hash;
11507 }
11508 #else
11509 int sip_is_replaces(sip_header_t const *header);
11510 #endif
11511
11512 #define sip_replaces_p(h) sip_is_replaces((h))
11513
11514
11542 #if SU_HAVE_INLINE
11543 su_inline
11544 #endif
11545 sip_replaces_t *sip_replaces_dup(su_home_t *home, sip_replaces_t const *hdr)
11546 __attribute__((__malloc__));
11547
11548 #if SU_HAVE_INLINE
11549 su_inline
11550 sip_replaces_t *sip_replaces_dup(su_home_t *home, sip_replaces_t const *hdr)
11551 {
11552 return (sip_replaces_t *)
11553 msg_header_dup_as(home, sip_replaces_class, (msg_header_t const *)hdr);
11554 }
11555 #endif
11556
11584 #if SU_HAVE_INLINE
11585 su_inline
11586 #endif
11587 sip_replaces_t *sip_replaces_copy(su_home_t *home, sip_replaces_t const *hdr)
11588 __attribute__((__malloc__));
11589
11590 #if SU_HAVE_INLINE
11591 su_inline
11592 sip_replaces_t *sip_replaces_copy(su_home_t *home, sip_replaces_t const *hdr)
11593 {
11594 return (sip_replaces_t *)
11595 msg_header_copy_as(home, sip_replaces_class, (msg_header_t const *)hdr);
11596 }
11597 #endif
11598
11613 #if SU_HAVE_INLINE
11614 su_inline
11615 #endif
11616 sip_replaces_t *sip_replaces_make(su_home_t *home, char const *s)
11617 __attribute__((__malloc__));
11618
11619 #if SU_HAVE_INLINE
11620 su_inline sip_replaces_t *sip_replaces_make(su_home_t *home, char const *s)
11621 {
11622 return (sip_replaces_t *)sip_header_make(home, sip_replaces_class, s);
11623 }
11624 #endif
11625
11643 #if SU_HAVE_INLINE
11644 su_inline
11645 #endif
11646 sip_replaces_t *sip_replaces_format(su_home_t *home, char const *fmt, ...)
11647 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11648
11649 #if SU_HAVE_INLINE
11650 su_inline sip_replaces_t *sip_replaces_format(su_home_t *home, char const *fmt, ...)
11651 {
11652 sip_header_t *h;
11653 va_list ap;
11654
11655 va_start(ap, fmt);
11656 h = sip_header_vformat(home, sip_replaces_class, fmt, ap);
11657 va_end(ap);
11658
11659 return (sip_replaces_t *)h;
11660 }
11661 #endif
11662
11670 SOFIAPUBFUN issize_t sip_session_expires_d(su_home_t *, msg_header_t *,
11671 char *s, isize_t slen);
11672
11674 SOFIAPUBFUN issize_t sip_session_expires_e(char b[], isize_t bsiz,
11675 msg_header_t const *h, int flags);
11676
11681 #define sip_session_expires(sip) \
11682 ((sip_session_expires_t *)msg_header_access((msg_pub_t*)(sip), sip_session_expires_class))
11683
11697 #define SIP_SESSION_EXPIRES_INIT() SIP_HDR_INIT(session_expires)
11698
11713 #if SU_HAVE_INLINE
11714 su_inline sip_session_expires_t *sip_session_expires_init(sip_session_expires_t x[1])
11715 {
11716 return SIP_HEADER_INIT(x, sip_session_expires_class, sizeof(sip_session_expires_t));
11717 }
11718 #else
11719 #define sip_session_expires_init(x) \
11720 SIP_HEADER_INIT(x, sip_session_expires_class, sizeof(sip_session_expires_t))
11721 #endif
11722
11734 #if SU_HAVE_INLINE
11735 su_inline int sip_is_session_expires(sip_header_t const *header)
11736 {
11737 return header && header->sh_class->hc_hash == sip_session_expires_hash;
11738 }
11739 #else
11740 int sip_is_session_expires(sip_header_t const *header);
11741 #endif
11742
11743 #define sip_session_expires_p(h) sip_is_session_expires((h))
11744
11745
11773 #if SU_HAVE_INLINE
11774 su_inline
11775 #endif
11776 sip_session_expires_t *sip_session_expires_dup(su_home_t *home, sip_session_expires_t const *hdr)
11777 __attribute__((__malloc__));
11778
11779 #if SU_HAVE_INLINE
11780 su_inline
11781 sip_session_expires_t *sip_session_expires_dup(su_home_t *home, sip_session_expires_t const *hdr)
11782 {
11783 return (sip_session_expires_t *)
11784 msg_header_dup_as(home, sip_session_expires_class, (msg_header_t const *)hdr);
11785 }
11786 #endif
11787
11815 #if SU_HAVE_INLINE
11816 su_inline
11817 #endif
11818 sip_session_expires_t *sip_session_expires_copy(su_home_t *home, sip_session_expires_t const *hdr)
11819 __attribute__((__malloc__));
11820
11821 #if SU_HAVE_INLINE
11822 su_inline
11823 sip_session_expires_t *sip_session_expires_copy(su_home_t *home, sip_session_expires_t const *hdr)
11824 {
11825 return (sip_session_expires_t *)
11826 msg_header_copy_as(home, sip_session_expires_class, (msg_header_t const *)hdr);
11827 }
11828 #endif
11829
11844 #if SU_HAVE_INLINE
11845 su_inline
11846 #endif
11847 sip_session_expires_t *sip_session_expires_make(su_home_t *home, char const *s)
11848 __attribute__((__malloc__));
11849
11850 #if SU_HAVE_INLINE
11851 su_inline sip_session_expires_t *sip_session_expires_make(su_home_t *home, char const *s)
11852 {
11853 return (sip_session_expires_t *)sip_header_make(home, sip_session_expires_class, s);
11854 }
11855 #endif
11856
11874 #if SU_HAVE_INLINE
11875 su_inline
11876 #endif
11877 sip_session_expires_t *sip_session_expires_format(su_home_t *home, char const *fmt, ...)
11878 __attribute__((__malloc__, __format__ (printf, 2, 3)));
11879
11880 #if SU_HAVE_INLINE
11881 su_inline sip_session_expires_t *sip_session_expires_format(su_home_t *home, char const *fmt, ...)
11882 {
11883 sip_header_t *h;
11884 va_list ap;
11885
11886 va_start(ap, fmt);
11887 h = sip_header_vformat(home, sip_session_expires_class, fmt, ap);
11888 va_end(ap);
11889
11890 return (sip_session_expires_t *)h;
11891 }
11892 #endif
11893
11901 SOFIAPUBFUN issize_t sip_min_se_d(su_home_t *, msg_header_t *,
11902 char *s, isize_t slen);
11903
11905 SOFIAPUBFUN issize_t sip_min_se_e(char b[], isize_t bsiz,
11906 msg_header_t const *h, int flags);
11907
11912 #define sip_min_se(sip) \
11913 ((sip_min_se_t *)msg_header_access((msg_pub_t*)(sip), sip_min_se_class))
11914
11928 #define SIP_MIN_SE_INIT() SIP_HDR_INIT(min_se)
11929
11944 #if SU_HAVE_INLINE
11945 su_inline sip_min_se_t *sip_min_se_init(sip_min_se_t x[1])
11946 {
11947 return SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t));
11948 }
11949 #else
11950 #define sip_min_se_init(x) \
11951 SIP_HEADER_INIT(x, sip_min_se_class, sizeof(sip_min_se_t))
11952 #endif
11953
11965 #if SU_HAVE_INLINE
11966 su_inline int sip_is_min_se(sip_header_t const *header)
11967 {
11968 return header && header->sh_class->hc_hash == sip_min_se_hash;
11969 }
11970 #else
11971 int sip_is_min_se(sip_header_t const *header);
11972 #endif
11973
11974 #define sip_min_se_p(h) sip_is_min_se((h))
11975
11976
12004 #if SU_HAVE_INLINE
12005 su_inline
12006 #endif
12007 sip_min_se_t *sip_min_se_dup(su_home_t *home, sip_min_se_t const *hdr)
12008 __attribute__((__malloc__));
12009
12010 #if SU_HAVE_INLINE
12011 su_inline
12012 sip_min_se_t *sip_min_se_dup(su_home_t *home, sip_min_se_t const *hdr)
12013 {
12014 return (sip_min_se_t *)
12015 msg_header_dup_as(home, sip_min_se_class, (msg_header_t const *)hdr);
12016 }
12017 #endif
12018
12046 #if SU_HAVE_INLINE
12047 su_inline
12048 #endif
12049 sip_min_se_t *sip_min_se_copy(su_home_t *home, sip_min_se_t const *hdr)
12050 __attribute__((__malloc__));
12051
12052 #if SU_HAVE_INLINE
12053 su_inline
12054 sip_min_se_t *sip_min_se_copy(su_home_t *home, sip_min_se_t const *hdr)
12055 {
12056 return (sip_min_se_t *)
12057 msg_header_copy_as(home, sip_min_se_class, (msg_header_t const *)hdr);
12058 }
12059 #endif
12060
12075 #if SU_HAVE_INLINE
12076 su_inline
12077 #endif
12078 sip_min_se_t *sip_min_se_make(su_home_t *home, char const *s)
12079 __attribute__((__malloc__));
12080
12081 #if SU_HAVE_INLINE
12082 su_inline sip_min_se_t *sip_min_se_make(su_home_t *home, char const *s)
12083 {
12084 return (sip_min_se_t *)sip_header_make(home, sip_min_se_class, s);
12085 }
12086 #endif
12087
12105 #if SU_HAVE_INLINE
12106 su_inline
12107 #endif
12108 sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
12109 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12110
12111 #if SU_HAVE_INLINE
12112 su_inline sip_min_se_t *sip_min_se_format(su_home_t *home, char const *fmt, ...)
12113 {
12114 sip_header_t *h;
12115 va_list ap;
12116
12117 va_start(ap, fmt);
12118 h = sip_header_vformat(home, sip_min_se_class, fmt, ap);
12119 va_end(ap);
12120
12121 return (sip_min_se_t *)h;
12122 }
12123 #endif
12124
12132 SOFIAPUBFUN issize_t sip_path_d(su_home_t *, msg_header_t *,
12133 char *s, isize_t slen);
12134
12136 SOFIAPUBFUN issize_t sip_path_e(char b[], isize_t bsiz,
12137 msg_header_t const *h, int flags);
12138
12143 #define sip_path(sip) \
12144 ((sip_path_t *)msg_header_access((msg_pub_t*)(sip), sip_path_class))
12145
12159 #define SIP_PATH_INIT() SIP_HDR_INIT(path)
12160
12175 #if SU_HAVE_INLINE
12176 su_inline sip_path_t *sip_path_init(sip_path_t x[1])
12177 {
12178 return SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t));
12179 }
12180 #else
12181 #define sip_path_init(x) \
12182 SIP_HEADER_INIT(x, sip_path_class, sizeof(sip_path_t))
12183 #endif
12184
12196 #if SU_HAVE_INLINE
12197 su_inline int sip_is_path(sip_header_t const *header)
12198 {
12199 return header && header->sh_class->hc_hash == sip_path_hash;
12200 }
12201 #else
12202 int sip_is_path(sip_header_t const *header);
12203 #endif
12204
12205 #define sip_path_p(h) sip_is_path((h))
12206
12207
12235 #if SU_HAVE_INLINE
12236 su_inline
12237 #endif
12238 sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
12239 __attribute__((__malloc__));
12240
12241 #if SU_HAVE_INLINE
12242 su_inline
12243 sip_path_t *sip_path_dup(su_home_t *home, sip_path_t const *hdr)
12244 {
12245 return (sip_path_t *)
12246 msg_header_dup_as(home, sip_path_class, (msg_header_t const *)hdr);
12247 }
12248 #endif
12249
12277 #if SU_HAVE_INLINE
12278 su_inline
12279 #endif
12280 sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
12281 __attribute__((__malloc__));
12282
12283 #if SU_HAVE_INLINE
12284 su_inline
12285 sip_path_t *sip_path_copy(su_home_t *home, sip_path_t const *hdr)
12286 {
12287 return (sip_path_t *)
12288 msg_header_copy_as(home, sip_path_class, (msg_header_t const *)hdr);
12289 }
12290 #endif
12291
12306 #if SU_HAVE_INLINE
12307 su_inline
12308 #endif
12309 sip_path_t *sip_path_make(su_home_t *home, char const *s)
12310 __attribute__((__malloc__));
12311
12312 #if SU_HAVE_INLINE
12313 su_inline sip_path_t *sip_path_make(su_home_t *home, char const *s)
12314 {
12315 return (sip_path_t *)sip_header_make(home, sip_path_class, s);
12316 }
12317 #endif
12318
12336 #if SU_HAVE_INLINE
12337 su_inline
12338 #endif
12339 sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
12340 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12341
12342 #if SU_HAVE_INLINE
12343 su_inline sip_path_t *sip_path_format(su_home_t *home, char const *fmt, ...)
12344 {
12345 sip_header_t *h;
12346 va_list ap;
12347
12348 va_start(ap, fmt);
12349 h = sip_header_vformat(home, sip_path_class, fmt, ap);
12350 va_end(ap);
12351
12352 return (sip_path_t *)h;
12353 }
12354 #endif
12355
12363 SOFIAPUBFUN issize_t sip_service_route_d(su_home_t *, msg_header_t *,
12364 char *s, isize_t slen);
12365
12367 SOFIAPUBFUN issize_t sip_service_route_e(char b[], isize_t bsiz,
12368 msg_header_t const *h, int flags);
12369
12374 #define sip_service_route(sip) \
12375 ((sip_service_route_t *)msg_header_access((msg_pub_t*)(sip), sip_service_route_class))
12376
12390 #define SIP_SERVICE_ROUTE_INIT() SIP_HDR_INIT(service_route)
12391
12406 #if SU_HAVE_INLINE
12407 su_inline sip_service_route_t *sip_service_route_init(sip_service_route_t x[1])
12408 {
12409 return SIP_HEADER_INIT(x, sip_service_route_class, sizeof(sip_service_route_t));
12410 }
12411 #else
12412 #define sip_service_route_init(x) \
12413 SIP_HEADER_INIT(x, sip_service_route_class, sizeof(sip_service_route_t))
12414 #endif
12415
12427 #if SU_HAVE_INLINE
12428 su_inline int sip_is_service_route(sip_header_t const *header)
12429 {
12430 return header && header->sh_class->hc_hash == sip_service_route_hash;
12431 }
12432 #else
12433 int sip_is_service_route(sip_header_t const *header);
12434 #endif
12435
12436 #define sip_service_route_p(h) sip_is_service_route((h))
12437
12438
12466 #if SU_HAVE_INLINE
12467 su_inline
12468 #endif
12469 sip_service_route_t *sip_service_route_dup(su_home_t *home, sip_service_route_t const *hdr)
12470 __attribute__((__malloc__));
12471
12472 #if SU_HAVE_INLINE
12473 su_inline
12474 sip_service_route_t *sip_service_route_dup(su_home_t *home, sip_service_route_t const *hdr)
12475 {
12476 return (sip_service_route_t *)
12477 msg_header_dup_as(home, sip_service_route_class, (msg_header_t const *)hdr);
12478 }
12479 #endif
12480
12508 #if SU_HAVE_INLINE
12509 su_inline
12510 #endif
12511 sip_service_route_t *sip_service_route_copy(su_home_t *home, sip_service_route_t const *hdr)
12512 __attribute__((__malloc__));
12513
12514 #if SU_HAVE_INLINE
12515 su_inline
12516 sip_service_route_t *sip_service_route_copy(su_home_t *home, sip_service_route_t const *hdr)
12517 {
12518 return (sip_service_route_t *)
12519 msg_header_copy_as(home, sip_service_route_class, (msg_header_t const *)hdr);
12520 }
12521 #endif
12522
12537 #if SU_HAVE_INLINE
12538 su_inline
12539 #endif
12540 sip_service_route_t *sip_service_route_make(su_home_t *home, char const *s)
12541 __attribute__((__malloc__));
12542
12543 #if SU_HAVE_INLINE
12544 su_inline sip_service_route_t *sip_service_route_make(su_home_t *home, char const *s)
12545 {
12546 return (sip_service_route_t *)sip_header_make(home, sip_service_route_class, s);
12547 }
12548 #endif
12549
12567 #if SU_HAVE_INLINE
12568 su_inline
12569 #endif
12570 sip_service_route_t *sip_service_route_format(su_home_t *home, char const *fmt, ...)
12571 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12572
12573 #if SU_HAVE_INLINE
12574 su_inline sip_service_route_t *sip_service_route_format(su_home_t *home, char const *fmt, ...)
12575 {
12576 sip_header_t *h;
12577 va_list ap;
12578
12579 va_start(ap, fmt);
12580 h = sip_header_vformat(home, sip_service_route_class, fmt, ap);
12581 va_end(ap);
12582
12583 return (sip_service_route_t *)h;
12584 }
12585 #endif
12586
12594 SOFIAPUBFUN issize_t sip_reason_d(su_home_t *, msg_header_t *,
12595 char *s, isize_t slen);
12596
12598 SOFIAPUBFUN issize_t sip_reason_e(char b[], isize_t bsiz,
12599 msg_header_t const *h, int flags);
12600
12605 #define sip_reason(sip) \
12606 ((sip_reason_t *)msg_header_access((msg_pub_t*)(sip), sip_reason_class))
12607
12621 #define SIP_REASON_INIT() SIP_HDR_INIT(reason)
12622
12637 #if SU_HAVE_INLINE
12638 su_inline sip_reason_t *sip_reason_init(sip_reason_t x[1])
12639 {
12640 return SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t));
12641 }
12642 #else
12643 #define sip_reason_init(x) \
12644 SIP_HEADER_INIT(x, sip_reason_class, sizeof(sip_reason_t))
12645 #endif
12646
12658 #if SU_HAVE_INLINE
12659 su_inline int sip_is_reason(sip_header_t const *header)
12660 {
12661 return header && header->sh_class->hc_hash == sip_reason_hash;
12662 }
12663 #else
12664 int sip_is_reason(sip_header_t const *header);
12665 #endif
12666
12667 #define sip_reason_p(h) sip_is_reason((h))
12668
12669
12697 #if SU_HAVE_INLINE
12698 su_inline
12699 #endif
12700 sip_reason_t *sip_reason_dup(su_home_t *home, sip_reason_t const *hdr)
12701 __attribute__((__malloc__));
12702
12703 #if SU_HAVE_INLINE
12704 su_inline
12705 sip_reason_t *sip_reason_dup(su_home_t *home, sip_reason_t const *hdr)
12706 {
12707 return (sip_reason_t *)
12708 msg_header_dup_as(home, sip_reason_class, (msg_header_t const *)hdr);
12709 }
12710 #endif
12711
12739 #if SU_HAVE_INLINE
12740 su_inline
12741 #endif
12742 sip_reason_t *sip_reason_copy(su_home_t *home, sip_reason_t const *hdr)
12743 __attribute__((__malloc__));
12744
12745 #if SU_HAVE_INLINE
12746 su_inline
12747 sip_reason_t *sip_reason_copy(su_home_t *home, sip_reason_t const *hdr)
12748 {
12749 return (sip_reason_t *)
12750 msg_header_copy_as(home, sip_reason_class, (msg_header_t const *)hdr);
12751 }
12752 #endif
12753
12768 #if SU_HAVE_INLINE
12769 su_inline
12770 #endif
12771 sip_reason_t *sip_reason_make(su_home_t *home, char const *s)
12772 __attribute__((__malloc__));
12773
12774 #if SU_HAVE_INLINE
12775 su_inline sip_reason_t *sip_reason_make(su_home_t *home, char const *s)
12776 {
12777 return (sip_reason_t *)sip_header_make(home, sip_reason_class, s);
12778 }
12779 #endif
12780
12798 #if SU_HAVE_INLINE
12799 su_inline
12800 #endif
12801 sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
12802 __attribute__((__malloc__, __format__ (printf, 2, 3)));
12803
12804 #if SU_HAVE_INLINE
12805 su_inline sip_reason_t *sip_reason_format(su_home_t *home, char const *fmt, ...)
12806 {
12807 sip_header_t *h;
12808 va_list ap;
12809
12810 va_start(ap, fmt);
12811 h = sip_header_vformat(home, sip_reason_class, fmt, ap);
12812 va_end(ap);
12813
12814 return (sip_reason_t *)h;
12815 }
12816 #endif
12817
12825 SOFIAPUBFUN issize_t sip_security_client_d(su_home_t *, msg_header_t *,
12826 char *s, isize_t slen);
12827
12829 SOFIAPUBFUN issize_t sip_security_client_e(char b[], isize_t bsiz,
12830 msg_header_t const *h, int flags);
12831
12836 #define sip_security_client(sip) \
12837 ((sip_security_client_t *)msg_header_access((msg_pub_t*)(sip), sip_security_client_class))
12838
12852 #define SIP_SECURITY_CLIENT_INIT() SIP_HDR_INIT(security_client)
12853
12868 #if SU_HAVE_INLINE
12869 su_inline sip_security_client_t *sip_security_client_init(sip_security_client_t x[1])
12870 {
12871 return SIP_HEADER_INIT(x, sip_security_client_class, sizeof(sip_security_client_t));
12872 }
12873 #else
12874 #define sip_security_client_init(x) \
12875 SIP_HEADER_INIT(x, sip_security_client_class, sizeof(sip_security_client_t))
12876 #endif
12877
12889 #if SU_HAVE_INLINE
12890 su_inline int sip_is_security_client(sip_header_t const *header)
12891 {
12892 return header && header->sh_class->hc_hash == sip_security_client_hash;
12893 }
12894 #else
12895 int sip_is_security_client(sip_header_t const *header);
12896 #endif
12897
12898 #define sip_security_client_p(h) sip_is_security_client((h))
12899
12900
12928 #if SU_HAVE_INLINE
12929 su_inline
12930 #endif
12931 sip_security_client_t *sip_security_client_dup(su_home_t *home, sip_security_client_t const *hdr)
12932 __attribute__((__malloc__));
12933
12934 #if SU_HAVE_INLINE
12935 su_inline
12936 sip_security_client_t *sip_security_client_dup(su_home_t *home, sip_security_client_t const *hdr)
12937 {
12938 return (sip_security_client_t *)
12939 msg_header_dup_as(home, sip_security_client_class, (msg_header_t const *)hdr);
12940 }
12941 #endif
12942
12970 #if SU_HAVE_INLINE
12971 su_inline
12972 #endif
12973 sip_security_client_t *sip_security_client_copy(su_home_t *home, sip_security_client_t const *hdr)
12974 __attribute__((__malloc__));
12975
12976 #if SU_HAVE_INLINE
12977 su_inline
12978 sip_security_client_t *sip_security_client_copy(su_home_t *home, sip_security_client_t const *hdr)
12979 {
12980 return (sip_security_client_t *)
12981 msg_header_copy_as(home, sip_security_client_class, (msg_header_t const *)hdr);
12982 }
12983 #endif
12984
12999 #if SU_HAVE_INLINE
13000 su_inline
13001 #endif
13002 sip_security_client_t *sip_security_client_make(su_home_t *home, char const *s)
13003 __attribute__((__malloc__));
13004
13005 #if SU_HAVE_INLINE
13006 su_inline sip_security_client_t *sip_security_client_make(su_home_t *home, char const *s)
13007 {
13008 return (sip_security_client_t *)sip_header_make(home, sip_security_client_class, s);
13009 }
13010 #endif
13011
13029 #if SU_HAVE_INLINE
13030 su_inline
13031 #endif
13032 sip_security_client_t *sip_security_client_format(su_home_t *home, char const *fmt, ...)
13033 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13034
13035 #if SU_HAVE_INLINE
13036 su_inline sip_security_client_t *sip_security_client_format(su_home_t *home, char const *fmt, ...)
13037 {
13038 sip_header_t *h;
13039 va_list ap;
13040
13041 va_start(ap, fmt);
13042 h = sip_header_vformat(home, sip_security_client_class, fmt, ap);
13043 va_end(ap);
13044
13045 return (sip_security_client_t *)h;
13046 }
13047 #endif
13048
13056 SOFIAPUBFUN issize_t sip_security_server_d(su_home_t *, msg_header_t *,
13057 char *s, isize_t slen);
13058
13060 SOFIAPUBFUN issize_t sip_security_server_e(char b[], isize_t bsiz,
13061 msg_header_t const *h, int flags);
13062
13067 #define sip_security_server(sip) \
13068 ((sip_security_server_t *)msg_header_access((msg_pub_t*)(sip), sip_security_server_class))
13069
13083 #define SIP_SECURITY_SERVER_INIT() SIP_HDR_INIT(security_server)
13084
13099 #if SU_HAVE_INLINE
13100 su_inline sip_security_server_t *sip_security_server_init(sip_security_server_t x[1])
13101 {
13102 return SIP_HEADER_INIT(x, sip_security_server_class, sizeof(sip_security_server_t));
13103 }
13104 #else
13105 #define sip_security_server_init(x) \
13106 SIP_HEADER_INIT(x, sip_security_server_class, sizeof(sip_security_server_t))
13107 #endif
13108
13120 #if SU_HAVE_INLINE
13121 su_inline int sip_is_security_server(sip_header_t const *header)
13122 {
13123 return header && header->sh_class->hc_hash == sip_security_server_hash;
13124 }
13125 #else
13126 int sip_is_security_server(sip_header_t const *header);
13127 #endif
13128
13129 #define sip_security_server_p(h) sip_is_security_server((h))
13130
13131
13159 #if SU_HAVE_INLINE
13160 su_inline
13161 #endif
13162 sip_security_server_t *sip_security_server_dup(su_home_t *home, sip_security_server_t const *hdr)
13163 __attribute__((__malloc__));
13164
13165 #if SU_HAVE_INLINE
13166 su_inline
13167 sip_security_server_t *sip_security_server_dup(su_home_t *home, sip_security_server_t const *hdr)
13168 {
13169 return (sip_security_server_t *)
13170 msg_header_dup_as(home, sip_security_server_class, (msg_header_t const *)hdr);
13171 }
13172 #endif
13173
13201 #if SU_HAVE_INLINE
13202 su_inline
13203 #endif
13204 sip_security_server_t *sip_security_server_copy(su_home_t *home, sip_security_server_t const *hdr)
13205 __attribute__((__malloc__));
13206
13207 #if SU_HAVE_INLINE
13208 su_inline
13209 sip_security_server_t *sip_security_server_copy(su_home_t *home, sip_security_server_t const *hdr)
13210 {
13211 return (sip_security_server_t *)
13212 msg_header_copy_as(home, sip_security_server_class, (msg_header_t const *)hdr);
13213 }
13214 #endif
13215
13230 #if SU_HAVE_INLINE
13231 su_inline
13232 #endif
13233 sip_security_server_t *sip_security_server_make(su_home_t *home, char const *s)
13234 __attribute__((__malloc__));
13235
13236 #if SU_HAVE_INLINE
13237 su_inline sip_security_server_t *sip_security_server_make(su_home_t *home, char const *s)
13238 {
13239 return (sip_security_server_t *)sip_header_make(home, sip_security_server_class, s);
13240 }
13241 #endif
13242
13260 #if SU_HAVE_INLINE
13261 su_inline
13262 #endif
13263 sip_security_server_t *sip_security_server_format(su_home_t *home, char const *fmt, ...)
13264 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13265
13266 #if SU_HAVE_INLINE
13267 su_inline sip_security_server_t *sip_security_server_format(su_home_t *home, char const *fmt, ...)
13268 {
13269 sip_header_t *h;
13270 va_list ap;
13271
13272 va_start(ap, fmt);
13273 h = sip_header_vformat(home, sip_security_server_class, fmt, ap);
13274 va_end(ap);
13275
13276 return (sip_security_server_t *)h;
13277 }
13278 #endif
13279
13287 SOFIAPUBFUN issize_t sip_security_verify_d(su_home_t *, msg_header_t *,
13288 char *s, isize_t slen);
13289
13291 SOFIAPUBFUN issize_t sip_security_verify_e(char b[], isize_t bsiz,
13292 msg_header_t const *h, int flags);
13293
13298 #define sip_security_verify(sip) \
13299 ((sip_security_verify_t *)msg_header_access((msg_pub_t*)(sip), sip_security_verify_class))
13300
13314 #define SIP_SECURITY_VERIFY_INIT() SIP_HDR_INIT(security_verify)
13315
13330 #if SU_HAVE_INLINE
13331 su_inline sip_security_verify_t *sip_security_verify_init(sip_security_verify_t x[1])
13332 {
13333 return SIP_HEADER_INIT(x, sip_security_verify_class, sizeof(sip_security_verify_t));
13334 }
13335 #else
13336 #define sip_security_verify_init(x) \
13337 SIP_HEADER_INIT(x, sip_security_verify_class, sizeof(sip_security_verify_t))
13338 #endif
13339
13351 #if SU_HAVE_INLINE
13352 su_inline int sip_is_security_verify(sip_header_t const *header)
13353 {
13354 return header && header->sh_class->hc_hash == sip_security_verify_hash;
13355 }
13356 #else
13357 int sip_is_security_verify(sip_header_t const *header);
13358 #endif
13359
13360 #define sip_security_verify_p(h) sip_is_security_verify((h))
13361
13362
13390 #if SU_HAVE_INLINE
13391 su_inline
13392 #endif
13393 sip_security_verify_t *sip_security_verify_dup(su_home_t *home, sip_security_verify_t const *hdr)
13394 __attribute__((__malloc__));
13395
13396 #if SU_HAVE_INLINE
13397 su_inline
13398 sip_security_verify_t *sip_security_verify_dup(su_home_t *home, sip_security_verify_t const *hdr)
13399 {
13400 return (sip_security_verify_t *)
13401 msg_header_dup_as(home, sip_security_verify_class, (msg_header_t const *)hdr);
13402 }
13403 #endif
13404
13432 #if SU_HAVE_INLINE
13433 su_inline
13434 #endif
13435 sip_security_verify_t *sip_security_verify_copy(su_home_t *home, sip_security_verify_t const *hdr)
13436 __attribute__((__malloc__));
13437
13438 #if SU_HAVE_INLINE
13439 su_inline
13440 sip_security_verify_t *sip_security_verify_copy(su_home_t *home, sip_security_verify_t const *hdr)
13441 {
13442 return (sip_security_verify_t *)
13443 msg_header_copy_as(home, sip_security_verify_class, (msg_header_t const *)hdr);
13444 }
13445 #endif
13446
13461 #if SU_HAVE_INLINE
13462 su_inline
13463 #endif
13464 sip_security_verify_t *sip_security_verify_make(su_home_t *home, char const *s)
13465 __attribute__((__malloc__));
13466
13467 #if SU_HAVE_INLINE
13468 su_inline sip_security_verify_t *sip_security_verify_make(su_home_t *home, char const *s)
13469 {
13470 return (sip_security_verify_t *)sip_header_make(home, sip_security_verify_class, s);
13471 }
13472 #endif
13473
13491 #if SU_HAVE_INLINE
13492 su_inline
13493 #endif
13494 sip_security_verify_t *sip_security_verify_format(su_home_t *home, char const *fmt, ...)
13495 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13496
13497 #if SU_HAVE_INLINE
13498 su_inline sip_security_verify_t *sip_security_verify_format(su_home_t *home, char const *fmt, ...)
13499 {
13500 sip_header_t *h;
13501 va_list ap;
13502
13503 va_start(ap, fmt);
13504 h = sip_header_vformat(home, sip_security_verify_class, fmt, ap);
13505 va_end(ap);
13506
13507 return (sip_security_verify_t *)h;
13508 }
13509 #endif
13510
13518 SOFIAPUBFUN issize_t sip_privacy_d(su_home_t *, msg_header_t *,
13519 char *s, isize_t slen);
13520
13522 SOFIAPUBFUN issize_t sip_privacy_e(char b[], isize_t bsiz,
13523 msg_header_t const *h, int flags);
13524
13529 #define sip_privacy(sip) \
13530 ((sip_privacy_t *)msg_header_access((msg_pub_t*)(sip), sip_privacy_class))
13531
13545 #define SIP_PRIVACY_INIT() SIP_HDR_INIT(privacy)
13546
13561 #if SU_HAVE_INLINE
13562 su_inline sip_privacy_t *sip_privacy_init(sip_privacy_t x[1])
13563 {
13564 return SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t));
13565 }
13566 #else
13567 #define sip_privacy_init(x) \
13568 SIP_HEADER_INIT(x, sip_privacy_class, sizeof(sip_privacy_t))
13569 #endif
13570
13582 #if SU_HAVE_INLINE
13583 su_inline int sip_is_privacy(sip_header_t const *header)
13584 {
13585 return header && header->sh_class->hc_hash == sip_privacy_hash;
13586 }
13587 #else
13588 int sip_is_privacy(sip_header_t const *header);
13589 #endif
13590
13591 #define sip_privacy_p(h) sip_is_privacy((h))
13592
13593
13621 #if SU_HAVE_INLINE
13622 su_inline
13623 #endif
13624 sip_privacy_t *sip_privacy_dup(su_home_t *home, sip_privacy_t const *hdr)
13625 __attribute__((__malloc__));
13626
13627 #if SU_HAVE_INLINE
13628 su_inline
13629 sip_privacy_t *sip_privacy_dup(su_home_t *home, sip_privacy_t const *hdr)
13630 {
13631 return (sip_privacy_t *)
13632 msg_header_dup_as(home, sip_privacy_class, (msg_header_t const *)hdr);
13633 }
13634 #endif
13635
13663 #if SU_HAVE_INLINE
13664 su_inline
13665 #endif
13666 sip_privacy_t *sip_privacy_copy(su_home_t *home, sip_privacy_t const *hdr)
13667 __attribute__((__malloc__));
13668
13669 #if SU_HAVE_INLINE
13670 su_inline
13671 sip_privacy_t *sip_privacy_copy(su_home_t *home, sip_privacy_t const *hdr)
13672 {
13673 return (sip_privacy_t *)
13674 msg_header_copy_as(home, sip_privacy_class, (msg_header_t const *)hdr);
13675 }
13676 #endif
13677
13692 #if SU_HAVE_INLINE
13693 su_inline
13694 #endif
13695 sip_privacy_t *sip_privacy_make(su_home_t *home, char const *s)
13696 __attribute__((__malloc__));
13697
13698 #if SU_HAVE_INLINE
13699 su_inline sip_privacy_t *sip_privacy_make(su_home_t *home, char const *s)
13700 {
13701 return (sip_privacy_t *)sip_header_make(home, sip_privacy_class, s);
13702 }
13703 #endif
13704
13722 #if SU_HAVE_INLINE
13723 su_inline
13724 #endif
13725 sip_privacy_t *sip_privacy_format(su_home_t *home, char const *fmt, ...)
13726 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13727
13728 #if SU_HAVE_INLINE
13729 su_inline sip_privacy_t *sip_privacy_format(su_home_t *home, char const *fmt, ...)
13730 {
13731 sip_header_t *h;
13732 va_list ap;
13733
13734 va_start(ap, fmt);
13735 h = sip_header_vformat(home, sip_privacy_class, fmt, ap);
13736 va_end(ap);
13737
13738 return (sip_privacy_t *)h;
13739 }
13740 #endif
13741
13749 SOFIAPUBFUN issize_t sip_etag_d(su_home_t *, msg_header_t *,
13750 char *s, isize_t slen);
13751
13753 SOFIAPUBFUN issize_t sip_etag_e(char b[], isize_t bsiz,
13754 msg_header_t const *h, int flags);
13755
13760 #define sip_etag(sip) \
13761 ((sip_etag_t *)msg_header_access((msg_pub_t*)(sip), sip_etag_class))
13762
13776 #define SIP_ETAG_INIT() SIP_HDR_INIT(etag)
13777
13792 #if SU_HAVE_INLINE
13793 su_inline sip_etag_t *sip_etag_init(sip_etag_t x[1])
13794 {
13795 return SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t));
13796 }
13797 #else
13798 #define sip_etag_init(x) \
13799 SIP_HEADER_INIT(x, sip_etag_class, sizeof(sip_etag_t))
13800 #endif
13801
13813 #if SU_HAVE_INLINE
13814 su_inline int sip_is_etag(sip_header_t const *header)
13815 {
13816 return header && header->sh_class->hc_hash == sip_etag_hash;
13817 }
13818 #else
13819 int sip_is_etag(sip_header_t const *header);
13820 #endif
13821
13822 #define sip_etag_p(h) sip_is_etag((h))
13823
13824
13852 #if SU_HAVE_INLINE
13853 su_inline
13854 #endif
13855 sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
13856 __attribute__((__malloc__));
13857
13858 #if SU_HAVE_INLINE
13859 su_inline
13860 sip_etag_t *sip_etag_dup(su_home_t *home, sip_etag_t const *hdr)
13861 {
13862 return (sip_etag_t *)
13863 msg_header_dup_as(home, sip_etag_class, (msg_header_t const *)hdr);
13864 }
13865 #endif
13866
13894 #if SU_HAVE_INLINE
13895 su_inline
13896 #endif
13897 sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
13898 __attribute__((__malloc__));
13899
13900 #if SU_HAVE_INLINE
13901 su_inline
13902 sip_etag_t *sip_etag_copy(su_home_t *home, sip_etag_t const *hdr)
13903 {
13904 return (sip_etag_t *)
13905 msg_header_copy_as(home, sip_etag_class, (msg_header_t const *)hdr);
13906 }
13907 #endif
13908
13923 #if SU_HAVE_INLINE
13924 su_inline
13925 #endif
13926 sip_etag_t *sip_etag_make(su_home_t *home, char const *s)
13927 __attribute__((__malloc__));
13928
13929 #if SU_HAVE_INLINE
13930 su_inline sip_etag_t *sip_etag_make(su_home_t *home, char const *s)
13931 {
13932 return (sip_etag_t *)sip_header_make(home, sip_etag_class, s);
13933 }
13934 #endif
13935
13953 #if SU_HAVE_INLINE
13954 su_inline
13955 #endif
13956 sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
13957 __attribute__((__malloc__, __format__ (printf, 2, 3)));
13958
13959 #if SU_HAVE_INLINE
13960 su_inline sip_etag_t *sip_etag_format(su_home_t *home, char const *fmt, ...)
13961 {
13962 sip_header_t *h;
13963 va_list ap;
13964
13965 va_start(ap, fmt);
13966 h = sip_header_vformat(home, sip_etag_class, fmt, ap);
13967 va_end(ap);
13968
13969 return (sip_etag_t *)h;
13970 }
13971 #endif
13972
13980 SOFIAPUBFUN issize_t sip_if_match_d(su_home_t *, msg_header_t *,
13981 char *s, isize_t slen);
13982
13984 SOFIAPUBFUN issize_t sip_if_match_e(char b[], isize_t bsiz,
13985 msg_header_t const *h, int flags);
13986
13991 #define sip_if_match(sip) \
13992 ((sip_if_match_t *)msg_header_access((msg_pub_t*)(sip), sip_if_match_class))
13993
14007 #define SIP_IF_MATCH_INIT() SIP_HDR_INIT(if_match)
14008
14023 #if SU_HAVE_INLINE
14024 su_inline sip_if_match_t *sip_if_match_init(sip_if_match_t x[1])
14025 {
14026 return SIP_HEADER_INIT(x, sip_if_match_class, sizeof(sip_if_match_t));
14027 }
14028 #else
14029 #define sip_if_match_init(x) \
14030 SIP_HEADER_INIT(x, sip_if_match_class, sizeof(sip_if_match_t))
14031 #endif
14032
14044 #if SU_HAVE_INLINE
14045 su_inline int sip_is_if_match(sip_header_t const *header)
14046 {
14047 return header && header->sh_class->hc_hash == sip_if_match_hash;
14048 }
14049 #else
14050 int sip_is_if_match(sip_header_t const *header);
14051 #endif
14052
14053 #define sip_if_match_p(h) sip_is_if_match((h))
14054
14055
14083 #if SU_HAVE_INLINE
14084 su_inline
14085 #endif
14086 sip_if_match_t *sip_if_match_dup(su_home_t *home, sip_if_match_t const *hdr)
14087 __attribute__((__malloc__));
14088
14089 #if SU_HAVE_INLINE
14090 su_inline
14091 sip_if_match_t *sip_if_match_dup(su_home_t *home, sip_if_match_t const *hdr)
14092 {
14093 return (sip_if_match_t *)
14094 msg_header_dup_as(home, sip_if_match_class, (msg_header_t const *)hdr);
14095 }
14096 #endif
14097
14125 #if SU_HAVE_INLINE
14126 su_inline
14127 #endif
14128 sip_if_match_t *sip_if_match_copy(su_home_t *home, sip_if_match_t const *hdr)
14129 __attribute__((__malloc__));
14130
14131 #if SU_HAVE_INLINE
14132 su_inline
14133 sip_if_match_t *sip_if_match_copy(su_home_t *home, sip_if_match_t const *hdr)
14134 {
14135 return (sip_if_match_t *)
14136 msg_header_copy_as(home, sip_if_match_class, (msg_header_t const *)hdr);
14137 }
14138 #endif
14139
14154 #if SU_HAVE_INLINE
14155 su_inline
14156 #endif
14157 sip_if_match_t *sip_if_match_make(su_home_t *home, char const *s)
14158 __attribute__((__malloc__));
14159
14160 #if SU_HAVE_INLINE
14161 su_inline sip_if_match_t *sip_if_match_make(su_home_t *home, char const *s)
14162 {
14163 return (sip_if_match_t *)sip_header_make(home, sip_if_match_class, s);
14164 }
14165 #endif
14166
14184 #if SU_HAVE_INLINE
14185 su_inline
14186 #endif
14187 sip_if_match_t *sip_if_match_format(su_home_t *home, char const *fmt, ...)
14188 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14189
14190 #if SU_HAVE_INLINE
14191 su_inline sip_if_match_t *sip_if_match_format(su_home_t *home, char const *fmt, ...)
14192 {
14193 sip_header_t *h;
14194 va_list ap;
14195
14196 va_start(ap, fmt);
14197 h = sip_header_vformat(home, sip_if_match_class, fmt, ap);
14198 va_end(ap);
14199
14200 return (sip_if_match_t *)h;
14201 }
14202 #endif
14203
14211 SOFIAPUBFUN issize_t sip_mime_version_d(su_home_t *, msg_header_t *,
14212 char *s, isize_t slen);
14213
14215 SOFIAPUBFUN issize_t sip_mime_version_e(char b[], isize_t bsiz,
14216 msg_header_t const *h, int flags);
14217
14222 #define sip_mime_version(sip) \
14223 ((sip_mime_version_t *)msg_header_access((msg_pub_t*)(sip), sip_mime_version_class))
14224
14238 #define SIP_MIME_VERSION_INIT() SIP_HDR_INIT(mime_version)
14239
14254 #if SU_HAVE_INLINE
14255 su_inline sip_mime_version_t *sip_mime_version_init(sip_mime_version_t x[1])
14256 {
14257 return SIP_HEADER_INIT(x, sip_mime_version_class, sizeof(sip_mime_version_t));
14258 }
14259 #else
14260 #define sip_mime_version_init(x) \
14261 SIP_HEADER_INIT(x, sip_mime_version_class, sizeof(sip_mime_version_t))
14262 #endif
14263
14275 #if SU_HAVE_INLINE
14276 su_inline int sip_is_mime_version(sip_header_t const *header)
14277 {
14278 return header && header->sh_class->hc_hash == sip_mime_version_hash;
14279 }
14280 #else
14281 int sip_is_mime_version(sip_header_t const *header);
14282 #endif
14283
14284 #define sip_mime_version_p(h) sip_is_mime_version((h))
14285
14286
14314 #if SU_HAVE_INLINE
14315 su_inline
14316 #endif
14317 sip_mime_version_t *sip_mime_version_dup(su_home_t *home, sip_mime_version_t const *hdr)
14318 __attribute__((__malloc__));
14319
14320 #if SU_HAVE_INLINE
14321 su_inline
14322 sip_mime_version_t *sip_mime_version_dup(su_home_t *home, sip_mime_version_t const *hdr)
14323 {
14324 return (sip_mime_version_t *)
14325 msg_header_dup_as(home, sip_mime_version_class, (msg_header_t const *)hdr);
14326 }
14327 #endif
14328
14356 #if SU_HAVE_INLINE
14357 su_inline
14358 #endif
14359 sip_mime_version_t *sip_mime_version_copy(su_home_t *home, sip_mime_version_t const *hdr)
14360 __attribute__((__malloc__));
14361
14362 #if SU_HAVE_INLINE
14363 su_inline
14364 sip_mime_version_t *sip_mime_version_copy(su_home_t *home, sip_mime_version_t const *hdr)
14365 {
14366 return (sip_mime_version_t *)
14367 msg_header_copy_as(home, sip_mime_version_class, (msg_header_t const *)hdr);
14368 }
14369 #endif
14370
14385 #if SU_HAVE_INLINE
14386 su_inline
14387 #endif
14388 sip_mime_version_t *sip_mime_version_make(su_home_t *home, char const *s)
14389 __attribute__((__malloc__));
14390
14391 #if SU_HAVE_INLINE
14392 su_inline sip_mime_version_t *sip_mime_version_make(su_home_t *home, char const *s)
14393 {
14394 return (sip_mime_version_t *)sip_header_make(home, sip_mime_version_class, s);
14395 }
14396 #endif
14397
14415 #if SU_HAVE_INLINE
14416 su_inline
14417 #endif
14418 sip_mime_version_t *sip_mime_version_format(su_home_t *home, char const *fmt, ...)
14419 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14420
14421 #if SU_HAVE_INLINE
14422 su_inline sip_mime_version_t *sip_mime_version_format(su_home_t *home, char const *fmt, ...)
14423 {
14424 sip_header_t *h;
14425 va_list ap;
14426
14427 va_start(ap, fmt);
14428 h = sip_header_vformat(home, sip_mime_version_class, fmt, ap);
14429 va_end(ap);
14430
14431 return (sip_mime_version_t *)h;
14432 }
14433 #endif
14434
14442 SOFIAPUBFUN issize_t sip_content_type_d(su_home_t *, msg_header_t *,
14443 char *s, isize_t slen);
14444
14446 SOFIAPUBFUN issize_t sip_content_type_e(char b[], isize_t bsiz,
14447 msg_header_t const *h, int flags);
14448
14453 #define sip_content_type(sip) \
14454 ((sip_content_type_t *)msg_header_access((msg_pub_t*)(sip), sip_content_type_class))
14455
14469 #define SIP_CONTENT_TYPE_INIT() SIP_HDR_INIT(content_type)
14470
14485 #if SU_HAVE_INLINE
14486 su_inline sip_content_type_t *sip_content_type_init(sip_content_type_t x[1])
14487 {
14488 return SIP_HEADER_INIT(x, sip_content_type_class, sizeof(sip_content_type_t));
14489 }
14490 #else
14491 #define sip_content_type_init(x) \
14492 SIP_HEADER_INIT(x, sip_content_type_class, sizeof(sip_content_type_t))
14493 #endif
14494
14506 #if SU_HAVE_INLINE
14507 su_inline int sip_is_content_type(sip_header_t const *header)
14508 {
14509 return header && header->sh_class->hc_hash == sip_content_type_hash;
14510 }
14511 #else
14512 int sip_is_content_type(sip_header_t const *header);
14513 #endif
14514
14515 #define sip_content_type_p(h) sip_is_content_type((h))
14516
14517
14545 #if SU_HAVE_INLINE
14546 su_inline
14547 #endif
14548 sip_content_type_t *sip_content_type_dup(su_home_t *home, sip_content_type_t const *hdr)
14549 __attribute__((__malloc__));
14550
14551 #if SU_HAVE_INLINE
14552 su_inline
14553 sip_content_type_t *sip_content_type_dup(su_home_t *home, sip_content_type_t const *hdr)
14554 {
14555 return (sip_content_type_t *)
14556 msg_header_dup_as(home, sip_content_type_class, (msg_header_t const *)hdr);
14557 }
14558 #endif
14559
14587 #if SU_HAVE_INLINE
14588 su_inline
14589 #endif
14590 sip_content_type_t *sip_content_type_copy(su_home_t *home, sip_content_type_t const *hdr)
14591 __attribute__((__malloc__));
14592
14593 #if SU_HAVE_INLINE
14594 su_inline
14595 sip_content_type_t *sip_content_type_copy(su_home_t *home, sip_content_type_t const *hdr)
14596 {
14597 return (sip_content_type_t *)
14598 msg_header_copy_as(home, sip_content_type_class, (msg_header_t const *)hdr);
14599 }
14600 #endif
14601
14616 #if SU_HAVE_INLINE
14617 su_inline
14618 #endif
14619 sip_content_type_t *sip_content_type_make(su_home_t *home, char const *s)
14620 __attribute__((__malloc__));
14621
14622 #if SU_HAVE_INLINE
14623 su_inline sip_content_type_t *sip_content_type_make(su_home_t *home, char const *s)
14624 {
14625 return (sip_content_type_t *)sip_header_make(home, sip_content_type_class, s);
14626 }
14627 #endif
14628
14646 #if SU_HAVE_INLINE
14647 su_inline
14648 #endif
14649 sip_content_type_t *sip_content_type_format(su_home_t *home, char const *fmt, ...)
14650 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14651
14652 #if SU_HAVE_INLINE
14653 su_inline sip_content_type_t *sip_content_type_format(su_home_t *home, char const *fmt, ...)
14654 {
14655 sip_header_t *h;
14656 va_list ap;
14657
14658 va_start(ap, fmt);
14659 h = sip_header_vformat(home, sip_content_type_class, fmt, ap);
14660 va_end(ap);
14661
14662 return (sip_content_type_t *)h;
14663 }
14664 #endif
14665
14673 SOFIAPUBFUN issize_t sip_content_encoding_d(su_home_t *, msg_header_t *,
14674 char *s, isize_t slen);
14675
14677 SOFIAPUBFUN issize_t sip_content_encoding_e(char b[], isize_t bsiz,
14678 msg_header_t const *h, int flags);
14679
14684 #define sip_content_encoding(sip) \
14685 ((sip_content_encoding_t *)msg_header_access((msg_pub_t*)(sip), sip_content_encoding_class))
14686
14700 #define SIP_CONTENT_ENCODING_INIT() SIP_HDR_INIT(content_encoding)
14701
14716 #if SU_HAVE_INLINE
14717 su_inline sip_content_encoding_t *sip_content_encoding_init(sip_content_encoding_t x[1])
14718 {
14719 return SIP_HEADER_INIT(x, sip_content_encoding_class, sizeof(sip_content_encoding_t));
14720 }
14721 #else
14722 #define sip_content_encoding_init(x) \
14723 SIP_HEADER_INIT(x, sip_content_encoding_class, sizeof(sip_content_encoding_t))
14724 #endif
14725
14737 #if SU_HAVE_INLINE
14738 su_inline int sip_is_content_encoding(sip_header_t const *header)
14739 {
14740 return header && header->sh_class->hc_hash == sip_content_encoding_hash;
14741 }
14742 #else
14743 int sip_is_content_encoding(sip_header_t const *header);
14744 #endif
14745
14746 #define sip_content_encoding_p(h) sip_is_content_encoding((h))
14747
14748
14776 #if SU_HAVE_INLINE
14777 su_inline
14778 #endif
14779 sip_content_encoding_t *sip_content_encoding_dup(su_home_t *home, sip_content_encoding_t const *hdr)
14780 __attribute__((__malloc__));
14781
14782 #if SU_HAVE_INLINE
14783 su_inline
14784 sip_content_encoding_t *sip_content_encoding_dup(su_home_t *home, sip_content_encoding_t const *hdr)
14785 {
14786 return (sip_content_encoding_t *)
14787 msg_header_dup_as(home, sip_content_encoding_class, (msg_header_t const *)hdr);
14788 }
14789 #endif
14790
14818 #if SU_HAVE_INLINE
14819 su_inline
14820 #endif
14821 sip_content_encoding_t *sip_content_encoding_copy(su_home_t *home, sip_content_encoding_t const *hdr)
14822 __attribute__((__malloc__));
14823
14824 #if SU_HAVE_INLINE
14825 su_inline
14826 sip_content_encoding_t *sip_content_encoding_copy(su_home_t *home, sip_content_encoding_t const *hdr)
14827 {
14828 return (sip_content_encoding_t *)
14829 msg_header_copy_as(home, sip_content_encoding_class, (msg_header_t const *)hdr);
14830 }
14831 #endif
14832
14847 #if SU_HAVE_INLINE
14848 su_inline
14849 #endif
14850 sip_content_encoding_t *sip_content_encoding_make(su_home_t *home, char const *s)
14851 __attribute__((__malloc__));
14852
14853 #if SU_HAVE_INLINE
14854 su_inline sip_content_encoding_t *sip_content_encoding_make(su_home_t *home, char const *s)
14855 {
14856 return (sip_content_encoding_t *)sip_header_make(home, sip_content_encoding_class, s);
14857 }
14858 #endif
14859
14877 #if SU_HAVE_INLINE
14878 su_inline
14879 #endif
14880 sip_content_encoding_t *sip_content_encoding_format(su_home_t *home, char const *fmt, ...)
14881 __attribute__((__malloc__, __format__ (printf, 2, 3)));
14882
14883 #if SU_HAVE_INLINE
14884 su_inline sip_content_encoding_t *sip_content_encoding_format(su_home_t *home, char const *fmt, ...)
14885 {
14886 sip_header_t *h;
14887 va_list ap;
14888
14889 va_start(ap, fmt);
14890 h = sip_header_vformat(home, sip_content_encoding_class, fmt, ap);
14891 va_end(ap);
14892
14893 return (sip_content_encoding_t *)h;
14894 }
14895 #endif
14896
14904 SOFIAPUBFUN issize_t sip_content_language_d(su_home_t *, msg_header_t *,
14905 char *s, isize_t slen);
14906
14908 SOFIAPUBFUN issize_t sip_content_language_e(char b[], isize_t bsiz,
14909 msg_header_t const *h, int flags);
14910
14915 #define sip_content_language(sip) \
14916 ((sip_content_language_t *)msg_header_access((msg_pub_t*)(sip), sip_content_language_class))
14917
14931 #define SIP_CONTENT_LANGUAGE_INIT() SIP_HDR_INIT(content_language)
14932
14947 #if SU_HAVE_INLINE
14948 su_inline sip_content_language_t *sip_content_language_init(sip_content_language_t x[1])
14949 {
14950 return SIP_HEADER_INIT(x, sip_content_language_class, sizeof(sip_content_language_t));
14951 }
14952 #else
14953 #define sip_content_language_init(x) \
14954 SIP_HEADER_INIT(x, sip_content_language_class, sizeof(sip_content_language_t))
14955 #endif
14956
14968 #if SU_HAVE_INLINE
14969 su_inline int sip_is_content_language(sip_header_t const *header)
14970 {
14971 return header && header->sh_class->hc_hash == sip_content_language_hash;
14972 }
14973 #else
14974 int sip_is_content_language(sip_header_t const *header);
14975 #endif
14976
14977 #define sip_content_language_p(h) sip_is_content_language((h))
14978
14979
15007 #if SU_HAVE_INLINE
15008 su_inline
15009 #endif
15010 sip_content_language_t *sip_content_language_dup(su_home_t *home, sip_content_language_t const *hdr)
15011 __attribute__((__malloc__));
15012
15013 #if SU_HAVE_INLINE
15014 su_inline
15015 sip_content_language_t *sip_content_language_dup(su_home_t *home, sip_content_language_t const *hdr)
15016 {
15017 return (sip_content_language_t *)
15018 msg_header_dup_as(home, sip_content_language_class, (msg_header_t const *)hdr);
15019 }
15020 #endif
15021
15049 #if SU_HAVE_INLINE
15050 su_inline
15051 #endif
15052 sip_content_language_t *sip_content_language_copy(su_home_t *home, sip_content_language_t const *hdr)
15053 __attribute__((__malloc__));
15054
15055 #if SU_HAVE_INLINE
15056 su_inline
15057 sip_content_language_t *sip_content_language_copy(su_home_t *home, sip_content_language_t const *hdr)
15058 {
15059 return (sip_content_language_t *)
15060 msg_header_copy_as(home, sip_content_language_class, (msg_header_t const *)hdr);
15061 }
15062 #endif
15063
15078 #if SU_HAVE_INLINE
15079 su_inline
15080 #endif
15081 sip_content_language_t *sip_content_language_make(su_home_t *home, char const *s)
15082 __attribute__((__malloc__));
15083
15084 #if SU_HAVE_INLINE
15085 su_inline sip_content_language_t *sip_content_language_make(su_home_t *home, char const *s)
15086 {
15087 return (sip_content_language_t *)sip_header_make(home, sip_content_language_class, s);
15088 }
15089 #endif
15090
15108 #if SU_HAVE_INLINE
15109 su_inline
15110 #endif
15111 sip_content_language_t *sip_content_language_format(su_home_t *home, char const *fmt, ...)
15112 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15113
15114 #if SU_HAVE_INLINE
15115 su_inline sip_content_language_t *sip_content_language_format(su_home_t *home, char const *fmt, ...)
15116 {
15117 sip_header_t *h;
15118 va_list ap;
15119
15120 va_start(ap, fmt);
15121 h = sip_header_vformat(home, sip_content_language_class, fmt, ap);
15122 va_end(ap);
15123
15124 return (sip_content_language_t *)h;
15125 }
15126 #endif
15127
15135 SOFIAPUBFUN issize_t sip_content_disposition_d(su_home_t *, msg_header_t *,
15136 char *s, isize_t slen);
15137
15139 SOFIAPUBFUN issize_t sip_content_disposition_e(char b[], isize_t bsiz,
15140 msg_header_t const *h, int flags);
15141
15146 #define sip_content_disposition(sip) \
15147 ((sip_content_disposition_t *)msg_header_access((msg_pub_t*)(sip), sip_content_disposition_class))
15148
15162 #define SIP_CONTENT_DISPOSITION_INIT() SIP_HDR_INIT(content_disposition)
15163
15178 #if SU_HAVE_INLINE
15179 su_inline sip_content_disposition_t *sip_content_disposition_init(sip_content_disposition_t x[1])
15180 {
15181 return SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t));
15182 }
15183 #else
15184 #define sip_content_disposition_init(x) \
15185 SIP_HEADER_INIT(x, sip_content_disposition_class, sizeof(sip_content_disposition_t))
15186 #endif
15187
15199 #if SU_HAVE_INLINE
15200 su_inline int sip_is_content_disposition(sip_header_t const *header)
15201 {
15202 return header && header->sh_class->hc_hash == sip_content_disposition_hash;
15203 }
15204 #else
15205 int sip_is_content_disposition(sip_header_t const *header);
15206 #endif
15207
15208 #define sip_content_disposition_p(h) sip_is_content_disposition((h))
15209
15210
15238 #if SU_HAVE_INLINE
15239 su_inline
15240 #endif
15241 sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
15242 __attribute__((__malloc__));
15243
15244 #if SU_HAVE_INLINE
15245 su_inline
15246 sip_content_disposition_t *sip_content_disposition_dup(su_home_t *home, sip_content_disposition_t const *hdr)
15247 {
15248 return (sip_content_disposition_t *)
15249 msg_header_dup_as(home, sip_content_disposition_class, (msg_header_t const *)hdr);
15250 }
15251 #endif
15252
15280 #if SU_HAVE_INLINE
15281 su_inline
15282 #endif
15283 sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
15284 __attribute__((__malloc__));
15285
15286 #if SU_HAVE_INLINE
15287 su_inline
15288 sip_content_disposition_t *sip_content_disposition_copy(su_home_t *home, sip_content_disposition_t const *hdr)
15289 {
15290 return (sip_content_disposition_t *)
15291 msg_header_copy_as(home, sip_content_disposition_class, (msg_header_t const *)hdr);
15292 }
15293 #endif
15294
15309 #if SU_HAVE_INLINE
15310 su_inline
15311 #endif
15312 sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
15313 __attribute__((__malloc__));
15314
15315 #if SU_HAVE_INLINE
15316 su_inline sip_content_disposition_t *sip_content_disposition_make(su_home_t *home, char const *s)
15317 {
15318 return (sip_content_disposition_t *)sip_header_make(home, sip_content_disposition_class, s);
15319 }
15320 #endif
15321
15339 #if SU_HAVE_INLINE
15340 su_inline
15341 #endif
15342 sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
15343 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15344
15345 #if SU_HAVE_INLINE
15346 su_inline sip_content_disposition_t *sip_content_disposition_format(su_home_t *home, char const *fmt, ...)
15347 {
15348 sip_header_t *h;
15349 va_list ap;
15350
15351 va_start(ap, fmt);
15352 h = sip_header_vformat(home, sip_content_disposition_class, fmt, ap);
15353 va_end(ap);
15354
15355 return (sip_content_disposition_t *)h;
15356 }
15357 #endif
15358
15366 SOFIAPUBFUN issize_t sip_content_length_d(su_home_t *, msg_header_t *,
15367 char *s, isize_t slen);
15368
15370 SOFIAPUBFUN issize_t sip_content_length_e(char b[], isize_t bsiz,
15371 msg_header_t const *h, int flags);
15372
15377 #define sip_content_length(sip) \
15378 ((sip_content_length_t *)msg_header_access((msg_pub_t*)(sip), sip_content_length_class))
15379
15393 #define SIP_CONTENT_LENGTH_INIT() SIP_HDR_INIT(content_length)
15394
15409 #if SU_HAVE_INLINE
15410 su_inline sip_content_length_t *sip_content_length_init(sip_content_length_t x[1])
15411 {
15412 return SIP_HEADER_INIT(x, sip_content_length_class, sizeof(sip_content_length_t));
15413 }
15414 #else
15415 #define sip_content_length_init(x) \
15416 SIP_HEADER_INIT(x, sip_content_length_class, sizeof(sip_content_length_t))
15417 #endif
15418
15430 #if SU_HAVE_INLINE
15431 su_inline int sip_is_content_length(sip_header_t const *header)
15432 {
15433 return header && header->sh_class->hc_hash == sip_content_length_hash;
15434 }
15435 #else
15436 int sip_is_content_length(sip_header_t const *header);
15437 #endif
15438
15439 #define sip_content_length_p(h) sip_is_content_length((h))
15440
15441
15469 #if SU_HAVE_INLINE
15470 su_inline
15471 #endif
15472 sip_content_length_t *sip_content_length_dup(su_home_t *home, sip_content_length_t const *hdr)
15473 __attribute__((__malloc__));
15474
15475 #if SU_HAVE_INLINE
15476 su_inline
15477 sip_content_length_t *sip_content_length_dup(su_home_t *home, sip_content_length_t const *hdr)
15478 {
15479 return (sip_content_length_t *)
15480 msg_header_dup_as(home, sip_content_length_class, (msg_header_t const *)hdr);
15481 }
15482 #endif
15483
15511 #if SU_HAVE_INLINE
15512 su_inline
15513 #endif
15514 sip_content_length_t *sip_content_length_copy(su_home_t *home, sip_content_length_t const *hdr)
15515 __attribute__((__malloc__));
15516
15517 #if SU_HAVE_INLINE
15518 su_inline
15519 sip_content_length_t *sip_content_length_copy(su_home_t *home, sip_content_length_t const *hdr)
15520 {
15521 return (sip_content_length_t *)
15522 msg_header_copy_as(home, sip_content_length_class, (msg_header_t const *)hdr);
15523 }
15524 #endif
15525
15540 #if SU_HAVE_INLINE
15541 su_inline
15542 #endif
15543 sip_content_length_t *sip_content_length_make(su_home_t *home, char const *s)
15544 __attribute__((__malloc__));
15545
15546 #if SU_HAVE_INLINE
15547 su_inline sip_content_length_t *sip_content_length_make(su_home_t *home, char const *s)
15548 {
15549 return (sip_content_length_t *)sip_header_make(home, sip_content_length_class, s);
15550 }
15551 #endif
15552
15570 #if SU_HAVE_INLINE
15571 su_inline
15572 #endif
15573 sip_content_length_t *sip_content_length_format(su_home_t *home, char const *fmt, ...)
15574 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15575
15576 #if SU_HAVE_INLINE
15577 su_inline sip_content_length_t *sip_content_length_format(su_home_t *home, char const *fmt, ...)
15578 {
15579 sip_header_t *h;
15580 va_list ap;
15581
15582 va_start(ap, fmt);
15583 h = sip_header_vformat(home, sip_content_length_class, fmt, ap);
15584 va_end(ap);
15585
15586 return (sip_content_length_t *)h;
15587 }
15588 #endif
15589
15597 SOFIAPUBFUN issize_t sip_unknown_d(su_home_t *, msg_header_t *,
15598 char *s, isize_t slen);
15599
15601 SOFIAPUBFUN issize_t sip_unknown_e(char b[], isize_t bsiz,
15602 msg_header_t const *h, int flags);
15603
15608 #define sip_unknown(sip) \
15609 ((sip_unknown_t *)msg_header_access((msg_pub_t*)(sip), sip_unknown_class))
15610
15624 #define SIP_UNKNOWN_INIT() SIP_HDR_INIT(unknown)
15625
15640 #if SU_HAVE_INLINE
15641 su_inline sip_unknown_t *sip_unknown_init(sip_unknown_t x[1])
15642 {
15643 return SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t));
15644 }
15645 #else
15646 #define sip_unknown_init(x) \
15647 SIP_HEADER_INIT(x, sip_unknown_class, sizeof(sip_unknown_t))
15648 #endif
15649
15661 #if SU_HAVE_INLINE
15662 su_inline int sip_is_unknown(sip_header_t const *header)
15663 {
15664 return header && header->sh_class->hc_hash == sip_unknown_hash;
15665 }
15666 #else
15667 int sip_is_unknown(sip_header_t const *header);
15668 #endif
15669
15670 #define sip_unknown_p(h) sip_is_unknown((h))
15671
15672
15700 #if SU_HAVE_INLINE
15701 su_inline
15702 #endif
15703 sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
15704 __attribute__((__malloc__));
15705
15706 #if SU_HAVE_INLINE
15707 su_inline
15708 sip_unknown_t *sip_unknown_dup(su_home_t *home, sip_unknown_t const *hdr)
15709 {
15710 return (sip_unknown_t *)
15711 msg_header_dup_as(home, sip_unknown_class, (msg_header_t const *)hdr);
15712 }
15713 #endif
15714
15742 #if SU_HAVE_INLINE
15743 su_inline
15744 #endif
15745 sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
15746 __attribute__((__malloc__));
15747
15748 #if SU_HAVE_INLINE
15749 su_inline
15750 sip_unknown_t *sip_unknown_copy(su_home_t *home, sip_unknown_t const *hdr)
15751 {
15752 return (sip_unknown_t *)
15753 msg_header_copy_as(home, sip_unknown_class, (msg_header_t const *)hdr);
15754 }
15755 #endif
15756
15771 #if SU_HAVE_INLINE
15772 su_inline
15773 #endif
15774 sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
15775 __attribute__((__malloc__));
15776
15777 #if SU_HAVE_INLINE
15778 su_inline sip_unknown_t *sip_unknown_make(su_home_t *home, char const *s)
15779 {
15780 return (sip_unknown_t *)sip_header_make(home, sip_unknown_class, s);
15781 }
15782 #endif
15783
15801 #if SU_HAVE_INLINE
15802 su_inline
15803 #endif
15804 sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
15805 __attribute__((__malloc__, __format__ (printf, 2, 3)));
15806
15807 #if SU_HAVE_INLINE
15808 su_inline sip_unknown_t *sip_unknown_format(su_home_t *home, char const *fmt, ...)
15809 {
15810 sip_header_t *h;
15811 va_list ap;
15812
15813 va_start(ap, fmt);
15814 h = sip_header_vformat(home, sip_unknown_class, fmt, ap);
15815 va_end(ap);
15816
15817 return (sip_unknown_t *)h;
15818 }
15819 #endif
15820
15828 SOFIAPUBFUN issize_t sip_error_d(su_home_t *, msg_header_t *,
15829 char *s, isize_t slen);
15830
15832 SOFIAPUBFUN issize_t sip_error_e(char b[], isize_t bsiz,
15833 msg_header_t const *h, int flags);
15834
15839 #define sip_error(sip) \
15840 ((sip_error_t *)msg_header_access((msg_pub_t*)(sip), sip_error_class))
15841
15855 #define SIP_ERROR_INIT() SIP_HDR_INIT(error)
15856
15871 #if SU_HAVE_INLINE
15872 su_inline sip_error_t *sip_error_init(sip_error_t x[1])
15873 {
15874 return SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t));
15875 }
15876 #else
15877 #define sip_error_init(x) \
15878 SIP_HEADER_INIT(x, sip_error_class, sizeof(sip_error_t))
15879 #endif
15880
15892 #if SU_HAVE_INLINE
15893 su_inline int sip_is_error(sip_header_t const *header)
15894 {
15895 return header && header->sh_class->hc_hash == sip_error_hash;
15896 }
15897 #else
15898 int sip_is_error(sip_header_t const *header);
15899 #endif
15900
15901 #define sip_error_p(h) sip_is_error((h))
15902
15903
15931 #if SU_HAVE_INLINE
15932 su_inline
15933 #endif
15934 sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
15935 __attribute__((__malloc__));
15936
15937 #if SU_HAVE_INLINE
15938 su_inline
15939 sip_error_t *sip_error_dup(su_home_t *home, sip_error_t const *hdr)
15940 {
15941 return (sip_error_t *)
15942 msg_header_dup_as(home, sip_error_class, (msg_header_t const *)hdr);
15943 }
15944 #endif
15945
15973 #if SU_HAVE_INLINE
15974 su_inline
15975 #endif
15976 sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
15977 __attribute__((__malloc__));
15978
15979 #if SU_HAVE_INLINE
15980 su_inline
15981 sip_error_t *sip_error_copy(su_home_t *home, sip_error_t const *hdr)
15982 {
15983 return (sip_error_t *)
15984 msg_header_copy_as(home, sip_error_class, (msg_header_t const *)hdr);
15985 }
15986 #endif
15987
16002 #if SU_HAVE_INLINE
16003 su_inline
16004 #endif
16005 sip_error_t *sip_error_make(su_home_t *home, char const *s)
16006 __attribute__((__malloc__));
16007
16008 #if SU_HAVE_INLINE
16009 su_inline sip_error_t *sip_error_make(su_home_t *home, char const *s)
16010 {
16011 return (sip_error_t *)sip_header_make(home, sip_error_class, s);
16012 }
16013 #endif
16014
16032 #if SU_HAVE_INLINE
16033 su_inline
16034 #endif
16035 sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
16036 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16037
16038 #if SU_HAVE_INLINE
16039 su_inline sip_error_t *sip_error_format(su_home_t *home, char const *fmt, ...)
16040 {
16041 sip_header_t *h;
16042 va_list ap;
16043
16044 va_start(ap, fmt);
16045 h = sip_header_vformat(home, sip_error_class, fmt, ap);
16046 va_end(ap);
16047
16048 return (sip_error_t *)h;
16049 }
16050 #endif
16051
16059 SOFIAPUBFUN issize_t sip_separator_d(su_home_t *, msg_header_t *,
16060 char *s, isize_t slen);
16061
16063 SOFIAPUBFUN issize_t sip_separator_e(char b[], isize_t bsiz,
16064 msg_header_t const *h, int flags);
16065
16070 #define sip_separator(sip) \
16071 ((sip_separator_t *)msg_header_access((msg_pub_t*)(sip), sip_separator_class))
16072
16086 #define SIP_SEPARATOR_INIT() SIP_HDR_INIT(separator)
16087
16102 #if SU_HAVE_INLINE
16103 su_inline sip_separator_t *sip_separator_init(sip_separator_t x[1])
16104 {
16105 return SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t));
16106 }
16107 #else
16108 #define sip_separator_init(x) \
16109 SIP_HEADER_INIT(x, sip_separator_class, sizeof(sip_separator_t))
16110 #endif
16111
16123 #if SU_HAVE_INLINE
16124 su_inline int sip_is_separator(sip_header_t const *header)
16125 {
16126 return header && header->sh_class->hc_hash == sip_separator_hash;
16127 }
16128 #else
16129 int sip_is_separator(sip_header_t const *header);
16130 #endif
16131
16132 #define sip_separator_p(h) sip_is_separator((h))
16133
16134
16162 #if SU_HAVE_INLINE
16163 su_inline
16164 #endif
16165 sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
16166 __attribute__((__malloc__));
16167
16168 #if SU_HAVE_INLINE
16169 su_inline
16170 sip_separator_t *sip_separator_dup(su_home_t *home, sip_separator_t const *hdr)
16171 {
16172 return (sip_separator_t *)
16173 msg_header_dup_as(home, sip_separator_class, (msg_header_t const *)hdr);
16174 }
16175 #endif
16176
16204 #if SU_HAVE_INLINE
16205 su_inline
16206 #endif
16207 sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
16208 __attribute__((__malloc__));
16209
16210 #if SU_HAVE_INLINE
16211 su_inline
16212 sip_separator_t *sip_separator_copy(su_home_t *home, sip_separator_t const *hdr)
16213 {
16214 return (sip_separator_t *)
16215 msg_header_copy_as(home, sip_separator_class, (msg_header_t const *)hdr);
16216 }
16217 #endif
16218
16233 #if SU_HAVE_INLINE
16234 su_inline
16235 #endif
16236 sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
16237 __attribute__((__malloc__));
16238
16239 #if SU_HAVE_INLINE
16240 su_inline sip_separator_t *sip_separator_make(su_home_t *home, char const *s)
16241 {
16242 return (sip_separator_t *)sip_header_make(home, sip_separator_class, s);
16243 }
16244 #endif
16245
16263 #if SU_HAVE_INLINE
16264 su_inline
16265 #endif
16266 sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
16267 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16268
16269 #if SU_HAVE_INLINE
16270 su_inline sip_separator_t *sip_separator_format(su_home_t *home, char const *fmt, ...)
16271 {
16272 sip_header_t *h;
16273 va_list ap;
16274
16275 va_start(ap, fmt);
16276 h = sip_header_vformat(home, sip_separator_class, fmt, ap);
16277 va_end(ap);
16278
16279 return (sip_separator_t *)h;
16280 }
16281 #endif
16282
16290 SOFIAPUBFUN issize_t sip_payload_d(su_home_t *, msg_header_t *,
16291 char *s, isize_t slen);
16292
16294 SOFIAPUBFUN issize_t sip_payload_e(char b[], isize_t bsiz,
16295 msg_header_t const *h, int flags);
16296
16301 #define sip_payload(sip) \
16302 ((sip_payload_t *)msg_header_access((msg_pub_t*)(sip), sip_payload_class))
16303
16317 #define SIP_PAYLOAD_INIT() SIP_HDR_INIT(payload)
16318
16333 #if SU_HAVE_INLINE
16334 su_inline sip_payload_t *sip_payload_init(sip_payload_t x[1])
16335 {
16336 return SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t));
16337 }
16338 #else
16339 #define sip_payload_init(x) \
16340 SIP_HEADER_INIT(x, sip_payload_class, sizeof(sip_payload_t))
16341 #endif
16342
16354 #if SU_HAVE_INLINE
16355 su_inline int sip_is_payload(sip_header_t const *header)
16356 {
16357 return header && header->sh_class->hc_hash == sip_payload_hash;
16358 }
16359 #else
16360 int sip_is_payload(sip_header_t const *header);
16361 #endif
16362
16363 #define sip_payload_p(h) sip_is_payload((h))
16364
16365
16393 #if SU_HAVE_INLINE
16394 su_inline
16395 #endif
16396 sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
16397 __attribute__((__malloc__));
16398
16399 #if SU_HAVE_INLINE
16400 su_inline
16401 sip_payload_t *sip_payload_dup(su_home_t *home, sip_payload_t const *hdr)
16402 {
16403 return (sip_payload_t *)
16404 msg_header_dup_as(home, sip_payload_class, (msg_header_t const *)hdr);
16405 }
16406 #endif
16407
16435 #if SU_HAVE_INLINE
16436 su_inline
16437 #endif
16438 sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
16439 __attribute__((__malloc__));
16440
16441 #if SU_HAVE_INLINE
16442 su_inline
16443 sip_payload_t *sip_payload_copy(su_home_t *home, sip_payload_t const *hdr)
16444 {
16445 return (sip_payload_t *)
16446 msg_header_copy_as(home, sip_payload_class, (msg_header_t const *)hdr);
16447 }
16448 #endif
16449
16464 #if SU_HAVE_INLINE
16465 su_inline
16466 #endif
16467 sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
16468 __attribute__((__malloc__));
16469
16470 #if SU_HAVE_INLINE
16471 su_inline sip_payload_t *sip_payload_make(su_home_t *home, char const *s)
16472 {
16473 return (sip_payload_t *)sip_header_make(home, sip_payload_class, s);
16474 }
16475 #endif
16476
16494 #if SU_HAVE_INLINE
16495 su_inline
16496 #endif
16497 sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
16498 __attribute__((__malloc__, __format__ (printf, 2, 3)));
16499
16500 #if SU_HAVE_INLINE
16501 su_inline sip_payload_t *sip_payload_format(su_home_t *home, char const *fmt, ...)
16502 {
16503 sip_header_t *h;
16504 va_list ap;
16505
16506 va_start(ap, fmt);
16507 h = sip_header_vformat(home, sip_payload_class, fmt, ap);
16508 va_end(ap);
16509
16510 return (sip_payload_t *)h;
16511 }
16512 #endif
16513
16516 SOFIA_END_DECLS
16517 #endif