http
1.12.11
|
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) */