sofia-sip/msg_mime_protos.h

Go to the documentation of this file.
00001 /*
00002  * This file is part of the Sofia-SIP package
00003  *
00004  * Copyright (C) 2005 Nokia Corporation.
00005  *
00006  * Contact: Pekka Pessi <pekka.pessi@nokia-email.address.hidden>
00007  *
00008  * This library is free software; you can redistribute it and/or
00009  * modify it under the terms of the GNU Lesser General Public License
00010  * as published by the Free Software Foundation; either version 2.1 of
00011  * the License, or (at your option) any later version.
00012  *
00013  * This library is distributed in the hope that it will be useful, but
00014  * WITHOUT ANY WARRANTY; without even the implied warranty of
00015  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
00016  * Lesser General Public License for more details.
00017  *
00018  * You should have received a copy of the GNU Lesser General Public
00019  * License along with this library; if not, write to the Free Software
00020  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
00021  * 02110-1301 USA
00022  *
00023  */
00024 
00025 #ifndef MSG_MIME_PROTOS_H
00026 
00027 #define MSG_MIME_PROTOS_H 
00028 
00039 #ifndef MSG_PARSER_H
00040 #include <sofia-sip/msg_parser.h>
00041 #endif
00042 #ifndef MSG_MIME_H
00043 #include <sofia-sip/msg_mime.h>
00044 #endif
00045 #ifndef MSG_MCLASS_H
00046 #include <sofia-sip/msg_mclass.h>
00047 #endif
00048 #ifndef MSG_MCLASS_H
00049 #include <sofia-sip/msg_mclass.h>
00050 #endif
00051 
00052 SOFIA_BEGIN_DECLS
00053 
00054 MSG_DLL extern msg_mclass_t const msg_multipart_mclass[1];
00055 
00056 #define msg_multipart_class ((msg_hclass_t *)msg_multipart_mclass)
00057 
00058 
00059 /* Declare internal prototypes for Content-Type header */
00060 
00065 enum { 
00067   msg_content_type_hash = 51226 
00068 };
00069 
00071 MSG_DLL msg_parse_f msg_content_type_d;
00072 
00074 MSG_DLL msg_print_f msg_content_type_e;
00075 
00076 MSG_DLL msg_xtra_f msg_content_type_dup_xtra;
00077 MSG_DLL msg_dup_f msg_content_type_dup_one;
00078 
00087 #ifndef msg_content_type_class
00088 MSG_DLL extern msg_hclass_t msg_content_type_class[];
00089 #endif
00090 
00102 #define MSG_CONTENT_TYPE_INIT() MSG_HDR_INIT(content_type)
00103 
00118 #if SU_HAVE_INLINE
00119 su_inline msg_content_type_t *msg_content_type_init(msg_content_type_t x[1])
00120 {
00121   return MSG_HEADER_INIT(x, msg_content_type_class, sizeof(msg_content_type_t));
00122 }
00123 #else
00124 #define msg_content_type_init(x) \
00125   MSG_HEADER_INIT(x, msg_content_type_class, sizeof(msg_content_type_t))
00126 #endif
00127 
00140 #if SU_HAVE_INLINE
00141 su_inline int msg_is_content_type(msg_header_t const *header)
00142 {
00143   return header && header->sh_class->hc_hash == msg_content_type_hash;
00144 }
00145 #else
00146 int msg_is_content_type(msg_header_t const *header);
00147 #endif
00148 
00149 #define msg_content_type_p(h) msg_is_content_type((h))
00150 
00178 #if SU_HAVE_INLINE
00179 su_inline
00180 #endif
00181 msg_content_type_t *msg_content_type_dup(su_home_t *home, 
00182                                  msg_content_type_t const *header);
00183 
00184 #if SU_HAVE_INLINE
00185 su_inline
00186 msg_content_type_t *msg_content_type_dup(su_home_t *home, 
00187                                  msg_content_type_t const *header)
00188 {
00189   return (msg_content_type_t *)
00190     msg_header_dup_as(home, msg_content_type_class, (msg_header_t const *)header); 
00191 }
00192 #endif
00193 
00194 
00223 #if SU_HAVE_INLINE
00224 su_inline
00225 #endif
00226 msg_content_type_t *msg_content_type_copy(su_home_t *home, 
00227                                   msg_content_type_t const *header);
00228 
00229 #if SU_HAVE_INLINE
00230 su_inline
00231 msg_content_type_t *msg_content_type_copy(su_home_t *home, 
00232                                   msg_content_type_t const *header)
00233 {
00234   return (msg_content_type_t *)
00235     msg_header_copy_as(home, msg_content_type_class, (msg_header_t const *)header); 
00236 }
00237 #endif
00238 
00239 
00256 #if SU_HAVE_INLINE
00257 su_inline msg_content_type_t *msg_content_type_make(su_home_t *home, char const *s)
00258 {
00259   return (msg_content_type_t*)msg_header_make(home, msg_content_type_class, s);
00260 }
00261 #else
00262 msg_content_type_t *msg_content_type_make(su_home_t *home, char const *s);
00263 #endif
00264 
00265 
00287 #if SU_HAVE_INLINE
00288 su_inline
00289 #endif
00290 msg_content_type_t *msg_content_type_format(su_home_t *home, char const *fmt, ...)
00291      __attribute__((__format__ (printf, 2, 3)));
00292 
00293 #if SU_HAVE_INLINE
00294 su_inline msg_content_type_t *msg_content_type_format(su_home_t *home, char const *fmt, ...)
00295 {
00296   msg_header_t *h;
00297   va_list ap;
00298   
00299   va_start(ap, fmt);
00300   h = msg_header_vformat(home, msg_content_type_class, fmt, ap);
00301   va_end(ap);
00302  
00303   return (msg_content_type_t*)h;
00304 }
00305 #endif
00306 
00309 /* Declare internal prototypes for Content-Disposition header */
00310 
00315 enum { 
00317   msg_content_disposition_hash = 16333 
00318 };
00319 
00321 MSG_DLL msg_parse_f msg_content_disposition_d;
00322 
00324 MSG_DLL msg_print_f msg_content_disposition_e;
00325 
00326 MSG_DLL msg_xtra_f msg_content_disposition_dup_xtra;
00327 MSG_DLL msg_dup_f msg_content_disposition_dup_one;
00328 
00337 #ifndef msg_content_disposition_class
00338 MSG_DLL extern msg_hclass_t msg_content_disposition_class[];
00339 #endif
00340 
00352 #define MSG_CONTENT_DISPOSITION_INIT() MSG_HDR_INIT(content_disposition)
00353 
00368 #if SU_HAVE_INLINE
00369 su_inline msg_content_disposition_t *msg_content_disposition_init(msg_content_disposition_t x[1])
00370 {
00371   return MSG_HEADER_INIT(x, msg_content_disposition_class, sizeof(msg_content_disposition_t));
00372 }
00373 #else
00374 #define msg_content_disposition_init(x) \
00375   MSG_HEADER_INIT(x, msg_content_disposition_class, sizeof(msg_content_disposition_t))
00376 #endif
00377 
00390 #if SU_HAVE_INLINE
00391 su_inline int msg_is_content_disposition(msg_header_t const *header)
00392 {
00393   return header && header->sh_class->hc_hash == msg_content_disposition_hash;
00394 }
00395 #else
00396 int msg_is_content_disposition(msg_header_t const *header);
00397 #endif
00398 
00399 #define msg_content_disposition_p(h) msg_is_content_disposition((h))
00400 
00428 #if SU_HAVE_INLINE
00429 su_inline
00430 #endif
00431 msg_content_disposition_t *msg_content_disposition_dup(su_home_t *home, 
00432                                  msg_content_disposition_t const *header);
00433 
00434 #if SU_HAVE_INLINE
00435 su_inline
00436 msg_content_disposition_t *msg_content_disposition_dup(su_home_t *home, 
00437                                  msg_content_disposition_t const *header)
00438 {
00439   return (msg_content_disposition_t *)
00440     msg_header_dup_as(home, msg_content_disposition_class, (msg_header_t const *)header); 
00441 }
00442 #endif
00443 
00444 
00473 #if SU_HAVE_INLINE
00474 su_inline
00475 #endif
00476 msg_content_disposition_t *msg_content_disposition_copy(su_home_t *home, 
00477                                   msg_content_disposition_t const *header);
00478 
00479 #if SU_HAVE_INLINE
00480 su_inline
00481 msg_content_disposition_t *msg_content_disposition_copy(su_home_t *home, 
00482                                   msg_content_disposition_t const *header)
00483 {
00484   return (msg_content_disposition_t *)
00485     msg_header_copy_as(home, msg_content_disposition_class, (msg_header_t const *)header); 
00486 }
00487 #endif
00488 
00489 
00506 #if SU_HAVE_INLINE
00507 su_inline msg_content_disposition_t *msg_content_disposition_make(su_home_t *home, char const *s)
00508 {
00509   return (msg_content_disposition_t*)msg_header_make(home, msg_content_disposition_class, s);
00510 }
00511 #else
00512 msg_content_disposition_t *msg_content_disposition_make(su_home_t *home, char const *s);
00513 #endif
00514 
00515 
00537 #if SU_HAVE_INLINE
00538 su_inline
00539 #endif
00540 msg_content_disposition_t *msg_content_disposition_format(su_home_t *home, char const *fmt, ...)
00541      __attribute__((__format__ (printf, 2, 3)));
00542 
00543 #if SU_HAVE_INLINE
00544 su_inline msg_content_disposition_t *msg_content_disposition_format(su_home_t *home, char const *fmt, ...)
00545 {
00546   msg_header_t *h;
00547   va_list ap;
00548   
00549   va_start(ap, fmt);
00550   h = msg_header_vformat(home, msg_content_disposition_class, fmt, ap);
00551   va_end(ap);
00552  
00553   return (msg_content_disposition_t*)h;
00554 }
00555 #endif
00556 
00559 /* Declare internal prototypes for Content-Location header */
00560 
00565 enum { 
00567   msg_content_location_hash = 3453 
00568 };
00569 
00571 MSG_DLL msg_parse_f msg_content_location_d;
00572 
00574 MSG_DLL msg_print_f msg_content_location_e;
00575 
00576 MSG_DLL msg_xtra_f msg_content_location_dup_xtra;
00577 MSG_DLL msg_dup_f msg_content_location_dup_one;
00578 
00587 #ifndef msg_content_location_class
00588 MSG_DLL extern msg_hclass_t msg_content_location_class[];
00589 #endif
00590 
00602 #define MSG_CONTENT_LOCATION_INIT() MSG_HDR_INIT(content_location)
00603 
00618 #if SU_HAVE_INLINE
00619 su_inline msg_content_location_t *msg_content_location_init(msg_content_location_t x[1])
00620 {
00621   return MSG_HEADER_INIT(x, msg_content_location_class, sizeof(msg_content_location_t));
00622 }
00623 #else
00624 #define msg_content_location_init(x) \
00625   MSG_HEADER_INIT(x, msg_content_location_class, sizeof(msg_content_location_t))
00626 #endif
00627 
00640 #if SU_HAVE_INLINE
00641 su_inline int msg_is_content_location(msg_header_t const *header)
00642 {
00643   return header && header->sh_class->hc_hash == msg_content_location_hash;
00644 }
00645 #else
00646 int msg_is_content_location(msg_header_t const *header);
00647 #endif
00648 
00649 #define msg_content_location_p(h) msg_is_content_location((h))
00650 
00678 #if SU_HAVE_INLINE
00679 su_inline
00680 #endif
00681 msg_content_location_t *msg_content_location_dup(su_home_t *home, 
00682                                  msg_content_location_t const *header);
00683 
00684 #if SU_HAVE_INLINE
00685 su_inline
00686 msg_content_location_t *msg_content_location_dup(su_home_t *home, 
00687                                  msg_content_location_t const *header)
00688 {
00689   return (msg_content_location_t *)
00690     msg_header_dup_as(home, msg_content_location_class, (msg_header_t const *)header); 
00691 }
00692 #endif
00693 
00694 
00723 #if SU_HAVE_INLINE
00724 su_inline
00725 #endif
00726 msg_content_location_t *msg_content_location_copy(su_home_t *home, 
00727                                   msg_content_location_t const *header);
00728 
00729 #if SU_HAVE_INLINE
00730 su_inline
00731 msg_content_location_t *msg_content_location_copy(su_home_t *home, 
00732                                   msg_content_location_t const *header)
00733 {
00734   return (msg_content_location_t *)
00735     msg_header_copy_as(home, msg_content_location_class, (msg_header_t const *)header); 
00736 }
00737 #endif
00738 
00739 
00756 #if SU_HAVE_INLINE
00757 su_inline msg_content_location_t *msg_content_location_make(su_home_t *home, char const *s)
00758 {
00759   return (msg_content_location_t*)msg_header_make(home, msg_content_location_class, s);
00760 }
00761 #else
00762 msg_content_location_t *msg_content_location_make(su_home_t *home, char const *s);
00763 #endif
00764 
00765 
00787 #if SU_HAVE_INLINE
00788 su_inline
00789 #endif
00790 msg_content_location_t *msg_content_location_format(su_home_t *home, char const *fmt, ...)
00791      __attribute__((__format__ (printf, 2, 3)));
00792 
00793 #if SU_HAVE_INLINE
00794 su_inline msg_content_location_t *msg_content_location_format(su_home_t *home, char const *fmt, ...)
00795 {
00796   msg_header_t *h;
00797   va_list ap;
00798   
00799   va_start(ap, fmt);
00800   h = msg_header_vformat(home, msg_content_location_class, fmt, ap);
00801   va_end(ap);
00802  
00803   return (msg_content_location_t*)h;
00804 }
00805 #endif
00806 
00809 /* Declare internal prototypes for Content-ID header */
00810 
00815 enum { 
00817   msg_content_id_hash = 42909 
00818 };
00819 
00821 MSG_DLL msg_parse_f msg_content_id_d;
00822 
00824 MSG_DLL msg_print_f msg_content_id_e;
00825 
00826 MSG_DLL msg_xtra_f msg_content_id_dup_xtra;
00827 MSG_DLL msg_dup_f msg_content_id_dup_one;
00828 
00837 #ifndef msg_content_id_class
00838 MSG_DLL extern msg_hclass_t msg_content_id_class[];
00839 #endif
00840 
00852 #define MSG_CONTENT_ID_INIT() MSG_HDR_INIT(content_id)
00853 
00868 #if SU_HAVE_INLINE
00869 su_inline msg_content_id_t *msg_content_id_init(msg_content_id_t x[1])
00870 {
00871   return MSG_HEADER_INIT(x, msg_content_id_class, sizeof(msg_content_id_t));
00872 }
00873 #else
00874 #define msg_content_id_init(x) \
00875   MSG_HEADER_INIT(x, msg_content_id_class, sizeof(msg_content_id_t))
00876 #endif
00877 
00890 #if SU_HAVE_INLINE
00891 su_inline int msg_is_content_id(msg_header_t const *header)
00892 {
00893   return header && header->sh_class->hc_hash == msg_content_id_hash;
00894 }
00895 #else
00896 int msg_is_content_id(msg_header_t const *header);
00897 #endif
00898 
00899 #define msg_content_id_p(h) msg_is_content_id((h))
00900 
00928 #if SU_HAVE_INLINE
00929 su_inline
00930 #endif
00931 msg_content_id_t *msg_content_id_dup(su_home_t *home, 
00932                                  msg_content_id_t const *header);
00933 
00934 #if SU_HAVE_INLINE
00935 su_inline
00936 msg_content_id_t *msg_content_id_dup(su_home_t *home, 
00937                                  msg_content_id_t const *header)
00938 {
00939   return (msg_content_id_t *)
00940     msg_header_dup_as(home, msg_content_id_class, (msg_header_t const *)header); 
00941 }
00942 #endif
00943 
00944 
00973 #if SU_HAVE_INLINE
00974 su_inline
00975 #endif
00976 msg_content_id_t *msg_content_id_copy(su_home_t *home, 
00977                                   msg_content_id_t const *header);
00978 
00979 #if SU_HAVE_INLINE
00980 su_inline
00981 msg_content_id_t *msg_content_id_copy(su_home_t *home, 
00982                                   msg_content_id_t const *header)
00983 {
00984   return (msg_content_id_t *)
00985     msg_header_copy_as(home, msg_content_id_class, (msg_header_t const *)header); 
00986 }
00987 #endif
00988 
00989 
01006 #if SU_HAVE_INLINE
01007 su_inline msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s)
01008 {
01009   return (msg_content_id_t*)msg_header_make(home, msg_content_id_class, s);
01010 }
01011 #else
01012 msg_content_id_t *msg_content_id_make(su_home_t *home, char const *s);
01013 #endif
01014 
01015 
01037 #if SU_HAVE_INLINE
01038 su_inline
01039 #endif
01040 msg_content_id_t *msg_content_id_format(su_home_t *home, char const *fmt, ...)
01041      __attribute__((__format__ (printf, 2, 3)));
01042 
01043 #if SU_HAVE_INLINE
01044 su_inline msg_content_id_t *msg_content_id_format(su_home_t *home, char const *fmt, ...)
01045 {
01046   msg_header_t *h;
01047   va_list ap;
01048   
01049   va_start(ap, fmt);
01050   h = msg_header_vformat(home, msg_content_id_class, fmt, ap);
01051   va_end(ap);
01052  
01053   return (msg_content_id_t*)h;
01054 }
01055 #endif
01056 
01059 /* Declare internal prototypes for Content-Language header */
01060 
01065 enum { 
01067   msg_content_language_hash = 62108 
01068 };
01069 
01071 MSG_DLL msg_parse_f msg_content_language_d;
01072 
01074 MSG_DLL msg_print_f msg_content_language_e;
01075 
01076 MSG_DLL msg_xtra_f msg_content_language_dup_xtra;
01077 MSG_DLL msg_dup_f msg_content_language_dup_one;
01078 
01087 #ifndef msg_content_language_class
01088 MSG_DLL extern msg_hclass_t msg_content_language_class[];
01089 #endif
01090 
01102 #define MSG_CONTENT_LANGUAGE_INIT() MSG_HDR_INIT(content_language)
01103 
01118 #if SU_HAVE_INLINE
01119 su_inline msg_content_language_t *msg_content_language_init(msg_content_language_t x[1])
01120 {
01121   return MSG_HEADER_INIT(x, msg_content_language_class, sizeof(msg_content_language_t));
01122 }
01123 #else
01124 #define msg_content_language_init(x) \
01125   MSG_HEADER_INIT(x, msg_content_language_class, sizeof(msg_content_language_t))
01126 #endif
01127 
01140 #if SU_HAVE_INLINE
01141 su_inline int msg_is_content_language(msg_header_t const *header)
01142 {
01143   return header && header->sh_class->hc_hash == msg_content_language_hash;
01144 }
01145 #else
01146 int msg_is_content_language(msg_header_t const *header);
01147 #endif
01148 
01149 #define msg_content_language_p(h) msg_is_content_language((h))
01150 
01178 #if SU_HAVE_INLINE
01179 su_inline
01180 #endif
01181 msg_content_language_t *msg_content_language_dup(su_home_t *home, 
01182                                  msg_content_language_t const *header);
01183 
01184 #if SU_HAVE_INLINE
01185 su_inline
01186 msg_content_language_t *msg_content_language_dup(su_home_t *home, 
01187                                  msg_content_language_t const *header)
01188 {
01189   return (msg_content_language_t *)
01190     msg_header_dup_as(home, msg_content_language_class, (msg_header_t const *)header); 
01191 }
01192 #endif
01193 
01194 
01223 #if SU_HAVE_INLINE
01224 su_inline
01225 #endif
01226 msg_content_language_t *msg_content_language_copy(su_home_t *home, 
01227                                   msg_content_language_t const *header);
01228 
01229 #if SU_HAVE_INLINE
01230 su_inline
01231 msg_content_language_t *msg_content_language_copy(su_home_t *home, 
01232                                   msg_content_language_t const *header)
01233 {
01234   return (msg_content_language_t *)
01235     msg_header_copy_as(home, msg_content_language_class, (msg_header_t const *)header); 
01236 }
01237 #endif
01238 
01239 
01256 #if SU_HAVE_INLINE
01257 su_inline msg_content_language_t *msg_content_language_make(su_home_t *home, char const *s)
01258 {
01259   return (msg_content_language_t*)msg_header_make(home, msg_content_language_class, s);
01260 }
01261 #else
01262 msg_content_language_t *msg_content_language_make(su_home_t *home, char const *s);
01263 #endif
01264 
01265 
01287 #if SU_HAVE_INLINE
01288 su_inline
01289 #endif
01290 msg_content_language_t *msg_content_language_format(su_home_t *home, char const *fmt, ...)
01291      __attribute__((__format__ (printf, 2, 3)));
01292 
01293 #if SU_HAVE_INLINE
01294 su_inline msg_content_language_t *msg_content_language_format(su_home_t *home, char const *fmt, ...)
01295 {
01296   msg_header_t *h;
01297   va_list ap;
01298   
01299   va_start(ap, fmt);
01300   h = msg_header_vformat(home, msg_content_language_class, fmt, ap);
01301   va_end(ap);
01302  
01303   return (msg_content_language_t*)h;
01304 }
01305 #endif
01306 
01309 /* Declare internal prototypes for Content-Encoding header */
01310 
01315 enum { 
01317   msg_content_encoding_hash = 8707 
01318 };
01319 
01321 MSG_DLL msg_parse_f msg_content_encoding_d;
01322 
01324 MSG_DLL msg_print_f msg_content_encoding_e;
01325 
01326 MSG_DLL msg_xtra_f msg_content_encoding_dup_xtra;
01327 MSG_DLL msg_dup_f msg_content_encoding_dup_one;
01328 
01337 #ifndef msg_content_encoding_class
01338 MSG_DLL extern msg_hclass_t msg_content_encoding_class[];
01339 #endif
01340 
01352 #define MSG_CONTENT_ENCODING_INIT() MSG_HDR_INIT(content_encoding)
01353 
01368 #if SU_HAVE_INLINE
01369 su_inline msg_content_encoding_t *msg_content_encoding_init(msg_content_encoding_t x[1])
01370 {
01371   return MSG_HEADER_INIT(x, msg_content_encoding_class, sizeof(msg_content_encoding_t));
01372 }
01373 #else
01374 #define msg_content_encoding_init(x) \
01375   MSG_HEADER_INIT(x, msg_content_encoding_class, sizeof(msg_content_encoding_t))
01376 #endif
01377 
01390 #if SU_HAVE_INLINE
01391 su_inline int msg_is_content_encoding(msg_header_t const *header)
01392 {
01393   return header && header->sh_class->hc_hash == msg_content_encoding_hash;
01394 }
01395 #else
01396 int msg_is_content_encoding(msg_header_t const *header);
01397 #endif
01398 
01399 #define msg_content_encoding_p(h) msg_is_content_encoding((h))
01400 
01428 #if SU_HAVE_INLINE
01429 su_inline
01430 #endif
01431 msg_content_encoding_t *msg_content_encoding_dup(su_home_t *home, 
01432                                  msg_content_encoding_t const *header);
01433 
01434 #if SU_HAVE_INLINE
01435 su_inline
01436 msg_content_encoding_t *msg_content_encoding_dup(su_home_t *home, 
01437                                  msg_content_encoding_t const *header)
01438 {
01439   return (msg_content_encoding_t *)
01440     msg_header_dup_as(home, msg_content_encoding_class, (msg_header_t const *)header); 
01441 }
01442 #endif
01443 
01444 
01473 #if SU_HAVE_INLINE
01474 su_inline
01475 #endif
01476 msg_content_encoding_t *msg_content_encoding_copy(su_home_t *home, 
01477                                   msg_content_encoding_t const *header);
01478 
01479 #if SU_HAVE_INLINE
01480 su_inline
01481 msg_content_encoding_t *msg_content_encoding_copy(su_home_t *home, 
01482                                   msg_content_encoding_t const *header)
01483 {
01484   return (msg_content_encoding_t *)
01485     msg_header_copy_as(home, msg_content_encoding_class, (msg_header_t const *)header); 
01486 }
01487 #endif
01488 
01489 
01506 #if SU_HAVE_INLINE
01507 su_inline msg_content_encoding_t *msg_content_encoding_make(su_home_t *home, char const *s)
01508 {
01509   return (msg_content_encoding_t*)msg_header_make(home, msg_content_encoding_class, s);
01510 }
01511 #else
01512 msg_content_encoding_t *msg_content_encoding_make(su_home_t *home, char const *s);
01513 #endif
01514 
01515 
01537 #if SU_HAVE_INLINE
01538 su_inline
01539 #endif
01540 msg_content_encoding_t *msg_content_encoding_format(su_home_t *home, char const *fmt, ...)
01541      __attribute__((__format__ (printf, 2, 3)));
01542 
01543 #if SU_HAVE_INLINE
01544 su_inline msg_content_encoding_t *msg_content_encoding_format(su_home_t *home, char const *fmt, ...)
01545 {
01546   msg_header_t *h;
01547   va_list ap;
01548   
01549   va_start(ap, fmt);
01550   h = msg_header_vformat(home, msg_content_encoding_class, fmt, ap);
01551   va_end(ap);
01552  
01553   return (msg_content_encoding_t*)h;
01554 }
01555 #endif
01556 
01559 /* Declare internal prototypes for Content-Transfer-Encoding header */
01560 
01565 enum { 
01567   msg_content_transfer_encoding_hash = 7853 
01568 };
01569 
01571 MSG_DLL msg_parse_f msg_content_transfer_encoding_d;
01572 
01574 MSG_DLL msg_print_f msg_content_transfer_encoding_e;
01575 
01576 MSG_DLL msg_xtra_f msg_content_transfer_encoding_dup_xtra;
01577 MSG_DLL msg_dup_f msg_content_transfer_encoding_dup_one;
01578 
01587 #ifndef msg_content_transfer_encoding_class
01588 MSG_DLL extern msg_hclass_t msg_content_transfer_encoding_class[];
01589 #endif
01590 
01602 #define MSG_CONTENT_TRANSFER_ENCODING_INIT() MSG_HDR_INIT(content_transfer_encoding)
01603 
01618 #if SU_HAVE_INLINE
01619 su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_init(msg_content_transfer_encoding_t x[1])
01620 {
01621   return MSG_HEADER_INIT(x, msg_content_transfer_encoding_class, sizeof(msg_content_transfer_encoding_t));
01622 }
01623 #else
01624 #define msg_content_transfer_encoding_init(x) \
01625   MSG_HEADER_INIT(x, msg_content_transfer_encoding_class, sizeof(msg_content_transfer_encoding_t))
01626 #endif
01627 
01640 #if SU_HAVE_INLINE
01641 su_inline int msg_is_content_transfer_encoding(msg_header_t const *header)
01642 {
01643   return header && header->sh_class->hc_hash == msg_content_transfer_encoding_hash;
01644 }
01645 #else
01646 int msg_is_content_transfer_encoding(msg_header_t const *header);
01647 #endif
01648 
01649 #define msg_content_transfer_encoding_p(h) msg_is_content_transfer_encoding((h))
01650 
01678 #if SU_HAVE_INLINE
01679 su_inline
01680 #endif
01681 msg_content_transfer_encoding_t *msg_content_transfer_encoding_dup(su_home_t *home, 
01682                                  msg_content_transfer_encoding_t const *header);
01683 
01684 #if SU_HAVE_INLINE
01685 su_inline
01686 msg_content_transfer_encoding_t *msg_content_transfer_encoding_dup(su_home_t *home, 
01687                                  msg_content_transfer_encoding_t const *header)
01688 {
01689   return (msg_content_transfer_encoding_t *)
01690     msg_header_dup_as(home, msg_content_transfer_encoding_class, (msg_header_t const *)header); 
01691 }
01692 #endif
01693 
01694 
01723 #if SU_HAVE_INLINE
01724 su_inline
01725 #endif
01726 msg_content_transfer_encoding_t *msg_content_transfer_encoding_copy(su_home_t *home, 
01727                                   msg_content_transfer_encoding_t const *header);
01728 
01729 #if SU_HAVE_INLINE
01730 su_inline
01731 msg_content_transfer_encoding_t *msg_content_transfer_encoding_copy(su_home_t *home, 
01732                                   msg_content_transfer_encoding_t const *header)
01733 {
01734   return (msg_content_transfer_encoding_t *)
01735     msg_header_copy_as(home, msg_content_transfer_encoding_class, (msg_header_t const *)header); 
01736 }
01737 #endif
01738 
01739 
01756 #if SU_HAVE_INLINE
01757 su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_make(su_home_t *home, char const *s)
01758 {
01759   return (msg_content_transfer_encoding_t*)msg_header_make(home, msg_content_transfer_encoding_class, s);
01760 }
01761 #else
01762 msg_content_transfer_encoding_t *msg_content_transfer_encoding_make(su_home_t *home, char const *s);
01763 #endif
01764 
01765 
01787 #if SU_HAVE_INLINE
01788 su_inline
01789 #endif
01790 msg_content_transfer_encoding_t *msg_content_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
01791      __attribute__((__format__ (printf, 2, 3)));
01792 
01793 #if SU_HAVE_INLINE
01794 su_inline msg_content_transfer_encoding_t *msg_content_transfer_encoding_format(su_home_t *home, char const *fmt, ...)
01795 {
01796   msg_header_t *h;
01797   va_list ap;
01798   
01799   va_start(ap, fmt);
01800   h = msg_header_vformat(home, msg_content_transfer_encoding_class, fmt, ap);
01801   va_end(ap);
01802  
01803   return (msg_content_transfer_encoding_t*)h;
01804 }
01805 #endif
01806 
01809 /* Declare internal prototypes for Accept header */
01810 
01815 enum { 
01817   msg_accept_hash = 29344 
01818 };
01819 
01821 MSG_DLL msg_parse_f msg_accept_d;
01822 
01824 MSG_DLL msg_print_f msg_accept_e;
01825 
01826 MSG_DLL msg_xtra_f msg_accept_dup_xtra;
01827 MSG_DLL msg_dup_f msg_accept_dup_one;
01828 
01837 #ifndef msg_accept_class
01838 MSG_DLL extern msg_hclass_t msg_accept_class[];
01839 #endif
01840 
01852 #define MSG_ACCEPT_INIT() MSG_HDR_INIT(accept)
01853 
01868 #if SU_HAVE_INLINE
01869 su_inline msg_accept_t *msg_accept_init(msg_accept_t x[1])
01870 {
01871   return MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t));
01872 }
01873 #else
01874 #define msg_accept_init(x) \
01875   MSG_HEADER_INIT(x, msg_accept_class, sizeof(msg_accept_t))
01876 #endif
01877 
01890 #if SU_HAVE_INLINE
01891 su_inline int msg_is_accept(msg_header_t const *header)
01892 {
01893   return header && header->sh_class->hc_hash == msg_accept_hash;
01894 }
01895 #else
01896 int msg_is_accept(msg_header_t const *header);
01897 #endif
01898 
01899 #define msg_accept_p(h) msg_is_accept((h))
01900 
01928 #if SU_HAVE_INLINE
01929 su_inline
01930 #endif
01931 msg_accept_t *msg_accept_dup(su_home_t *home, 
01932                                  msg_accept_t const *header);
01933 
01934 #if SU_HAVE_INLINE
01935 su_inline
01936 msg_accept_t *msg_accept_dup(su_home_t *home, 
01937                                  msg_accept_t const *header)
01938 {
01939   return (msg_accept_t *)
01940     msg_header_dup_as(home, msg_accept_class, (msg_header_t const *)header); 
01941 }
01942 #endif
01943 
01944 
01973 #if SU_HAVE_INLINE
01974 su_inline
01975 #endif
01976 msg_accept_t *msg_accept_copy(su_home_t *home, 
01977                                   msg_accept_t const *header);
01978 
01979 #if SU_HAVE_INLINE
01980 su_inline
01981 msg_accept_t *msg_accept_copy(su_home_t *home, 
01982                                   msg_accept_t const *header)
01983 {
01984   return (msg_accept_t *)
01985     msg_header_copy_as(home, msg_accept_class, (msg_header_t const *)header); 
01986 }
01987 #endif
01988 
01989 
02006 #if SU_HAVE_INLINE
02007 su_inline msg_accept_t *msg_accept_make(su_home_t *home, char const *s)
02008 {
02009   return (msg_accept_t*)msg_header_make(home, msg_accept_class, s);
02010 }
02011 #else
02012 msg_accept_t *msg_accept_make(su_home_t *home, char const *s);
02013 #endif
02014 
02015 
02037 #if SU_HAVE_INLINE
02038 su_inline
02039 #endif
02040 msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
02041      __attribute__((__format__ (printf, 2, 3)));
02042 
02043 #if SU_HAVE_INLINE
02044 su_inline msg_accept_t *msg_accept_format(su_home_t *home, char const *fmt, ...)
02045 {
02046   msg_header_t *h;
02047   va_list ap;
02048   
02049   va_start(ap, fmt);
02050   h = msg_header_vformat(home, msg_accept_class, fmt, ap);
02051   va_end(ap);
02052  
02053   return (msg_accept_t*)h;
02054 }
02055 #endif
02056 
02059 /* Declare internal prototypes for Accept-Charset header */
02060 
02065 enum { 
02067   msg_accept_charset_hash = 41803 
02068 };
02069 
02071 MSG_DLL msg_parse_f msg_accept_charset_d;
02072 
02074 MSG_DLL msg_print_f msg_accept_charset_e;
02075 
02076 MSG_DLL msg_xtra_f msg_accept_charset_dup_xtra;
02077 MSG_DLL msg_dup_f msg_accept_charset_dup_one;
02078 
02087 #ifndef msg_accept_charset_class
02088 MSG_DLL extern msg_hclass_t msg_accept_charset_class[];
02089 #endif
02090 
02102 #define MSG_ACCEPT_CHARSET_INIT() MSG_HDR_INIT(accept_charset)
02103 
02118 #if SU_HAVE_INLINE
02119 su_inline msg_accept_charset_t *msg_accept_charset_init(msg_accept_charset_t x[1])
02120 {
02121   return MSG_HEADER_INIT(x, msg_accept_charset_class, sizeof(msg_accept_charset_t));
02122 }
02123 #else
02124 #define msg_accept_charset_init(x) \
02125   MSG_HEADER_INIT(x, msg_accept_charset_class, sizeof(msg_accept_charset_t))
02126 #endif
02127 
02140 #if SU_HAVE_INLINE
02141 su_inline int msg_is_accept_charset(msg_header_t const *header)
02142 {
02143   return header && header->sh_class->hc_hash == msg_accept_charset_hash;
02144 }
02145 #else
02146 int msg_is_accept_charset(msg_header_t const *header);
02147 #endif
02148 
02149 #define msg_accept_charset_p(h) msg_is_accept_charset((h))
02150 
02178 #if SU_HAVE_INLINE
02179 su_inline
02180 #endif
02181 msg_accept_charset_t *msg_accept_charset_dup(su_home_t *home, 
02182                                  msg_accept_charset_t const *header);
02183 
02184 #if SU_HAVE_INLINE
02185 su_inline
02186 msg_accept_charset_t *msg_accept_charset_dup(su_home_t *home, 
02187                                  msg_accept_charset_t const *header)
02188 {
02189   return (msg_accept_charset_t *)
02190     msg_header_dup_as(home, msg_accept_charset_class, (msg_header_t const *)header); 
02191 }
02192 #endif
02193 
02194 
02223 #if SU_HAVE_INLINE
02224 su_inline
02225 #endif
02226 msg_accept_charset_t *msg_accept_charset_copy(su_home_t *home, 
02227                                   msg_accept_charset_t const *header);
02228 
02229 #if SU_HAVE_INLINE
02230 su_inline
02231 msg_accept_charset_t *msg_accept_charset_copy(su_home_t *home, 
02232                                   msg_accept_charset_t const *header)
02233 {
02234   return (msg_accept_charset_t *)
02235     msg_header_copy_as(home, msg_accept_charset_class, (msg_header_t const *)header); 
02236 }
02237 #endif
02238 
02239 
02256 #if SU_HAVE_INLINE
02257 su_inline msg_accept_charset_t *msg_accept_charset_make(su_home_t *home, char const *s)
02258 {
02259   return (msg_accept_charset_t*)msg_header_make(home, msg_accept_charset_class, s);
02260 }
02261 #else
02262 msg_accept_charset_t *msg_accept_charset_make(su_home_t *home, char const *s);
02263 #endif
02264 
02265 
02287 #if SU_HAVE_INLINE
02288 su_inline
02289 #endif
02290 msg_accept_charset_t *msg_accept_charset_format(su_home_t *home, char const *fmt, ...)
02291      __attribute__((__format__ (printf, 2, 3)));
02292 
02293 #if SU_HAVE_INLINE
02294 su_inline msg_accept_charset_t *msg_accept_charset_format(su_home_t *home, char const *fmt, ...)
02295 {
02296   msg_header_t *h;
02297   va_list ap;
02298   
02299   va_start(ap, fmt);
02300   h = msg_header_vformat(home, msg_accept_charset_class, fmt, ap);
02301   va_end(ap);
02302  
02303   return (msg_accept_charset_t*)h;
02304 }
02305 #endif
02306 
02309 /* Declare internal prototypes for Accept-Encoding header */
02310 
02315 enum { 
02317   msg_accept_encoding_hash = 35932 
02318 };
02319 
02321 MSG_DLL msg_parse_f msg_accept_encoding_d;
02322 
02324 MSG_DLL msg_print_f msg_accept_encoding_e;
02325 
02326 MSG_DLL msg_xtra_f msg_accept_encoding_dup_xtra;
02327 MSG_DLL msg_dup_f msg_accept_encoding_dup_one;
02328 
02337 #ifndef msg_accept_encoding_class
02338 MSG_DLL extern msg_hclass_t msg_accept_encoding_class[];
02339 #endif
02340 
02352 #define MSG_ACCEPT_ENCODING_INIT() MSG_HDR_INIT(accept_encoding)
02353 
02368 #if SU_HAVE_INLINE
02369 su_inline msg_accept_encoding_t *msg_accept_encoding_init(msg_accept_encoding_t x[1])
02370 {
02371   return MSG_HEADER_INIT(x, msg_accept_encoding_class, sizeof(msg_accept_encoding_t));
02372 }
02373 #else
02374 #define msg_accept_encoding_init(x) \
02375   MSG_HEADER_INIT(x, msg_accept_encoding_class, sizeof(msg_accept_encoding_t))
02376 #endif
02377 
02390 #if SU_HAVE_INLINE
02391 su_inline int msg_is_accept_encoding(msg_header_t const *header)
02392 {
02393   return header && header->sh_class->hc_hash == msg_accept_encoding_hash;
02394 }
02395 #else
02396 int msg_is_accept_encoding(msg_header_t const *header);
02397 #endif
02398 
02399 #define msg_accept_encoding_p(h) msg_is_accept_encoding((h))
02400 
02428 #if SU_HAVE_INLINE
02429 su_inline
02430 #endif
02431 msg_accept_encoding_t *msg_accept_encoding_dup(su_home_t *home, 
02432                                  msg_accept_encoding_t const *header);
02433 
02434 #if SU_HAVE_INLINE
02435 su_inline
02436 msg_accept_encoding_t *msg_accept_encoding_dup(su_home_t *home, 
02437                                  msg_accept_encoding_t const *header)
02438 {
02439   return (msg_accept_encoding_t *)
02440     msg_header_dup_as(home, msg_accept_encoding_class, (msg_header_t const *)header); 
02441 }
02442 #endif
02443 
02444 
02473 #if SU_HAVE_INLINE
02474 su_inline
02475 #endif
02476 msg_accept_encoding_t *msg_accept_encoding_copy(su_home_t *home, 
02477                                   msg_accept_encoding_t const *header);
02478 
02479 #if SU_HAVE_INLINE
02480 su_inline
02481 msg_accept_encoding_t *msg_accept_encoding_copy(su_home_t *home, 
02482                                   msg_accept_encoding_t const *header)
02483 {
02484   return (msg_accept_encoding_t *)
02485     msg_header_copy_as(home, msg_accept_encoding_class, (msg_header_t const *)header); 
02486 }
02487 #endif
02488 
02489 
02506 #if SU_HAVE_INLINE
02507 su_inline msg_accept_encoding_t *msg_accept_encoding_make(su_home_t *home, char const *s)
02508 {
02509   return (msg_accept_encoding_t*)msg_header_make(home, msg_accept_encoding_class, s);
02510 }
02511 #else
02512 msg_accept_encoding_t *msg_accept_encoding_make(su_home_t *home, char const *s);
02513 #endif
02514 
02515 
02537 #if SU_HAVE_INLINE
02538 su_inline
02539 #endif
02540 msg_accept_encoding_t *msg_accept_encoding_format(su_home_t *home, char const *fmt, ...)
02541      __attribute__((__format__ (printf, 2, 3)));
02542 
02543 #if SU_HAVE_INLINE
02544 su_inline msg_accept_encoding_t *msg_accept_encoding_format(su_home_t *home, char const *fmt, ...)
02545 {
02546   msg_header_t *h;
02547   va_list ap;
02548   
02549   va_start(ap, fmt);
02550   h = msg_header_vformat(home, msg_accept_encoding_class, fmt, ap);
02551   va_end(ap);
02552  
02553   return (msg_accept_encoding_t*)h;
02554 }
02555 #endif
02556 
02559 /* Declare internal prototypes for Accept-Language header */
02560 
02565 enum { 
02567   msg_accept_language_hash = 23797 
02568 };
02569 
02571 MSG_DLL msg_parse_f msg_accept_language_d;
02572 
02574 MSG_DLL msg_print_f msg_accept_language_e;
02575 
02576 MSG_DLL msg_xtra_f msg_accept_language_dup_xtra;
02577 MSG_DLL msg_dup_f msg_accept_language_dup_one;
02578 
02587 #ifndef msg_accept_language_class
02588 MSG_DLL extern msg_hclass_t msg_accept_language_class[];
02589 #endif
02590 
02602 #define MSG_ACCEPT_LANGUAGE_INIT() MSG_HDR_INIT(accept_language)
02603 
02618 #if SU_HAVE_INLINE
02619 su_inline msg_accept_language_t *msg_accept_language_init(msg_accept_language_t x[1])
02620 {
02621   return MSG_HEADER_INIT(x, msg_accept_language_class, sizeof(msg_accept_language_t));
02622 }
02623 #else
02624 #define msg_accept_language_init(x) \
02625   MSG_HEADER_INIT(x, msg_accept_language_class, sizeof(msg_accept_language_t))
02626 #endif
02627 
02640 #if SU_HAVE_INLINE
02641 su_inline int msg_is_accept_language(msg_header_t const *header)
02642 {
02643   return header && header->sh_class->hc_hash == msg_accept_language_hash;
02644 }
02645 #else
02646 int msg_is_accept_language(msg_header_t const *header);
02647 #endif
02648 
02649 #define msg_accept_language_p(h) msg_is_accept_language((h))
02650 
02678 #if SU_HAVE_INLINE
02679 su_inline
02680 #endif
02681 msg_accept_language_t *msg_accept_language_dup(su_home_t *home, 
02682                                  msg_accept_language_t const *header);
02683 
02684 #if SU_HAVE_INLINE
02685 su_inline
02686 msg_accept_language_t *msg_accept_language_dup(su_home_t *home, 
02687                                  msg_accept_language_t const *header)
02688 {
02689   return (msg_accept_language_t *)
02690     msg_header_dup_as(home, msg_accept_language_class, (msg_header_t const *)header); 
02691 }
02692 #endif
02693 
02694 
02723 #if SU_HAVE_INLINE
02724 su_inline
02725 #endif
02726 msg_accept_language_t *msg_accept_language_copy(su_home_t *home, 
02727                                   msg_accept_language_t const *header);
02728 
02729 #if SU_HAVE_INLINE
02730 su_inline
02731 msg_accept_language_t *msg_accept_language_copy(su_home_t *home, 
02732                                   msg_accept_language_t const *header)
02733 {
02734   return (msg_accept_language_t *)
02735     msg_header_copy_as(home, msg_accept_language_class, (msg_header_t const *)header); 
02736 }
02737 #endif
02738 
02739 
02756 #if SU_HAVE_INLINE
02757 su_inline msg_accept_language_t *msg_accept_language_make(su_home_t *home, char const *s)
02758 {
02759   return (msg_accept_language_t*)msg_header_make(home, msg_accept_language_class, s);
02760 }
02761 #else
02762 msg_accept_language_t *msg_accept_language_make(su_home_t *home, char const *s);
02763 #endif
02764 
02765 
02787 #if SU_HAVE_INLINE
02788 su_inline
02789 #endif
02790 msg_accept_language_t *msg_accept_language_format(su_home_t *home, char const *fmt, ...)
02791      __attribute__((__format__ (printf, 2, 3)));
02792 
02793 #if SU_HAVE_INLINE
02794 su_inline msg_accept_language_t *msg_accept_language_format(su_home_t *home, char const *fmt, ...)
02795 {
02796   msg_header_t *h;
02797   va_list ap;
02798   
02799   va_start(ap, fmt);
02800   h = msg_header_vformat(home, msg_accept_language_class, fmt, ap);
02801   va_end(ap);
02802  
02803   return (msg_accept_language_t*)h;
02804 }
02805 #endif
02806 
02809 /* Declare internal prototypes for MIME-Version header */
02810 
02815 enum { 
02817   msg_mime_version_hash = 49047 
02818 };
02819 
02821 MSG_DLL msg_parse_f msg_mime_version_d;
02822 
02824 MSG_DLL msg_print_f msg_mime_version_e;
02825 
02826 MSG_DLL msg_xtra_f msg_mime_version_dup_xtra;
02827 MSG_DLL msg_dup_f msg_mime_version_dup_one;
02828 
02837 #ifndef msg_mime_version_class
02838 MSG_DLL extern msg_hclass_t msg_mime_version_class[];
02839 #endif
02840 
02852 #define MSG_MIME_VERSION_INIT() MSG_HDR_INIT(mime_version)
02853 
02868 #if SU_HAVE_INLINE
02869 su_inline msg_mime_version_t *msg_mime_version_init(msg_mime_version_t x[1])
02870 {
02871   return MSG_HEADER_INIT(x, msg_mime_version_class, sizeof(msg_mime_version_t));
02872 }
02873 #else
02874 #define msg_mime_version_init(x) \
02875   MSG_HEADER_INIT(x, msg_mime_version_class, sizeof(msg_mime_version_t))
02876 #endif
02877 
02890 #if SU_HAVE_INLINE
02891 su_inline int msg_is_mime_version(msg_header_t const *header)
02892 {
02893   return header && header->sh_class->hc_hash == msg_mime_version_hash;
02894 }
02895 #else
02896 int msg_is_mime_version(msg_header_t const *header);
02897 #endif
02898 
02899 #define msg_mime_version_p(h) msg_is_mime_version((h))
02900 
02928 #if SU_HAVE_INLINE
02929 su_inline
02930 #endif
02931 msg_mime_version_t *msg_mime_version_dup(su_home_t *home, 
02932                                  msg_mime_version_t const *header);
02933 
02934 #if SU_HAVE_INLINE
02935 su_inline
02936 msg_mime_version_t *msg_mime_version_dup(su_home_t *home, 
02937                                  msg_mime_version_t const *header)
02938 {
02939   return (msg_mime_version_t *)
02940     msg_header_dup_as(home, msg_mime_version_class, (msg_header_t const *)header); 
02941 }
02942 #endif
02943 
02944 
02973 #if SU_HAVE_INLINE
02974 su_inline
02975 #endif
02976 msg_mime_version_t *msg_mime_version_copy(su_home_t *home, 
02977                                   msg_mime_version_t const *header);
02978 
02979 #if SU_HAVE_INLINE
02980 su_inline
02981 msg_mime_version_t *msg_mime_version_copy(su_home_t *home, 
02982                                   msg_mime_version_t const *header)
02983 {
02984   return (msg_mime_version_t *)
02985     msg_header_copy_as(home, msg_mime_version_class, (msg_header_t const *)header); 
02986 }
02987 #endif
02988 
02989 
03006 #if SU_HAVE_INLINE
03007 su_inline msg_mime_version_t *msg_mime_version_make(su_home_t *home, char const *s)
03008 {
03009   return (msg_mime_version_t*)msg_header_make(home, msg_mime_version_class, s);
03010 }
03011 #else
03012 msg_mime_version_t *msg_mime_version_make(su_home_t *home, char const *s);
03013 #endif
03014 
03015 
03037 #if SU_HAVE_INLINE
03038 su_inline
03039 #endif
03040 msg_mime_version_t *msg_mime_version_format(su_home_t *home, char const *fmt, ...)
03041      __attribute__((__format__ (printf, 2, 3)));
03042 
03043 #if SU_HAVE_INLINE
03044 su_inline msg_mime_version_t *msg_mime_version_format(su_home_t *home, char const *fmt, ...)
03045 {
03046   msg_header_t *h;
03047   va_list ap;
03048   
03049   va_start(ap, fmt);
03050   h = msg_header_vformat(home, msg_mime_version_class, fmt, ap);
03051   va_end(ap);
03052  
03053   return (msg_mime_version_t*)h;
03054 }
03055 #endif
03056 
03059 /* Declare internal prototypes for Content-MD5 header */
03060 
03065 enum { 
03067   msg_content_md5_hash = 60494 
03068 };
03069 
03071 MSG_DLL msg_parse_f msg_content_md5_d;
03072 
03074 MSG_DLL msg_print_f msg_content_md5_e;
03075 
03076 MSG_DLL msg_xtra_f msg_content_md5_dup_xtra;
03077 MSG_DLL msg_dup_f msg_content_md5_dup_one;
03078 
03087 #ifndef msg_content_md5_class
03088 MSG_DLL extern msg_hclass_t msg_content_md5_class[];
03089 #endif
03090 
03102 #define MSG_CONTENT_MD5_INIT() MSG_HDR_INIT(content_md5)
03103 
03118 #if SU_HAVE_INLINE
03119 su_inline msg_content_md5_t *msg_content_md5_init(msg_content_md5_t x[1])
03120 {
03121   return MSG_HEADER_INIT(x, msg_content_md5_class, sizeof(msg_content_md5_t));
03122 }
03123 #else
03124 #define msg_content_md5_init(x) \
03125   MSG_HEADER_INIT(x, msg_content_md5_class, sizeof(msg_content_md5_t))
03126 #endif
03127 
03140 #if SU_HAVE_INLINE
03141 su_inline int msg_is_content_md5(msg_header_t const *header)
03142 {
03143   return header && header->sh_class->hc_hash == msg_content_md5_hash;
03144 }
03145 #else
03146 int msg_is_content_md5(msg_header_t const *header);
03147 #endif
03148 
03149 #define msg_content_md5_p(h) msg_is_content_md5((h))
03150 
03178 #if SU_HAVE_INLINE
03179 su_inline
03180 #endif
03181 msg_content_md5_t *msg_content_md5_dup(su_home_t *home, 
03182                                  msg_content_md5_t const *header);
03183 
03184 #if SU_HAVE_INLINE
03185 su_inline
03186 msg_content_md5_t *msg_content_md5_dup(su_home_t *home, 
03187                                  msg_content_md5_t const *header)
03188 {
03189   return (msg_content_md5_t *)
03190     msg_header_dup_as(home, msg_content_md5_class, (msg_header_t const *)header); 
03191 }
03192 #endif
03193 
03194 
03223 #if SU_HAVE_INLINE
03224 su_inline
03225 #endif
03226 msg_content_md5_t *msg_content_md5_copy(su_home_t *home, 
03227                                   msg_content_md5_t const *header);
03228 
03229 #if SU_HAVE_INLINE
03230 su_inline
03231 msg_content_md5_t *msg_content_md5_copy(su_home_t *home, 
03232                                   msg_content_md5_t const *header)
03233 {
03234   return (msg_content_md5_t *)
03235     msg_header_copy_as(home, msg_content_md5_class, (msg_header_t const *)header); 
03236 }
03237 #endif
03238 
03239 
03256 #if SU_HAVE_INLINE
03257 su_inline msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s)
03258 {
03259   return (msg_content_md5_t*)msg_header_make(home, msg_content_md5_class, s);
03260 }
03261 #else
03262 msg_content_md5_t *msg_content_md5_make(su_home_t *home, char const *s);
03263 #endif
03264 
03265 
03287 #if SU_HAVE_INLINE
03288 su_inline
03289 #endif
03290 msg_content_md5_t *msg_content_md5_format(su_home_t *home, char const *fmt, ...)
03291      __attribute__((__format__ (printf, 2, 3)));
03292 
03293 #if SU_HAVE_INLINE
03294 su_inline msg_content_md5_t *msg_content_md5_format(su_home_t *home, char const *fmt, ...)
03295 {
03296   msg_header_t *h;
03297   va_list ap;
03298   
03299   va_start(ap, fmt);
03300   h = msg_header_vformat(home, msg_content_md5_class, fmt, ap);
03301   va_end(ap);
03302  
03303   return (msg_content_md5_t*)h;
03304 }
03305 #endif
03306 
03309 /* Declare internal prototypes for Content-Length header */
03310 
03315 enum { 
03317   msg_content_length_hash = 8402 
03318 };
03319 
03321 MSG_DLL msg_parse_f msg_content_length_d;
03322 
03324 MSG_DLL msg_print_f msg_content_length_e;
03325 
03326 MSG_DLL msg_xtra_f msg_content_length_dup_xtra;
03327 MSG_DLL msg_dup_f msg_content_length_dup_one;
03328 
03337 #ifndef msg_content_length_class
03338 MSG_DLL extern msg_hclass_t msg_content_length_class[];
03339 #endif
03340 
03352 #define MSG_CONTENT_LENGTH_INIT() MSG_HDR_INIT(content_length)
03353 
03368 #if SU_HAVE_INLINE
03369 su_inline msg_content_length_t *msg_content_length_init(msg_content_length_t x[1])
03370 {
03371   return MSG_HEADER_INIT(x, msg_content_length_class, sizeof(msg_content_length_t));
03372 }
03373 #else
03374 #define msg_content_length_init(x) \
03375   MSG_HEADER_INIT(x, msg_content_length_class, sizeof(msg_content_length_t))
03376 #endif
03377 
03390 #if SU_HAVE_INLINE
03391 su_inline int msg_is_content_length(msg_header_t const *header)
03392 {
03393   return header && header->sh_class->hc_hash == msg_content_length_hash;
03394 }
03395 #else
03396 int msg_is_content_length(msg_header_t const *header);
03397 #endif
03398 
03399 #define msg_content_length_p(h) msg_is_content_length((h))
03400 
03428 #if SU_HAVE_INLINE
03429 su_inline
03430 #endif
03431 msg_content_length_t *msg_content_length_dup(su_home_t *home, 
03432                                  msg_content_length_t const *header);
03433 
03434 #if SU_HAVE_INLINE
03435 su_inline
03436 msg_content_length_t *msg_content_length_dup(su_home_t *home, 
03437                                  msg_content_length_t const *header)
03438 {
03439   return (msg_content_length_t *)
03440     msg_header_dup_as(home, msg_content_length_class, (msg_header_t const *)header); 
03441 }
03442 #endif
03443 
03444 
03473 #if SU_HAVE_INLINE
03474 su_inline
03475 #endif
03476 msg_content_length_t *msg_content_length_copy(su_home_t *home, 
03477                                   msg_content_length_t const *header);
03478 
03479 #if SU_HAVE_INLINE
03480 su_inline
03481 msg_content_length_t *msg_content_length_copy(su_home_t *home, 
03482                                   msg_content_length_t const *header)
03483 {
03484   return (msg_content_length_t *)
03485     msg_header_copy_as(home, msg_content_length_class, (msg_header_t const *)header); 
03486 }
03487 #endif
03488 
03489 
03506 #if SU_HAVE_INLINE
03507 su_inline msg_content_length_t *msg_content_length_make(su_home_t *home, char const *s)
03508 {
03509   return (msg_content_length_t*)msg_header_make(home, msg_content_length_class, s);
03510 }
03511 #else
03512 msg_content_length_t *msg_content_length_make(su_home_t *home, char const *s);
03513 #endif
03514 
03515 
03537 #if SU_HAVE_INLINE
03538 su_inline
03539 #endif
03540 msg_content_length_t *msg_content_length_format(su_home_t *home, char const *fmt, ...)
03541      __attribute__((__format__ (printf, 2, 3)));
03542 
03543 #if SU_HAVE_INLINE
03544 su_inline msg_content_length_t *msg_content_length_format(su_home_t *home, char const *fmt, ...)
03545 {
03546   msg_header_t *h;
03547   va_list ap;
03548   
03549   va_start(ap, fmt);
03550   h = msg_header_vformat(home, msg_content_length_class, fmt, ap);
03551   va_end(ap);
03552  
03553   return (msg_content_length_t*)h;
03554 }
03555 #endif
03556 
03559 /* Declare internal prototypes for Recursive multipart header */
03560 
03565 enum { 
03567   msg_multipart_hash = 58884 
03568 };
03569 
03571 MSG_DLL msg_parse_f msg_multipart_d;
03572 
03574 MSG_DLL msg_print_f msg_multipart_e;
03575 
03576 MSG_DLL msg_xtra_f msg_multipart_dup_xtra;
03577 MSG_DLL msg_dup_f msg_multipart_dup_one;
03578 
03587 #ifndef msg_multipart_class
03588 MSG_DLL extern msg_hclass_t msg_multipart_class[];
03589 #endif
03590 
03602 #define MSG_MULTIPART_INIT() MSG_HDR_INIT(multipart)
03603 
03618 #if SU_HAVE_INLINE
03619 su_inline msg_multipart_t *msg_multipart_init(msg_multipart_t x[1])
03620 {
03621   return MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t));
03622 }
03623 #else
03624 #define msg_multipart_init(x) \
03625   MSG_HEADER_INIT(x, msg_multipart_class, sizeof(msg_multipart_t))
03626 #endif
03627 
03640 #if SU_HAVE_INLINE
03641 su_inline int msg_is_multipart(msg_header_t const *header)
03642 {
03643   return header && header->sh_class->hc_hash == msg_multipart_hash;
03644 }
03645 #else
03646 int msg_is_multipart(msg_header_t const *header);
03647 #endif
03648 
03649 #define msg_multipart_p(h) msg_is_multipart((h))
03650 
03678 #if SU_HAVE_INLINE
03679 su_inline
03680 #endif
03681 msg_multipart_t *msg_multipart_dup(su_home_t *home, 
03682                                  msg_multipart_t const *header);
03683 
03684 #if SU_HAVE_INLINE
03685 su_inline
03686 msg_multipart_t *msg_multipart_dup(su_home_t *home, 
03687                                  msg_multipart_t const *header)
03688 {
03689   return (msg_multipart_t *)
03690     msg_header_dup_as(home, msg_multipart_class, (msg_header_t const *)header); 
03691 }
03692 #endif
03693 
03694 
03723 #if SU_HAVE_INLINE
03724 su_inline
03725 #endif
03726 msg_multipart_t *msg_multipart_copy(su_home_t *home, 
03727                                   msg_multipart_t const *header);
03728 
03729 #if SU_HAVE_INLINE
03730 su_inline
03731 msg_multipart_t *msg_multipart_copy(su_home_t *home, 
03732                                   msg_multipart_t const *header)
03733 {
03734   return (msg_multipart_t *)
03735     msg_header_copy_as(home, msg_multipart_class, (msg_header_t const *)header); 
03736 }
03737 #endif
03738 
03739 
03756 #if SU_HAVE_INLINE
03757 su_inline msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s)
03758 {
03759   return (msg_multipart_t*)msg_header_make(home, msg_multipart_class, s);
03760 }
03761 #else
03762 msg_multipart_t *msg_multipart_make(su_home_t *home, char const *s);
03763 #endif
03764 
03765 
03787 #if SU_HAVE_INLINE
03788 su_inline
03789 #endif
03790 msg_multipart_t *msg_multipart_format(su_home_t *home, char const *fmt, ...)
03791      __attribute__((__format__ (printf, 2, 3)));
03792 
03793 #if SU_HAVE_INLINE
03794 su_inline msg_multipart_t *msg_multipart_format(su_home_t *home, char const *fmt, ...)
03795 {
03796   msg_header_t *h;
03797   va_list ap;
03798   
03799   va_start(ap, fmt);
03800   h = msg_header_vformat(home, msg_multipart_class, fmt, ap);
03801   va_end(ap);
03802  
03803   return (msg_multipart_t*)h;
03804 }
03805 #endif
03806 
03809 /* Declare internal prototypes for Warning header */
03810 
03815 enum { 
03817   msg_warning_hash = 4130 
03818 };
03819 
03821 MSG_DLL msg_parse_f msg_warning_d;
03822 
03824 MSG_DLL msg_print_f msg_warning_e;
03825 
03826 MSG_DLL msg_xtra_f msg_warning_dup_xtra;
03827 MSG_DLL msg_dup_f msg_warning_dup_one;
03828 
03837 #ifndef msg_warning_class
03838 MSG_DLL extern msg_hclass_t msg_warning_class[];
03839 #endif
03840 
03852 #define MSG_WARNING_INIT() MSG_HDR_INIT(warning)
03853 
03868 #if SU_HAVE_INLINE
03869 su_inline msg_warning_t *msg_warning_init(msg_warning_t x[1])
03870 {
03871   return MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t));
03872 }
03873 #else
03874 #define msg_warning_init(x) \
03875   MSG_HEADER_INIT(x, msg_warning_class, sizeof(msg_warning_t))
03876 #endif
03877 
03890 #if SU_HAVE_INLINE
03891 su_inline int msg_is_warning(msg_header_t const *header)
03892 {
03893   return header && header->sh_class->hc_hash == msg_warning_hash;
03894 }
03895 #else
03896 int msg_is_warning(msg_header_t const *header);
03897 #endif
03898 
03899 #define msg_warning_p(h) msg_is_warning((h))
03900 
03928 #if SU_HAVE_INLINE
03929 su_inline
03930 #endif
03931 msg_warning_t *msg_warning_dup(su_home_t *home, 
03932                                  msg_warning_t const *header);
03933 
03934 #if SU_HAVE_INLINE
03935 su_inline
03936 msg_warning_t *msg_warning_dup(su_home_t *home, 
03937                                  msg_warning_t const *header)
03938 {
03939   return (msg_warning_t *)
03940     msg_header_dup_as(home, msg_warning_class, (msg_header_t const *)header); 
03941 }
03942 #endif
03943 
03944 
03973 #if SU_HAVE_INLINE
03974 su_inline
03975 #endif
03976 msg_warning_t *msg_warning_copy(su_home_t *home, 
03977                                   msg_warning_t const *header);
03978 
03979 #if SU_HAVE_INLINE
03980 su_inline
03981 msg_warning_t *msg_warning_copy(su_home_t *home, 
03982                                   msg_warning_t const *header)
03983 {
03984   return (msg_warning_t *)
03985     msg_header_copy_as(home, msg_warning_class, (msg_header_t const *)header); 
03986 }
03987 #endif
03988 
03989 
04006 #if SU_HAVE_INLINE
04007 su_inline msg_warning_t *msg_warning_make(su_home_t *home, char const *s)
04008 {
04009   return (msg_warning_t*)msg_header_make(home, msg_warning_class, s);
04010 }
04011 #else
04012 msg_warning_t *msg_warning_make(su_home_t *home, char const *s);
04013 #endif
04014 
04015 
04037 #if SU_HAVE_INLINE
04038 su_inline
04039 #endif
04040 msg_warning_t *msg_warning_format(su_home_t *home, char const *fmt, ...)
04041      __attribute__((__format__ (printf, 2, 3)));
04042 
04043 #if SU_HAVE_INLINE
04044 su_inline msg_warning_t *msg_warning_format(su_home_t *home, char const *fmt, ...)
04045 {
04046   msg_header_t *h;
04047   va_list ap;
04048   
04049   va_start(ap, fmt);
04050   h = msg_header_vformat(home, msg_warning_class, fmt, ap);
04051   va_end(ap);
04052  
04053   return (msg_warning_t*)h;
04054 }
04055 #endif
04056 
04060 /* Internal prototypes */
04061 MSG_DLL msg_update_f msg_accept_update;
04062 MSG_DLL msg_update_f msg_accept_any_update;
04063 MSG_DLL msg_update_f msg_content_disposition_update;
04064 
04065 SOFIA_END_DECLS
04066 
04067 #endif 

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