sofia-sip/sip_protos.h

Go to the documentation of this file.
00001 /* -*- C -*-
00002  *
00003  * This file is part of the Sofia-SIP package
00004  *
00005  * Copyright (C) 2005 Nokia Corporation.
00006  *
00007  * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
00008  *
00009  * This library is free software; you can redistribute it and/or
00010  * modify it under the terms of the GNU Lesser General Public License
00011  * as published by the Free Software Foundation; either version 2.1 of
00012  * the License, or (at your option) any later version.
00013  *
00014  * This library is distributed in the hope that it will be useful, but
00015  * WITHOUT ANY WARRANTY; without even the implied warranty of
00016  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00017  * Lesser General Public License for more details.
00018  *
00019  * You should have received a copy of the GNU Lesser General Public
00020  * License along with this library; if not, write to the Free Software
00021  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00022  * 02110-1301 USA
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 /* !defined(SIP_PROTOS_H) */

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