sofia-sip/http_protos.h

Go to the documentation of this file.
00001 /*
00002  * This file is part of the Sofia-SIP package
00003  *
00004  * Copyright (C) 2005 Nokia Corporation.
00005  *
00006  * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
00007  *
00008  * This library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public License
00010  * as published by the Free Software Foundation; either version 2.1 of
00011  * the License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00021  * 02110-1301 USA
00022  *
00023  */
00024 
00025 #ifndef HTTP_PROTOS_H
00026 
00027 #define HTTP_PROTOS_H
00028 
00038 #include <sofia-sip/su_config.h>
00039 
00040 #ifndef HTTP_HEADER_H
00041 #include <sofia-sip/http_header.h>
00042 #endif
00043 #ifndef HTTP_HCLASSES_H
00044 #include <sofia-sip/http_hclasses.h>
00045 #endif
00046 
00047 #define http_header_make(h, c, s) \
00048   ((http_header_t *)msg_header_make((h), (c), (s)))
00049 #define http_header_vformat(h, c, f, a) \
00050   ((http_header_t *)msg_header_vformat((h), (c), (f), (a)))
00051 
00052 SOFIA_BEGIN_DECLS
00053 
00054 /* Declare internal prototypes for request line */
00055  
00058 enum { 
00060   http_request_hash = -1 
00061 };
00062 
00071 SOFIAPUBVAR msg_hclass_t http_request_class[];
00072 
00073 #ifndef HTTP_HCLASSES_ONLY
00074 
00076 SOFIAPUBFUN msg_parse_f http_request_d;
00077 
00079 SOFIAPUBFUN msg_print_f http_request_e;
00080 
00092 #define HTTP_REQUEST_INIT() HTTP_HDR_INIT(request)
00093 
00107 #if SU_HAVE_INLINE
00108 su_inline http_request_t *http_request_init(http_request_t x[1])
00109 {
00110   return HTTP_HEADER_INIT(x, http_request_class, sizeof(http_request_t));
00111 }
00112 #else
00113 #define http_request_init(x) \
00114   HTTP_HEADER_INIT(x, http_request_class, sizeof(http_request_t))
00115 #endif
00116 
00130 #if SU_HAVE_INLINE
00131 su_inline 
00132 int http_is_request(http_header_t const *header)
00133 {
00134   return header && header->sh_class->hc_hash == http_request_hash;
00135 }
00136 #else
00137 #define http_is_request(h) \
00138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_request_hash)
00139 #endif
00140 
00168 #if SU_HAVE_INLINE
00169 su_inline
00170 #endif
00171 http_request_t *http_request_dup(su_home_t *home, 
00172                                    http_request_t const *hdr)
00173      __attribute__((__malloc__));
00174 
00203 #if SU_HAVE_INLINE
00204 su_inline
00205 #endif
00206 http_request_t *http_request_copy(su_home_t *home, 
00207                                     http_request_t const *hdr)
00208      __attribute__((__malloc__));
00209 
00228 #if SU_HAVE_INLINE
00229 su_inline
00230 #endif
00231 http_request_t *http_request_make(su_home_t *home, char const *s)
00232      __attribute__((__malloc__));
00233 
00256 #if SU_HAVE_INLINE
00257 su_inline
00258 #endif
00259 http_request_t *http_request_format(su_home_t *home, char const *fmt, ...)
00260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00261 
00262 
00263 /* Inlined functions */
00264 #if SU_HAVE_INLINE
00265 su_inline
00266 http_request_t *http_request_format(su_home_t *home, char const *fmt, ...)
00267 {
00268   http_header_t *h;
00269   va_list ap;
00270   
00271   va_start(ap, fmt);
00272   h = http_header_vformat(home, http_request_class, fmt, ap);
00273   va_end(ap);
00274  
00275   return (http_request_t *)h;
00276 }
00277 
00278 su_inline
00279 http_request_t *http_request_dup(su_home_t *home, http_request_t const *o) 
00280 { 
00281   return (http_request_t *)
00282     msg_header_dup_as(home, http_request_class, (msg_header_t const *)o);
00283 }
00284 
00285 su_inline
00286 http_request_t *http_request_copy(su_home_t *home, http_request_t const *o) 
00287 { 
00288   return (http_request_t *)
00289     msg_header_copy_as(home, http_request_class, (msg_header_t const *)o); 
00290 }
00291 
00292 su_inline 
00293 http_request_t *http_request_make(su_home_t *home, char const *s)
00294 {
00295   return (http_request_t *)http_header_make(home, http_request_class, s);
00296 }
00297 #endif
00298 
00299 #endif /* !define HTTP_HCLASSES_ONLY */
00300 
00304 /* Declare internal prototypes for status line */
00305  
00308 enum { 
00310   http_status_hash = -2 
00311 };
00312 
00321 SOFIAPUBVAR msg_hclass_t http_status_class[];
00322 
00323 #ifndef HTTP_HCLASSES_ONLY
00324 
00326 SOFIAPUBFUN msg_parse_f http_status_d;
00327 
00329 SOFIAPUBFUN msg_print_f http_status_e;
00330 
00342 #define HTTP_STATUS_INIT() HTTP_HDR_INIT(status)
00343 
00357 #if SU_HAVE_INLINE
00358 su_inline http_status_t *http_status_init(http_status_t x[1])
00359 {
00360   return HTTP_HEADER_INIT(x, http_status_class, sizeof(http_status_t));
00361 }
00362 #else
00363 #define http_status_init(x) \
00364   HTTP_HEADER_INIT(x, http_status_class, sizeof(http_status_t))
00365 #endif
00366 
00380 #if SU_HAVE_INLINE
00381 su_inline 
00382 int http_is_status(http_header_t const *header)
00383 {
00384   return header && header->sh_class->hc_hash == http_status_hash;
00385 }
00386 #else
00387 #define http_is_status(h) \
00388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_status_hash)
00389 #endif
00390 
00418 #if SU_HAVE_INLINE
00419 su_inline
00420 #endif
00421 http_status_t *http_status_dup(su_home_t *home, 
00422                                    http_status_t const *hdr)
00423      __attribute__((__malloc__));
00424 
00453 #if SU_HAVE_INLINE
00454 su_inline
00455 #endif
00456 http_status_t *http_status_copy(su_home_t *home, 
00457                                     http_status_t const *hdr)
00458      __attribute__((__malloc__));
00459 
00478 #if SU_HAVE_INLINE
00479 su_inline
00480 #endif
00481 http_status_t *http_status_make(su_home_t *home, char const *s)
00482      __attribute__((__malloc__));
00483 
00506 #if SU_HAVE_INLINE
00507 su_inline
00508 #endif
00509 http_status_t *http_status_format(su_home_t *home, char const *fmt, ...)
00510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00511 
00512 
00513 /* Inlined functions */
00514 #if SU_HAVE_INLINE
00515 su_inline
00516 http_status_t *http_status_format(su_home_t *home, char const *fmt, ...)
00517 {
00518   http_header_t *h;
00519   va_list ap;
00520   
00521   va_start(ap, fmt);
00522   h = http_header_vformat(home, http_status_class, fmt, ap);
00523   va_end(ap);
00524  
00525   return (http_status_t *)h;
00526 }
00527 
00528 su_inline
00529 http_status_t *http_status_dup(su_home_t *home, http_status_t const *o) 
00530 { 
00531   return (http_status_t *)
00532     msg_header_dup_as(home, http_status_class, (msg_header_t const *)o);
00533 }
00534 
00535 su_inline
00536 http_status_t *http_status_copy(su_home_t *home, http_status_t const *o) 
00537 { 
00538   return (http_status_t *)
00539     msg_header_copy_as(home, http_status_class, (msg_header_t const *)o); 
00540 }
00541 
00542 su_inline 
00543 http_status_t *http_status_make(su_home_t *home, char const *s)
00544 {
00545   return (http_status_t *)http_header_make(home, http_status_class, s);
00546 }
00547 #endif
00548 
00549 #endif /* !define HTTP_HCLASSES_ONLY */
00550 
00554 /* Declare internal prototypes for Accept header */
00555  
00558 enum { 
00560   http_accept_hash = 29344 
00561 };
00562 
00571 SOFIAPUBVAR msg_hclass_t http_accept_class[];
00572 
00573 #ifndef HTTP_HCLASSES_ONLY
00574 
00576 SOFIAPUBFUN msg_parse_f http_accept_d;
00577 
00579 SOFIAPUBFUN msg_print_f http_accept_e;
00580 
00592 #define HTTP_ACCEPT_INIT() HTTP_HDR_INIT(accept)
00593 
00607 #if SU_HAVE_INLINE
00608 su_inline http_accept_t *http_accept_init(http_accept_t x[1])
00609 {
00610   return HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t));
00611 }
00612 #else
00613 #define http_accept_init(x) \
00614   HTTP_HEADER_INIT(x, http_accept_class, sizeof(http_accept_t))
00615 #endif
00616 
00630 #if SU_HAVE_INLINE
00631 su_inline 
00632 int http_is_accept(http_header_t const *header)
00633 {
00634   return header && header->sh_class->hc_hash == http_accept_hash;
00635 }
00636 #else
00637 #define http_is_accept(h) \
00638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_hash)
00639 #endif
00640 
00668 #if SU_HAVE_INLINE
00669 su_inline
00670 #endif
00671 http_accept_t *http_accept_dup(su_home_t *home, 
00672                                    http_accept_t const *hdr)
00673      __attribute__((__malloc__));
00674 
00703 #if SU_HAVE_INLINE
00704 su_inline
00705 #endif
00706 http_accept_t *http_accept_copy(su_home_t *home, 
00707                                     http_accept_t const *hdr)
00708      __attribute__((__malloc__));
00709 
00728 #if SU_HAVE_INLINE
00729 su_inline
00730 #endif
00731 http_accept_t *http_accept_make(su_home_t *home, char const *s)
00732      __attribute__((__malloc__));
00733 
00756 #if SU_HAVE_INLINE
00757 su_inline
00758 #endif
00759 http_accept_t *http_accept_format(su_home_t *home, char const *fmt, ...)
00760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00761 
00762 
00763 /* Inlined functions */
00764 #if SU_HAVE_INLINE
00765 su_inline
00766 http_accept_t *http_accept_format(su_home_t *home, char const *fmt, ...)
00767 {
00768   http_header_t *h;
00769   va_list ap;
00770   
00771   va_start(ap, fmt);
00772   h = http_header_vformat(home, http_accept_class, fmt, ap);
00773   va_end(ap);
00774  
00775   return (http_accept_t *)h;
00776 }
00777 
00778 su_inline
00779 http_accept_t *http_accept_dup(su_home_t *home, http_accept_t const *o) 
00780 { 
00781   return (http_accept_t *)
00782     msg_header_dup_as(home, http_accept_class, (msg_header_t const *)o);
00783 }
00784 
00785 su_inline
00786 http_accept_t *http_accept_copy(su_home_t *home, http_accept_t const *o) 
00787 { 
00788   return (http_accept_t *)
00789     msg_header_copy_as(home, http_accept_class, (msg_header_t const *)o); 
00790 }
00791 
00792 su_inline 
00793 http_accept_t *http_accept_make(su_home_t *home, char const *s)
00794 {
00795   return (http_accept_t *)http_header_make(home, http_accept_class, s);
00796 }
00797 #endif
00798 
00799 #endif /* !define HTTP_HCLASSES_ONLY */
00800 
00804 /* Declare internal prototypes for Accept-Charset header */
00805  
00808 enum { 
00810   http_accept_charset_hash = 41803 
00811 };
00812 
00821 SOFIAPUBVAR msg_hclass_t http_accept_charset_class[];
00822 
00823 #ifndef HTTP_HCLASSES_ONLY
00824 
00826 SOFIAPUBFUN msg_parse_f http_accept_charset_d;
00827 
00829 SOFIAPUBFUN msg_print_f http_accept_charset_e;
00830 
00842 #define HTTP_ACCEPT_CHARSET_INIT() HTTP_HDR_INIT(accept_charset)
00843 
00857 #if SU_HAVE_INLINE
00858 su_inline http_accept_charset_t *http_accept_charset_init(http_accept_charset_t x[1])
00859 {
00860   return HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t));
00861 }
00862 #else
00863 #define http_accept_charset_init(x) \
00864   HTTP_HEADER_INIT(x, http_accept_charset_class, sizeof(http_accept_charset_t))
00865 #endif
00866 
00880 #if SU_HAVE_INLINE
00881 su_inline 
00882 int http_is_accept_charset(http_header_t const *header)
00883 {
00884   return header && header->sh_class->hc_hash == http_accept_charset_hash;
00885 }
00886 #else
00887 #define http_is_accept_charset(h) \
00888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_charset_hash)
00889 #endif
00890 
00918 #if SU_HAVE_INLINE
00919 su_inline
00920 #endif
00921 http_accept_charset_t *http_accept_charset_dup(su_home_t *home, 
00922                                    http_accept_charset_t const *hdr)
00923      __attribute__((__malloc__));
00924 
00953 #if SU_HAVE_INLINE
00954 su_inline
00955 #endif
00956 http_accept_charset_t *http_accept_charset_copy(su_home_t *home, 
00957                                     http_accept_charset_t const *hdr)
00958      __attribute__((__malloc__));
00959 
00978 #if SU_HAVE_INLINE
00979 su_inline
00980 #endif
00981 http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
00982      __attribute__((__malloc__));
00983 
01006 #if SU_HAVE_INLINE
01007 su_inline
01008 #endif
01009 http_accept_charset_t *http_accept_charset_format(su_home_t *home, char const *fmt, ...)
01010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
01011 
01012 
01013 /* Inlined functions */
01014 #if SU_HAVE_INLINE
01015 su_inline
01016 http_accept_charset_t *http_accept_charset_format(su_home_t *home, char const *fmt, ...)
01017 {
01018   http_header_t *h;
01019   va_list ap;
01020   
01021   va_start(ap, fmt);
01022   h = http_header_vformat(home, http_accept_charset_class, fmt, ap);
01023   va_end(ap);
01024  
01025   return (http_accept_charset_t *)h;
01026 }
01027 
01028 su_inline
01029 http_accept_charset_t *http_accept_charset_dup(su_home_t *home, http_accept_charset_t const *o) 
01030 { 
01031   return (http_accept_charset_t *)
01032     msg_header_dup_as(home, http_accept_charset_class, (msg_header_t const *)o);
01033 }
01034 
01035 su_inline
01036 http_accept_charset_t *http_accept_charset_copy(su_home_t *home, http_accept_charset_t const *o) 
01037 { 
01038   return (http_accept_charset_t *)
01039     msg_header_copy_as(home, http_accept_charset_class, (msg_header_t const *)o); 
01040 }
01041 
01042 su_inline 
01043 http_accept_charset_t *http_accept_charset_make(su_home_t *home, char const *s)
01044 {
01045   return (http_accept_charset_t *)http_header_make(home, http_accept_charset_class, s);
01046 }
01047 #endif
01048 
01049 #endif /* !define HTTP_HCLASSES_ONLY */
01050 
01054 /* Declare internal prototypes for Accept-Encoding header */
01055  
01058 enum { 
01060   http_accept_encoding_hash = 35932 
01061 };
01062 
01071 SOFIAPUBVAR msg_hclass_t http_accept_encoding_class[];
01072 
01073 #ifndef HTTP_HCLASSES_ONLY
01074 
01076 SOFIAPUBFUN msg_parse_f http_accept_encoding_d;
01077 
01079 SOFIAPUBFUN msg_print_f http_accept_encoding_e;
01080 
01092 #define HTTP_ACCEPT_ENCODING_INIT() HTTP_HDR_INIT(accept_encoding)
01093 
01107 #if SU_HAVE_INLINE
01108 su_inline http_accept_encoding_t *http_accept_encoding_init(http_accept_encoding_t x[1])
01109 {
01110   return HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t));
01111 }
01112 #else
01113 #define http_accept_encoding_init(x) \
01114   HTTP_HEADER_INIT(x, http_accept_encoding_class, sizeof(http_accept_encoding_t))
01115 #endif
01116 
01130 #if SU_HAVE_INLINE
01131 su_inline 
01132 int http_is_accept_encoding(http_header_t const *header)
01133 {
01134   return header && header->sh_class->hc_hash == http_accept_encoding_hash;
01135 }
01136 #else
01137 #define http_is_accept_encoding(h) \
01138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_encoding_hash)
01139 #endif
01140 
01168 #if SU_HAVE_INLINE
01169 su_inline
01170 #endif
01171 http_accept_encoding_t *http_accept_encoding_dup(su_home_t *home, 
01172                                    http_accept_encoding_t const *hdr)
01173      __attribute__((__malloc__));
01174 
01203 #if SU_HAVE_INLINE
01204 su_inline
01205 #endif
01206 http_accept_encoding_t *http_accept_encoding_copy(su_home_t *home, 
01207                                     http_accept_encoding_t const *hdr)
01208      __attribute__((__malloc__));
01209 
01228 #if SU_HAVE_INLINE
01229 su_inline
01230 #endif
01231 http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
01232      __attribute__((__malloc__));
01233 
01256 #if SU_HAVE_INLINE
01257 su_inline
01258 #endif
01259 http_accept_encoding_t *http_accept_encoding_format(su_home_t *home, char const *fmt, ...)
01260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
01261 
01262 
01263 /* Inlined functions */
01264 #if SU_HAVE_INLINE
01265 su_inline
01266 http_accept_encoding_t *http_accept_encoding_format(su_home_t *home, char const *fmt, ...)
01267 {
01268   http_header_t *h;
01269   va_list ap;
01270   
01271   va_start(ap, fmt);
01272   h = http_header_vformat(home, http_accept_encoding_class, fmt, ap);
01273   va_end(ap);
01274  
01275   return (http_accept_encoding_t *)h;
01276 }
01277 
01278 su_inline
01279 http_accept_encoding_t *http_accept_encoding_dup(su_home_t *home, http_accept_encoding_t const *o) 
01280 { 
01281   return (http_accept_encoding_t *)
01282     msg_header_dup_as(home, http_accept_encoding_class, (msg_header_t const *)o);
01283 }
01284 
01285 su_inline
01286 http_accept_encoding_t *http_accept_encoding_copy(su_home_t *home, http_accept_encoding_t const *o) 
01287 { 
01288   return (http_accept_encoding_t *)
01289     msg_header_copy_as(home, http_accept_encoding_class, (msg_header_t const *)o); 
01290 }
01291 
01292 su_inline 
01293 http_accept_encoding_t *http_accept_encoding_make(su_home_t *home, char const *s)
01294 {
01295   return (http_accept_encoding_t *)http_header_make(home, http_accept_encoding_class, s);
01296 }
01297 #endif
01298 
01299 #endif /* !define HTTP_HCLASSES_ONLY */
01300 
01304 /* Declare internal prototypes for Accept-Language header */
01305  
01308 enum { 
01310   http_accept_language_hash = 23797 
01311 };
01312 
01321 SOFIAPUBVAR msg_hclass_t http_accept_language_class[];
01322 
01323 #ifndef HTTP_HCLASSES_ONLY
01324 
01326 SOFIAPUBFUN msg_parse_f http_accept_language_d;
01327 
01329 SOFIAPUBFUN msg_print_f http_accept_language_e;
01330 
01342 #define HTTP_ACCEPT_LANGUAGE_INIT() HTTP_HDR_INIT(accept_language)
01343 
01357 #if SU_HAVE_INLINE
01358 su_inline http_accept_language_t *http_accept_language_init(http_accept_language_t x[1])
01359 {
01360   return HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t));
01361 }
01362 #else
01363 #define http_accept_language_init(x) \
01364   HTTP_HEADER_INIT(x, http_accept_language_class, sizeof(http_accept_language_t))
01365 #endif
01366 
01380 #if SU_HAVE_INLINE
01381 su_inline 
01382 int http_is_accept_language(http_header_t const *header)
01383 {
01384   return header && header->sh_class->hc_hash == http_accept_language_hash;
01385 }
01386 #else
01387 #define http_is_accept_language(h) \
01388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_language_hash)
01389 #endif
01390 
01418 #if SU_HAVE_INLINE
01419 su_inline
01420 #endif
01421 http_accept_language_t *http_accept_language_dup(su_home_t *home, 
01422                                    http_accept_language_t const *hdr)
01423      __attribute__((__malloc__));
01424 
01453 #if SU_HAVE_INLINE
01454 su_inline
01455 #endif
01456 http_accept_language_t *http_accept_language_copy(su_home_t *home, 
01457                                     http_accept_language_t const *hdr)
01458      __attribute__((__malloc__));
01459 
01478 #if SU_HAVE_INLINE
01479 su_inline
01480 #endif
01481 http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
01482      __attribute__((__malloc__));
01483 
01506 #if SU_HAVE_INLINE
01507 su_inline
01508 #endif
01509 http_accept_language_t *http_accept_language_format(su_home_t *home, char const *fmt, ...)
01510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
01511 
01512 
01513 /* Inlined functions */
01514 #if SU_HAVE_INLINE
01515 su_inline
01516 http_accept_language_t *http_accept_language_format(su_home_t *home, char const *fmt, ...)
01517 {
01518   http_header_t *h;
01519   va_list ap;
01520   
01521   va_start(ap, fmt);
01522   h = http_header_vformat(home, http_accept_language_class, fmt, ap);
01523   va_end(ap);
01524  
01525   return (http_accept_language_t *)h;
01526 }
01527 
01528 su_inline
01529 http_accept_language_t *http_accept_language_dup(su_home_t *home, http_accept_language_t const *o) 
01530 { 
01531   return (http_accept_language_t *)
01532     msg_header_dup_as(home, http_accept_language_class, (msg_header_t const *)o);
01533 }
01534 
01535 su_inline
01536 http_accept_language_t *http_accept_language_copy(su_home_t *home, http_accept_language_t const *o) 
01537 { 
01538   return (http_accept_language_t *)
01539     msg_header_copy_as(home, http_accept_language_class, (msg_header_t const *)o); 
01540 }
01541 
01542 su_inline 
01543 http_accept_language_t *http_accept_language_make(su_home_t *home, char const *s)
01544 {
01545   return (http_accept_language_t *)http_header_make(home, http_accept_language_class, s);
01546 }
01547 #endif
01548 
01549 #endif /* !define HTTP_HCLASSES_ONLY */
01550 
01554 /* Declare internal prototypes for Accept-Ranges header */
01555  
01558 enum { 
01560   http_accept_ranges_hash = 59733 
01561 };
01562 
01571 SOFIAPUBVAR msg_hclass_t http_accept_ranges_class[];
01572 
01573 #ifndef HTTP_HCLASSES_ONLY
01574 
01576 SOFIAPUBFUN msg_parse_f http_accept_ranges_d;
01577 
01579 SOFIAPUBFUN msg_print_f http_accept_ranges_e;
01580 
01592 #define HTTP_ACCEPT_RANGES_INIT() HTTP_HDR_INIT(accept_ranges)
01593 
01607 #if SU_HAVE_INLINE
01608 su_inline http_accept_ranges_t *http_accept_ranges_init(http_accept_ranges_t x[1])
01609 {
01610   return HTTP_HEADER_INIT(x, http_accept_ranges_class, sizeof(http_accept_ranges_t));
01611 }
01612 #else
01613 #define http_accept_ranges_init(x) \
01614   HTTP_HEADER_INIT(x, http_accept_ranges_class, sizeof(http_accept_ranges_t))
01615 #endif
01616 
01630 #if SU_HAVE_INLINE
01631 su_inline 
01632 int http_is_accept_ranges(http_header_t const *header)
01633 {
01634   return header && header->sh_class->hc_hash == http_accept_ranges_hash;
01635 }
01636 #else
01637 #define http_is_accept_ranges(h) \
01638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_accept_ranges_hash)
01639 #endif
01640 
01668 #if SU_HAVE_INLINE
01669 su_inline
01670 #endif
01671 http_accept_ranges_t *http_accept_ranges_dup(su_home_t *home, 
01672                                    http_accept_ranges_t const *hdr)
01673      __attribute__((__malloc__));
01674 
01703 #if SU_HAVE_INLINE
01704 su_inline
01705 #endif
01706 http_accept_ranges_t *http_accept_ranges_copy(su_home_t *home, 
01707                                     http_accept_ranges_t const *hdr)
01708      __attribute__((__malloc__));
01709 
01728 #if SU_HAVE_INLINE
01729 su_inline
01730 #endif
01731 http_accept_ranges_t *http_accept_ranges_make(su_home_t *home, char const *s)
01732      __attribute__((__malloc__));
01733 
01756 #if SU_HAVE_INLINE
01757 su_inline
01758 #endif
01759 http_accept_ranges_t *http_accept_ranges_format(su_home_t *home, char const *fmt, ...)
01760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
01761 
01762 
01763 /* Inlined functions */
01764 #if SU_HAVE_INLINE
01765 su_inline
01766 http_accept_ranges_t *http_accept_ranges_format(su_home_t *home, char const *fmt, ...)
01767 {
01768   http_header_t *h;
01769   va_list ap;
01770   
01771   va_start(ap, fmt);
01772   h = http_header_vformat(home, http_accept_ranges_class, fmt, ap);
01773   va_end(ap);
01774  
01775   return (http_accept_ranges_t *)h;
01776 }
01777 
01778 su_inline
01779 http_accept_ranges_t *http_accept_ranges_dup(su_home_t *home, http_accept_ranges_t const *o) 
01780 { 
01781   return (http_accept_ranges_t *)
01782     msg_header_dup_as(home, http_accept_ranges_class, (msg_header_t const *)o);
01783 }
01784 
01785 su_inline
01786 http_accept_ranges_t *http_accept_ranges_copy(su_home_t *home, http_accept_ranges_t const *o) 
01787 { 
01788   return (http_accept_ranges_t *)
01789     msg_header_copy_as(home, http_accept_ranges_class, (msg_header_t const *)o); 
01790 }
01791 
01792 su_inline 
01793 http_accept_ranges_t *http_accept_ranges_make(su_home_t *home, char const *s)
01794 {
01795   return (http_accept_ranges_t *)http_header_make(home, http_accept_ranges_class, s);
01796 }
01797 #endif
01798 
01799 #endif /* !define HTTP_HCLASSES_ONLY */
01800 
01804 /* Declare internal prototypes for Allow header */
01805  
01808 enum { 
01810   http_allow_hash = 44519 
01811 };
01812 
01821 SOFIAPUBVAR msg_hclass_t http_allow_class[];
01822 
01823 #ifndef HTTP_HCLASSES_ONLY
01824 
01826 SOFIAPUBFUN msg_parse_f http_allow_d;
01827 
01829 SOFIAPUBFUN msg_print_f http_allow_e;
01830 
01842 #define HTTP_ALLOW_INIT() HTTP_HDR_INIT(allow)
01843 
01857 #if SU_HAVE_INLINE
01858 su_inline http_allow_t *http_allow_init(http_allow_t x[1])
01859 {
01860   return HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t));
01861 }
01862 #else
01863 #define http_allow_init(x) \
01864   HTTP_HEADER_INIT(x, http_allow_class, sizeof(http_allow_t))
01865 #endif
01866 
01880 #if SU_HAVE_INLINE
01881 su_inline 
01882 int http_is_allow(http_header_t const *header)
01883 {
01884   return header && header->sh_class->hc_hash == http_allow_hash;
01885 }
01886 #else
01887 #define http_is_allow(h) \
01888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_allow_hash)
01889 #endif
01890 
01918 #if SU_HAVE_INLINE
01919 su_inline
01920 #endif
01921 http_allow_t *http_allow_dup(su_home_t *home, 
01922                                    http_allow_t const *hdr)
01923      __attribute__((__malloc__));
01924 
01953 #if SU_HAVE_INLINE
01954 su_inline
01955 #endif
01956 http_allow_t *http_allow_copy(su_home_t *home, 
01957                                     http_allow_t const *hdr)
01958      __attribute__((__malloc__));
01959 
01978 #if SU_HAVE_INLINE
01979 su_inline
01980 #endif
01981 http_allow_t *http_allow_make(su_home_t *home, char const *s)
01982      __attribute__((__malloc__));
01983 
02006 #if SU_HAVE_INLINE
02007 su_inline
02008 #endif
02009 http_allow_t *http_allow_format(su_home_t *home, char const *fmt, ...)
02010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
02011 
02012 
02013 /* Inlined functions */
02014 #if SU_HAVE_INLINE
02015 su_inline
02016 http_allow_t *http_allow_format(su_home_t *home, char const *fmt, ...)
02017 {
02018   http_header_t *h;
02019   va_list ap;
02020   
02021   va_start(ap, fmt);
02022   h = http_header_vformat(home, http_allow_class, fmt, ap);
02023   va_end(ap);
02024  
02025   return (http_allow_t *)h;
02026 }
02027 
02028 su_inline
02029 http_allow_t *http_allow_dup(su_home_t *home, http_allow_t const *o) 
02030 { 
02031   return (http_allow_t *)
02032     msg_header_dup_as(home, http_allow_class, (msg_header_t const *)o);
02033 }
02034 
02035 su_inline
02036 http_allow_t *http_allow_copy(su_home_t *home, http_allow_t const *o) 
02037 { 
02038   return (http_allow_t *)
02039     msg_header_copy_as(home, http_allow_class, (msg_header_t const *)o); 
02040 }
02041 
02042 su_inline 
02043 http_allow_t *http_allow_make(su_home_t *home, char const *s)
02044 {
02045   return (http_allow_t *)http_header_make(home, http_allow_class, s);
02046 }
02047 #endif
02048 
02049 #endif /* !define HTTP_HCLASSES_ONLY */
02050 
02054 /* Declare internal prototypes for Authentication-Info header */
02055  
02058 enum { 
02060   http_authentication_info_hash = 20849 
02061 };
02062 
02071 SOFIAPUBVAR msg_hclass_t http_authentication_info_class[];
02072 
02073 #ifndef HTTP_HCLASSES_ONLY
02074 
02076 SOFIAPUBFUN msg_parse_f http_authentication_info_d;
02077 
02079 SOFIAPUBFUN msg_print_f http_authentication_info_e;
02080 
02092 #define HTTP_AUTHENTICATION_INFO_INIT() HTTP_HDR_INIT(authentication_info)
02093 
02107 #if SU_HAVE_INLINE
02108 su_inline http_authentication_info_t *http_authentication_info_init(http_authentication_info_t x[1])
02109 {
02110   return HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t));
02111 }
02112 #else
02113 #define http_authentication_info_init(x) \
02114   HTTP_HEADER_INIT(x, http_authentication_info_class, sizeof(http_authentication_info_t))
02115 #endif
02116 
02130 #if SU_HAVE_INLINE
02131 su_inline 
02132 int http_is_authentication_info(http_header_t const *header)
02133 {
02134   return header && header->sh_class->hc_hash == http_authentication_info_hash;
02135 }
02136 #else
02137 #define http_is_authentication_info(h) \
02138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authentication_info_hash)
02139 #endif
02140 
02168 #if SU_HAVE_INLINE
02169 su_inline
02170 #endif
02171 http_authentication_info_t *http_authentication_info_dup(su_home_t *home, 
02172                                    http_authentication_info_t const *hdr)
02173      __attribute__((__malloc__));
02174 
02203 #if SU_HAVE_INLINE
02204 su_inline
02205 #endif
02206 http_authentication_info_t *http_authentication_info_copy(su_home_t *home, 
02207                                     http_authentication_info_t const *hdr)
02208      __attribute__((__malloc__));
02209 
02228 #if SU_HAVE_INLINE
02229 su_inline
02230 #endif
02231 http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
02232      __attribute__((__malloc__));
02233 
02256 #if SU_HAVE_INLINE
02257 su_inline
02258 #endif
02259 http_authentication_info_t *http_authentication_info_format(su_home_t *home, char const *fmt, ...)
02260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
02261 
02262 
02263 /* Inlined functions */
02264 #if SU_HAVE_INLINE
02265 su_inline
02266 http_authentication_info_t *http_authentication_info_format(su_home_t *home, char const *fmt, ...)
02267 {
02268   http_header_t *h;
02269   va_list ap;
02270   
02271   va_start(ap, fmt);
02272   h = http_header_vformat(home, http_authentication_info_class, fmt, ap);
02273   va_end(ap);
02274  
02275   return (http_authentication_info_t *)h;
02276 }
02277 
02278 su_inline
02279 http_authentication_info_t *http_authentication_info_dup(su_home_t *home, http_authentication_info_t const *o) 
02280 { 
02281   return (http_authentication_info_t *)
02282     msg_header_dup_as(home, http_authentication_info_class, (msg_header_t const *)o);
02283 }
02284 
02285 su_inline
02286 http_authentication_info_t *http_authentication_info_copy(su_home_t *home, http_authentication_info_t const *o) 
02287 { 
02288   return (http_authentication_info_t *)
02289     msg_header_copy_as(home, http_authentication_info_class, (msg_header_t const *)o); 
02290 }
02291 
02292 su_inline 
02293 http_authentication_info_t *http_authentication_info_make(su_home_t *home, char const *s)
02294 {
02295   return (http_authentication_info_t *)http_header_make(home, http_authentication_info_class, s);
02296 }
02297 #endif
02298 
02299 #endif /* !define HTTP_HCLASSES_ONLY */
02300 
02304 /* Declare internal prototypes for Authorization header */
02305  
02308 enum { 
02310   http_authorization_hash = 36397 
02311 };
02312 
02321 SOFIAPUBVAR msg_hclass_t http_authorization_class[];
02322 
02323 #ifndef HTTP_HCLASSES_ONLY
02324 
02326 SOFIAPUBFUN msg_parse_f http_authorization_d;
02327 
02329 SOFIAPUBFUN msg_print_f http_authorization_e;
02330 
02342 #define HTTP_AUTHORIZATION_INIT() HTTP_HDR_INIT(authorization)
02343 
02357 #if SU_HAVE_INLINE
02358 su_inline http_authorization_t *http_authorization_init(http_authorization_t x[1])
02359 {
02360   return HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t));
02361 }
02362 #else
02363 #define http_authorization_init(x) \
02364   HTTP_HEADER_INIT(x, http_authorization_class, sizeof(http_authorization_t))
02365 #endif
02366 
02380 #if SU_HAVE_INLINE
02381 su_inline 
02382 int http_is_authorization(http_header_t const *header)
02383 {
02384   return header && header->sh_class->hc_hash == http_authorization_hash;
02385 }
02386 #else
02387 #define http_is_authorization(h) \
02388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_authorization_hash)
02389 #endif
02390 
02418 #if SU_HAVE_INLINE
02419 su_inline
02420 #endif
02421 http_authorization_t *http_authorization_dup(su_home_t *home, 
02422                                    http_authorization_t const *hdr)
02423      __attribute__((__malloc__));
02424 
02453 #if SU_HAVE_INLINE
02454 su_inline
02455 #endif
02456 http_authorization_t *http_authorization_copy(su_home_t *home, 
02457                                     http_authorization_t const *hdr)
02458      __attribute__((__malloc__));
02459 
02478 #if SU_HAVE_INLINE
02479 su_inline
02480 #endif
02481 http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
02482      __attribute__((__malloc__));
02483 
02506 #if SU_HAVE_INLINE
02507 su_inline
02508 #endif
02509 http_authorization_t *http_authorization_format(su_home_t *home, char const *fmt, ...)
02510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
02511 
02512 
02513 /* Inlined functions */
02514 #if SU_HAVE_INLINE
02515 su_inline
02516 http_authorization_t *http_authorization_format(su_home_t *home, char const *fmt, ...)
02517 {
02518   http_header_t *h;
02519   va_list ap;
02520   
02521   va_start(ap, fmt);
02522   h = http_header_vformat(home, http_authorization_class, fmt, ap);
02523   va_end(ap);
02524  
02525   return (http_authorization_t *)h;
02526 }
02527 
02528 su_inline
02529 http_authorization_t *http_authorization_dup(su_home_t *home, http_authorization_t const *o) 
02530 { 
02531   return (http_authorization_t *)
02532     msg_header_dup_as(home, http_authorization_class, (msg_header_t const *)o);
02533 }
02534 
02535 su_inline
02536 http_authorization_t *http_authorization_copy(su_home_t *home, http_authorization_t const *o) 
02537 { 
02538   return (http_authorization_t *)
02539     msg_header_copy_as(home, http_authorization_class, (msg_header_t const *)o); 
02540 }
02541 
02542 su_inline 
02543 http_authorization_t *http_authorization_make(su_home_t *home, char const *s)
02544 {
02545   return (http_authorization_t *)http_header_make(home, http_authorization_class, s);
02546 }
02547 #endif
02548 
02549 #endif /* !define HTTP_HCLASSES_ONLY */
02550 
02554 /* Declare internal prototypes for Age header */
02555  
02558 enum { 
02560   http_age_hash = 34725 
02561 };
02562 
02571 SOFIAPUBVAR msg_hclass_t http_age_class[];
02572 
02573 #ifndef HTTP_HCLASSES_ONLY
02574 
02576 SOFIAPUBFUN msg_parse_f http_age_d;
02577 
02579 SOFIAPUBFUN msg_print_f http_age_e;
02580 
02592 #define HTTP_AGE_INIT() HTTP_HDR_INIT(age)
02593 
02607 #if SU_HAVE_INLINE
02608 su_inline http_age_t *http_age_init(http_age_t x[1])
02609 {
02610   return HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t));
02611 }
02612 #else
02613 #define http_age_init(x) \
02614   HTTP_HEADER_INIT(x, http_age_class, sizeof(http_age_t))
02615 #endif
02616 
02630 #if SU_HAVE_INLINE
02631 su_inline 
02632 int http_is_age(http_header_t const *header)
02633 {
02634   return header && header->sh_class->hc_hash == http_age_hash;
02635 }
02636 #else
02637 #define http_is_age(h) \
02638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_age_hash)
02639 #endif
02640 
02668 #if SU_HAVE_INLINE
02669 su_inline
02670 #endif
02671 http_age_t *http_age_dup(su_home_t *home, 
02672                                    http_age_t const *hdr)
02673      __attribute__((__malloc__));
02674 
02703 #if SU_HAVE_INLINE
02704 su_inline
02705 #endif
02706 http_age_t *http_age_copy(su_home_t *home, 
02707                                     http_age_t const *hdr)
02708      __attribute__((__malloc__));
02709 
02728 #if SU_HAVE_INLINE
02729 su_inline
02730 #endif
02731 http_age_t *http_age_make(su_home_t *home, char const *s)
02732      __attribute__((__malloc__));
02733 
02756 #if SU_HAVE_INLINE
02757 su_inline
02758 #endif
02759 http_age_t *http_age_format(su_home_t *home, char const *fmt, ...)
02760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
02761 
02762 
02763 /* Inlined functions */
02764 #if SU_HAVE_INLINE
02765 su_inline
02766 http_age_t *http_age_format(su_home_t *home, char const *fmt, ...)
02767 {
02768   http_header_t *h;
02769   va_list ap;
02770   
02771   va_start(ap, fmt);
02772   h = http_header_vformat(home, http_age_class, fmt, ap);
02773   va_end(ap);
02774  
02775   return (http_age_t *)h;
02776 }
02777 
02778 su_inline
02779 http_age_t *http_age_dup(su_home_t *home, http_age_t const *o) 
02780 { 
02781   return (http_age_t *)
02782     msg_header_dup_as(home, http_age_class, (msg_header_t const *)o);
02783 }
02784 
02785 su_inline
02786 http_age_t *http_age_copy(su_home_t *home, http_age_t const *o) 
02787 { 
02788   return (http_age_t *)
02789     msg_header_copy_as(home, http_age_class, (msg_header_t const *)o); 
02790 }
02791 
02792 su_inline 
02793 http_age_t *http_age_make(su_home_t *home, char const *s)
02794 {
02795   return (http_age_t *)http_header_make(home, http_age_class, s);
02796 }
02797 #endif
02798 
02799 #endif /* !define HTTP_HCLASSES_ONLY */
02800 
02804 /* Declare internal prototypes for Cache-Control header */
02805  
02808 enum { 
02810   http_cache_control_hash = 48250 
02811 };
02812 
02821 SOFIAPUBVAR msg_hclass_t http_cache_control_class[];
02822 
02823 #ifndef HTTP_HCLASSES_ONLY
02824 
02826 SOFIAPUBFUN msg_parse_f http_cache_control_d;
02827 
02829 SOFIAPUBFUN msg_print_f http_cache_control_e;
02830 
02842 #define HTTP_CACHE_CONTROL_INIT() HTTP_HDR_INIT(cache_control)
02843 
02857 #if SU_HAVE_INLINE
02858 su_inline http_cache_control_t *http_cache_control_init(http_cache_control_t x[1])
02859 {
02860   return HTTP_HEADER_INIT(x, http_cache_control_class, sizeof(http_cache_control_t));
02861 }
02862 #else
02863 #define http_cache_control_init(x) \
02864   HTTP_HEADER_INIT(x, http_cache_control_class, sizeof(http_cache_control_t))
02865 #endif
02866 
02880 #if SU_HAVE_INLINE
02881 su_inline 
02882 int http_is_cache_control(http_header_t const *header)
02883 {
02884   return header && header->sh_class->hc_hash == http_cache_control_hash;
02885 }
02886 #else
02887 #define http_is_cache_control(h) \
02888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cache_control_hash)
02889 #endif
02890 
02918 #if SU_HAVE_INLINE
02919 su_inline
02920 #endif
02921 http_cache_control_t *http_cache_control_dup(su_home_t *home, 
02922                                    http_cache_control_t const *hdr)
02923      __attribute__((__malloc__));
02924 
02953 #if SU_HAVE_INLINE
02954 su_inline
02955 #endif
02956 http_cache_control_t *http_cache_control_copy(su_home_t *home, 
02957                                     http_cache_control_t const *hdr)
02958      __attribute__((__malloc__));
02959 
02978 #if SU_HAVE_INLINE
02979 su_inline
02980 #endif
02981 http_cache_control_t *http_cache_control_make(su_home_t *home, char const *s)
02982      __attribute__((__malloc__));
02983 
03006 #if SU_HAVE_INLINE
03007 su_inline
03008 #endif
03009 http_cache_control_t *http_cache_control_format(su_home_t *home, char const *fmt, ...)
03010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
03011 
03012 
03013 /* Inlined functions */
03014 #if SU_HAVE_INLINE
03015 su_inline
03016 http_cache_control_t *http_cache_control_format(su_home_t *home, char const *fmt, ...)
03017 {
03018   http_header_t *h;
03019   va_list ap;
03020   
03021   va_start(ap, fmt);
03022   h = http_header_vformat(home, http_cache_control_class, fmt, ap);
03023   va_end(ap);
03024  
03025   return (http_cache_control_t *)h;
03026 }
03027 
03028 su_inline
03029 http_cache_control_t *http_cache_control_dup(su_home_t *home, http_cache_control_t const *o) 
03030 { 
03031   return (http_cache_control_t *)
03032     msg_header_dup_as(home, http_cache_control_class, (msg_header_t const *)o);
03033 }
03034 
03035 su_inline
03036 http_cache_control_t *http_cache_control_copy(su_home_t *home, http_cache_control_t const *o) 
03037 { 
03038   return (http_cache_control_t *)
03039     msg_header_copy_as(home, http_cache_control_class, (msg_header_t const *)o); 
03040 }
03041 
03042 su_inline 
03043 http_cache_control_t *http_cache_control_make(su_home_t *home, char const *s)
03044 {
03045   return (http_cache_control_t *)http_header_make(home, http_cache_control_class, s);
03046 }
03047 #endif
03048 
03049 #endif /* !define HTTP_HCLASSES_ONLY */
03050 
03054 /* Declare internal prototypes for Connection header */
03055  
03058 enum { 
03060   http_connection_hash = 32700 
03061 };
03062 
03071 SOFIAPUBVAR msg_hclass_t http_connection_class[];
03072 
03073 #ifndef HTTP_HCLASSES_ONLY
03074 
03076 SOFIAPUBFUN msg_parse_f http_connection_d;
03077 
03079 SOFIAPUBFUN msg_print_f http_connection_e;
03080 
03092 #define HTTP_CONNECTION_INIT() HTTP_HDR_INIT(connection)
03093 
03107 #if SU_HAVE_INLINE
03108 su_inline http_connection_t *http_connection_init(http_connection_t x[1])
03109 {
03110   return HTTP_HEADER_INIT(x, http_connection_class, sizeof(http_connection_t));
03111 }
03112 #else
03113 #define http_connection_init(x) \
03114   HTTP_HEADER_INIT(x, http_connection_class, sizeof(http_connection_t))
03115 #endif
03116 
03130 #if SU_HAVE_INLINE
03131 su_inline 
03132 int http_is_connection(http_header_t const *header)
03133 {
03134   return header && header->sh_class->hc_hash == http_connection_hash;
03135 }
03136 #else
03137 #define http_is_connection(h) \
03138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_connection_hash)
03139 #endif
03140 
03168 #if SU_HAVE_INLINE
03169 su_inline
03170 #endif
03171 http_connection_t *http_connection_dup(su_home_t *home, 
03172                                    http_connection_t const *hdr)
03173      __attribute__((__malloc__));
03174 
03203 #if SU_HAVE_INLINE
03204 su_inline
03205 #endif
03206 http_connection_t *http_connection_copy(su_home_t *home, 
03207                                     http_connection_t const *hdr)
03208      __attribute__((__malloc__));
03209 
03228 #if SU_HAVE_INLINE
03229 su_inline
03230 #endif
03231 http_connection_t *http_connection_make(su_home_t *home, char const *s)
03232      __attribute__((__malloc__));
03233 
03256 #if SU_HAVE_INLINE
03257 su_inline
03258 #endif
03259 http_connection_t *http_connection_format(su_home_t *home, char const *fmt, ...)
03260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
03261 
03262 
03263 /* Inlined functions */
03264 #if SU_HAVE_INLINE
03265 su_inline
03266 http_connection_t *http_connection_format(su_home_t *home, char const *fmt, ...)
03267 {
03268   http_header_t *h;
03269   va_list ap;
03270   
03271   va_start(ap, fmt);
03272   h = http_header_vformat(home, http_connection_class, fmt, ap);
03273   va_end(ap);
03274  
03275   return (http_connection_t *)h;
03276 }
03277 
03278 su_inline
03279 http_connection_t *http_connection_dup(su_home_t *home, http_connection_t const *o) 
03280 { 
03281   return (http_connection_t *)
03282     msg_header_dup_as(home, http_connection_class, (msg_header_t const *)o);
03283 }
03284 
03285 su_inline
03286 http_connection_t *http_connection_copy(su_home_t *home, http_connection_t const *o) 
03287 { 
03288   return (http_connection_t *)
03289     msg_header_copy_as(home, http_connection_class, (msg_header_t const *)o); 
03290 }
03291 
03292 su_inline 
03293 http_connection_t *http_connection_make(su_home_t *home, char const *s)
03294 {
03295   return (http_connection_t *)http_header_make(home, http_connection_class, s);
03296 }
03297 #endif
03298 
03299 #endif /* !define HTTP_HCLASSES_ONLY */
03300 
03304 /* Declare internal prototypes for Date header */
03305  
03308 enum { 
03310   http_date_hash = 43982 
03311 };
03312 
03321 SOFIAPUBVAR msg_hclass_t http_date_class[];
03322 
03323 #ifndef HTTP_HCLASSES_ONLY
03324 
03326 SOFIAPUBFUN msg_parse_f http_date_d;
03327 
03329 SOFIAPUBFUN msg_print_f http_date_e;
03330 
03342 #define HTTP_DATE_INIT() HTTP_HDR_INIT(date)
03343 
03357 #if SU_HAVE_INLINE
03358 su_inline http_date_t *http_date_init(http_date_t x[1])
03359 {
03360   return HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t));
03361 }
03362 #else
03363 #define http_date_init(x) \
03364   HTTP_HEADER_INIT(x, http_date_class, sizeof(http_date_t))
03365 #endif
03366 
03380 #if SU_HAVE_INLINE
03381 su_inline 
03382 int http_is_date(http_header_t const *header)
03383 {
03384   return header && header->sh_class->hc_hash == http_date_hash;
03385 }
03386 #else
03387 #define http_is_date(h) \
03388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_date_hash)
03389 #endif
03390 
03418 #if SU_HAVE_INLINE
03419 su_inline
03420 #endif
03421 http_date_t *http_date_dup(su_home_t *home, 
03422                                    http_date_t const *hdr)
03423      __attribute__((__malloc__));
03424 
03453 #if SU_HAVE_INLINE
03454 su_inline
03455 #endif
03456 http_date_t *http_date_copy(su_home_t *home, 
03457                                     http_date_t const *hdr)
03458      __attribute__((__malloc__));
03459 
03478 #if SU_HAVE_INLINE
03479 su_inline
03480 #endif
03481 http_date_t *http_date_make(su_home_t *home, char const *s)
03482      __attribute__((__malloc__));
03483 
03506 #if SU_HAVE_INLINE
03507 su_inline
03508 #endif
03509 http_date_t *http_date_format(su_home_t *home, char const *fmt, ...)
03510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
03511 
03512 
03513 /* Inlined functions */
03514 #if SU_HAVE_INLINE
03515 su_inline
03516 http_date_t *http_date_format(su_home_t *home, char const *fmt, ...)
03517 {
03518   http_header_t *h;
03519   va_list ap;
03520   
03521   va_start(ap, fmt);
03522   h = http_header_vformat(home, http_date_class, fmt, ap);
03523   va_end(ap);
03524  
03525   return (http_date_t *)h;
03526 }
03527 
03528 su_inline
03529 http_date_t *http_date_dup(su_home_t *home, http_date_t const *o) 
03530 { 
03531   return (http_date_t *)
03532     msg_header_dup_as(home, http_date_class, (msg_header_t const *)o);
03533 }
03534 
03535 su_inline
03536 http_date_t *http_date_copy(su_home_t *home, http_date_t const *o) 
03537 { 
03538   return (http_date_t *)
03539     msg_header_copy_as(home, http_date_class, (msg_header_t const *)o); 
03540 }
03541 
03542 su_inline 
03543 http_date_t *http_date_make(su_home_t *home, char const *s)
03544 {
03545   return (http_date_t *)http_header_make(home, http_date_class, s);
03546 }
03547 #endif
03548 
03549 #endif /* !define HTTP_HCLASSES_ONLY */
03550 
03554 /* Declare internal prototypes for ETag header */
03555  
03558 enum { 
03560   http_etag_hash = 1813 
03561 };
03562 
03571 SOFIAPUBVAR msg_hclass_t http_etag_class[];
03572 
03573 #ifndef HTTP_HCLASSES_ONLY
03574 
03576 SOFIAPUBFUN msg_parse_f http_etag_d;
03577 
03579 SOFIAPUBFUN msg_print_f http_etag_e;
03580 
03592 #define HTTP_ETAG_INIT() HTTP_HDR_INIT(etag)
03593 
03607 #if SU_HAVE_INLINE
03608 su_inline http_etag_t *http_etag_init(http_etag_t x[1])
03609 {
03610   return HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t));
03611 }
03612 #else
03613 #define http_etag_init(x) \
03614   HTTP_HEADER_INIT(x, http_etag_class, sizeof(http_etag_t))
03615 #endif
03616 
03630 #if SU_HAVE_INLINE
03631 su_inline 
03632 int http_is_etag(http_header_t const *header)
03633 {
03634   return header && header->sh_class->hc_hash == http_etag_hash;
03635 }
03636 #else
03637 #define http_is_etag(h) \
03638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_etag_hash)
03639 #endif
03640 
03668 #if SU_HAVE_INLINE
03669 su_inline
03670 #endif
03671 http_etag_t *http_etag_dup(su_home_t *home, 
03672                                    http_etag_t const *hdr)
03673      __attribute__((__malloc__));
03674 
03703 #if SU_HAVE_INLINE
03704 su_inline
03705 #endif
03706 http_etag_t *http_etag_copy(su_home_t *home, 
03707                                     http_etag_t const *hdr)
03708      __attribute__((__malloc__));
03709 
03728 #if SU_HAVE_INLINE
03729 su_inline
03730 #endif
03731 http_etag_t *http_etag_make(su_home_t *home, char const *s)
03732      __attribute__((__malloc__));
03733 
03756 #if SU_HAVE_INLINE
03757 su_inline
03758 #endif
03759 http_etag_t *http_etag_format(su_home_t *home, char const *fmt, ...)
03760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
03761 
03762 
03763 /* Inlined functions */
03764 #if SU_HAVE_INLINE
03765 su_inline
03766 http_etag_t *http_etag_format(su_home_t *home, char const *fmt, ...)
03767 {
03768   http_header_t *h;
03769   va_list ap;
03770   
03771   va_start(ap, fmt);
03772   h = http_header_vformat(home, http_etag_class, fmt, ap);
03773   va_end(ap);
03774  
03775   return (http_etag_t *)h;
03776 }
03777 
03778 su_inline
03779 http_etag_t *http_etag_dup(su_home_t *home, http_etag_t const *o) 
03780 { 
03781   return (http_etag_t *)
03782     msg_header_dup_as(home, http_etag_class, (msg_header_t const *)o);
03783 }
03784 
03785 su_inline
03786 http_etag_t *http_etag_copy(su_home_t *home, http_etag_t const *o) 
03787 { 
03788   return (http_etag_t *)
03789     msg_header_copy_as(home, http_etag_class, (msg_header_t const *)o); 
03790 }
03791 
03792 su_inline 
03793 http_etag_t *http_etag_make(su_home_t *home, char const *s)
03794 {
03795   return (http_etag_t *)http_header_make(home, http_etag_class, s);
03796 }
03797 #endif
03798 
03799 #endif /* !define HTTP_HCLASSES_ONLY */
03800 
03804 /* Declare internal prototypes for Expect header */
03805  
03808 enum { 
03810   http_expect_hash = 30389 
03811 };
03812 
03821 SOFIAPUBVAR msg_hclass_t http_expect_class[];
03822 
03823 #ifndef HTTP_HCLASSES_ONLY
03824 
03826 SOFIAPUBFUN msg_parse_f http_expect_d;
03827 
03829 SOFIAPUBFUN msg_print_f http_expect_e;
03830 
03842 #define HTTP_EXPECT_INIT() HTTP_HDR_INIT(expect)
03843 
03857 #if SU_HAVE_INLINE
03858 su_inline http_expect_t *http_expect_init(http_expect_t x[1])
03859 {
03860   return HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t));
03861 }
03862 #else
03863 #define http_expect_init(x) \
03864   HTTP_HEADER_INIT(x, http_expect_class, sizeof(http_expect_t))
03865 #endif
03866 
03880 #if SU_HAVE_INLINE
03881 su_inline 
03882 int http_is_expect(http_header_t const *header)
03883 {
03884   return header && header->sh_class->hc_hash == http_expect_hash;
03885 }
03886 #else
03887 #define http_is_expect(h) \
03888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expect_hash)
03889 #endif
03890 
03918 #if SU_HAVE_INLINE
03919 su_inline
03920 #endif
03921 http_expect_t *http_expect_dup(su_home_t *home, 
03922                                    http_expect_t const *hdr)
03923      __attribute__((__malloc__));
03924 
03953 #if SU_HAVE_INLINE
03954 su_inline
03955 #endif
03956 http_expect_t *http_expect_copy(su_home_t *home, 
03957                                     http_expect_t const *hdr)
03958      __attribute__((__malloc__));
03959 
03978 #if SU_HAVE_INLINE
03979 su_inline
03980 #endif
03981 http_expect_t *http_expect_make(su_home_t *home, char const *s)
03982      __attribute__((__malloc__));
03983 
04006 #if SU_HAVE_INLINE
04007 su_inline
04008 #endif
04009 http_expect_t *http_expect_format(su_home_t *home, char const *fmt, ...)
04010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
04011 
04012 
04013 /* Inlined functions */
04014 #if SU_HAVE_INLINE
04015 su_inline
04016 http_expect_t *http_expect_format(su_home_t *home, char const *fmt, ...)
04017 {
04018   http_header_t *h;
04019   va_list ap;
04020   
04021   va_start(ap, fmt);
04022   h = http_header_vformat(home, http_expect_class, fmt, ap);
04023   va_end(ap);
04024  
04025   return (http_expect_t *)h;
04026 }
04027 
04028 su_inline
04029 http_expect_t *http_expect_dup(su_home_t *home, http_expect_t const *o) 
04030 { 
04031   return (http_expect_t *)
04032     msg_header_dup_as(home, http_expect_class, (msg_header_t const *)o);
04033 }
04034 
04035 su_inline
04036 http_expect_t *http_expect_copy(su_home_t *home, http_expect_t const *o) 
04037 { 
04038   return (http_expect_t *)
04039     msg_header_copy_as(home, http_expect_class, (msg_header_t const *)o); 
04040 }
04041 
04042 su_inline 
04043 http_expect_t *http_expect_make(su_home_t *home, char const *s)
04044 {
04045   return (http_expect_t *)http_header_make(home, http_expect_class, s);
04046 }
04047 #endif
04048 
04049 #endif /* !define HTTP_HCLASSES_ONLY */
04050 
04054 /* Declare internal prototypes for Expires header */
04055  
04058 enum { 
04060   http_expires_hash = 28680 
04061 };
04062 
04071 SOFIAPUBVAR msg_hclass_t http_expires_class[];
04072 
04073 #ifndef HTTP_HCLASSES_ONLY
04074 
04076 SOFIAPUBFUN msg_parse_f http_expires_d;
04077 
04079 SOFIAPUBFUN msg_print_f http_expires_e;
04080 
04092 #define HTTP_EXPIRES_INIT() HTTP_HDR_INIT(expires)
04093 
04107 #if SU_HAVE_INLINE
04108 su_inline http_expires_t *http_expires_init(http_expires_t x[1])
04109 {
04110   return HTTP_HEADER_INIT(x, http_expires_class, sizeof(http_expires_t));
04111 }
04112 #else
04113 #define http_expires_init(x) \
04114   HTTP_HEADER_INIT(x, http_expires_class, sizeof(http_expires_t))
04115 #endif
04116 
04130 #if SU_HAVE_INLINE
04131 su_inline 
04132 int http_is_expires(http_header_t const *header)
04133 {
04134   return header && header->sh_class->hc_hash == http_expires_hash;
04135 }
04136 #else
04137 #define http_is_expires(h) \
04138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_expires_hash)
04139 #endif
04140 
04168 #if SU_HAVE_INLINE
04169 su_inline
04170 #endif
04171 http_expires_t *http_expires_dup(su_home_t *home, 
04172                                    http_expires_t const *hdr)
04173      __attribute__((__malloc__));
04174 
04203 #if SU_HAVE_INLINE
04204 su_inline
04205 #endif
04206 http_expires_t *http_expires_copy(su_home_t *home, 
04207                                     http_expires_t const *hdr)
04208      __attribute__((__malloc__));
04209 
04228 #if SU_HAVE_INLINE
04229 su_inline
04230 #endif
04231 http_expires_t *http_expires_make(su_home_t *home, char const *s)
04232      __attribute__((__malloc__));
04233 
04256 #if SU_HAVE_INLINE
04257 su_inline
04258 #endif
04259 http_expires_t *http_expires_format(su_home_t *home, char const *fmt, ...)
04260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
04261 
04262 
04263 /* Inlined functions */
04264 #if SU_HAVE_INLINE
04265 su_inline
04266 http_expires_t *http_expires_format(su_home_t *home, char const *fmt, ...)
04267 {
04268   http_header_t *h;
04269   va_list ap;
04270   
04271   va_start(ap, fmt);
04272   h = http_header_vformat(home, http_expires_class, fmt, ap);
04273   va_end(ap);
04274  
04275   return (http_expires_t *)h;
04276 }
04277 
04278 su_inline
04279 http_expires_t *http_expires_dup(su_home_t *home, http_expires_t const *o) 
04280 { 
04281   return (http_expires_t *)
04282     msg_header_dup_as(home, http_expires_class, (msg_header_t const *)o);
04283 }
04284 
04285 su_inline
04286 http_expires_t *http_expires_copy(su_home_t *home, http_expires_t const *o) 
04287 { 
04288   return (http_expires_t *)
04289     msg_header_copy_as(home, http_expires_class, (msg_header_t const *)o); 
04290 }
04291 
04292 su_inline 
04293 http_expires_t *http_expires_make(su_home_t *home, char const *s)
04294 {
04295   return (http_expires_t *)http_header_make(home, http_expires_class, s);
04296 }
04297 #endif
04298 
04299 #endif /* !define HTTP_HCLASSES_ONLY */
04300 
04304 /* Declare internal prototypes for From header */
04305  
04308 enum { 
04310   http_from_hash = 15368 
04311 };
04312 
04321 SOFIAPUBVAR msg_hclass_t http_from_class[];
04322 
04323 #ifndef HTTP_HCLASSES_ONLY
04324 
04326 SOFIAPUBFUN msg_parse_f http_from_d;
04327 
04329 SOFIAPUBFUN msg_print_f http_from_e;
04330 
04342 #define HTTP_FROM_INIT() HTTP_HDR_INIT(from)
04343 
04357 #if SU_HAVE_INLINE
04358 su_inline http_from_t *http_from_init(http_from_t x[1])
04359 {
04360   return HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t));
04361 }
04362 #else
04363 #define http_from_init(x) \
04364   HTTP_HEADER_INIT(x, http_from_class, sizeof(http_from_t))
04365 #endif
04366 
04380 #if SU_HAVE_INLINE
04381 su_inline 
04382 int http_is_from(http_header_t const *header)
04383 {
04384   return header && header->sh_class->hc_hash == http_from_hash;
04385 }
04386 #else
04387 #define http_is_from(h) \
04388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_from_hash)
04389 #endif
04390 
04418 #if SU_HAVE_INLINE
04419 su_inline
04420 #endif
04421 http_from_t *http_from_dup(su_home_t *home, 
04422                                    http_from_t const *hdr)
04423      __attribute__((__malloc__));
04424 
04453 #if SU_HAVE_INLINE
04454 su_inline
04455 #endif
04456 http_from_t *http_from_copy(su_home_t *home, 
04457                                     http_from_t const *hdr)
04458      __attribute__((__malloc__));
04459 
04478 #if SU_HAVE_INLINE
04479 su_inline
04480 #endif
04481 http_from_t *http_from_make(su_home_t *home, char const *s)
04482      __attribute__((__malloc__));
04483 
04506 #if SU_HAVE_INLINE
04507 su_inline
04508 #endif
04509 http_from_t *http_from_format(su_home_t *home, char const *fmt, ...)
04510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
04511 
04512 
04513 /* Inlined functions */
04514 #if SU_HAVE_INLINE
04515 su_inline
04516 http_from_t *http_from_format(su_home_t *home, char const *fmt, ...)
04517 {
04518   http_header_t *h;
04519   va_list ap;
04520   
04521   va_start(ap, fmt);
04522   h = http_header_vformat(home, http_from_class, fmt, ap);
04523   va_end(ap);
04524  
04525   return (http_from_t *)h;
04526 }
04527 
04528 su_inline
04529 http_from_t *http_from_dup(su_home_t *home, http_from_t const *o) 
04530 { 
04531   return (http_from_t *)
04532     msg_header_dup_as(home, http_from_class, (msg_header_t const *)o);
04533 }
04534 
04535 su_inline
04536 http_from_t *http_from_copy(su_home_t *home, http_from_t const *o) 
04537 { 
04538   return (http_from_t *)
04539     msg_header_copy_as(home, http_from_class, (msg_header_t const *)o); 
04540 }
04541 
04542 su_inline 
04543 http_from_t *http_from_make(su_home_t *home, char const *s)
04544 {
04545   return (http_from_t *)http_header_make(home, http_from_class, s);
04546 }
04547 #endif
04548 
04549 #endif /* !define HTTP_HCLASSES_ONLY */
04550 
04554 /* Declare internal prototypes for Host header */
04555  
04558 enum { 
04560   http_host_hash = 33850 
04561 };
04562 
04571 SOFIAPUBVAR msg_hclass_t http_host_class[];
04572 
04573 #ifndef HTTP_HCLASSES_ONLY
04574 
04576 SOFIAPUBFUN msg_parse_f http_host_d;
04577 
04579 SOFIAPUBFUN msg_print_f http_host_e;
04580 
04592 #define HTTP_HOST_INIT() HTTP_HDR_INIT(host)
04593 
04607 #if SU_HAVE_INLINE
04608 su_inline http_host_t *http_host_init(http_host_t x[1])
04609 {
04610   return HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t));
04611 }
04612 #else
04613 #define http_host_init(x) \
04614   HTTP_HEADER_INIT(x, http_host_class, sizeof(http_host_t))
04615 #endif
04616 
04630 #if SU_HAVE_INLINE
04631 su_inline 
04632 int http_is_host(http_header_t const *header)
04633 {
04634   return header && header->sh_class->hc_hash == http_host_hash;
04635 }
04636 #else
04637 #define http_is_host(h) \
04638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_host_hash)
04639 #endif
04640 
04668 #if SU_HAVE_INLINE
04669 su_inline
04670 #endif
04671 http_host_t *http_host_dup(su_home_t *home, 
04672                                    http_host_t const *hdr)
04673      __attribute__((__malloc__));
04674 
04703 #if SU_HAVE_INLINE
04704 su_inline
04705 #endif
04706 http_host_t *http_host_copy(su_home_t *home, 
04707                                     http_host_t const *hdr)
04708      __attribute__((__malloc__));
04709 
04728 #if SU_HAVE_INLINE
04729 su_inline
04730 #endif
04731 http_host_t *http_host_make(su_home_t *home, char const *s)
04732      __attribute__((__malloc__));
04733 
04756 #if SU_HAVE_INLINE
04757 su_inline
04758 #endif
04759 http_host_t *http_host_format(su_home_t *home, char const *fmt, ...)
04760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
04761 
04762 
04763 /* Inlined functions */
04764 #if SU_HAVE_INLINE
04765 su_inline
04766 http_host_t *http_host_format(su_home_t *home, char const *fmt, ...)
04767 {
04768   http_header_t *h;
04769   va_list ap;
04770   
04771   va_start(ap, fmt);
04772   h = http_header_vformat(home, http_host_class, fmt, ap);
04773   va_end(ap);
04774  
04775   return (http_host_t *)h;
04776 }
04777 
04778 su_inline
04779 http_host_t *http_host_dup(su_home_t *home, http_host_t const *o) 
04780 { 
04781   return (http_host_t *)
04782     msg_header_dup_as(home, http_host_class, (msg_header_t const *)o);
04783 }
04784 
04785 su_inline
04786 http_host_t *http_host_copy(su_home_t *home, http_host_t const *o) 
04787 { 
04788   return (http_host_t *)
04789     msg_header_copy_as(home, http_host_class, (msg_header_t const *)o); 
04790 }
04791 
04792 su_inline 
04793 http_host_t *http_host_make(su_home_t *home, char const *s)
04794 {
04795   return (http_host_t *)http_header_make(home, http_host_class, s);
04796 }
04797 #endif
04798 
04799 #endif /* !define HTTP_HCLASSES_ONLY */
04800 
04804 /* Declare internal prototypes for If-Match header */
04805  
04808 enum { 
04810   http_if_match_hash = 805 
04811 };
04812 
04821 SOFIAPUBVAR msg_hclass_t http_if_match_class[];
04822 
04823 #ifndef HTTP_HCLASSES_ONLY
04824 
04826 SOFIAPUBFUN msg_parse_f http_if_match_d;
04827 
04829 SOFIAPUBFUN msg_print_f http_if_match_e;
04830 
04842 #define HTTP_IF_MATCH_INIT() HTTP_HDR_INIT(if_match)
04843 
04857 #if SU_HAVE_INLINE
04858 su_inline http_if_match_t *http_if_match_init(http_if_match_t x[1])
04859 {
04860   return HTTP_HEADER_INIT(x, http_if_match_class, sizeof(http_if_match_t));
04861 }
04862 #else
04863 #define http_if_match_init(x) \
04864   HTTP_HEADER_INIT(x, http_if_match_class, sizeof(http_if_match_t))
04865 #endif
04866 
04880 #if SU_HAVE_INLINE
04881 su_inline 
04882 int http_is_if_match(http_header_t const *header)
04883 {
04884   return header && header->sh_class->hc_hash == http_if_match_hash;
04885 }
04886 #else
04887 #define http_is_if_match(h) \
04888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_match_hash)
04889 #endif
04890 
04918 #if SU_HAVE_INLINE
04919 su_inline
04920 #endif
04921 http_if_match_t *http_if_match_dup(su_home_t *home, 
04922                                    http_if_match_t const *hdr)
04923      __attribute__((__malloc__));
04924 
04953 #if SU_HAVE_INLINE
04954 su_inline
04955 #endif
04956 http_if_match_t *http_if_match_copy(su_home_t *home, 
04957                                     http_if_match_t const *hdr)
04958      __attribute__((__malloc__));
04959 
04978 #if SU_HAVE_INLINE
04979 su_inline
04980 #endif
04981 http_if_match_t *http_if_match_make(su_home_t *home, char const *s)
04982      __attribute__((__malloc__));
04983 
05006 #if SU_HAVE_INLINE
05007 su_inline
05008 #endif
05009 http_if_match_t *http_if_match_format(su_home_t *home, char const *fmt, ...)
05010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
05011 
05012 
05013 /* Inlined functions */
05014 #if SU_HAVE_INLINE
05015 su_inline
05016 http_if_match_t *http_if_match_format(su_home_t *home, char const *fmt, ...)
05017 {
05018   http_header_t *h;
05019   va_list ap;
05020   
05021   va_start(ap, fmt);
05022   h = http_header_vformat(home, http_if_match_class, fmt, ap);
05023   va_end(ap);
05024  
05025   return (http_if_match_t *)h;
05026 }
05027 
05028 su_inline
05029 http_if_match_t *http_if_match_dup(su_home_t *home, http_if_match_t const *o) 
05030 { 
05031   return (http_if_match_t *)
05032     msg_header_dup_as(home, http_if_match_class, (msg_header_t const *)o);
05033 }
05034 
05035 su_inline
05036 http_if_match_t *http_if_match_copy(su_home_t *home, http_if_match_t const *o) 
05037 { 
05038   return (http_if_match_t *)
05039     msg_header_copy_as(home, http_if_match_class, (msg_header_t const *)o); 
05040 }
05041 
05042 su_inline 
05043 http_if_match_t *http_if_match_make(su_home_t *home, char const *s)
05044 {
05045   return (http_if_match_t *)http_header_make(home, http_if_match_class, s);
05046 }
05047 #endif
05048 
05049 #endif /* !define HTTP_HCLASSES_ONLY */
05050 
05054 /* Declare internal prototypes for If-Modified-Since header */
05055  
05058 enum { 
05060   http_if_modified_since_hash = 4424 
05061 };
05062 
05071 SOFIAPUBVAR msg_hclass_t http_if_modified_since_class[];
05072 
05073 #ifndef HTTP_HCLASSES_ONLY
05074 
05076 SOFIAPUBFUN msg_parse_f http_if_modified_since_d;
05077 
05079 SOFIAPUBFUN msg_print_f http_if_modified_since_e;
05080 
05092 #define HTTP_IF_MODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_modified_since)
05093 
05107 #if SU_HAVE_INLINE
05108 su_inline http_if_modified_since_t *http_if_modified_since_init(http_if_modified_since_t x[1])
05109 {
05110   return HTTP_HEADER_INIT(x, http_if_modified_since_class, sizeof(http_if_modified_since_t));
05111 }
05112 #else
05113 #define http_if_modified_since_init(x) \
05114   HTTP_HEADER_INIT(x, http_if_modified_since_class, sizeof(http_if_modified_since_t))
05115 #endif
05116 
05130 #if SU_HAVE_INLINE
05131 su_inline 
05132 int http_is_if_modified_since(http_header_t const *header)
05133 {
05134   return header && header->sh_class->hc_hash == http_if_modified_since_hash;
05135 }
05136 #else
05137 #define http_is_if_modified_since(h) \
05138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_modified_since_hash)
05139 #endif
05140 
05168 #if SU_HAVE_INLINE
05169 su_inline
05170 #endif
05171 http_if_modified_since_t *http_if_modified_since_dup(su_home_t *home, 
05172                                    http_if_modified_since_t const *hdr)
05173      __attribute__((__malloc__));
05174 
05203 #if SU_HAVE_INLINE
05204 su_inline
05205 #endif
05206 http_if_modified_since_t *http_if_modified_since_copy(su_home_t *home, 
05207                                     http_if_modified_since_t const *hdr)
05208      __attribute__((__malloc__));
05209 
05228 #if SU_HAVE_INLINE
05229 su_inline
05230 #endif
05231 http_if_modified_since_t *http_if_modified_since_make(su_home_t *home, char const *s)
05232      __attribute__((__malloc__));
05233 
05256 #if SU_HAVE_INLINE
05257 su_inline
05258 #endif
05259 http_if_modified_since_t *http_if_modified_since_format(su_home_t *home, char const *fmt, ...)
05260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
05261 
05262 
05263 /* Inlined functions */
05264 #if SU_HAVE_INLINE
05265 su_inline
05266 http_if_modified_since_t *http_if_modified_since_format(su_home_t *home, char const *fmt, ...)
05267 {
05268   http_header_t *h;
05269   va_list ap;
05270   
05271   va_start(ap, fmt);
05272   h = http_header_vformat(home, http_if_modified_since_class, fmt, ap);
05273   va_end(ap);
05274  
05275   return (http_if_modified_since_t *)h;
05276 }
05277 
05278 su_inline
05279 http_if_modified_since_t *http_if_modified_since_dup(su_home_t *home, http_if_modified_since_t const *o) 
05280 { 
05281   return (http_if_modified_since_t *)
05282     msg_header_dup_as(home, http_if_modified_since_class, (msg_header_t const *)o);
05283 }
05284 
05285 su_inline
05286 http_if_modified_since_t *http_if_modified_since_copy(su_home_t *home, http_if_modified_since_t const *o) 
05287 { 
05288   return (http_if_modified_since_t *)
05289     msg_header_copy_as(home, http_if_modified_since_class, (msg_header_t const *)o); 
05290 }
05291 
05292 su_inline 
05293 http_if_modified_since_t *http_if_modified_since_make(su_home_t *home, char const *s)
05294 {
05295   return (http_if_modified_since_t *)http_header_make(home, http_if_modified_since_class, s);
05296 }
05297 #endif
05298 
05299 #endif /* !define HTTP_HCLASSES_ONLY */
05300 
05304 /* Declare internal prototypes for If-None-Match header */
05305  
05308 enum { 
05310   http_if_none_match_hash = 64610 
05311 };
05312 
05321 SOFIAPUBVAR msg_hclass_t http_if_none_match_class[];
05322 
05323 #ifndef HTTP_HCLASSES_ONLY
05324 
05326 SOFIAPUBFUN msg_parse_f http_if_none_match_d;
05327 
05329 SOFIAPUBFUN msg_print_f http_if_none_match_e;
05330 
05342 #define HTTP_IF_NONE_MATCH_INIT() HTTP_HDR_INIT(if_none_match)
05343 
05357 #if SU_HAVE_INLINE
05358 su_inline http_if_none_match_t *http_if_none_match_init(http_if_none_match_t x[1])
05359 {
05360   return HTTP_HEADER_INIT(x, http_if_none_match_class, sizeof(http_if_none_match_t));
05361 }
05362 #else
05363 #define http_if_none_match_init(x) \
05364   HTTP_HEADER_INIT(x, http_if_none_match_class, sizeof(http_if_none_match_t))
05365 #endif
05366 
05380 #if SU_HAVE_INLINE
05381 su_inline 
05382 int http_is_if_none_match(http_header_t const *header)
05383 {
05384   return header && header->sh_class->hc_hash == http_if_none_match_hash;
05385 }
05386 #else
05387 #define http_is_if_none_match(h) \
05388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_none_match_hash)
05389 #endif
05390 
05418 #if SU_HAVE_INLINE
05419 su_inline
05420 #endif
05421 http_if_none_match_t *http_if_none_match_dup(su_home_t *home, 
05422                                    http_if_none_match_t const *hdr)
05423      __attribute__((__malloc__));
05424 
05453 #if SU_HAVE_INLINE
05454 su_inline
05455 #endif
05456 http_if_none_match_t *http_if_none_match_copy(su_home_t *home, 
05457                                     http_if_none_match_t const *hdr)
05458      __attribute__((__malloc__));
05459 
05478 #if SU_HAVE_INLINE
05479 su_inline
05480 #endif
05481 http_if_none_match_t *http_if_none_match_make(su_home_t *home, char const *s)
05482      __attribute__((__malloc__));
05483 
05506 #if SU_HAVE_INLINE
05507 su_inline
05508 #endif
05509 http_if_none_match_t *http_if_none_match_format(su_home_t *home, char const *fmt, ...)
05510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
05511 
05512 
05513 /* Inlined functions */
05514 #if SU_HAVE_INLINE
05515 su_inline
05516 http_if_none_match_t *http_if_none_match_format(su_home_t *home, char const *fmt, ...)
05517 {
05518   http_header_t *h;
05519   va_list ap;
05520   
05521   va_start(ap, fmt);
05522   h = http_header_vformat(home, http_if_none_match_class, fmt, ap);
05523   va_end(ap);
05524  
05525   return (http_if_none_match_t *)h;
05526 }
05527 
05528 su_inline
05529 http_if_none_match_t *http_if_none_match_dup(su_home_t *home, http_if_none_match_t const *o) 
05530 { 
05531   return (http_if_none_match_t *)
05532     msg_header_dup_as(home, http_if_none_match_class, (msg_header_t const *)o);
05533 }
05534 
05535 su_inline
05536 http_if_none_match_t *http_if_none_match_copy(su_home_t *home, http_if_none_match_t const *o) 
05537 { 
05538   return (http_if_none_match_t *)
05539     msg_header_copy_as(home, http_if_none_match_class, (msg_header_t const *)o); 
05540 }
05541 
05542 su_inline 
05543 http_if_none_match_t *http_if_none_match_make(su_home_t *home, char const *s)
05544 {
05545   return (http_if_none_match_t *)http_header_make(home, http_if_none_match_class, s);
05546 }
05547 #endif
05548 
05549 #endif /* !define HTTP_HCLASSES_ONLY */
05550 
05554 /* Declare internal prototypes for If-Range header */
05555  
05558 enum { 
05560   http_if_range_hash = 40469 
05561 };
05562 
05571 SOFIAPUBVAR msg_hclass_t http_if_range_class[];
05572 
05573 #ifndef HTTP_HCLASSES_ONLY
05574 
05576 SOFIAPUBFUN msg_parse_f http_if_range_d;
05577 
05579 SOFIAPUBFUN msg_print_f http_if_range_e;
05580 
05592 #define HTTP_IF_RANGE_INIT() HTTP_HDR_INIT(if_range)
05593 
05607 #if SU_HAVE_INLINE
05608 su_inline http_if_range_t *http_if_range_init(http_if_range_t x[1])
05609 {
05610   return HTTP_HEADER_INIT(x, http_if_range_class, sizeof(http_if_range_t));
05611 }
05612 #else
05613 #define http_if_range_init(x) \
05614   HTTP_HEADER_INIT(x, http_if_range_class, sizeof(http_if_range_t))
05615 #endif
05616 
05630 #if SU_HAVE_INLINE
05631 su_inline 
05632 int http_is_if_range(http_header_t const *header)
05633 {
05634   return header && header->sh_class->hc_hash == http_if_range_hash;
05635 }
05636 #else
05637 #define http_is_if_range(h) \
05638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_range_hash)
05639 #endif
05640 
05668 #if SU_HAVE_INLINE
05669 su_inline
05670 #endif
05671 http_if_range_t *http_if_range_dup(su_home_t *home, 
05672                                    http_if_range_t const *hdr)
05673      __attribute__((__malloc__));
05674 
05703 #if SU_HAVE_INLINE
05704 su_inline
05705 #endif
05706 http_if_range_t *http_if_range_copy(su_home_t *home, 
05707                                     http_if_range_t const *hdr)
05708      __attribute__((__malloc__));
05709 
05728 #if SU_HAVE_INLINE
05729 su_inline
05730 #endif
05731 http_if_range_t *http_if_range_make(su_home_t *home, char const *s)
05732      __attribute__((__malloc__));
05733 
05756 #if SU_HAVE_INLINE
05757 su_inline
05758 #endif
05759 http_if_range_t *http_if_range_format(su_home_t *home, char const *fmt, ...)
05760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
05761 
05762 
05763 /* Inlined functions */
05764 #if SU_HAVE_INLINE
05765 su_inline
05766 http_if_range_t *http_if_range_format(su_home_t *home, char const *fmt, ...)
05767 {
05768   http_header_t *h;
05769   va_list ap;
05770   
05771   va_start(ap, fmt);
05772   h = http_header_vformat(home, http_if_range_class, fmt, ap);
05773   va_end(ap);
05774  
05775   return (http_if_range_t *)h;
05776 }
05777 
05778 su_inline
05779 http_if_range_t *http_if_range_dup(su_home_t *home, http_if_range_t const *o) 
05780 { 
05781   return (http_if_range_t *)
05782     msg_header_dup_as(home, http_if_range_class, (msg_header_t const *)o);
05783 }
05784 
05785 su_inline
05786 http_if_range_t *http_if_range_copy(su_home_t *home, http_if_range_t const *o) 
05787 { 
05788   return (http_if_range_t *)
05789     msg_header_copy_as(home, http_if_range_class, (msg_header_t const *)o); 
05790 }
05791 
05792 su_inline 
05793 http_if_range_t *http_if_range_make(su_home_t *home, char const *s)
05794 {
05795   return (http_if_range_t *)http_header_make(home, http_if_range_class, s);
05796 }
05797 #endif
05798 
05799 #endif /* !define HTTP_HCLASSES_ONLY */
05800 
05804 /* Declare internal prototypes for If-Unmodified-Since header */
05805  
05808 enum { 
05810   http_if_unmodified_since_hash = 2675 
05811 };
05812 
05821 SOFIAPUBVAR msg_hclass_t http_if_unmodified_since_class[];
05822 
05823 #ifndef HTTP_HCLASSES_ONLY
05824 
05826 SOFIAPUBFUN msg_parse_f http_if_unmodified_since_d;
05827 
05829 SOFIAPUBFUN msg_print_f http_if_unmodified_since_e;
05830 
05842 #define HTTP_IF_UNMODIFIED_SINCE_INIT() HTTP_HDR_INIT(if_unmodified_since)
05843 
05857 #if SU_HAVE_INLINE
05858 su_inline http_if_unmodified_since_t *http_if_unmodified_since_init(http_if_unmodified_since_t x[1])
05859 {
05860   return HTTP_HEADER_INIT(x, http_if_unmodified_since_class, sizeof(http_if_unmodified_since_t));
05861 }
05862 #else
05863 #define http_if_unmodified_since_init(x) \
05864   HTTP_HEADER_INIT(x, http_if_unmodified_since_class, sizeof(http_if_unmodified_since_t))
05865 #endif
05866 
05880 #if SU_HAVE_INLINE
05881 su_inline 
05882 int http_is_if_unmodified_since(http_header_t const *header)
05883 {
05884   return header && header->sh_class->hc_hash == http_if_unmodified_since_hash;
05885 }
05886 #else
05887 #define http_is_if_unmodified_since(h) \
05888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_if_unmodified_since_hash)
05889 #endif
05890 
05918 #if SU_HAVE_INLINE
05919 su_inline
05920 #endif
05921 http_if_unmodified_since_t *http_if_unmodified_since_dup(su_home_t *home, 
05922                                    http_if_unmodified_since_t const *hdr)
05923      __attribute__((__malloc__));
05924 
05953 #if SU_HAVE_INLINE
05954 su_inline
05955 #endif
05956 http_if_unmodified_since_t *http_if_unmodified_since_copy(su_home_t *home, 
05957                                     http_if_unmodified_since_t const *hdr)
05958      __attribute__((__malloc__));
05959 
05978 #if SU_HAVE_INLINE
05979 su_inline
05980 #endif
05981 http_if_unmodified_since_t *http_if_unmodified_since_make(su_home_t *home, char const *s)
05982      __attribute__((__malloc__));
05983 
06006 #if SU_HAVE_INLINE
06007 su_inline
06008 #endif
06009 http_if_unmodified_since_t *http_if_unmodified_since_format(su_home_t *home, char const *fmt, ...)
06010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
06011 
06012 
06013 /* Inlined functions */
06014 #if SU_HAVE_INLINE
06015 su_inline
06016 http_if_unmodified_since_t *http_if_unmodified_since_format(su_home_t *home, char const *fmt, ...)
06017 {
06018   http_header_t *h;
06019   va_list ap;
06020   
06021   va_start(ap, fmt);
06022   h = http_header_vformat(home, http_if_unmodified_since_class, fmt, ap);
06023   va_end(ap);
06024  
06025   return (http_if_unmodified_since_t *)h;
06026 }
06027 
06028 su_inline
06029 http_if_unmodified_since_t *http_if_unmodified_since_dup(su_home_t *home, http_if_unmodified_since_t const *o) 
06030 { 
06031   return (http_if_unmodified_since_t *)
06032     msg_header_dup_as(home, http_if_unmodified_since_class, (msg_header_t const *)o);
06033 }
06034 
06035 su_inline
06036 http_if_unmodified_since_t *http_if_unmodified_since_copy(su_home_t *home, http_if_unmodified_since_t const *o) 
06037 { 
06038   return (http_if_unmodified_since_t *)
06039     msg_header_copy_as(home, http_if_unmodified_since_class, (msg_header_t const *)o); 
06040 }
06041 
06042 su_inline 
06043 http_if_unmodified_since_t *http_if_unmodified_since_make(su_home_t *home, char const *s)
06044 {
06045   return (http_if_unmodified_since_t *)http_header_make(home, http_if_unmodified_since_class, s);
06046 }
06047 #endif
06048 
06049 #endif /* !define HTTP_HCLASSES_ONLY */
06050 
06054 /* Declare internal prototypes for Last-Modified header */
06055  
06058 enum { 
06060   http_last_modified_hash = 19958 
06061 };
06062 
06071 SOFIAPUBVAR msg_hclass_t http_last_modified_class[];
06072 
06073 #ifndef HTTP_HCLASSES_ONLY
06074 
06076 SOFIAPUBFUN msg_parse_f http_last_modified_d;
06077 
06079 SOFIAPUBFUN msg_print_f http_last_modified_e;
06080 
06092 #define HTTP_LAST_MODIFIED_INIT() HTTP_HDR_INIT(last_modified)
06093 
06107 #if SU_HAVE_INLINE
06108 su_inline http_last_modified_t *http_last_modified_init(http_last_modified_t x[1])
06109 {
06110   return HTTP_HEADER_INIT(x, http_last_modified_class, sizeof(http_last_modified_t));
06111 }
06112 #else
06113 #define http_last_modified_init(x) \
06114   HTTP_HEADER_INIT(x, http_last_modified_class, sizeof(http_last_modified_t))
06115 #endif
06116 
06130 #if SU_HAVE_INLINE
06131 su_inline 
06132 int http_is_last_modified(http_header_t const *header)
06133 {
06134   return header && header->sh_class->hc_hash == http_last_modified_hash;
06135 }
06136 #else
06137 #define http_is_last_modified(h) \
06138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_last_modified_hash)
06139 #endif
06140 
06168 #if SU_HAVE_INLINE
06169 su_inline
06170 #endif
06171 http_last_modified_t *http_last_modified_dup(su_home_t *home, 
06172                                    http_last_modified_t const *hdr)
06173      __attribute__((__malloc__));
06174 
06203 #if SU_HAVE_INLINE
06204 su_inline
06205 #endif
06206 http_last_modified_t *http_last_modified_copy(su_home_t *home, 
06207                                     http_last_modified_t const *hdr)
06208      __attribute__((__malloc__));
06209 
06228 #if SU_HAVE_INLINE
06229 su_inline
06230 #endif
06231 http_last_modified_t *http_last_modified_make(su_home_t *home, char const *s)
06232      __attribute__((__malloc__));
06233 
06256 #if SU_HAVE_INLINE
06257 su_inline
06258 #endif
06259 http_last_modified_t *http_last_modified_format(su_home_t *home, char const *fmt, ...)
06260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
06261 
06262 
06263 /* Inlined functions */
06264 #if SU_HAVE_INLINE
06265 su_inline
06266 http_last_modified_t *http_last_modified_format(su_home_t *home, char const *fmt, ...)
06267 {
06268   http_header_t *h;
06269   va_list ap;
06270   
06271   va_start(ap, fmt);
06272   h = http_header_vformat(home, http_last_modified_class, fmt, ap);
06273   va_end(ap);
06274  
06275   return (http_last_modified_t *)h;
06276 }
06277 
06278 su_inline
06279 http_last_modified_t *http_last_modified_dup(su_home_t *home, http_last_modified_t const *o) 
06280 { 
06281   return (http_last_modified_t *)
06282     msg_header_dup_as(home, http_last_modified_class, (msg_header_t const *)o);
06283 }
06284 
06285 su_inline
06286 http_last_modified_t *http_last_modified_copy(su_home_t *home, http_last_modified_t const *o) 
06287 { 
06288   return (http_last_modified_t *)
06289     msg_header_copy_as(home, http_last_modified_class, (msg_header_t const *)o); 
06290 }
06291 
06292 su_inline 
06293 http_last_modified_t *http_last_modified_make(su_home_t *home, char const *s)
06294 {
06295   return (http_last_modified_t *)http_header_make(home, http_last_modified_class, s);
06296 }
06297 #endif
06298 
06299 #endif /* !define HTTP_HCLASSES_ONLY */
06300 
06304 /* Declare internal prototypes for Location header */
06305  
06308 enum { 
06310   http_location_hash = 60949 
06311 };
06312 
06321 SOFIAPUBVAR msg_hclass_t http_location_class[];
06322 
06323 #ifndef HTTP_HCLASSES_ONLY
06324 
06326 SOFIAPUBFUN msg_parse_f http_location_d;
06327 
06329 SOFIAPUBFUN msg_print_f http_location_e;
06330 
06342 #define HTTP_LOCATION_INIT() HTTP_HDR_INIT(location)
06343 
06357 #if SU_HAVE_INLINE
06358 su_inline http_location_t *http_location_init(http_location_t x[1])
06359 {
06360   return HTTP_HEADER_INIT(x, http_location_class, sizeof(http_location_t));
06361 }
06362 #else
06363 #define http_location_init(x) \
06364   HTTP_HEADER_INIT(x, http_location_class, sizeof(http_location_t))
06365 #endif
06366 
06380 #if SU_HAVE_INLINE
06381 su_inline 
06382 int http_is_location(http_header_t const *header)
06383 {
06384   return header && header->sh_class->hc_hash == http_location_hash;
06385 }
06386 #else
06387 #define http_is_location(h) \
06388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_location_hash)
06389 #endif
06390 
06418 #if SU_HAVE_INLINE
06419 su_inline
06420 #endif
06421 http_location_t *http_location_dup(su_home_t *home, 
06422                                    http_location_t const *hdr)
06423      __attribute__((__malloc__));
06424 
06453 #if SU_HAVE_INLINE
06454 su_inline
06455 #endif
06456 http_location_t *http_location_copy(su_home_t *home, 
06457                                     http_location_t const *hdr)
06458      __attribute__((__malloc__));
06459 
06478 #if SU_HAVE_INLINE
06479 su_inline
06480 #endif
06481 http_location_t *http_location_make(su_home_t *home, char const *s)
06482      __attribute__((__malloc__));
06483 
06506 #if SU_HAVE_INLINE
06507 su_inline
06508 #endif
06509 http_location_t *http_location_format(su_home_t *home, char const *fmt, ...)
06510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
06511 
06512 
06513 /* Inlined functions */
06514 #if SU_HAVE_INLINE
06515 su_inline
06516 http_location_t *http_location_format(su_home_t *home, char const *fmt, ...)
06517 {
06518   http_header_t *h;
06519   va_list ap;
06520   
06521   va_start(ap, fmt);
06522   h = http_header_vformat(home, http_location_class, fmt, ap);
06523   va_end(ap);
06524  
06525   return (http_location_t *)h;
06526 }
06527 
06528 su_inline
06529 http_location_t *http_location_dup(su_home_t *home, http_location_t const *o) 
06530 { 
06531   return (http_location_t *)
06532     msg_header_dup_as(home, http_location_class, (msg_header_t const *)o);
06533 }
06534 
06535 su_inline
06536 http_location_t *http_location_copy(su_home_t *home, http_location_t const *o) 
06537 { 
06538   return (http_location_t *)
06539     msg_header_copy_as(home, http_location_class, (msg_header_t const *)o); 
06540 }
06541 
06542 su_inline 
06543 http_location_t *http_location_make(su_home_t *home, char const *s)
06544 {
06545   return (http_location_t *)http_header_make(home, http_location_class, s);
06546 }
06547 #endif
06548 
06549 #endif /* !define HTTP_HCLASSES_ONLY */
06550 
06554 /* Declare internal prototypes for Max-Forwards header */
06555  
06558 enum { 
06560   http_max_forwards_hash = 27231 
06561 };
06562 
06571 SOFIAPUBVAR msg_hclass_t http_max_forwards_class[];
06572 
06573 #ifndef HTTP_HCLASSES_ONLY
06574 
06576 SOFIAPUBFUN msg_parse_f http_max_forwards_d;
06577 
06579 SOFIAPUBFUN msg_print_f http_max_forwards_e;
06580 
06592 #define HTTP_MAX_FORWARDS_INIT() HTTP_HDR_INIT(max_forwards)
06593 
06607 #if SU_HAVE_INLINE
06608 su_inline http_max_forwards_t *http_max_forwards_init(http_max_forwards_t x[1])
06609 {
06610   return HTTP_HEADER_INIT(x, http_max_forwards_class, sizeof(http_max_forwards_t));
06611 }
06612 #else
06613 #define http_max_forwards_init(x) \
06614   HTTP_HEADER_INIT(x, http_max_forwards_class, sizeof(http_max_forwards_t))
06615 #endif
06616 
06630 #if SU_HAVE_INLINE
06631 su_inline 
06632 int http_is_max_forwards(http_header_t const *header)
06633 {
06634   return header && header->sh_class->hc_hash == http_max_forwards_hash;
06635 }
06636 #else
06637 #define http_is_max_forwards(h) \
06638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_max_forwards_hash)
06639 #endif
06640 
06668 #if SU_HAVE_INLINE
06669 su_inline
06670 #endif
06671 http_max_forwards_t *http_max_forwards_dup(su_home_t *home, 
06672                                    http_max_forwards_t const *hdr)
06673      __attribute__((__malloc__));
06674 
06703 #if SU_HAVE_INLINE
06704 su_inline
06705 #endif
06706 http_max_forwards_t *http_max_forwards_copy(su_home_t *home, 
06707                                     http_max_forwards_t const *hdr)
06708      __attribute__((__malloc__));
06709 
06728 #if SU_HAVE_INLINE
06729 su_inline
06730 #endif
06731 http_max_forwards_t *http_max_forwards_make(su_home_t *home, char const *s)
06732      __attribute__((__malloc__));
06733 
06756 #if SU_HAVE_INLINE
06757 su_inline
06758 #endif
06759 http_max_forwards_t *http_max_forwards_format(su_home_t *home, char const *fmt, ...)
06760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
06761 
06762 
06763 /* Inlined functions */
06764 #if SU_HAVE_INLINE
06765 su_inline
06766 http_max_forwards_t *http_max_forwards_format(su_home_t *home, char const *fmt, ...)
06767 {
06768   http_header_t *h;
06769   va_list ap;
06770   
06771   va_start(ap, fmt);
06772   h = http_header_vformat(home, http_max_forwards_class, fmt, ap);
06773   va_end(ap);
06774  
06775   return (http_max_forwards_t *)h;
06776 }
06777 
06778 su_inline
06779 http_max_forwards_t *http_max_forwards_dup(su_home_t *home, http_max_forwards_t const *o) 
06780 { 
06781   return (http_max_forwards_t *)
06782     msg_header_dup_as(home, http_max_forwards_class, (msg_header_t const *)o);
06783 }
06784 
06785 su_inline
06786 http_max_forwards_t *http_max_forwards_copy(su_home_t *home, http_max_forwards_t const *o) 
06787 { 
06788   return (http_max_forwards_t *)
06789     msg_header_copy_as(home, http_max_forwards_class, (msg_header_t const *)o); 
06790 }
06791 
06792 su_inline 
06793 http_max_forwards_t *http_max_forwards_make(su_home_t *home, char const *s)
06794 {
06795   return (http_max_forwards_t *)http_header_make(home, http_max_forwards_class, s);
06796 }
06797 #endif
06798 
06799 #endif /* !define HTTP_HCLASSES_ONLY */
06800 
06804 /* Declare internal prototypes for Pragma header */
06805  
06808 enum { 
06810   http_pragma_hash = 49776 
06811 };
06812 
06821 SOFIAPUBVAR msg_hclass_t http_pragma_class[];
06822 
06823 #ifndef HTTP_HCLASSES_ONLY
06824 
06826 SOFIAPUBFUN msg_parse_f http_pragma_d;
06827 
06829 SOFIAPUBFUN msg_print_f http_pragma_e;
06830 
06842 #define HTTP_PRAGMA_INIT() HTTP_HDR_INIT(pragma)
06843 
06857 #if SU_HAVE_INLINE
06858 su_inline http_pragma_t *http_pragma_init(http_pragma_t x[1])
06859 {
06860   return HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t));
06861 }
06862 #else
06863 #define http_pragma_init(x) \
06864   HTTP_HEADER_INIT(x, http_pragma_class, sizeof(http_pragma_t))
06865 #endif
06866 
06880 #if SU_HAVE_INLINE
06881 su_inline 
06882 int http_is_pragma(http_header_t const *header)
06883 {
06884   return header && header->sh_class->hc_hash == http_pragma_hash;
06885 }
06886 #else
06887 #define http_is_pragma(h) \
06888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_pragma_hash)
06889 #endif
06890 
06918 #if SU_HAVE_INLINE
06919 su_inline
06920 #endif
06921 http_pragma_t *http_pragma_dup(su_home_t *home, 
06922                                    http_pragma_t const *hdr)
06923      __attribute__((__malloc__));
06924 
06953 #if SU_HAVE_INLINE
06954 su_inline
06955 #endif
06956 http_pragma_t *http_pragma_copy(su_home_t *home, 
06957                                     http_pragma_t const *hdr)
06958      __attribute__((__malloc__));
06959 
06978 #if SU_HAVE_INLINE
06979 su_inline
06980 #endif
06981 http_pragma_t *http_pragma_make(su_home_t *home, char const *s)
06982      __attribute__((__malloc__));
06983 
07006 #if SU_HAVE_INLINE
07007 su_inline
07008 #endif
07009 http_pragma_t *http_pragma_format(su_home_t *home, char const *fmt, ...)
07010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
07011 
07012 
07013 /* Inlined functions */
07014 #if SU_HAVE_INLINE
07015 su_inline
07016 http_pragma_t *http_pragma_format(su_home_t *home, char const *fmt, ...)
07017 {
07018   http_header_t *h;
07019   va_list ap;
07020   
07021   va_start(ap, fmt);
07022   h = http_header_vformat(home, http_pragma_class, fmt, ap);
07023   va_end(ap);
07024  
07025   return (http_pragma_t *)h;
07026 }
07027 
07028 su_inline
07029 http_pragma_t *http_pragma_dup(su_home_t *home, http_pragma_t const *o) 
07030 { 
07031   return (http_pragma_t *)
07032     msg_header_dup_as(home, http_pragma_class, (msg_header_t const *)o);
07033 }
07034 
07035 su_inline
07036 http_pragma_t *http_pragma_copy(su_home_t *home, http_pragma_t const *o) 
07037 { 
07038   return (http_pragma_t *)
07039     msg_header_copy_as(home, http_pragma_class, (msg_header_t const *)o); 
07040 }
07041 
07042 su_inline 
07043 http_pragma_t *http_pragma_make(su_home_t *home, char const *s)
07044 {
07045   return (http_pragma_t *)http_header_make(home, http_pragma_class, s);
07046 }
07047 #endif
07048 
07049 #endif /* !define HTTP_HCLASSES_ONLY */
07050 
07054 /* Declare internal prototypes for Proxy-Authenticate header */
07055  
07058 enum { 
07060   http_proxy_authenticate_hash = 57658 
07061 };
07062 
07071 SOFIAPUBVAR msg_hclass_t http_proxy_authenticate_class[];
07072 
07073 #ifndef HTTP_HCLASSES_ONLY
07074 
07076 SOFIAPUBFUN msg_parse_f http_proxy_authenticate_d;
07077 
07079 SOFIAPUBFUN msg_print_f http_proxy_authenticate_e;
07080 
07092 #define HTTP_PROXY_AUTHENTICATE_INIT() HTTP_HDR_INIT(proxy_authenticate)
07093 
07107 #if SU_HAVE_INLINE
07108 su_inline http_proxy_authenticate_t *http_proxy_authenticate_init(http_proxy_authenticate_t x[1])
07109 {
07110   return HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t));
07111 }
07112 #else
07113 #define http_proxy_authenticate_init(x) \
07114   HTTP_HEADER_INIT(x, http_proxy_authenticate_class, sizeof(http_proxy_authenticate_t))
07115 #endif
07116 
07130 #if SU_HAVE_INLINE
07131 su_inline 
07132 int http_is_proxy_authenticate(http_header_t const *header)
07133 {
07134   return header && header->sh_class->hc_hash == http_proxy_authenticate_hash;
07135 }
07136 #else
07137 #define http_is_proxy_authenticate(h) \
07138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authenticate_hash)
07139 #endif
07140 
07168 #if SU_HAVE_INLINE
07169 su_inline
07170 #endif
07171 http_proxy_authenticate_t *http_proxy_authenticate_dup(su_home_t *home, 
07172                                    http_proxy_authenticate_t const *hdr)
07173      __attribute__((__malloc__));
07174 
07203 #if SU_HAVE_INLINE
07204 su_inline
07205 #endif
07206 http_proxy_authenticate_t *http_proxy_authenticate_copy(su_home_t *home, 
07207                                     http_proxy_authenticate_t const *hdr)
07208      __attribute__((__malloc__));
07209 
07228 #if SU_HAVE_INLINE
07229 su_inline
07230 #endif
07231 http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
07232      __attribute__((__malloc__));
07233 
07256 #if SU_HAVE_INLINE
07257 su_inline
07258 #endif
07259 http_proxy_authenticate_t *http_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
07260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
07261 
07262 
07263 /* Inlined functions */
07264 #if SU_HAVE_INLINE
07265 su_inline
07266 http_proxy_authenticate_t *http_proxy_authenticate_format(su_home_t *home, char const *fmt, ...)
07267 {
07268   http_header_t *h;
07269   va_list ap;
07270   
07271   va_start(ap, fmt);
07272   h = http_header_vformat(home, http_proxy_authenticate_class, fmt, ap);
07273   va_end(ap);
07274  
07275   return (http_proxy_authenticate_t *)h;
07276 }
07277 
07278 su_inline
07279 http_proxy_authenticate_t *http_proxy_authenticate_dup(su_home_t *home, http_proxy_authenticate_t const *o) 
07280 { 
07281   return (http_proxy_authenticate_t *)
07282     msg_header_dup_as(home, http_proxy_authenticate_class, (msg_header_t const *)o);
07283 }
07284 
07285 su_inline
07286 http_proxy_authenticate_t *http_proxy_authenticate_copy(su_home_t *home, http_proxy_authenticate_t const *o) 
07287 { 
07288   return (http_proxy_authenticate_t *)
07289     msg_header_copy_as(home, http_proxy_authenticate_class, (msg_header_t const *)o); 
07290 }
07291 
07292 su_inline 
07293 http_proxy_authenticate_t *http_proxy_authenticate_make(su_home_t *home, char const *s)
07294 {
07295   return (http_proxy_authenticate_t *)http_header_make(home, http_proxy_authenticate_class, s);
07296 }
07297 #endif
07298 
07299 #endif /* !define HTTP_HCLASSES_ONLY */
07300 
07304 /* Declare internal prototypes for Proxy-Authorization header */
07305  
07308 enum { 
07310   http_proxy_authorization_hash = 21244 
07311 };
07312 
07321 SOFIAPUBVAR msg_hclass_t http_proxy_authorization_class[];
07322 
07323 #ifndef HTTP_HCLASSES_ONLY
07324 
07326 SOFIAPUBFUN msg_parse_f http_proxy_authorization_d;
07327 
07329 SOFIAPUBFUN msg_print_f http_proxy_authorization_e;
07330 
07342 #define HTTP_PROXY_AUTHORIZATION_INIT() HTTP_HDR_INIT(proxy_authorization)
07343 
07357 #if SU_HAVE_INLINE
07358 su_inline http_proxy_authorization_t *http_proxy_authorization_init(http_proxy_authorization_t x[1])
07359 {
07360   return HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t));
07361 }
07362 #else
07363 #define http_proxy_authorization_init(x) \
07364   HTTP_HEADER_INIT(x, http_proxy_authorization_class, sizeof(http_proxy_authorization_t))
07365 #endif
07366 
07380 #if SU_HAVE_INLINE
07381 su_inline 
07382 int http_is_proxy_authorization(http_header_t const *header)
07383 {
07384   return header && header->sh_class->hc_hash == http_proxy_authorization_hash;
07385 }
07386 #else
07387 #define http_is_proxy_authorization(h) \
07388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_authorization_hash)
07389 #endif
07390 
07418 #if SU_HAVE_INLINE
07419 su_inline
07420 #endif
07421 http_proxy_authorization_t *http_proxy_authorization_dup(su_home_t *home, 
07422                                    http_proxy_authorization_t const *hdr)
07423      __attribute__((__malloc__));
07424 
07453 #if SU_HAVE_INLINE
07454 su_inline
07455 #endif
07456 http_proxy_authorization_t *http_proxy_authorization_copy(su_home_t *home, 
07457                                     http_proxy_authorization_t const *hdr)
07458      __attribute__((__malloc__));
07459 
07478 #if SU_HAVE_INLINE
07479 su_inline
07480 #endif
07481 http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
07482      __attribute__((__malloc__));
07483 
07506 #if SU_HAVE_INLINE
07507 su_inline
07508 #endif
07509 http_proxy_authorization_t *http_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
07510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
07511 
07512 
07513 /* Inlined functions */
07514 #if SU_HAVE_INLINE
07515 su_inline
07516 http_proxy_authorization_t *http_proxy_authorization_format(su_home_t *home, char const *fmt, ...)
07517 {
07518   http_header_t *h;
07519   va_list ap;
07520   
07521   va_start(ap, fmt);
07522   h = http_header_vformat(home, http_proxy_authorization_class, fmt, ap);
07523   va_end(ap);
07524  
07525   return (http_proxy_authorization_t *)h;
07526 }
07527 
07528 su_inline
07529 http_proxy_authorization_t *http_proxy_authorization_dup(su_home_t *home, http_proxy_authorization_t const *o) 
07530 { 
07531   return (http_proxy_authorization_t *)
07532     msg_header_dup_as(home, http_proxy_authorization_class, (msg_header_t const *)o);
07533 }
07534 
07535 su_inline
07536 http_proxy_authorization_t *http_proxy_authorization_copy(su_home_t *home, http_proxy_authorization_t const *o) 
07537 { 
07538   return (http_proxy_authorization_t *)
07539     msg_header_copy_as(home, http_proxy_authorization_class, (msg_header_t const *)o); 
07540 }
07541 
07542 su_inline 
07543 http_proxy_authorization_t *http_proxy_authorization_make(su_home_t *home, char const *s)
07544 {
07545   return (http_proxy_authorization_t *)http_header_make(home, http_proxy_authorization_class, s);
07546 }
07547 #endif
07548 
07549 #endif /* !define HTTP_HCLASSES_ONLY */
07550 
07554 /* Declare internal prototypes for Range header */
07555  
07558 enum { 
07560   http_range_hash = 20297 
07561 };
07562 
07571 SOFIAPUBVAR msg_hclass_t http_range_class[];
07572 
07573 #ifndef HTTP_HCLASSES_ONLY
07574 
07576 SOFIAPUBFUN msg_parse_f http_range_d;
07577 
07579 SOFIAPUBFUN msg_print_f http_range_e;
07580 
07592 #define HTTP_RANGE_INIT() HTTP_HDR_INIT(range)
07593 
07607 #if SU_HAVE_INLINE
07608 su_inline http_range_t *http_range_init(http_range_t x[1])
07609 {
07610   return HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t));
07611 }
07612 #else
07613 #define http_range_init(x) \
07614   HTTP_HEADER_INIT(x, http_range_class, sizeof(http_range_t))
07615 #endif
07616 
07630 #if SU_HAVE_INLINE
07631 su_inline 
07632 int http_is_range(http_header_t const *header)
07633 {
07634   return header && header->sh_class->hc_hash == http_range_hash;
07635 }
07636 #else
07637 #define http_is_range(h) \
07638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_range_hash)
07639 #endif
07640 
07668 #if SU_HAVE_INLINE
07669 su_inline
07670 #endif
07671 http_range_t *http_range_dup(su_home_t *home, 
07672                                    http_range_t const *hdr)
07673      __attribute__((__malloc__));
07674 
07703 #if SU_HAVE_INLINE
07704 su_inline
07705 #endif
07706 http_range_t *http_range_copy(su_home_t *home, 
07707                                     http_range_t const *hdr)
07708      __attribute__((__malloc__));
07709 
07728 #if SU_HAVE_INLINE
07729 su_inline
07730 #endif
07731 http_range_t *http_range_make(su_home_t *home, char const *s)
07732      __attribute__((__malloc__));
07733 
07756 #if SU_HAVE_INLINE
07757 su_inline
07758 #endif
07759 http_range_t *http_range_format(su_home_t *home, char const *fmt, ...)
07760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
07761 
07762 
07763 /* Inlined functions */
07764 #if SU_HAVE_INLINE
07765 su_inline
07766 http_range_t *http_range_format(su_home_t *home, char const *fmt, ...)
07767 {
07768   http_header_t *h;
07769   va_list ap;
07770   
07771   va_start(ap, fmt);
07772   h = http_header_vformat(home, http_range_class, fmt, ap);
07773   va_end(ap);
07774  
07775   return (http_range_t *)h;
07776 }
07777 
07778 su_inline
07779 http_range_t *http_range_dup(su_home_t *home, http_range_t const *o) 
07780 { 
07781   return (http_range_t *)
07782     msg_header_dup_as(home, http_range_class, (msg_header_t const *)o);
07783 }
07784 
07785 su_inline
07786 http_range_t *http_range_copy(su_home_t *home, http_range_t const *o) 
07787 { 
07788   return (http_range_t *)
07789     msg_header_copy_as(home, http_range_class, (msg_header_t const *)o); 
07790 }
07791 
07792 su_inline 
07793 http_range_t *http_range_make(su_home_t *home, char const *s)
07794 {
07795   return (http_range_t *)http_header_make(home, http_range_class, s);
07796 }
07797 #endif
07798 
07799 #endif /* !define HTTP_HCLASSES_ONLY */
07800 
07804 /* Declare internal prototypes for Referer header */
07805  
07808 enum { 
07810   http_referer_hash = 64523 
07811 };
07812 
07821 SOFIAPUBVAR msg_hclass_t http_referer_class[];
07822 
07823 #ifndef HTTP_HCLASSES_ONLY
07824 
07826 SOFIAPUBFUN msg_parse_f http_referer_d;
07827 
07829 SOFIAPUBFUN msg_print_f http_referer_e;
07830 
07842 #define HTTP_REFERER_INIT() HTTP_HDR_INIT(referer)
07843 
07857 #if SU_HAVE_INLINE
07858 su_inline http_referer_t *http_referer_init(http_referer_t x[1])
07859 {
07860   return HTTP_HEADER_INIT(x, http_referer_class, sizeof(http_referer_t));
07861 }
07862 #else
07863 #define http_referer_init(x) \
07864   HTTP_HEADER_INIT(x, http_referer_class, sizeof(http_referer_t))
07865 #endif
07866 
07880 #if SU_HAVE_INLINE
07881 su_inline 
07882 int http_is_referer(http_header_t const *header)
07883 {
07884   return header && header->sh_class->hc_hash == http_referer_hash;
07885 }
07886 #else
07887 #define http_is_referer(h) \
07888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_referer_hash)
07889 #endif
07890 
07918 #if SU_HAVE_INLINE
07919 su_inline
07920 #endif
07921 http_referer_t *http_referer_dup(su_home_t *home, 
07922                                    http_referer_t const *hdr)
07923      __attribute__((__malloc__));
07924 
07953 #if SU_HAVE_INLINE
07954 su_inline
07955 #endif
07956 http_referer_t *http_referer_copy(su_home_t *home, 
07957                                     http_referer_t const *hdr)
07958      __attribute__((__malloc__));
07959 
07978 #if SU_HAVE_INLINE
07979 su_inline
07980 #endif
07981 http_referer_t *http_referer_make(su_home_t *home, char const *s)
07982      __attribute__((__malloc__));
07983 
08006 #if SU_HAVE_INLINE
08007 su_inline
08008 #endif
08009 http_referer_t *http_referer_format(su_home_t *home, char const *fmt, ...)
08010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
08011 
08012 
08013 /* Inlined functions */
08014 #if SU_HAVE_INLINE
08015 su_inline
08016 http_referer_t *http_referer_format(su_home_t *home, char const *fmt, ...)
08017 {
08018   http_header_t *h;
08019   va_list ap;
08020   
08021   va_start(ap, fmt);
08022   h = http_header_vformat(home, http_referer_class, fmt, ap);
08023   va_end(ap);
08024  
08025   return (http_referer_t *)h;
08026 }
08027 
08028 su_inline
08029 http_referer_t *http_referer_dup(su_home_t *home, http_referer_t const *o) 
08030 { 
08031   return (http_referer_t *)
08032     msg_header_dup_as(home, http_referer_class, (msg_header_t const *)o);
08033 }
08034 
08035 su_inline
08036 http_referer_t *http_referer_copy(su_home_t *home, http_referer_t const *o) 
08037 { 
08038   return (http_referer_t *)
08039     msg_header_copy_as(home, http_referer_class, (msg_header_t const *)o); 
08040 }
08041 
08042 su_inline 
08043 http_referer_t *http_referer_make(su_home_t *home, char const *s)
08044 {
08045   return (http_referer_t *)http_header_make(home, http_referer_class, s);
08046 }
08047 #endif
08048 
08049 #endif /* !define HTTP_HCLASSES_ONLY */
08050 
08054 /* Declare internal prototypes for Retry-After header */
08055  
08058 enum { 
08060   http_retry_after_hash = 30349 
08061 };
08062 
08071 SOFIAPUBVAR msg_hclass_t http_retry_after_class[];
08072 
08073 #ifndef HTTP_HCLASSES_ONLY
08074 
08076 SOFIAPUBFUN msg_parse_f http_retry_after_d;
08077 
08079 SOFIAPUBFUN msg_print_f http_retry_after_e;
08080 
08092 #define HTTP_RETRY_AFTER_INIT() HTTP_HDR_INIT(retry_after)
08093 
08107 #if SU_HAVE_INLINE
08108 su_inline http_retry_after_t *http_retry_after_init(http_retry_after_t x[1])
08109 {
08110   return HTTP_HEADER_INIT(x, http_retry_after_class, sizeof(http_retry_after_t));
08111 }
08112 #else
08113 #define http_retry_after_init(x) \
08114   HTTP_HEADER_INIT(x, http_retry_after_class, sizeof(http_retry_after_t))
08115 #endif
08116 
08130 #if SU_HAVE_INLINE
08131 su_inline 
08132 int http_is_retry_after(http_header_t const *header)
08133 {
08134   return header && header->sh_class->hc_hash == http_retry_after_hash;
08135 }
08136 #else
08137 #define http_is_retry_after(h) \
08138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_retry_after_hash)
08139 #endif
08140 
08168 #if SU_HAVE_INLINE
08169 su_inline
08170 #endif
08171 http_retry_after_t *http_retry_after_dup(su_home_t *home, 
08172                                    http_retry_after_t const *hdr)
08173      __attribute__((__malloc__));
08174 
08203 #if SU_HAVE_INLINE
08204 su_inline
08205 #endif
08206 http_retry_after_t *http_retry_after_copy(su_home_t *home, 
08207                                     http_retry_after_t const *hdr)
08208      __attribute__((__malloc__));
08209 
08228 #if SU_HAVE_INLINE
08229 su_inline
08230 #endif
08231 http_retry_after_t *http_retry_after_make(su_home_t *home, char const *s)
08232      __attribute__((__malloc__));
08233 
08256 #if SU_HAVE_INLINE
08257 su_inline
08258 #endif
08259 http_retry_after_t *http_retry_after_format(su_home_t *home, char const *fmt, ...)
08260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
08261 
08262 
08263 /* Inlined functions */
08264 #if SU_HAVE_INLINE
08265 su_inline
08266 http_retry_after_t *http_retry_after_format(su_home_t *home, char const *fmt, ...)
08267 {
08268   http_header_t *h;
08269   va_list ap;
08270   
08271   va_start(ap, fmt);
08272   h = http_header_vformat(home, http_retry_after_class, fmt, ap);
08273   va_end(ap);
08274  
08275   return (http_retry_after_t *)h;
08276 }
08277 
08278 su_inline
08279 http_retry_after_t *http_retry_after_dup(su_home_t *home, http_retry_after_t const *o) 
08280 { 
08281   return (http_retry_after_t *)
08282     msg_header_dup_as(home, http_retry_after_class, (msg_header_t const *)o);
08283 }
08284 
08285 su_inline
08286 http_retry_after_t *http_retry_after_copy(su_home_t *home, http_retry_after_t const *o) 
08287 { 
08288   return (http_retry_after_t *)
08289     msg_header_copy_as(home, http_retry_after_class, (msg_header_t const *)o); 
08290 }
08291 
08292 su_inline 
08293 http_retry_after_t *http_retry_after_make(su_home_t *home, char const *s)
08294 {
08295   return (http_retry_after_t *)http_header_make(home, http_retry_after_class, s);
08296 }
08297 #endif
08298 
08299 #endif /* !define HTTP_HCLASSES_ONLY */
08300 
08304 /* Declare internal prototypes for Server header */
08305  
08308 enum { 
08310   http_server_hash = 31323 
08311 };
08312 
08321 SOFIAPUBVAR msg_hclass_t http_server_class[];
08322 
08323 #ifndef HTTP_HCLASSES_ONLY
08324 
08326 SOFIAPUBFUN msg_parse_f http_server_d;
08327 
08329 SOFIAPUBFUN msg_print_f http_server_e;
08330 
08342 #define HTTP_SERVER_INIT() HTTP_HDR_INIT(server)
08343 
08357 #if SU_HAVE_INLINE
08358 su_inline http_server_t *http_server_init(http_server_t x[1])
08359 {
08360   return HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t));
08361 }
08362 #else
08363 #define http_server_init(x) \
08364   HTTP_HEADER_INIT(x, http_server_class, sizeof(http_server_t))
08365 #endif
08366 
08380 #if SU_HAVE_INLINE
08381 su_inline 
08382 int http_is_server(http_header_t const *header)
08383 {
08384   return header && header->sh_class->hc_hash == http_server_hash;
08385 }
08386 #else
08387 #define http_is_server(h) \
08388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_server_hash)
08389 #endif
08390 
08418 #if SU_HAVE_INLINE
08419 su_inline
08420 #endif
08421 http_server_t *http_server_dup(su_home_t *home, 
08422                                    http_server_t const *hdr)
08423      __attribute__((__malloc__));
08424 
08453 #if SU_HAVE_INLINE
08454 su_inline
08455 #endif
08456 http_server_t *http_server_copy(su_home_t *home, 
08457                                     http_server_t const *hdr)
08458      __attribute__((__malloc__));
08459 
08478 #if SU_HAVE_INLINE
08479 su_inline
08480 #endif
08481 http_server_t *http_server_make(su_home_t *home, char const *s)
08482      __attribute__((__malloc__));
08483 
08506 #if SU_HAVE_INLINE
08507 su_inline
08508 #endif
08509 http_server_t *http_server_format(su_home_t *home, char const *fmt, ...)
08510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
08511 
08512 
08513 /* Inlined functions */
08514 #if SU_HAVE_INLINE
08515 su_inline
08516 http_server_t *http_server_format(su_home_t *home, char const *fmt, ...)
08517 {
08518   http_header_t *h;
08519   va_list ap;
08520   
08521   va_start(ap, fmt);
08522   h = http_header_vformat(home, http_server_class, fmt, ap);
08523   va_end(ap);
08524  
08525   return (http_server_t *)h;
08526 }
08527 
08528 su_inline
08529 http_server_t *http_server_dup(su_home_t *home, http_server_t const *o) 
08530 { 
08531   return (http_server_t *)
08532     msg_header_dup_as(home, http_server_class, (msg_header_t const *)o);
08533 }
08534 
08535 su_inline
08536 http_server_t *http_server_copy(su_home_t *home, http_server_t const *o) 
08537 { 
08538   return (http_server_t *)
08539     msg_header_copy_as(home, http_server_class, (msg_header_t const *)o); 
08540 }
08541 
08542 su_inline 
08543 http_server_t *http_server_make(su_home_t *home, char const *s)
08544 {
08545   return (http_server_t *)http_header_make(home, http_server_class, s);
08546 }
08547 #endif
08548 
08549 #endif /* !define HTTP_HCLASSES_ONLY */
08550 
08554 /* Declare internal prototypes for TE header */
08555  
08558 enum { 
08560   http_te_hash = 5165 
08561 };
08562 
08571 SOFIAPUBVAR msg_hclass_t http_te_class[];
08572 
08573 #ifndef HTTP_HCLASSES_ONLY
08574 
08576 SOFIAPUBFUN msg_parse_f http_te_d;
08577 
08579 SOFIAPUBFUN msg_print_f http_te_e;
08580 
08592 #define HTTP_TE_INIT() HTTP_HDR_INIT(te)
08593 
08607 #if SU_HAVE_INLINE
08608 su_inline http_te_t *http_te_init(http_te_t x[1])
08609 {
08610   return HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t));
08611 }
08612 #else
08613 #define http_te_init(x) \
08614   HTTP_HEADER_INIT(x, http_te_class, sizeof(http_te_t))
08615 #endif
08616 
08630 #if SU_HAVE_INLINE
08631 su_inline 
08632 int http_is_te(http_header_t const *header)
08633 {
08634   return header && header->sh_class->hc_hash == http_te_hash;
08635 }
08636 #else
08637 #define http_is_te(h) \
08638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_te_hash)
08639 #endif
08640 
08668 #if SU_HAVE_INLINE
08669 su_inline
08670 #endif
08671 http_te_t *http_te_dup(su_home_t *home, 
08672                                    http_te_t const *hdr)
08673      __attribute__((__malloc__));
08674 
08703 #if SU_HAVE_INLINE
08704 su_inline
08705 #endif
08706 http_te_t *http_te_copy(su_home_t *home, 
08707                                     http_te_t const *hdr)
08708      __attribute__((__malloc__));
08709 
08728 #if SU_HAVE_INLINE
08729 su_inline
08730 #endif
08731 http_te_t *http_te_make(su_home_t *home, char const *s)
08732      __attribute__((__malloc__));
08733 
08756 #if SU_HAVE_INLINE
08757 su_inline
08758 #endif
08759 http_te_t *http_te_format(su_home_t *home, char const *fmt, ...)
08760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
08761 
08762 
08763 /* Inlined functions */
08764 #if SU_HAVE_INLINE
08765 su_inline
08766 http_te_t *http_te_format(su_home_t *home, char const *fmt, ...)
08767 {
08768   http_header_t *h;
08769   va_list ap;
08770   
08771   va_start(ap, fmt);
08772   h = http_header_vformat(home, http_te_class, fmt, ap);
08773   va_end(ap);
08774  
08775   return (http_te_t *)h;
08776 }
08777 
08778 su_inline
08779 http_te_t *http_te_dup(su_home_t *home, http_te_t const *o) 
08780 { 
08781   return (http_te_t *)
08782     msg_header_dup_as(home, http_te_class, (msg_header_t const *)o);
08783 }
08784 
08785 su_inline
08786 http_te_t *http_te_copy(su_home_t *home, http_te_t const *o) 
08787 { 
08788   return (http_te_t *)
08789     msg_header_copy_as(home, http_te_class, (msg_header_t const *)o); 
08790 }
08791 
08792 su_inline 
08793 http_te_t *http_te_make(su_home_t *home, char const *s)
08794 {
08795   return (http_te_t *)http_header_make(home, http_te_class, s);
08796 }
08797 #endif
08798 
08799 #endif /* !define HTTP_HCLASSES_ONLY */
08800 
08804 /* Declare internal prototypes for Trailer header */
08805  
08808 enum { 
08810   http_trailer_hash = 11015 
08811 };
08812 
08821 SOFIAPUBVAR msg_hclass_t http_trailer_class[];
08822 
08823 #ifndef HTTP_HCLASSES_ONLY
08824 
08826 SOFIAPUBFUN msg_parse_f http_trailer_d;
08827 
08829 SOFIAPUBFUN msg_print_f http_trailer_e;
08830 
08842 #define HTTP_TRAILER_INIT() HTTP_HDR_INIT(trailer)
08843 
08857 #if SU_HAVE_INLINE
08858 su_inline http_trailer_t *http_trailer_init(http_trailer_t x[1])
08859 {
08860   return HTTP_HEADER_INIT(x, http_trailer_class, sizeof(http_trailer_t));
08861 }
08862 #else
08863 #define http_trailer_init(x) \
08864   HTTP_HEADER_INIT(x, http_trailer_class, sizeof(http_trailer_t))
08865 #endif
08866 
08880 #if SU_HAVE_INLINE
08881 su_inline 
08882 int http_is_trailer(http_header_t const *header)
08883 {
08884   return header && header->sh_class->hc_hash == http_trailer_hash;
08885 }
08886 #else
08887 #define http_is_trailer(h) \
08888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_trailer_hash)
08889 #endif
08890 
08918 #if SU_HAVE_INLINE
08919 su_inline
08920 #endif
08921 http_trailer_t *http_trailer_dup(su_home_t *home, 
08922                                    http_trailer_t const *hdr)
08923      __attribute__((__malloc__));
08924 
08953 #if SU_HAVE_INLINE
08954 su_inline
08955 #endif
08956 http_trailer_t *http_trailer_copy(su_home_t *home, 
08957                                     http_trailer_t const *hdr)
08958      __attribute__((__malloc__));
08959 
08978 #if SU_HAVE_INLINE
08979 su_inline
08980 #endif
08981 http_trailer_t *http_trailer_make(su_home_t *home, char const *s)
08982      __attribute__((__malloc__));
08983 
09006 #if SU_HAVE_INLINE
09007 su_inline
09008 #endif
09009 http_trailer_t *http_trailer_format(su_home_t *home, char const *fmt, ...)
09010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
09011 
09012 
09013 /* Inlined functions */
09014 #if SU_HAVE_INLINE
09015 su_inline
09016 http_trailer_t *http_trailer_format(su_home_t *home, char const *fmt, ...)
09017 {
09018   http_header_t *h;
09019   va_list ap;
09020   
09021   va_start(ap, fmt);
09022   h = http_header_vformat(home, http_trailer_class, fmt, ap);
09023   va_end(ap);
09024  
09025   return (http_trailer_t *)h;
09026 }
09027 
09028 su_inline
09029 http_trailer_t *http_trailer_dup(su_home_t *home, http_trailer_t const *o) 
09030 { 
09031   return (http_trailer_t *)
09032     msg_header_dup_as(home, http_trailer_class, (msg_header_t const *)o);
09033 }
09034 
09035 su_inline
09036 http_trailer_t *http_trailer_copy(su_home_t *home, http_trailer_t const *o) 
09037 { 
09038   return (http_trailer_t *)
09039     msg_header_copy_as(home, http_trailer_class, (msg_header_t const *)o); 
09040 }
09041 
09042 su_inline 
09043 http_trailer_t *http_trailer_make(su_home_t *home, char const *s)
09044 {
09045   return (http_trailer_t *)http_header_make(home, http_trailer_class, s);
09046 }
09047 #endif
09048 
09049 #endif /* !define HTTP_HCLASSES_ONLY */
09050 
09054 /* Declare internal prototypes for Transfer-Encoding header */
09055  
09058 enum { 
09060   http_transfer_encoding_hash = 25509 
09061 };
09062 
09071 SOFIAPUBVAR msg_hclass_t http_transfer_encoding_class[];
09072 
09073 #ifndef HTTP_HCLASSES_ONLY
09074 
09076 SOFIAPUBFUN msg_parse_f http_transfer_encoding_d;
09077 
09079 SOFIAPUBFUN msg_print_f http_transfer_encoding_e;
09080 
09092 #define HTTP_TRANSFER_ENCODING_INIT() HTTP_HDR_INIT(transfer_encoding)
09093 
09107 #if SU_HAVE_INLINE
09108 su_inline http_transfer_encoding_t *http_transfer_encoding_init(http_transfer_encoding_t x[1])
09109 {
09110   return HTTP_HEADER_INIT(x, http_transfer_encoding_class, sizeof(http_transfer_encoding_t));
09111 }
09112 #else
09113 #define http_transfer_encoding_init(x) \
09114   HTTP_HEADER_INIT(x, http_transfer_encoding_class, sizeof(http_transfer_encoding_t))
09115 #endif
09116 
09130 #if SU_HAVE_INLINE
09131 su_inline 
09132 int http_is_transfer_encoding(http_header_t const *header)
09133 {
09134   return header && header->sh_class->hc_hash == http_transfer_encoding_hash;
09135 }
09136 #else
09137 #define http_is_transfer_encoding(h) \
09138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_transfer_encoding_hash)
09139 #endif
09140 
09168 #if SU_HAVE_INLINE
09169 su_inline
09170 #endif
09171 http_transfer_encoding_t *http_transfer_encoding_dup(su_home_t *home, 
09172                                    http_transfer_encoding_t const *hdr)
09173      __attribute__((__malloc__));
09174 
09203 #if SU_HAVE_INLINE
09204 su_inline
09205 #endif
09206 http_transfer_encoding_t *http_transfer_encoding_copy(su_home_t *home, 
09207                                     http_transfer_encoding_t const *hdr)
09208      __attribute__((__malloc__));
09209 
09228 #if SU_HAVE_INLINE
09229 su_inline
09230 #endif
09231 http_transfer_encoding_t *http_transfer_encoding_make(su_home_t *home, char const *s)
09232      __attribute__((__malloc__));
09233 
09256 #if SU_HAVE_INLINE
09257 su_inline
09258 #endif
09259 http_transfer_encoding_t *http_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
09260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
09261 
09262 
09263 /* Inlined functions */
09264 #if SU_HAVE_INLINE
09265 su_inline
09266 http_transfer_encoding_t *http_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
09267 {
09268   http_header_t *h;
09269   va_list ap;
09270   
09271   va_start(ap, fmt);
09272   h = http_header_vformat(home, http_transfer_encoding_class, fmt, ap);
09273   va_end(ap);
09274  
09275   return (http_transfer_encoding_t *)h;
09276 }
09277 
09278 su_inline
09279 http_transfer_encoding_t *http_transfer_encoding_dup(su_home_t *home, http_transfer_encoding_t const *o) 
09280 { 
09281   return (http_transfer_encoding_t *)
09282     msg_header_dup_as(home, http_transfer_encoding_class, (msg_header_t const *)o);
09283 }
09284 
09285 su_inline
09286 http_transfer_encoding_t *http_transfer_encoding_copy(su_home_t *home, http_transfer_encoding_t const *o) 
09287 { 
09288   return (http_transfer_encoding_t *)
09289     msg_header_copy_as(home, http_transfer_encoding_class, (msg_header_t const *)o); 
09290 }
09291 
09292 su_inline 
09293 http_transfer_encoding_t *http_transfer_encoding_make(su_home_t *home, char const *s)
09294 {
09295   return (http_transfer_encoding_t *)http_header_make(home, http_transfer_encoding_class, s);
09296 }
09297 #endif
09298 
09299 #endif /* !define HTTP_HCLASSES_ONLY */
09300 
09304 /* Declare internal prototypes for Upgrade header */
09305  
09308 enum { 
09310   http_upgrade_hash = 16256 
09311 };
09312 
09321 SOFIAPUBVAR msg_hclass_t http_upgrade_class[];
09322 
09323 #ifndef HTTP_HCLASSES_ONLY
09324 
09326 SOFIAPUBFUN msg_parse_f http_upgrade_d;
09327 
09329 SOFIAPUBFUN msg_print_f http_upgrade_e;
09330 
09342 #define HTTP_UPGRADE_INIT() HTTP_HDR_INIT(upgrade)
09343 
09357 #if SU_HAVE_INLINE
09358 su_inline http_upgrade_t *http_upgrade_init(http_upgrade_t x[1])
09359 {
09360   return HTTP_HEADER_INIT(x, http_upgrade_class, sizeof(http_upgrade_t));
09361 }
09362 #else
09363 #define http_upgrade_init(x) \
09364   HTTP_HEADER_INIT(x, http_upgrade_class, sizeof(http_upgrade_t))
09365 #endif
09366 
09380 #if SU_HAVE_INLINE
09381 su_inline 
09382 int http_is_upgrade(http_header_t const *header)
09383 {
09384   return header && header->sh_class->hc_hash == http_upgrade_hash;
09385 }
09386 #else
09387 #define http_is_upgrade(h) \
09388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_upgrade_hash)
09389 #endif
09390 
09418 #if SU_HAVE_INLINE
09419 su_inline
09420 #endif
09421 http_upgrade_t *http_upgrade_dup(su_home_t *home, 
09422                                    http_upgrade_t const *hdr)
09423      __attribute__((__malloc__));
09424 
09453 #if SU_HAVE_INLINE
09454 su_inline
09455 #endif
09456 http_upgrade_t *http_upgrade_copy(su_home_t *home, 
09457                                     http_upgrade_t const *hdr)
09458      __attribute__((__malloc__));
09459 
09478 #if SU_HAVE_INLINE
09479 su_inline
09480 #endif
09481 http_upgrade_t *http_upgrade_make(su_home_t *home, char const *s)
09482      __attribute__((__malloc__));
09483 
09506 #if SU_HAVE_INLINE
09507 su_inline
09508 #endif
09509 http_upgrade_t *http_upgrade_format(su_home_t *home, char const *fmt, ...)
09510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
09511 
09512 
09513 /* Inlined functions */
09514 #if SU_HAVE_INLINE
09515 su_inline
09516 http_upgrade_t *http_upgrade_format(su_home_t *home, char const *fmt, ...)
09517 {
09518   http_header_t *h;
09519   va_list ap;
09520   
09521   va_start(ap, fmt);
09522   h = http_header_vformat(home, http_upgrade_class, fmt, ap);
09523   va_end(ap);
09524  
09525   return (http_upgrade_t *)h;
09526 }
09527 
09528 su_inline
09529 http_upgrade_t *http_upgrade_dup(su_home_t *home, http_upgrade_t const *o) 
09530 { 
09531   return (http_upgrade_t *)
09532     msg_header_dup_as(home, http_upgrade_class, (msg_header_t const *)o);
09533 }
09534 
09535 su_inline
09536 http_upgrade_t *http_upgrade_copy(su_home_t *home, http_upgrade_t const *o) 
09537 { 
09538   return (http_upgrade_t *)
09539     msg_header_copy_as(home, http_upgrade_class, (msg_header_t const *)o); 
09540 }
09541 
09542 su_inline 
09543 http_upgrade_t *http_upgrade_make(su_home_t *home, char const *s)
09544 {
09545   return (http_upgrade_t *)http_header_make(home, http_upgrade_class, s);
09546 }
09547 #endif
09548 
09549 #endif /* !define HTTP_HCLASSES_ONLY */
09550 
09554 /* Declare internal prototypes for User-Agent header */
09555  
09558 enum { 
09560   http_user_agent_hash = 40911 
09561 };
09562 
09571 SOFIAPUBVAR msg_hclass_t http_user_agent_class[];
09572 
09573 #ifndef HTTP_HCLASSES_ONLY
09574 
09576 SOFIAPUBFUN msg_parse_f http_user_agent_d;
09577 
09579 SOFIAPUBFUN msg_print_f http_user_agent_e;
09580 
09592 #define HTTP_USER_AGENT_INIT() HTTP_HDR_INIT(user_agent)
09593 
09607 #if SU_HAVE_INLINE
09608 su_inline http_user_agent_t *http_user_agent_init(http_user_agent_t x[1])
09609 {
09610   return HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t));
09611 }
09612 #else
09613 #define http_user_agent_init(x) \
09614   HTTP_HEADER_INIT(x, http_user_agent_class, sizeof(http_user_agent_t))
09615 #endif
09616 
09630 #if SU_HAVE_INLINE
09631 su_inline 
09632 int http_is_user_agent(http_header_t const *header)
09633 {
09634   return header && header->sh_class->hc_hash == http_user_agent_hash;
09635 }
09636 #else
09637 #define http_is_user_agent(h) \
09638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_user_agent_hash)
09639 #endif
09640 
09668 #if SU_HAVE_INLINE
09669 su_inline
09670 #endif
09671 http_user_agent_t *http_user_agent_dup(su_home_t *home, 
09672                                    http_user_agent_t const *hdr)
09673      __attribute__((__malloc__));
09674 
09703 #if SU_HAVE_INLINE
09704 su_inline
09705 #endif
09706 http_user_agent_t *http_user_agent_copy(su_home_t *home, 
09707                                     http_user_agent_t const *hdr)
09708      __attribute__((__malloc__));
09709 
09728 #if SU_HAVE_INLINE
09729 su_inline
09730 #endif
09731 http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
09732      __attribute__((__malloc__));
09733 
09756 #if SU_HAVE_INLINE
09757 su_inline
09758 #endif
09759 http_user_agent_t *http_user_agent_format(su_home_t *home, char const *fmt, ...)
09760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
09761 
09762 
09763 /* Inlined functions */
09764 #if SU_HAVE_INLINE
09765 su_inline
09766 http_user_agent_t *http_user_agent_format(su_home_t *home, char const *fmt, ...)
09767 {
09768   http_header_t *h;
09769   va_list ap;
09770   
09771   va_start(ap, fmt);
09772   h = http_header_vformat(home, http_user_agent_class, fmt, ap);
09773   va_end(ap);
09774  
09775   return (http_user_agent_t *)h;
09776 }
09777 
09778 su_inline
09779 http_user_agent_t *http_user_agent_dup(su_home_t *home, http_user_agent_t const *o) 
09780 { 
09781   return (http_user_agent_t *)
09782     msg_header_dup_as(home, http_user_agent_class, (msg_header_t const *)o);
09783 }
09784 
09785 su_inline
09786 http_user_agent_t *http_user_agent_copy(su_home_t *home, http_user_agent_t const *o) 
09787 { 
09788   return (http_user_agent_t *)
09789     msg_header_copy_as(home, http_user_agent_class, (msg_header_t const *)o); 
09790 }
09791 
09792 su_inline 
09793 http_user_agent_t *http_user_agent_make(su_home_t *home, char const *s)
09794 {
09795   return (http_user_agent_t *)http_header_make(home, http_user_agent_class, s);
09796 }
09797 #endif
09798 
09799 #endif /* !define HTTP_HCLASSES_ONLY */
09800 
09804 /* Declare internal prototypes for Vary header */
09805  
09808 enum { 
09810   http_vary_hash = 57074 
09811 };
09812 
09821 SOFIAPUBVAR msg_hclass_t http_vary_class[];
09822 
09823 #ifndef HTTP_HCLASSES_ONLY
09824 
09826 SOFIAPUBFUN msg_parse_f http_vary_d;
09827 
09829 SOFIAPUBFUN msg_print_f http_vary_e;
09830 
09842 #define HTTP_VARY_INIT() HTTP_HDR_INIT(vary)
09843 
09857 #if SU_HAVE_INLINE
09858 su_inline http_vary_t *http_vary_init(http_vary_t x[1])
09859 {
09860   return HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t));
09861 }
09862 #else
09863 #define http_vary_init(x) \
09864   HTTP_HEADER_INIT(x, http_vary_class, sizeof(http_vary_t))
09865 #endif
09866 
09880 #if SU_HAVE_INLINE
09881 su_inline 
09882 int http_is_vary(http_header_t const *header)
09883 {
09884   return header && header->sh_class->hc_hash == http_vary_hash;
09885 }
09886 #else
09887 #define http_is_vary(h) \
09888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_vary_hash)
09889 #endif
09890 
09918 #if SU_HAVE_INLINE
09919 su_inline
09920 #endif
09921 http_vary_t *http_vary_dup(su_home_t *home, 
09922                                    http_vary_t const *hdr)
09923      __attribute__((__malloc__));
09924 
09953 #if SU_HAVE_INLINE
09954 su_inline
09955 #endif
09956 http_vary_t *http_vary_copy(su_home_t *home, 
09957                                     http_vary_t const *hdr)
09958      __attribute__((__malloc__));
09959 
09978 #if SU_HAVE_INLINE
09979 su_inline
09980 #endif
09981 http_vary_t *http_vary_make(su_home_t *home, char const *s)
09982      __attribute__((__malloc__));
09983 
10006 #if SU_HAVE_INLINE
10007 su_inline
10008 #endif
10009 http_vary_t *http_vary_format(su_home_t *home, char const *fmt, ...)
10010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
10011 
10012 
10013 /* Inlined functions */
10014 #if SU_HAVE_INLINE
10015 su_inline
10016 http_vary_t *http_vary_format(su_home_t *home, char const *fmt, ...)
10017 {
10018   http_header_t *h;
10019   va_list ap;
10020   
10021   va_start(ap, fmt);
10022   h = http_header_vformat(home, http_vary_class, fmt, ap);
10023   va_end(ap);
10024  
10025   return (http_vary_t *)h;
10026 }
10027 
10028 su_inline
10029 http_vary_t *http_vary_dup(su_home_t *home, http_vary_t const *o) 
10030 { 
10031   return (http_vary_t *)
10032     msg_header_dup_as(home, http_vary_class, (msg_header_t const *)o);
10033 }
10034 
10035 su_inline
10036 http_vary_t *http_vary_copy(su_home_t *home, http_vary_t const *o) 
10037 { 
10038   return (http_vary_t *)
10039     msg_header_copy_as(home, http_vary_class, (msg_header_t const *)o); 
10040 }
10041 
10042 su_inline 
10043 http_vary_t *http_vary_make(su_home_t *home, char const *s)
10044 {
10045   return (http_vary_t *)http_header_make(home, http_vary_class, s);
10046 }
10047 #endif
10048 
10049 #endif /* !define HTTP_HCLASSES_ONLY */
10050 
10054 /* Declare internal prototypes for Via header */
10055  
10058 enum { 
10060   http_via_hash = 46244 
10061 };
10062 
10071 SOFIAPUBVAR msg_hclass_t http_via_class[];
10072 
10073 #ifndef HTTP_HCLASSES_ONLY
10074 
10076 SOFIAPUBFUN msg_parse_f http_via_d;
10077 
10079 SOFIAPUBFUN msg_print_f http_via_e;
10080 
10092 #define HTTP_VIA_INIT() HTTP_HDR_INIT(via)
10093 
10107 #if SU_HAVE_INLINE
10108 su_inline http_via_t *http_via_init(http_via_t x[1])
10109 {
10110   return HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t));
10111 }
10112 #else
10113 #define http_via_init(x) \
10114   HTTP_HEADER_INIT(x, http_via_class, sizeof(http_via_t))
10115 #endif
10116 
10130 #if SU_HAVE_INLINE
10131 su_inline 
10132 int http_is_via(http_header_t const *header)
10133 {
10134   return header && header->sh_class->hc_hash == http_via_hash;
10135 }
10136 #else
10137 #define http_is_via(h) \
10138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_via_hash)
10139 #endif
10140 
10168 #if SU_HAVE_INLINE
10169 su_inline
10170 #endif
10171 http_via_t *http_via_dup(su_home_t *home, 
10172                                    http_via_t const *hdr)
10173      __attribute__((__malloc__));
10174 
10203 #if SU_HAVE_INLINE
10204 su_inline
10205 #endif
10206 http_via_t *http_via_copy(su_home_t *home, 
10207                                     http_via_t const *hdr)
10208      __attribute__((__malloc__));
10209 
10228 #if SU_HAVE_INLINE
10229 su_inline
10230 #endif
10231 http_via_t *http_via_make(su_home_t *home, char const *s)
10232      __attribute__((__malloc__));
10233 
10256 #if SU_HAVE_INLINE
10257 su_inline
10258 #endif
10259 http_via_t *http_via_format(su_home_t *home, char const *fmt, ...)
10260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
10261 
10262 
10263 /* Inlined functions */
10264 #if SU_HAVE_INLINE
10265 su_inline
10266 http_via_t *http_via_format(su_home_t *home, char const *fmt, ...)
10267 {
10268   http_header_t *h;
10269   va_list ap;
10270   
10271   va_start(ap, fmt);
10272   h = http_header_vformat(home, http_via_class, fmt, ap);
10273   va_end(ap);
10274  
10275   return (http_via_t *)h;
10276 }
10277 
10278 su_inline
10279 http_via_t *http_via_dup(su_home_t *home, http_via_t const *o) 
10280 { 
10281   return (http_via_t *)
10282     msg_header_dup_as(home, http_via_class, (msg_header_t const *)o);
10283 }
10284 
10285 su_inline
10286 http_via_t *http_via_copy(su_home_t *home, http_via_t const *o) 
10287 { 
10288   return (http_via_t *)
10289     msg_header_copy_as(home, http_via_class, (msg_header_t const *)o); 
10290 }
10291 
10292 su_inline 
10293 http_via_t *http_via_make(su_home_t *home, char const *s)
10294 {
10295   return (http_via_t *)http_header_make(home, http_via_class, s);
10296 }
10297 #endif
10298 
10299 #endif /* !define HTTP_HCLASSES_ONLY */
10300 
10304 /* Declare internal prototypes for Warning header */
10305  
10308 enum { 
10310   http_warning_hash = 4130 
10311 };
10312 
10321 SOFIAPUBVAR msg_hclass_t http_warning_class[];
10322 
10323 #ifndef HTTP_HCLASSES_ONLY
10324 
10326 SOFIAPUBFUN msg_parse_f http_warning_d;
10327 
10329 SOFIAPUBFUN msg_print_f http_warning_e;
10330 
10342 #define HTTP_WARNING_INIT() HTTP_HDR_INIT(warning)
10343 
10357 #if SU_HAVE_INLINE
10358 su_inline http_warning_t *http_warning_init(http_warning_t x[1])
10359 {
10360   return HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t));
10361 }
10362 #else
10363 #define http_warning_init(x) \
10364   HTTP_HEADER_INIT(x, http_warning_class, sizeof(http_warning_t))
10365 #endif
10366 
10380 #if SU_HAVE_INLINE
10381 su_inline 
10382 int http_is_warning(http_header_t const *header)
10383 {
10384   return header && header->sh_class->hc_hash == http_warning_hash;
10385 }
10386 #else
10387 #define http_is_warning(h) \
10388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_warning_hash)
10389 #endif
10390 
10418 #if SU_HAVE_INLINE
10419 su_inline
10420 #endif
10421 http_warning_t *http_warning_dup(su_home_t *home, 
10422                                    http_warning_t const *hdr)
10423      __attribute__((__malloc__));
10424 
10453 #if SU_HAVE_INLINE
10454 su_inline
10455 #endif
10456 http_warning_t *http_warning_copy(su_home_t *home, 
10457                                     http_warning_t const *hdr)
10458      __attribute__((__malloc__));
10459 
10478 #if SU_HAVE_INLINE
10479 su_inline
10480 #endif
10481 http_warning_t *http_warning_make(su_home_t *home, char const *s)
10482      __attribute__((__malloc__));
10483 
10506 #if SU_HAVE_INLINE
10507 su_inline
10508 #endif
10509 http_warning_t *http_warning_format(su_home_t *home, char const *fmt, ...)
10510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
10511 
10512 
10513 /* Inlined functions */
10514 #if SU_HAVE_INLINE
10515 su_inline
10516 http_warning_t *http_warning_format(su_home_t *home, char const *fmt, ...)
10517 {
10518   http_header_t *h;
10519   va_list ap;
10520   
10521   va_start(ap, fmt);
10522   h = http_header_vformat(home, http_warning_class, fmt, ap);
10523   va_end(ap);
10524  
10525   return (http_warning_t *)h;
10526 }
10527 
10528 su_inline
10529 http_warning_t *http_warning_dup(su_home_t *home, http_warning_t const *o) 
10530 { 
10531   return (http_warning_t *)
10532     msg_header_dup_as(home, http_warning_class, (msg_header_t const *)o);
10533 }
10534 
10535 su_inline
10536 http_warning_t *http_warning_copy(su_home_t *home, http_warning_t const *o) 
10537 { 
10538   return (http_warning_t *)
10539     msg_header_copy_as(home, http_warning_class, (msg_header_t const *)o); 
10540 }
10541 
10542 su_inline 
10543 http_warning_t *http_warning_make(su_home_t *home, char const *s)
10544 {
10545   return (http_warning_t *)http_header_make(home, http_warning_class, s);
10546 }
10547 #endif
10548 
10549 #endif /* !define HTTP_HCLASSES_ONLY */
10550 
10554 /* Declare internal prototypes for WWW-Authenticate header */
10555  
10558 enum { 
10560   http_www_authenticate_hash = 16217 
10561 };
10562 
10571 SOFIAPUBVAR msg_hclass_t http_www_authenticate_class[];
10572 
10573 #ifndef HTTP_HCLASSES_ONLY
10574 
10576 SOFIAPUBFUN msg_parse_f http_www_authenticate_d;
10577 
10579 SOFIAPUBFUN msg_print_f http_www_authenticate_e;
10580 
10592 #define HTTP_WWW_AUTHENTICATE_INIT() HTTP_HDR_INIT(www_authenticate)
10593 
10607 #if SU_HAVE_INLINE
10608 su_inline http_www_authenticate_t *http_www_authenticate_init(http_www_authenticate_t x[1])
10609 {
10610   return HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t));
10611 }
10612 #else
10613 #define http_www_authenticate_init(x) \
10614   HTTP_HEADER_INIT(x, http_www_authenticate_class, sizeof(http_www_authenticate_t))
10615 #endif
10616 
10630 #if SU_HAVE_INLINE
10631 su_inline 
10632 int http_is_www_authenticate(http_header_t const *header)
10633 {
10634   return header && header->sh_class->hc_hash == http_www_authenticate_hash;
10635 }
10636 #else
10637 #define http_is_www_authenticate(h) \
10638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_www_authenticate_hash)
10639 #endif
10640 
10668 #if SU_HAVE_INLINE
10669 su_inline
10670 #endif
10671 http_www_authenticate_t *http_www_authenticate_dup(su_home_t *home, 
10672                                    http_www_authenticate_t const *hdr)
10673      __attribute__((__malloc__));
10674 
10703 #if SU_HAVE_INLINE
10704 su_inline
10705 #endif
10706 http_www_authenticate_t *http_www_authenticate_copy(su_home_t *home, 
10707                                     http_www_authenticate_t const *hdr)
10708      __attribute__((__malloc__));
10709 
10728 #if SU_HAVE_INLINE
10729 su_inline
10730 #endif
10731 http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
10732      __attribute__((__malloc__));
10733 
10756 #if SU_HAVE_INLINE
10757 su_inline
10758 #endif
10759 http_www_authenticate_t *http_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
10761 
10762 
10763 /* Inlined functions */
10764 #if SU_HAVE_INLINE
10765 su_inline
10766 http_www_authenticate_t *http_www_authenticate_format(su_home_t *home, char const *fmt, ...)
10767 {
10768   http_header_t *h;
10769   va_list ap;
10770   
10771   va_start(ap, fmt);
10772   h = http_header_vformat(home, http_www_authenticate_class, fmt, ap);
10773   va_end(ap);
10774  
10775   return (http_www_authenticate_t *)h;
10776 }
10777 
10778 su_inline
10779 http_www_authenticate_t *http_www_authenticate_dup(su_home_t *home, http_www_authenticate_t const *o) 
10780 { 
10781   return (http_www_authenticate_t *)
10782     msg_header_dup_as(home, http_www_authenticate_class, (msg_header_t const *)o);
10783 }
10784 
10785 su_inline
10786 http_www_authenticate_t *http_www_authenticate_copy(su_home_t *home, http_www_authenticate_t const *o) 
10787 { 
10788   return (http_www_authenticate_t *)
10789     msg_header_copy_as(home, http_www_authenticate_class, (msg_header_t const *)o); 
10790 }
10791 
10792 su_inline 
10793 http_www_authenticate_t *http_www_authenticate_make(su_home_t *home, char const *s)
10794 {
10795   return (http_www_authenticate_t *)http_header_make(home, http_www_authenticate_class, s);
10796 }
10797 #endif
10798 
10799 #endif /* !define HTTP_HCLASSES_ONLY */
10800 
10804 /* Declare internal prototypes for Proxy-Connection header */
10805  
10808 enum { 
10810   http_proxy_connection_hash = 60183 
10811 };
10812 
10821 SOFIAPUBVAR msg_hclass_t http_proxy_connection_class[];
10822 
10823 #ifndef HTTP_HCLASSES_ONLY
10824 
10826 SOFIAPUBFUN msg_parse_f http_proxy_connection_d;
10827 
10829 SOFIAPUBFUN msg_print_f http_proxy_connection_e;
10830 
10842 #define HTTP_PROXY_CONNECTION_INIT() HTTP_HDR_INIT(proxy_connection)
10843 
10857 #if SU_HAVE_INLINE
10858 su_inline http_proxy_connection_t *http_proxy_connection_init(http_proxy_connection_t x[1])
10859 {
10860   return HTTP_HEADER_INIT(x, http_proxy_connection_class, sizeof(http_proxy_connection_t));
10861 }
10862 #else
10863 #define http_proxy_connection_init(x) \
10864   HTTP_HEADER_INIT(x, http_proxy_connection_class, sizeof(http_proxy_connection_t))
10865 #endif
10866 
10880 #if SU_HAVE_INLINE
10881 su_inline 
10882 int http_is_proxy_connection(http_header_t const *header)
10883 {
10884   return header && header->sh_class->hc_hash == http_proxy_connection_hash;
10885 }
10886 #else
10887 #define http_is_proxy_connection(h) \
10888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_proxy_connection_hash)
10889 #endif
10890 
10918 #if SU_HAVE_INLINE
10919 su_inline
10920 #endif
10921 http_proxy_connection_t *http_proxy_connection_dup(su_home_t *home, 
10922                                    http_proxy_connection_t const *hdr)
10923      __attribute__((__malloc__));
10924 
10953 #if SU_HAVE_INLINE
10954 su_inline
10955 #endif
10956 http_proxy_connection_t *http_proxy_connection_copy(su_home_t *home, 
10957                                     http_proxy_connection_t const *hdr)
10958      __attribute__((__malloc__));
10959 
10978 #if SU_HAVE_INLINE
10979 su_inline
10980 #endif
10981 http_proxy_connection_t *http_proxy_connection_make(su_home_t *home, char const *s)
10982      __attribute__((__malloc__));
10983 
11006 #if SU_HAVE_INLINE
11007 su_inline
11008 #endif
11009 http_proxy_connection_t *http_proxy_connection_format(su_home_t *home, char const *fmt, ...)
11010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
11011 
11012 
11013 /* Inlined functions */
11014 #if SU_HAVE_INLINE
11015 su_inline
11016 http_proxy_connection_t *http_proxy_connection_format(su_home_t *home, char const *fmt, ...)
11017 {
11018   http_header_t *h;
11019   va_list ap;
11020   
11021   va_start(ap, fmt);
11022   h = http_header_vformat(home, http_proxy_connection_class, fmt, ap);
11023   va_end(ap);
11024  
11025   return (http_proxy_connection_t *)h;
11026 }
11027 
11028 su_inline
11029 http_proxy_connection_t *http_proxy_connection_dup(su_home_t *home, http_proxy_connection_t const *o) 
11030 { 
11031   return (http_proxy_connection_t *)
11032     msg_header_dup_as(home, http_proxy_connection_class, (msg_header_t const *)o);
11033 }
11034 
11035 su_inline
11036 http_proxy_connection_t *http_proxy_connection_copy(su_home_t *home, http_proxy_connection_t const *o) 
11037 { 
11038   return (http_proxy_connection_t *)
11039     msg_header_copy_as(home, http_proxy_connection_class, (msg_header_t const *)o); 
11040 }
11041 
11042 su_inline 
11043 http_proxy_connection_t *http_proxy_connection_make(su_home_t *home, char const *s)
11044 {
11045   return (http_proxy_connection_t *)http_header_make(home, http_proxy_connection_class, s);
11046 }
11047 #endif
11048 
11049 #endif /* !define HTTP_HCLASSES_ONLY */
11050 
11054 /* Declare internal prototypes for Set-Cookie header */
11055  
11058 enum { 
11060   http_set_cookie_hash = 57887 
11061 };
11062 
11071 SOFIAPUBVAR msg_hclass_t http_set_cookie_class[];
11072 
11073 #ifndef HTTP_HCLASSES_ONLY
11074 
11076 SOFIAPUBFUN msg_parse_f http_set_cookie_d;
11077 
11079 SOFIAPUBFUN msg_print_f http_set_cookie_e;
11080 
11092 #define HTTP_SET_COOKIE_INIT() HTTP_HDR_INIT(set_cookie)
11093 
11107 #if SU_HAVE_INLINE
11108 su_inline http_set_cookie_t *http_set_cookie_init(http_set_cookie_t x[1])
11109 {
11110   return HTTP_HEADER_INIT(x, http_set_cookie_class, sizeof(http_set_cookie_t));
11111 }
11112 #else
11113 #define http_set_cookie_init(x) \
11114   HTTP_HEADER_INIT(x, http_set_cookie_class, sizeof(http_set_cookie_t))
11115 #endif
11116 
11130 #if SU_HAVE_INLINE
11131 su_inline 
11132 int http_is_set_cookie(http_header_t const *header)
11133 {
11134   return header && header->sh_class->hc_hash == http_set_cookie_hash;
11135 }
11136 #else
11137 #define http_is_set_cookie(h) \
11138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_set_cookie_hash)
11139 #endif
11140 
11168 #if SU_HAVE_INLINE
11169 su_inline
11170 #endif
11171 http_set_cookie_t *http_set_cookie_dup(su_home_t *home, 
11172                                    http_set_cookie_t const *hdr)
11173      __attribute__((__malloc__));
11174 
11203 #if SU_HAVE_INLINE
11204 su_inline
11205 #endif
11206 http_set_cookie_t *http_set_cookie_copy(su_home_t *home, 
11207                                     http_set_cookie_t const *hdr)
11208      __attribute__((__malloc__));
11209 
11228 #if SU_HAVE_INLINE
11229 su_inline
11230 #endif
11231 http_set_cookie_t *http_set_cookie_make(su_home_t *home, char const *s)
11232      __attribute__((__malloc__));
11233 
11256 #if SU_HAVE_INLINE
11257 su_inline
11258 #endif
11259 http_set_cookie_t *http_set_cookie_format(su_home_t *home, char const *fmt, ...)
11260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
11261 
11262 
11263 /* Inlined functions */
11264 #if SU_HAVE_INLINE
11265 su_inline
11266 http_set_cookie_t *http_set_cookie_format(su_home_t *home, char const *fmt, ...)
11267 {
11268   http_header_t *h;
11269   va_list ap;
11270   
11271   va_start(ap, fmt);
11272   h = http_header_vformat(home, http_set_cookie_class, fmt, ap);
11273   va_end(ap);
11274  
11275   return (http_set_cookie_t *)h;
11276 }
11277 
11278 su_inline
11279 http_set_cookie_t *http_set_cookie_dup(su_home_t *home, http_set_cookie_t const *o) 
11280 { 
11281   return (http_set_cookie_t *)
11282     msg_header_dup_as(home, http_set_cookie_class, (msg_header_t const *)o);
11283 }
11284 
11285 su_inline
11286 http_set_cookie_t *http_set_cookie_copy(su_home_t *home, http_set_cookie_t const *o) 
11287 { 
11288   return (http_set_cookie_t *)
11289     msg_header_copy_as(home, http_set_cookie_class, (msg_header_t const *)o); 
11290 }
11291 
11292 su_inline 
11293 http_set_cookie_t *http_set_cookie_make(su_home_t *home, char const *s)
11294 {
11295   return (http_set_cookie_t *)http_header_make(home, http_set_cookie_class, s);
11296 }
11297 #endif
11298 
11299 #endif /* !define HTTP_HCLASSES_ONLY */
11300 
11304 /* Declare internal prototypes for Cookie header */
11305  
11308 enum { 
11310   http_cookie_hash = 78 
11311 };
11312 
11321 SOFIAPUBVAR msg_hclass_t http_cookie_class[];
11322 
11323 #ifndef HTTP_HCLASSES_ONLY
11324 
11326 SOFIAPUBFUN msg_parse_f http_cookie_d;
11327 
11329 SOFIAPUBFUN msg_print_f http_cookie_e;
11330 
11342 #define HTTP_COOKIE_INIT() HTTP_HDR_INIT(cookie)
11343 
11357 #if SU_HAVE_INLINE
11358 su_inline http_cookie_t *http_cookie_init(http_cookie_t x[1])
11359 {
11360   return HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t));
11361 }
11362 #else
11363 #define http_cookie_init(x) \
11364   HTTP_HEADER_INIT(x, http_cookie_class, sizeof(http_cookie_t))
11365 #endif
11366 
11380 #if SU_HAVE_INLINE
11381 su_inline 
11382 int http_is_cookie(http_header_t const *header)
11383 {
11384   return header && header->sh_class->hc_hash == http_cookie_hash;
11385 }
11386 #else
11387 #define http_is_cookie(h) \
11388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_cookie_hash)
11389 #endif
11390 
11418 #if SU_HAVE_INLINE
11419 su_inline
11420 #endif
11421 http_cookie_t *http_cookie_dup(su_home_t *home, 
11422                                    http_cookie_t const *hdr)
11423      __attribute__((__malloc__));
11424 
11453 #if SU_HAVE_INLINE
11454 su_inline
11455 #endif
11456 http_cookie_t *http_cookie_copy(su_home_t *home, 
11457                                     http_cookie_t const *hdr)
11458      __attribute__((__malloc__));
11459 
11478 #if SU_HAVE_INLINE
11479 su_inline
11480 #endif
11481 http_cookie_t *http_cookie_make(su_home_t *home, char const *s)
11482      __attribute__((__malloc__));
11483 
11506 #if SU_HAVE_INLINE
11507 su_inline
11508 #endif
11509 http_cookie_t *http_cookie_format(su_home_t *home, char const *fmt, ...)
11510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
11511 
11512 
11513 /* Inlined functions */
11514 #if SU_HAVE_INLINE
11515 su_inline
11516 http_cookie_t *http_cookie_format(su_home_t *home, char const *fmt, ...)
11517 {
11518   http_header_t *h;
11519   va_list ap;
11520   
11521   va_start(ap, fmt);
11522   h = http_header_vformat(home, http_cookie_class, fmt, ap);
11523   va_end(ap);
11524  
11525   return (http_cookie_t *)h;
11526 }
11527 
11528 su_inline
11529 http_cookie_t *http_cookie_dup(su_home_t *home, http_cookie_t const *o) 
11530 { 
11531   return (http_cookie_t *)
11532     msg_header_dup_as(home, http_cookie_class, (msg_header_t const *)o);
11533 }
11534 
11535 su_inline
11536 http_cookie_t *http_cookie_copy(su_home_t *home, http_cookie_t const *o) 
11537 { 
11538   return (http_cookie_t *)
11539     msg_header_copy_as(home, http_cookie_class, (msg_header_t const *)o); 
11540 }
11541 
11542 su_inline 
11543 http_cookie_t *http_cookie_make(su_home_t *home, char const *s)
11544 {
11545   return (http_cookie_t *)http_header_make(home, http_cookie_class, s);
11546 }
11547 #endif
11548 
11549 #endif /* !define HTTP_HCLASSES_ONLY */
11550 
11554 /* Declare internal prototypes for MIME-Version header */
11555  
11558 enum { 
11560   http_mime_version_hash = 49047 
11561 };
11562 
11571 SOFIAPUBVAR msg_hclass_t http_mime_version_class[];
11572 
11573 #ifndef HTTP_HCLASSES_ONLY
11574 
11576 SOFIAPUBFUN msg_parse_f http_mime_version_d;
11577 
11579 SOFIAPUBFUN msg_print_f http_mime_version_e;
11580 
11592 #define HTTP_MIME_VERSION_INIT() HTTP_HDR_INIT(mime_version)
11593 
11607 #if SU_HAVE_INLINE
11608 su_inline http_mime_version_t *http_mime_version_init(http_mime_version_t x[1])
11609 {
11610   return HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t));
11611 }
11612 #else
11613 #define http_mime_version_init(x) \
11614   HTTP_HEADER_INIT(x, http_mime_version_class, sizeof(http_mime_version_t))
11615 #endif
11616 
11630 #if SU_HAVE_INLINE
11631 su_inline 
11632 int http_is_mime_version(http_header_t const *header)
11633 {
11634   return header && header->sh_class->hc_hash == http_mime_version_hash;
11635 }
11636 #else
11637 #define http_is_mime_version(h) \
11638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_mime_version_hash)
11639 #endif
11640 
11668 #if SU_HAVE_INLINE
11669 su_inline
11670 #endif
11671 http_mime_version_t *http_mime_version_dup(su_home_t *home, 
11672                                    http_mime_version_t const *hdr)
11673      __attribute__((__malloc__));
11674 
11703 #if SU_HAVE_INLINE
11704 su_inline
11705 #endif
11706 http_mime_version_t *http_mime_version_copy(su_home_t *home, 
11707                                     http_mime_version_t const *hdr)
11708      __attribute__((__malloc__));
11709 
11728 #if SU_HAVE_INLINE
11729 su_inline
11730 #endif
11731 http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
11732      __attribute__((__malloc__));
11733 
11756 #if SU_HAVE_INLINE
11757 su_inline
11758 #endif
11759 http_mime_version_t *http_mime_version_format(su_home_t *home, char const *fmt, ...)
11760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
11761 
11762 
11763 /* Inlined functions */
11764 #if SU_HAVE_INLINE
11765 su_inline
11766 http_mime_version_t *http_mime_version_format(su_home_t *home, char const *fmt, ...)
11767 {
11768   http_header_t *h;
11769   va_list ap;
11770   
11771   va_start(ap, fmt);
11772   h = http_header_vformat(home, http_mime_version_class, fmt, ap);
11773   va_end(ap);
11774  
11775   return (http_mime_version_t *)h;
11776 }
11777 
11778 su_inline
11779 http_mime_version_t *http_mime_version_dup(su_home_t *home, http_mime_version_t const *o) 
11780 { 
11781   return (http_mime_version_t *)
11782     msg_header_dup_as(home, http_mime_version_class, (msg_header_t const *)o);
11783 }
11784 
11785 su_inline
11786 http_mime_version_t *http_mime_version_copy(su_home_t *home, http_mime_version_t const *o) 
11787 { 
11788   return (http_mime_version_t *)
11789     msg_header_copy_as(home, http_mime_version_class, (msg_header_t const *)o); 
11790 }
11791 
11792 su_inline 
11793 http_mime_version_t *http_mime_version_make(su_home_t *home, char const *s)
11794 {
11795   return (http_mime_version_t *)http_header_make(home, http_mime_version_class, s);
11796 }
11797 #endif
11798 
11799 #endif /* !define HTTP_HCLASSES_ONLY */
11800 
11804 /* Declare internal prototypes for Content-Encoding header */
11805  
11808 enum { 
11810   http_content_encoding_hash = 8707 
11811 };
11812 
11821 SOFIAPUBVAR msg_hclass_t http_content_encoding_class[];
11822 
11823 #ifndef HTTP_HCLASSES_ONLY
11824 
11826 SOFIAPUBFUN msg_parse_f http_content_encoding_d;
11827 
11829 SOFIAPUBFUN msg_print_f http_content_encoding_e;
11830 
11842 #define HTTP_CONTENT_ENCODING_INIT() HTTP_HDR_INIT(content_encoding)
11843 
11857 #if SU_HAVE_INLINE
11858 su_inline http_content_encoding_t *http_content_encoding_init(http_content_encoding_t x[1])
11859 {
11860   return HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t));
11861 }
11862 #else
11863 #define http_content_encoding_init(x) \
11864   HTTP_HEADER_INIT(x, http_content_encoding_class, sizeof(http_content_encoding_t))
11865 #endif
11866 
11880 #if SU_HAVE_INLINE
11881 su_inline 
11882 int http_is_content_encoding(http_header_t const *header)
11883 {
11884   return header && header->sh_class->hc_hash == http_content_encoding_hash;
11885 }
11886 #else
11887 #define http_is_content_encoding(h) \
11888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_encoding_hash)
11889 #endif
11890 
11918 #if SU_HAVE_INLINE
11919 su_inline
11920 #endif
11921 http_content_encoding_t *http_content_encoding_dup(su_home_t *home, 
11922                                    http_content_encoding_t const *hdr)
11923      __attribute__((__malloc__));
11924 
11953 #if SU_HAVE_INLINE
11954 su_inline
11955 #endif
11956 http_content_encoding_t *http_content_encoding_copy(su_home_t *home, 
11957                                     http_content_encoding_t const *hdr)
11958      __attribute__((__malloc__));
11959 
11978 #if SU_HAVE_INLINE
11979 su_inline
11980 #endif
11981 http_content_encoding_t *http_content_encoding_make(su_home_t *home, char const *s)
11982      __attribute__((__malloc__));
11983 
12006 #if SU_HAVE_INLINE
12007 su_inline
12008 #endif
12009 http_content_encoding_t *http_content_encoding_format(su_home_t *home, char const *fmt, ...)
12010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
12011 
12012 
12013 /* Inlined functions */
12014 #if SU_HAVE_INLINE
12015 su_inline
12016 http_content_encoding_t *http_content_encoding_format(su_home_t *home, char const *fmt, ...)
12017 {
12018   http_header_t *h;
12019   va_list ap;
12020   
12021   va_start(ap, fmt);
12022   h = http_header_vformat(home, http_content_encoding_class, fmt, ap);
12023   va_end(ap);
12024  
12025   return (http_content_encoding_t *)h;
12026 }
12027 
12028 su_inline
12029 http_content_encoding_t *http_content_encoding_dup(su_home_t *home, http_content_encoding_t const *o) 
12030 { 
12031   return (http_content_encoding_t *)
12032     msg_header_dup_as(home, http_content_encoding_class, (msg_header_t const *)o);
12033 }
12034 
12035 su_inline
12036 http_content_encoding_t *http_content_encoding_copy(su_home_t *home, http_content_encoding_t const *o) 
12037 { 
12038   return (http_content_encoding_t *)
12039     msg_header_copy_as(home, http_content_encoding_class, (msg_header_t const *)o); 
12040 }
12041 
12042 su_inline 
12043 http_content_encoding_t *http_content_encoding_make(su_home_t *home, char const *s)
12044 {
12045   return (http_content_encoding_t *)http_header_make(home, http_content_encoding_class, s);
12046 }
12047 #endif
12048 
12049 #endif /* !define HTTP_HCLASSES_ONLY */
12050 
12054 /* Declare internal prototypes for Content-Language header */
12055  
12058 enum { 
12060   http_content_language_hash = 62108 
12061 };
12062 
12071 SOFIAPUBVAR msg_hclass_t http_content_language_class[];
12072 
12073 #ifndef HTTP_HCLASSES_ONLY
12074 
12076 SOFIAPUBFUN msg_parse_f http_content_language_d;
12077 
12079 SOFIAPUBFUN msg_print_f http_content_language_e;
12080 
12092 #define HTTP_CONTENT_LANGUAGE_INIT() HTTP_HDR_INIT(content_language)
12093 
12107 #if SU_HAVE_INLINE
12108 su_inline http_content_language_t *http_content_language_init(http_content_language_t x[1])
12109 {
12110   return HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t));
12111 }
12112 #else
12113 #define http_content_language_init(x) \
12114   HTTP_HEADER_INIT(x, http_content_language_class, sizeof(http_content_language_t))
12115 #endif
12116 
12130 #if SU_HAVE_INLINE
12131 su_inline 
12132 int http_is_content_language(http_header_t const *header)
12133 {
12134   return header && header->sh_class->hc_hash == http_content_language_hash;
12135 }
12136 #else
12137 #define http_is_content_language(h) \
12138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_language_hash)
12139 #endif
12140 
12168 #if SU_HAVE_INLINE
12169 su_inline
12170 #endif
12171 http_content_language_t *http_content_language_dup(su_home_t *home, 
12172                                    http_content_language_t const *hdr)
12173      __attribute__((__malloc__));
12174 
12203 #if SU_HAVE_INLINE
12204 su_inline
12205 #endif
12206 http_content_language_t *http_content_language_copy(su_home_t *home, 
12207                                     http_content_language_t const *hdr)
12208      __attribute__((__malloc__));
12209 
12228 #if SU_HAVE_INLINE
12229 su_inline
12230 #endif
12231 http_content_language_t *http_content_language_make(su_home_t *home, char const *s)
12232      __attribute__((__malloc__));
12233 
12256 #if SU_HAVE_INLINE
12257 su_inline
12258 #endif
12259 http_content_language_t *http_content_language_format(su_home_t *home, char const *fmt, ...)
12260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
12261 
12262 
12263 /* Inlined functions */
12264 #if SU_HAVE_INLINE
12265 su_inline
12266 http_content_language_t *http_content_language_format(su_home_t *home, char const *fmt, ...)
12267 {
12268   http_header_t *h;
12269   va_list ap;
12270   
12271   va_start(ap, fmt);
12272   h = http_header_vformat(home, http_content_language_class, fmt, ap);
12273   va_end(ap);
12274  
12275   return (http_content_language_t *)h;
12276 }
12277 
12278 su_inline
12279 http_content_language_t *http_content_language_dup(su_home_t *home, http_content_language_t const *o) 
12280 { 
12281   return (http_content_language_t *)
12282     msg_header_dup_as(home, http_content_language_class, (msg_header_t const *)o);
12283 }
12284 
12285 su_inline
12286 http_content_language_t *http_content_language_copy(su_home_t *home, http_content_language_t const *o) 
12287 { 
12288   return (http_content_language_t *)
12289     msg_header_copy_as(home, http_content_language_class, (msg_header_t const *)o); 
12290 }
12291 
12292 su_inline 
12293 http_content_language_t *http_content_language_make(su_home_t *home, char const *s)
12294 {
12295   return (http_content_language_t *)http_header_make(home, http_content_language_class, s);
12296 }
12297 #endif
12298 
12299 #endif /* !define HTTP_HCLASSES_ONLY */
12300 
12304 /* Declare internal prototypes for Content-Length header */
12305  
12308 enum { 
12310   http_content_length_hash = 8402 
12311 };
12312 
12321 SOFIAPUBVAR msg_hclass_t http_content_length_class[];
12322 
12323 #ifndef HTTP_HCLASSES_ONLY
12324 
12326 SOFIAPUBFUN msg_parse_f http_content_length_d;
12327 
12329 SOFIAPUBFUN msg_print_f http_content_length_e;
12330 
12342 #define HTTP_CONTENT_LENGTH_INIT() HTTP_HDR_INIT(content_length)
12343 
12357 #if SU_HAVE_INLINE
12358 su_inline http_content_length_t *http_content_length_init(http_content_length_t x[1])
12359 {
12360   return HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t));
12361 }
12362 #else
12363 #define http_content_length_init(x) \
12364   HTTP_HEADER_INIT(x, http_content_length_class, sizeof(http_content_length_t))
12365 #endif
12366 
12380 #if SU_HAVE_INLINE
12381 su_inline 
12382 int http_is_content_length(http_header_t const *header)
12383 {
12384   return header && header->sh_class->hc_hash == http_content_length_hash;
12385 }
12386 #else
12387 #define http_is_content_length(h) \
12388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_length_hash)
12389 #endif
12390 
12418 #if SU_HAVE_INLINE
12419 su_inline
12420 #endif
12421 http_content_length_t *http_content_length_dup(su_home_t *home, 
12422                                    http_content_length_t const *hdr)
12423      __attribute__((__malloc__));
12424 
12453 #if SU_HAVE_INLINE
12454 su_inline
12455 #endif
12456 http_content_length_t *http_content_length_copy(su_home_t *home, 
12457                                     http_content_length_t const *hdr)
12458      __attribute__((__malloc__));
12459 
12478 #if SU_HAVE_INLINE
12479 su_inline
12480 #endif
12481 http_content_length_t *http_content_length_make(su_home_t *home, char const *s)
12482      __attribute__((__malloc__));
12483 
12506 #if SU_HAVE_INLINE
12507 su_inline
12508 #endif
12509 http_content_length_t *http_content_length_format(su_home_t *home, char const *fmt, ...)
12510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
12511 
12512 
12513 /* Inlined functions */
12514 #if SU_HAVE_INLINE
12515 su_inline
12516 http_content_length_t *http_content_length_format(su_home_t *home, char const *fmt, ...)
12517 {
12518   http_header_t *h;
12519   va_list ap;
12520   
12521   va_start(ap, fmt);
12522   h = http_header_vformat(home, http_content_length_class, fmt, ap);
12523   va_end(ap);
12524  
12525   return (http_content_length_t *)h;
12526 }
12527 
12528 su_inline
12529 http_content_length_t *http_content_length_dup(su_home_t *home, http_content_length_t const *o) 
12530 { 
12531   return (http_content_length_t *)
12532     msg_header_dup_as(home, http_content_length_class, (msg_header_t const *)o);
12533 }
12534 
12535 su_inline
12536 http_content_length_t *http_content_length_copy(su_home_t *home, http_content_length_t const *o) 
12537 { 
12538   return (http_content_length_t *)
12539     msg_header_copy_as(home, http_content_length_class, (msg_header_t const *)o); 
12540 }
12541 
12542 su_inline 
12543 http_content_length_t *http_content_length_make(su_home_t *home, char const *s)
12544 {
12545   return (http_content_length_t *)http_header_make(home, http_content_length_class, s);
12546 }
12547 #endif
12548 
12549 #endif /* !define HTTP_HCLASSES_ONLY */
12550 
12554 /* Declare internal prototypes for Content-Location header */
12555  
12558 enum { 
12560   http_content_location_hash = 3453 
12561 };
12562 
12571 SOFIAPUBVAR msg_hclass_t http_content_location_class[];
12572 
12573 #ifndef HTTP_HCLASSES_ONLY
12574 
12576 SOFIAPUBFUN msg_parse_f http_content_location_d;
12577 
12579 SOFIAPUBFUN msg_print_f http_content_location_e;
12580 
12592 #define HTTP_CONTENT_LOCATION_INIT() HTTP_HDR_INIT(content_location)
12593 
12607 #if SU_HAVE_INLINE
12608 su_inline http_content_location_t *http_content_location_init(http_content_location_t x[1])
12609 {
12610   return HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t));
12611 }
12612 #else
12613 #define http_content_location_init(x) \
12614   HTTP_HEADER_INIT(x, http_content_location_class, sizeof(http_content_location_t))
12615 #endif
12616 
12630 #if SU_HAVE_INLINE
12631 su_inline 
12632 int http_is_content_location(http_header_t const *header)
12633 {
12634   return header && header->sh_class->hc_hash == http_content_location_hash;
12635 }
12636 #else
12637 #define http_is_content_location(h) \
12638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_location_hash)
12639 #endif
12640 
12668 #if SU_HAVE_INLINE
12669 su_inline
12670 #endif
12671 http_content_location_t *http_content_location_dup(su_home_t *home, 
12672                                    http_content_location_t const *hdr)
12673      __attribute__((__malloc__));
12674 
12703 #if SU_HAVE_INLINE
12704 su_inline
12705 #endif
12706 http_content_location_t *http_content_location_copy(su_home_t *home, 
12707                                     http_content_location_t const *hdr)
12708      __attribute__((__malloc__));
12709 
12728 #if SU_HAVE_INLINE
12729 su_inline
12730 #endif
12731 http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
12732      __attribute__((__malloc__));
12733 
12756 #if SU_HAVE_INLINE
12757 su_inline
12758 #endif
12759 http_content_location_t *http_content_location_format(su_home_t *home, char const *fmt, ...)
12760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
12761 
12762 
12763 /* Inlined functions */
12764 #if SU_HAVE_INLINE
12765 su_inline
12766 http_content_location_t *http_content_location_format(su_home_t *home, char const *fmt, ...)
12767 {
12768   http_header_t *h;
12769   va_list ap;
12770   
12771   va_start(ap, fmt);
12772   h = http_header_vformat(home, http_content_location_class, fmt, ap);
12773   va_end(ap);
12774  
12775   return (http_content_location_t *)h;
12776 }
12777 
12778 su_inline
12779 http_content_location_t *http_content_location_dup(su_home_t *home, http_content_location_t const *o) 
12780 { 
12781   return (http_content_location_t *)
12782     msg_header_dup_as(home, http_content_location_class, (msg_header_t const *)o);
12783 }
12784 
12785 su_inline
12786 http_content_location_t *http_content_location_copy(su_home_t *home, http_content_location_t const *o) 
12787 { 
12788   return (http_content_location_t *)
12789     msg_header_copy_as(home, http_content_location_class, (msg_header_t const *)o); 
12790 }
12791 
12792 su_inline 
12793 http_content_location_t *http_content_location_make(su_home_t *home, char const *s)
12794 {
12795   return (http_content_location_t *)http_header_make(home, http_content_location_class, s);
12796 }
12797 #endif
12798 
12799 #endif /* !define HTTP_HCLASSES_ONLY */
12800 
12804 /* Declare internal prototypes for Content-MD5 header */
12805  
12808 enum { 
12810   http_content_md5_hash = 60494 
12811 };
12812 
12821 SOFIAPUBVAR msg_hclass_t http_content_md5_class[];
12822 
12823 #ifndef HTTP_HCLASSES_ONLY
12824 
12826 SOFIAPUBFUN msg_parse_f http_content_md5_d;
12827 
12829 SOFIAPUBFUN msg_print_f http_content_md5_e;
12830 
12842 #define HTTP_CONTENT_MD5_INIT() HTTP_HDR_INIT(content_md5)
12843 
12857 #if SU_HAVE_INLINE
12858 su_inline http_content_md5_t *http_content_md5_init(http_content_md5_t x[1])
12859 {
12860   return HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t));
12861 }
12862 #else
12863 #define http_content_md5_init(x) \
12864   HTTP_HEADER_INIT(x, http_content_md5_class, sizeof(http_content_md5_t))
12865 #endif
12866 
12880 #if SU_HAVE_INLINE
12881 su_inline 
12882 int http_is_content_md5(http_header_t const *header)
12883 {
12884   return header && header->sh_class->hc_hash == http_content_md5_hash;
12885 }
12886 #else
12887 #define http_is_content_md5(h) \
12888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_md5_hash)
12889 #endif
12890 
12918 #if SU_HAVE_INLINE
12919 su_inline
12920 #endif
12921 http_content_md5_t *http_content_md5_dup(su_home_t *home, 
12922                                    http_content_md5_t const *hdr)
12923      __attribute__((__malloc__));
12924 
12953 #if SU_HAVE_INLINE
12954 su_inline
12955 #endif
12956 http_content_md5_t *http_content_md5_copy(su_home_t *home, 
12957                                     http_content_md5_t const *hdr)
12958      __attribute__((__malloc__));
12959 
12978 #if SU_HAVE_INLINE
12979 su_inline
12980 #endif
12981 http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
12982      __attribute__((__malloc__));
12983 
13006 #if SU_HAVE_INLINE
13007 su_inline
13008 #endif
13009 http_content_md5_t *http_content_md5_format(su_home_t *home, char const *fmt, ...)
13010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
13011 
13012 
13013 /* Inlined functions */
13014 #if SU_HAVE_INLINE
13015 su_inline
13016 http_content_md5_t *http_content_md5_format(su_home_t *home, char const *fmt, ...)
13017 {
13018   http_header_t *h;
13019   va_list ap;
13020   
13021   va_start(ap, fmt);
13022   h = http_header_vformat(home, http_content_md5_class, fmt, ap);
13023   va_end(ap);
13024  
13025   return (http_content_md5_t *)h;
13026 }
13027 
13028 su_inline
13029 http_content_md5_t *http_content_md5_dup(su_home_t *home, http_content_md5_t const *o) 
13030 { 
13031   return (http_content_md5_t *)
13032     msg_header_dup_as(home, http_content_md5_class, (msg_header_t const *)o);
13033 }
13034 
13035 su_inline
13036 http_content_md5_t *http_content_md5_copy(su_home_t *home, http_content_md5_t const *o) 
13037 { 
13038   return (http_content_md5_t *)
13039     msg_header_copy_as(home, http_content_md5_class, (msg_header_t const *)o); 
13040 }
13041 
13042 su_inline 
13043 http_content_md5_t *http_content_md5_make(su_home_t *home, char const *s)
13044 {
13045   return (http_content_md5_t *)http_header_make(home, http_content_md5_class, s);
13046 }
13047 #endif
13048 
13049 #endif /* !define HTTP_HCLASSES_ONLY */
13050 
13054 /* Declare internal prototypes for Content-Range header */
13055  
13058 enum { 
13060   http_content_range_hash = 64465 
13061 };
13062 
13071 SOFIAPUBVAR msg_hclass_t http_content_range_class[];
13072 
13073 #ifndef HTTP_HCLASSES_ONLY
13074 
13076 SOFIAPUBFUN msg_parse_f http_content_range_d;
13077 
13079 SOFIAPUBFUN msg_print_f http_content_range_e;
13080 
13092 #define HTTP_CONTENT_RANGE_INIT() HTTP_HDR_INIT(content_range)
13093 
13107 #if SU_HAVE_INLINE
13108 su_inline http_content_range_t *http_content_range_init(http_content_range_t x[1])
13109 {
13110   return HTTP_HEADER_INIT(x, http_content_range_class, sizeof(http_content_range_t));
13111 }
13112 #else
13113 #define http_content_range_init(x) \
13114   HTTP_HEADER_INIT(x, http_content_range_class, sizeof(http_content_range_t))
13115 #endif
13116 
13130 #if SU_HAVE_INLINE
13131 su_inline 
13132 int http_is_content_range(http_header_t const *header)
13133 {
13134   return header && header->sh_class->hc_hash == http_content_range_hash;
13135 }
13136 #else
13137 #define http_is_content_range(h) \
13138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_range_hash)
13139 #endif
13140 
13168 #if SU_HAVE_INLINE
13169 su_inline
13170 #endif
13171 http_content_range_t *http_content_range_dup(su_home_t *home, 
13172                                    http_content_range_t const *hdr)
13173      __attribute__((__malloc__));
13174 
13203 #if SU_HAVE_INLINE
13204 su_inline
13205 #endif
13206 http_content_range_t *http_content_range_copy(su_home_t *home, 
13207                                     http_content_range_t const *hdr)
13208      __attribute__((__malloc__));
13209 
13228 #if SU_HAVE_INLINE
13229 su_inline
13230 #endif
13231 http_content_range_t *http_content_range_make(su_home_t *home, char const *s)
13232      __attribute__((__malloc__));
13233 
13256 #if SU_HAVE_INLINE
13257 su_inline
13258 #endif
13259 http_content_range_t *http_content_range_format(su_home_t *home, char const *fmt, ...)
13260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
13261 
13262 
13263 /* Inlined functions */
13264 #if SU_HAVE_INLINE
13265 su_inline
13266 http_content_range_t *http_content_range_format(su_home_t *home, char const *fmt, ...)
13267 {
13268   http_header_t *h;
13269   va_list ap;
13270   
13271   va_start(ap, fmt);
13272   h = http_header_vformat(home, http_content_range_class, fmt, ap);
13273   va_end(ap);
13274  
13275   return (http_content_range_t *)h;
13276 }
13277 
13278 su_inline
13279 http_content_range_t *http_content_range_dup(su_home_t *home, http_content_range_t const *o) 
13280 { 
13281   return (http_content_range_t *)
13282     msg_header_dup_as(home, http_content_range_class, (msg_header_t const *)o);
13283 }
13284 
13285 su_inline
13286 http_content_range_t *http_content_range_copy(su_home_t *home, http_content_range_t const *o) 
13287 { 
13288   return (http_content_range_t *)
13289     msg_header_copy_as(home, http_content_range_class, (msg_header_t const *)o); 
13290 }
13291 
13292 su_inline 
13293 http_content_range_t *http_content_range_make(su_home_t *home, char const *s)
13294 {
13295   return (http_content_range_t *)http_header_make(home, http_content_range_class, s);
13296 }
13297 #endif
13298 
13299 #endif /* !define HTTP_HCLASSES_ONLY */
13300 
13304 /* Declare internal prototypes for Content-Type header */
13305  
13308 enum { 
13310   http_content_type_hash = 51226 
13311 };
13312 
13321 SOFIAPUBVAR msg_hclass_t http_content_type_class[];
13322 
13323 #ifndef HTTP_HCLASSES_ONLY
13324 
13326 SOFIAPUBFUN msg_parse_f http_content_type_d;
13327 
13329 SOFIAPUBFUN msg_print_f http_content_type_e;
13330 
13342 #define HTTP_CONTENT_TYPE_INIT() HTTP_HDR_INIT(content_type)
13343 
13357 #if SU_HAVE_INLINE
13358 su_inline http_content_type_t *http_content_type_init(http_content_type_t x[1])
13359 {
13360   return HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t));
13361 }
13362 #else
13363 #define http_content_type_init(x) \
13364   HTTP_HEADER_INIT(x, http_content_type_class, sizeof(http_content_type_t))
13365 #endif
13366 
13380 #if SU_HAVE_INLINE
13381 su_inline 
13382 int http_is_content_type(http_header_t const *header)
13383 {
13384   return header && header->sh_class->hc_hash == http_content_type_hash;
13385 }
13386 #else
13387 #define http_is_content_type(h) \
13388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_content_type_hash)
13389 #endif
13390 
13418 #if SU_HAVE_INLINE
13419 su_inline
13420 #endif
13421 http_content_type_t *http_content_type_dup(su_home_t *home, 
13422                                    http_content_type_t const *hdr)
13423      __attribute__((__malloc__));
13424 
13453 #if SU_HAVE_INLINE
13454 su_inline
13455 #endif
13456 http_content_type_t *http_content_type_copy(su_home_t *home, 
13457                                     http_content_type_t const *hdr)
13458      __attribute__((__malloc__));
13459 
13478 #if SU_HAVE_INLINE
13479 su_inline
13480 #endif
13481 http_content_type_t *http_content_type_make(su_home_t *home, char const *s)
13482      __attribute__((__malloc__));
13483 
13506 #if SU_HAVE_INLINE
13507 su_inline
13508 #endif
13509 http_content_type_t *http_content_type_format(su_home_t *home, char const *fmt, ...)
13510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
13511 
13512 
13513 /* Inlined functions */
13514 #if SU_HAVE_INLINE
13515 su_inline
13516 http_content_type_t *http_content_type_format(su_home_t *home, char const *fmt, ...)
13517 {
13518   http_header_t *h;
13519   va_list ap;
13520   
13521   va_start(ap, fmt);
13522   h = http_header_vformat(home, http_content_type_class, fmt, ap);
13523   va_end(ap);
13524  
13525   return (http_content_type_t *)h;
13526 }
13527 
13528 su_inline
13529 http_content_type_t *http_content_type_dup(su_home_t *home, http_content_type_t const *o) 
13530 { 
13531   return (http_content_type_t *)
13532     msg_header_dup_as(home, http_content_type_class, (msg_header_t const *)o);
13533 }
13534 
13535 su_inline
13536 http_content_type_t *http_content_type_copy(su_home_t *home, http_content_type_t const *o) 
13537 { 
13538   return (http_content_type_t *)
13539     msg_header_copy_as(home, http_content_type_class, (msg_header_t const *)o); 
13540 }
13541 
13542 su_inline 
13543 http_content_type_t *http_content_type_make(su_home_t *home, char const *s)
13544 {
13545   return (http_content_type_t *)http_header_make(home, http_content_type_class, s);
13546 }
13547 #endif
13548 
13549 #endif /* !define HTTP_HCLASSES_ONLY */
13550 
13554 /* Declare internal prototypes for unknown headers */
13555  
13558 enum { 
13560   http_unknown_hash = -3 
13561 };
13562 
13571 SOFIAPUBVAR msg_hclass_t http_unknown_class[];
13572 
13573 #ifndef HTTP_HCLASSES_ONLY
13574 
13576 SOFIAPUBFUN msg_parse_f http_unknown_d;
13577 
13579 SOFIAPUBFUN msg_print_f http_unknown_e;
13580 
13592 #define HTTP_UNKNOWN_INIT() HTTP_HDR_INIT(unknown)
13593 
13607 #if SU_HAVE_INLINE
13608 su_inline http_unknown_t *http_unknown_init(http_unknown_t x[1])
13609 {
13610   return HTTP_HEADER_INIT(x, http_unknown_class, sizeof(http_unknown_t));
13611 }
13612 #else
13613 #define http_unknown_init(x) \
13614   HTTP_HEADER_INIT(x, http_unknown_class, sizeof(http_unknown_t))
13615 #endif
13616 
13630 #if SU_HAVE_INLINE
13631 su_inline 
13632 int http_is_unknown(http_header_t const *header)
13633 {
13634   return header && header->sh_class->hc_hash == http_unknown_hash;
13635 }
13636 #else
13637 #define http_is_unknown(h) \
13638  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_unknown_hash)
13639 #endif
13640 
13668 #if SU_HAVE_INLINE
13669 su_inline
13670 #endif
13671 http_unknown_t *http_unknown_dup(su_home_t *home, 
13672                                    http_unknown_t const *hdr)
13673      __attribute__((__malloc__));
13674 
13703 #if SU_HAVE_INLINE
13704 su_inline
13705 #endif
13706 http_unknown_t *http_unknown_copy(su_home_t *home, 
13707                                     http_unknown_t const *hdr)
13708      __attribute__((__malloc__));
13709 
13728 #if SU_HAVE_INLINE
13729 su_inline
13730 #endif
13731 http_unknown_t *http_unknown_make(su_home_t *home, char const *s)
13732      __attribute__((__malloc__));
13733 
13756 #if SU_HAVE_INLINE
13757 su_inline
13758 #endif
13759 http_unknown_t *http_unknown_format(su_home_t *home, char const *fmt, ...)
13760      __attribute__((__malloc__, __format__ (printf, 2, 3)));
13761 
13762 
13763 /* Inlined functions */
13764 #if SU_HAVE_INLINE
13765 su_inline
13766 http_unknown_t *http_unknown_format(su_home_t *home, char const *fmt, ...)
13767 {
13768   http_header_t *h;
13769   va_list ap;
13770   
13771   va_start(ap, fmt);
13772   h = http_header_vformat(home, http_unknown_class, fmt, ap);
13773   va_end(ap);
13774  
13775   return (http_unknown_t *)h;
13776 }
13777 
13778 su_inline
13779 http_unknown_t *http_unknown_dup(su_home_t *home, http_unknown_t const *o) 
13780 { 
13781   return (http_unknown_t *)
13782     msg_header_dup_as(home, http_unknown_class, (msg_header_t const *)o);
13783 }
13784 
13785 su_inline
13786 http_unknown_t *http_unknown_copy(su_home_t *home, http_unknown_t const *o) 
13787 { 
13788   return (http_unknown_t *)
13789     msg_header_copy_as(home, http_unknown_class, (msg_header_t const *)o); 
13790 }
13791 
13792 su_inline 
13793 http_unknown_t *http_unknown_make(su_home_t *home, char const *s)
13794 {
13795   return (http_unknown_t *)http_header_make(home, http_unknown_class, s);
13796 }
13797 #endif
13798 
13799 #endif /* !define HTTP_HCLASSES_ONLY */
13800 
13804 /* Declare internal prototypes for erroneous headers */
13805  
13808 enum { 
13810   http_error_hash = -4 
13811 };
13812 
13821 SOFIAPUBVAR msg_hclass_t http_error_class[];
13822 
13823 #ifndef HTTP_HCLASSES_ONLY
13824 
13826 SOFIAPUBFUN msg_parse_f http_error_d;
13827 
13829 SOFIAPUBFUN msg_print_f http_error_e;
13830 
13842 #define HTTP_ERROR_INIT() HTTP_HDR_INIT(error)
13843 
13857 #if SU_HAVE_INLINE
13858 su_inline http_error_t *http_error_init(http_error_t x[1])
13859 {
13860   return HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t));
13861 }
13862 #else
13863 #define http_error_init(x) \
13864   HTTP_HEADER_INIT(x, http_error_class, sizeof(http_error_t))
13865 #endif
13866 
13880 #if SU_HAVE_INLINE
13881 su_inline 
13882 int http_is_error(http_header_t const *header)
13883 {
13884   return header && header->sh_class->hc_hash == http_error_hash;
13885 }
13886 #else
13887 #define http_is_error(h) \
13888  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_error_hash)
13889 #endif
13890 
13918 #if SU_HAVE_INLINE
13919 su_inline
13920 #endif
13921 http_error_t *http_error_dup(su_home_t *home, 
13922                                    http_error_t const *hdr)
13923      __attribute__((__malloc__));
13924 
13953 #if SU_HAVE_INLINE
13954 su_inline
13955 #endif
13956 http_error_t *http_error_copy(su_home_t *home, 
13957                                     http_error_t const *hdr)
13958      __attribute__((__malloc__));
13959 
13978 #if SU_HAVE_INLINE
13979 su_inline
13980 #endif
13981 http_error_t *http_error_make(su_home_t *home, char const *s)
13982      __attribute__((__malloc__));
13983 
14006 #if SU_HAVE_INLINE
14007 su_inline
14008 #endif
14009 http_error_t *http_error_format(su_home_t *home, char const *fmt, ...)
14010      __attribute__((__malloc__, __format__ (printf, 2, 3)));
14011 
14012 
14013 /* Inlined functions */
14014 #if SU_HAVE_INLINE
14015 su_inline
14016 http_error_t *http_error_format(su_home_t *home, char const *fmt, ...)
14017 {
14018   http_header_t *h;
14019   va_list ap;
14020   
14021   va_start(ap, fmt);
14022   h = http_header_vformat(home, http_error_class, fmt, ap);
14023   va_end(ap);
14024  
14025   return (http_error_t *)h;
14026 }
14027 
14028 su_inline
14029 http_error_t *http_error_dup(su_home_t *home, http_error_t const *o) 
14030 { 
14031   return (http_error_t *)
14032     msg_header_dup_as(home, http_error_class, (msg_header_t const *)o);
14033 }
14034 
14035 su_inline
14036 http_error_t *http_error_copy(su_home_t *home, http_error_t const *o) 
14037 { 
14038   return (http_error_t *)
14039     msg_header_copy_as(home, http_error_class, (msg_header_t const *)o); 
14040 }
14041 
14042 su_inline 
14043 http_error_t *http_error_make(su_home_t *home, char const *s)
14044 {
14045   return (http_error_t *)http_header_make(home, http_error_class, s);
14046 }
14047 #endif
14048 
14049 #endif /* !define HTTP_HCLASSES_ONLY */
14050 
14054 /* Declare internal prototypes for separator line between headers and body */
14055  
14058 enum { 
14060   http_separator_hash = -5 
14061 };
14062 
14071 SOFIAPUBVAR msg_hclass_t http_separator_class[];
14072 
14073 #ifndef HTTP_HCLASSES_ONLY
14074 
14076 SOFIAPUBFUN msg_parse_f http_separator_d;
14077 
14079 SOFIAPUBFUN msg_print_f http_separator_e;
14080 
14092 #define HTTP_SEPARATOR_INIT() HTTP_HDR_INIT(separator)
14093 
14107 #if SU_HAVE_INLINE
14108 su_inline http_separator_t *http_separator_init(http_separator_t x[1])
14109 {
14110   return HTTP_HEADER_INIT(x, http_separator_class, sizeof(http_separator_t));
14111 }
14112 #else
14113 #define http_separator_init(x) \
14114   HTTP_HEADER_INIT(x, http_separator_class, sizeof(http_separator_t))
14115 #endif
14116 
14130 #if SU_HAVE_INLINE
14131 su_inline 
14132 int http_is_separator(http_header_t const *header)
14133 {
14134   return header && header->sh_class->hc_hash == http_separator_hash;
14135 }
14136 #else
14137 #define http_is_separator(h) \
14138  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_separator_hash)
14139 #endif
14140 
14168 #if SU_HAVE_INLINE
14169 su_inline
14170 #endif
14171 http_separator_t *http_separator_dup(su_home_t *home, 
14172                                    http_separator_t const *hdr)
14173      __attribute__((__malloc__));
14174 
14203 #if SU_HAVE_INLINE
14204 su_inline
14205 #endif
14206 http_separator_t *http_separator_copy(su_home_t *home, 
14207                                     http_separator_t const *hdr)
14208      __attribute__((__malloc__));
14209 
14228 #if SU_HAVE_INLINE
14229 su_inline
14230 #endif
14231 http_separator_t *http_separator_make(su_home_t *home, char const *s)
14232      __attribute__((__malloc__));
14233 
14256 #if SU_HAVE_INLINE
14257 su_inline
14258 #endif
14259 http_separator_t *http_separator_format(su_home_t *home, char const *fmt, ...)
14260      __attribute__((__malloc__, __format__ (printf, 2, 3)));
14261 
14262 
14263 /* Inlined functions */
14264 #if SU_HAVE_INLINE
14265 su_inline
14266 http_separator_t *http_separator_format(su_home_t *home, char const *fmt, ...)
14267 {
14268   http_header_t *h;
14269   va_list ap;
14270   
14271   va_start(ap, fmt);
14272   h = http_header_vformat(home, http_separator_class, fmt, ap);
14273   va_end(ap);
14274  
14275   return (http_separator_t *)h;
14276 }
14277 
14278 su_inline
14279 http_separator_t *http_separator_dup(su_home_t *home, http_separator_t const *o) 
14280 { 
14281   return (http_separator_t *)
14282     msg_header_dup_as(home, http_separator_class, (msg_header_t const *)o);
14283 }
14284 
14285 su_inline
14286 http_separator_t *http_separator_copy(su_home_t *home, http_separator_t const *o) 
14287 { 
14288   return (http_separator_t *)
14289     msg_header_copy_as(home, http_separator_class, (msg_header_t const *)o); 
14290 }
14291 
14292 su_inline 
14293 http_separator_t *http_separator_make(su_home_t *home, char const *s)
14294 {
14295   return (http_separator_t *)http_header_make(home, http_separator_class, s);
14296 }
14297 #endif
14298 
14299 #endif /* !define HTTP_HCLASSES_ONLY */
14300 
14304 /* Declare internal prototypes for message payload */
14305  
14308 enum { 
14310   http_payload_hash = -6 
14311 };
14312 
14321 SOFIAPUBVAR msg_hclass_t http_payload_class[];
14322 
14323 #ifndef HTTP_HCLASSES_ONLY
14324 
14326 SOFIAPUBFUN msg_parse_f http_payload_d;
14327 
14329 SOFIAPUBFUN msg_print_f http_payload_e;
14330 
14342 #define HTTP_PAYLOAD_INIT() HTTP_HDR_INIT(payload)
14343 
14357 #if SU_HAVE_INLINE
14358 su_inline http_payload_t *http_payload_init(http_payload_t x[1])
14359 {
14360   return HTTP_HEADER_INIT(x, http_payload_class, sizeof(http_payload_t));
14361 }
14362 #else
14363 #define http_payload_init(x) \
14364   HTTP_HEADER_INIT(x, http_payload_class, sizeof(http_payload_t))
14365 #endif
14366 
14380 #if SU_HAVE_INLINE
14381 su_inline 
14382 int http_is_payload(http_header_t const *header)
14383 {
14384   return header && header->sh_class->hc_hash == http_payload_hash;
14385 }
14386 #else
14387 #define http_is_payload(h) \
14388  ((h) && ((msg_common_t *)(h))->h_class->hc_hash == http_payload_hash)
14389 #endif
14390 
14418 #if SU_HAVE_INLINE
14419 su_inline
14420 #endif
14421 http_payload_t *http_payload_dup(su_home_t *home, 
14422                                    http_payload_t const *hdr)
14423      __attribute__((__malloc__));
14424 
14453 #if SU_HAVE_INLINE
14454 su_inline
14455 #endif
14456 http_payload_t *http_payload_copy(su_home_t *home, 
14457                                     http_payload_t const *hdr)
14458      __attribute__((__malloc__));
14459 
14478 #if SU_HAVE_INLINE
14479 su_inline
14480 #endif
14481 http_payload_t *http_payload_make(su_home_t *home, char const *s)
14482      __attribute__((__malloc__));
14483 
14506 #if SU_HAVE_INLINE
14507 su_inline
14508 #endif
14509 http_payload_t *http_payload_format(su_home_t *home, char const *fmt, ...)
14510      __attribute__((__malloc__, __format__ (printf, 2, 3)));
14511 
14512 
14513 /* Inlined functions */
14514 #if SU_HAVE_INLINE
14515 su_inline
14516 http_payload_t *http_payload_format(su_home_t *home, char const *fmt, ...)
14517 {
14518   http_header_t *h;
14519   va_list ap;
14520   
14521   va_start(ap, fmt);
14522   h = http_header_vformat(home, http_payload_class, fmt, ap);
14523   va_end(ap);
14524  
14525   return (http_payload_t *)h;
14526 }
14527 
14528 su_inline
14529 http_payload_t *http_payload_dup(su_home_t *home, http_payload_t const *o) 
14530 { 
14531   return (http_payload_t *)
14532     msg_header_dup_as(home, http_payload_class, (msg_header_t const *)o);
14533 }
14534 
14535 su_inline
14536 http_payload_t *http_payload_copy(su_home_t *home, http_payload_t const *o) 
14537 { 
14538   return (http_payload_t *)
14539     msg_header_copy_as(home, http_payload_class, (msg_header_t const *)o); 
14540 }
14541 
14542 su_inline 
14543 http_payload_t *http_payload_make(su_home_t *home, char const *s)
14544 {
14545   return (http_payload_t *)http_header_make(home, http_payload_class, s);
14546 }
14547 #endif
14548 
14549 #endif /* !define HTTP_HCLASSES_ONLY */
14550 
14554 SOFIA_END_DECLS
14555 #endif /* !defined(HTTP_PROTOS_H) */

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