sofia-sip/msg_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_PROTOS_H
00026 
00027 #define MSG_PROTOS_H 
00028 
00041 #ifndef MSG_HEADER_H
00042 #include <sofia-sip/msg_header.h>
00043 #endif
00044 
00045 SOFIA_BEGIN_DECLS
00046 
00047 enum {
00048   msg_request_hash = -1,
00049   msg_status_hash = -2
00050 };
00051 
00052 
00053 /* Declare internal prototypes for unknown headers */
00054 
00059 enum { 
00061   msg_unknown_hash = -3 
00062 };
00063 
00065 MSG_DLL msg_parse_f msg_unknown_d;
00066 
00068 MSG_DLL msg_print_f msg_unknown_e;
00069 
00078 MSG_DLL extern msg_hclass_t msg_unknown_class[];
00079 
00091 #define MSG_UNKNOWN_INIT() MSG_HDR_INIT(unknown)
00092 
00107 #if SU_HAVE_INLINE
00108 su_inline msg_unknown_t *msg_unknown_init(msg_unknown_t x[1])
00109 {
00110   return MSG_HEADER_INIT(x, msg_unknown_class, sizeof(msg_unknown_t));
00111 }
00112 #else
00113 #define msg_unknown_init(x) \
00114   MSG_HEADER_INIT(x, msg_unknown_class, sizeof(msg_unknown_t))
00115 #endif
00116 
00130 #if SU_HAVE_INLINE
00131 su_inline int msg_is_unknown(msg_header_t const *header)
00132 {
00133   msg_generic_t const *h = (msg_generic_t *)header;
00134   return h && h->g_common->h_class->hc_hash == msg_unknown_hash;
00135 }
00136 #else
00137 int msg_is_unknown(msg_header_t const *header);
00138 #endif
00139 
00167 #if SU_HAVE_INLINE
00168 su_inline
00169 #endif
00170 msg_unknown_t *msg_unknown_dup(su_home_t *home, 
00171                                  msg_unknown_t const *header)
00172      __attribute__((__malloc__));
00173 
00174 #if SU_HAVE_INLINE
00175 su_inline
00176 msg_unknown_t *msg_unknown_dup(su_home_t *home, 
00177                                  msg_unknown_t const *header)
00178 {
00179   return (msg_unknown_t *)
00180     msg_header_dup_as(home, msg_unknown_class, (msg_header_t const *)header); 
00181 }
00182 #endif
00183 
00184 
00213 #if SU_HAVE_INLINE
00214 su_inline
00215 #endif
00216 msg_unknown_t *msg_unknown_copy(su_home_t *home, 
00217                                   msg_unknown_t const *header)
00218      __attribute__((__malloc__));
00219 
00220 #if SU_HAVE_INLINE
00221 su_inline
00222 msg_unknown_t *msg_unknown_copy(su_home_t *home, 
00223                                   msg_unknown_t const *header)
00224 {
00225   return (msg_unknown_t *)
00226     msg_header_copy_as(home, msg_unknown_class, (msg_header_t const *)header); 
00227 }
00228 #endif
00229 
00248 #if SU_HAVE_INLINE
00249 su_inline msg_unknown_t *msg_unknown_make(su_home_t *home, char const *s)
00250 {
00251   return (msg_unknown_t*)msg_header_make(home, msg_unknown_class, s);
00252 }
00253 #else
00254 msg_unknown_t *msg_unknown_make(su_home_t *home, char const *s)
00255      __attribute__((__malloc__));
00256 #endif
00257 
00280 #if SU_HAVE_INLINE
00281 su_inline
00282 #endif
00283 msg_unknown_t *msg_unknown_format(su_home_t *home, char const *fmt, ...)
00284      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00285 
00286 #if SU_HAVE_INLINE
00287 su_inline msg_unknown_t *msg_unknown_format(su_home_t *home, char const *fmt, ...)
00288 {
00289   msg_header_t *h;
00290   va_list ap;
00291   
00292   va_start(ap, fmt);
00293   h = msg_header_vformat(home, msg_unknown_class, fmt, ap);
00294   va_end(ap);
00295  
00296   return (msg_unknown_t*)h;
00297 }
00298 #endif
00299 
00302 /* Declare internal prototypes for erroneous headers */
00303 
00308 enum { 
00310   msg_error_hash = -4 
00311 };
00312 
00314 MSG_DLL msg_parse_f msg_error_d;
00315 
00317 MSG_DLL msg_print_f msg_error_e;
00318 
00327 MSG_DLL extern msg_hclass_t msg_error_class[];
00328 
00340 #define MSG_ERROR_INIT() MSG_HDR_INIT(error)
00341 
00356 #if SU_HAVE_INLINE
00357 su_inline msg_error_t *msg_error_init(msg_error_t x[1])
00358 {
00359   return MSG_HEADER_INIT(x, msg_error_class, sizeof(msg_error_t));
00360 }
00361 #else
00362 #define msg_error_init(x) \
00363   MSG_HEADER_INIT(x, msg_error_class, sizeof(msg_error_t))
00364 #endif
00365 
00379 #if SU_HAVE_INLINE
00380 su_inline int msg_is_error(msg_header_t const *header)
00381 {
00382   msg_generic_t const *h = (msg_generic_t *)header;
00383   return h && h->g_common->h_class->hc_hash == msg_error_hash;
00384 }
00385 #else
00386 int msg_is_error(msg_header_t const *header);
00387 #endif
00388 
00416 #if SU_HAVE_INLINE
00417 su_inline
00418 #endif
00419 msg_error_t *msg_error_dup(su_home_t *home, 
00420                                  msg_error_t const *header)
00421      __attribute__((__malloc__));
00422 
00423 #if SU_HAVE_INLINE
00424 su_inline
00425 msg_error_t *msg_error_dup(su_home_t *home, 
00426                                  msg_error_t const *header)
00427 {
00428   return (msg_error_t *)
00429     msg_header_dup_as(home, msg_error_class, (msg_header_t const *)header); 
00430 }
00431 #endif
00432 
00433 
00462 #if SU_HAVE_INLINE
00463 su_inline
00464 #endif
00465 msg_error_t *msg_error_copy(su_home_t *home, 
00466                                   msg_error_t const *header)
00467      __attribute__((__malloc__));
00468 
00469 #if SU_HAVE_INLINE
00470 su_inline
00471 msg_error_t *msg_error_copy(su_home_t *home, 
00472                                   msg_error_t const *header)
00473 {
00474   return (msg_error_t *)
00475     msg_header_copy_as(home, msg_error_class, (msg_header_t const *)header); 
00476 }
00477 #endif
00478 
00497 #if SU_HAVE_INLINE
00498 su_inline msg_error_t *msg_error_make(su_home_t *home, char const *s)
00499 {
00500   return (msg_error_t*)msg_header_make(home, msg_error_class, s);
00501 }
00502 #else
00503 msg_error_t *msg_error_make(su_home_t *home, char const *s)
00504      __attribute__((__malloc__));
00505 #endif
00506 
00529 #if SU_HAVE_INLINE
00530 su_inline
00531 #endif
00532 msg_error_t *msg_error_format(su_home_t *home, char const *fmt, ...)
00533      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00534 
00535 #if SU_HAVE_INLINE
00536 su_inline msg_error_t *msg_error_format(su_home_t *home, char const *fmt, ...)
00537 {
00538   msg_header_t *h;
00539   va_list ap;
00540   
00541   va_start(ap, fmt);
00542   h = msg_header_vformat(home, msg_error_class, fmt, ap);
00543   va_end(ap);
00544  
00545   return (msg_error_t*)h;
00546 }
00547 #endif
00548 
00551 /* Declare internal prototypes for separator line between headers and body */
00552 
00557 enum { 
00559   msg_separator_hash = -5 
00560 };
00561 
00563 MSG_DLL msg_parse_f msg_separator_d;
00564 
00566 MSG_DLL msg_print_f msg_separator_e;
00567 
00576 MSG_DLL extern msg_hclass_t msg_separator_class[];
00577 
00589 #define MSG_SEPARATOR_INIT() MSG_HDR_INIT(separator)
00590 
00605 #if SU_HAVE_INLINE
00606 su_inline msg_separator_t *msg_separator_init(msg_separator_t x[1])
00607 {
00608   return MSG_HEADER_INIT(x, msg_separator_class, sizeof(msg_separator_t));
00609 }
00610 #else
00611 #define msg_separator_init(x) \
00612   MSG_HEADER_INIT(x, msg_separator_class, sizeof(msg_separator_t))
00613 #endif
00614 
00628 #if SU_HAVE_INLINE
00629 su_inline int msg_is_separator(msg_header_t const *header)
00630 {
00631   msg_generic_t const *h = (msg_generic_t *)header;
00632   return h && h->g_common->h_class->hc_hash == msg_separator_hash;
00633 }
00634 #else
00635 int msg_is_separator(msg_header_t const *header);
00636 #endif
00637 
00665 #if SU_HAVE_INLINE
00666 su_inline
00667 #endif
00668 msg_separator_t *msg_separator_dup(su_home_t *home, 
00669                                  msg_separator_t const *header)
00670      __attribute__((__malloc__));
00671 
00672 #if SU_HAVE_INLINE
00673 su_inline
00674 msg_separator_t *msg_separator_dup(su_home_t *home, 
00675                                  msg_separator_t const *header)
00676 {
00677   return (msg_separator_t *)
00678     msg_header_dup_as(home, msg_separator_class, (msg_header_t const *)header); 
00679 }
00680 #endif
00681 
00682 
00711 #if SU_HAVE_INLINE
00712 su_inline
00713 #endif
00714 msg_separator_t *msg_separator_copy(su_home_t *home, 
00715                                   msg_separator_t const *header)
00716      __attribute__((__malloc__));
00717 
00718 #if SU_HAVE_INLINE
00719 su_inline
00720 msg_separator_t *msg_separator_copy(su_home_t *home, 
00721                                   msg_separator_t const *header)
00722 {
00723   return (msg_separator_t *)
00724     msg_header_copy_as(home, msg_separator_class, (msg_header_t const *)header); 
00725 }
00726 #endif
00727 
00746 #if SU_HAVE_INLINE
00747 su_inline msg_separator_t *msg_separator_make(su_home_t *home, char const *s)
00748 {
00749   return (msg_separator_t*)msg_header_make(home, msg_separator_class, s);
00750 }
00751 #else
00752 msg_separator_t *msg_separator_make(su_home_t *home, char const *s)
00753      __attribute__((__malloc__));
00754 #endif
00755 
00778 #if SU_HAVE_INLINE
00779 su_inline
00780 #endif
00781 msg_separator_t *msg_separator_format(su_home_t *home, char const *fmt, ...)
00782      __attribute__((__malloc__, __format__ (printf, 2, 3)));
00783 
00784 #if SU_HAVE_INLINE
00785 su_inline msg_separator_t *msg_separator_format(su_home_t *home, char const *fmt, ...)
00786 {
00787   msg_header_t *h;
00788   va_list ap;
00789   
00790   va_start(ap, fmt);
00791   h = msg_header_vformat(home, msg_separator_class, fmt, ap);
00792   va_end(ap);
00793  
00794   return (msg_separator_t*)h;
00795 }
00796 #endif
00797 
00800 /* Declare internal prototypes for message payload */
00801 
00806 enum { 
00808   msg_payload_hash = -6 
00809 };
00810 
00812 MSG_DLL msg_parse_f msg_payload_d;
00813 
00815 MSG_DLL msg_print_f msg_payload_e;
00816 
00825 MSG_DLL extern msg_hclass_t msg_payload_class[];
00826 
00838 #define MSG_PAYLOAD_INIT() MSG_HDR_INIT(payload)
00839 
00854 #if SU_HAVE_INLINE
00855 su_inline msg_payload_t *msg_payload_init(msg_payload_t x[1])
00856 {
00857   return MSG_HEADER_INIT(x, msg_payload_class, sizeof(msg_payload_t));
00858 }
00859 #else
00860 #define msg_payload_init(x) \
00861   MSG_HEADER_INIT(x, msg_payload_class, sizeof(msg_payload_t))
00862 #endif
00863 
00877 #if SU_HAVE_INLINE
00878 su_inline int msg_is_payload(msg_header_t const *header)
00879 {
00880   msg_generic_t const *h = (msg_generic_t *)header;
00881   return h && h->g_common->h_class->hc_hash == msg_payload_hash;
00882 }
00883 #else
00884 int msg_is_payload(msg_header_t const *header);
00885 #endif
00886 
00914 #if SU_HAVE_INLINE
00915 su_inline
00916 #endif
00917 msg_payload_t *msg_payload_dup(su_home_t *home, 
00918                                  msg_payload_t const *header)
00919      __attribute__((__malloc__));
00920 
00921 #if SU_HAVE_INLINE
00922 su_inline
00923 msg_payload_t *msg_payload_dup(su_home_t *home, 
00924                                  msg_payload_t const *header)
00925 {
00926   return (msg_payload_t *)
00927     msg_header_dup_as(home, msg_payload_class, (msg_header_t const *)header); 
00928 }
00929 #endif
00930 
00931 
00960 #if SU_HAVE_INLINE
00961 su_inline
00962 #endif
00963 msg_payload_t *msg_payload_copy(su_home_t *home, 
00964                                   msg_payload_t const *header)
00965      __attribute__((__malloc__));
00966 
00967 #if SU_HAVE_INLINE
00968 su_inline
00969 msg_payload_t *msg_payload_copy(su_home_t *home, 
00970                                   msg_payload_t const *header)
00971 {
00972   return (msg_payload_t *)
00973     msg_header_copy_as(home, msg_payload_class, (msg_header_t const *)header); 
00974 }
00975 #endif
00976 
00995 #if SU_HAVE_INLINE
00996 su_inline msg_payload_t *msg_payload_make(su_home_t *home, char const *s)
00997 {
00998   return (msg_payload_t*)msg_header_make(home, msg_payload_class, s);
00999 }
01000 #else
01001 msg_payload_t *msg_payload_make(su_home_t *home, char const *s)
01002      __attribute__((__malloc__));
01003 #endif
01004 
01027 #if SU_HAVE_INLINE
01028 su_inline
01029 #endif
01030 msg_payload_t *msg_payload_format(su_home_t *home, char const *fmt, ...)
01031      __attribute__((__malloc__, __format__ (printf, 2, 3)));
01032 
01033 #if SU_HAVE_INLINE
01034 su_inline msg_payload_t *msg_payload_format(su_home_t *home, char const *fmt, ...)
01035 {
01036   msg_header_t *h;
01037   va_list ap;
01038   
01039   va_start(ap, fmt);
01040   h = msg_header_vformat(home, msg_payload_class, fmt, ap);
01041   va_end(ap);
01042  
01043   return (msg_payload_t*)h;
01044 }
01045 #endif
01046 
01050 SOFIA_END_DECLS
01051 
01052 #endif 

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