1949 lines
62 KiB
C
1949 lines
62 KiB
C
/* $Id$ */
|
|
/*
|
|
* Copyright (C) 2003-2007 Benny Prijono <benny@prijono.org>
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*/
|
|
#ifndef __PJSIP_SIP_MSG_H__
|
|
#define __PJSIP_SIP_MSG_H__
|
|
|
|
/**
|
|
* @file pjsip/sip_msg.h
|
|
* @brief SIP Message Structure.
|
|
*/
|
|
|
|
#include <pjsip/sip_types.h>
|
|
#include <pjsip/sip_uri.h>
|
|
#include <pj/list.h>
|
|
|
|
PJ_BEGIN_DECL
|
|
|
|
/**
|
|
* @defgroup PJSIP_MSG Messaging Elements
|
|
* @ingroup PJSIP_CORE
|
|
* @brief Various SIP message elements such as methods, headers, URIs, etc.
|
|
* @{
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @defgroup PJSIP_MSG_METHOD Methods
|
|
* @brief Method names and manipulation.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* This enumeration declares SIP methods as described by RFC3261. Additional
|
|
* methods do exist, and they are described by corresponding RFCs for the SIP
|
|
* extentensions. Since they won't alter the characteristic of the processing
|
|
* of the message, they don't need to be explicitly mentioned here.
|
|
*/
|
|
typedef enum pjsip_method_e
|
|
{
|
|
PJSIP_INVITE_METHOD, /**< INVITE method, for establishing dialogs. */
|
|
PJSIP_CANCEL_METHOD, /**< CANCEL method, for cancelling request. */
|
|
PJSIP_ACK_METHOD, /**< ACK method. */
|
|
PJSIP_BYE_METHOD, /**< BYE method, for terminating dialog. */
|
|
PJSIP_REGISTER_METHOD, /**< REGISTER method. */
|
|
PJSIP_OPTIONS_METHOD, /**< OPTIONS method. */
|
|
|
|
PJSIP_OTHER_METHOD /**< Other method. */
|
|
|
|
} pjsip_method_e;
|
|
|
|
|
|
|
|
/**
|
|
* This structure represents a SIP method.
|
|
* Application must always use either #pjsip_method_init or #pjsip_method_set
|
|
* to make sure that method name is initialized correctly. This way, the name
|
|
* member will always contain a valid method string regardless whether the ID
|
|
* is recognized or not.
|
|
*/
|
|
struct pjsip_method
|
|
{
|
|
pjsip_method_e id; /**< Method ID, from \a pjsip_method_e. */
|
|
pj_str_t name; /**< Method name, which will always contain the
|
|
method string. */
|
|
};
|
|
|
|
|
|
/*
|
|
* For convenience, standard method structures are defined in the library.
|
|
*/
|
|
/** INVITE method constant. @see pjsip_get_invite_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_invite_method;
|
|
|
|
/** CANCEL method constant. @see pjsip_get_cancel_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_cancel_method;
|
|
|
|
/** ACK method constant. @see pjsip_get_ack_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_ack_method;
|
|
|
|
/** BYE method constant. @see pjsip_get_bye_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_bye_method;
|
|
|
|
/** REGISTER method constant. @see pjsip_get_register_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_register_method;
|
|
|
|
/** OPTIONS method constant. @see pjsip_get_options_method() */
|
|
PJ_DECL_DATA(const pjsip_method) pjsip_options_method;
|
|
|
|
/*
|
|
* Accessor functions for standard SIP methods.
|
|
*/
|
|
/** Get INVITE method constant. */
|
|
PJ_DECL(const pjsip_method*) pjsip_get_invite_method(void);
|
|
/** Get CANCEL method constant. */
|
|
PJ_DECL(const pjsip_method*) pjsip_get_cancel_method(void);
|
|
/** Get ACK method constant. */
|
|
PJ_DECL(const pjsip_method*) pjsip_get_ack_method(void);
|
|
/** Get BYE method constant. */
|
|
PJ_DECL(const pjsip_method*) pjsip_get_bye_method(void);
|
|
/** Get REGISTER method constant.*/
|
|
PJ_DECL(const pjsip_method*) pjsip_get_register_method(void);
|
|
/** Get OPTIONS method constant. */
|
|
PJ_DECL(const pjsip_method*) pjsip_get_options_method(void);
|
|
|
|
|
|
/*
|
|
* Accessor functions
|
|
*/
|
|
|
|
/**
|
|
* Initialize the method structure from a string.
|
|
* This function will check whether the method is a known method then set
|
|
* both the id and name accordingly.
|
|
*
|
|
* @param m The method to initialize.
|
|
* @param pool Pool where memory allocation will be allocated from, if required.
|
|
* @param str The method string.
|
|
*/
|
|
PJ_DECL(void) pjsip_method_init( pjsip_method *m,
|
|
pj_pool_t *pool,
|
|
const pj_str_t *str);
|
|
|
|
/**
|
|
* Initialize the method structure from a string, without cloning the string.
|
|
* See #pjsip_method_init.
|
|
*
|
|
* @param m The method structure to be initialized.
|
|
* @param str The method string.
|
|
*/
|
|
PJ_DECL(void) pjsip_method_init_np( pjsip_method *m,
|
|
pj_str_t *str);
|
|
|
|
/**
|
|
* Set the method with the predefined method ID.
|
|
* This function will also set the name member of the structure to the correct
|
|
* string according to the method.
|
|
*
|
|
* @param m The method structure.
|
|
* @param id The method ID.
|
|
*/
|
|
PJ_DECL(void) pjsip_method_set( pjsip_method *m, pjsip_method_e id );
|
|
|
|
|
|
/**
|
|
* Copy one method structure to another. If the method is of the known methods,
|
|
* then memory allocation is not required.
|
|
*
|
|
* @param pool Pool to allocate memory from, if required.
|
|
* @param method The destination method to copy to.
|
|
* @param rhs The source method to copy from.
|
|
*/
|
|
PJ_DECL(void) pjsip_method_copy( pj_pool_t *pool,
|
|
pjsip_method *method,
|
|
const pjsip_method *rhs );
|
|
|
|
/**
|
|
* Compare one method with another, and conveniently determine whether the
|
|
* first method is equal, less than, or greater than the second method.
|
|
*
|
|
* @param m1 The first method.
|
|
* @param m2 The second method.
|
|
*
|
|
* @return Zero if equal, otherwise will return -1 if less or +1 if greater.
|
|
*/
|
|
PJ_DECL(int) pjsip_method_cmp( const pjsip_method *m1, const pjsip_method *m2);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @defgroup PJSIP_MSG_HDR Header Fields
|
|
* @brief Declarations for various SIP header fields.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Header types, as defined by RFC3261.
|
|
*/
|
|
typedef enum pjsip_hdr_e
|
|
{
|
|
/*
|
|
* These are the headers documented in RFC3261. Headers not documented
|
|
* there must have type PJSIP_H_OTHER, and the header type itself is
|
|
* recorded in the header name string.
|
|
*
|
|
* DO NOT CHANGE THE VALUE/ORDER OF THE HEADER IDs!!!.
|
|
*/
|
|
PJSIP_H_ACCEPT,
|
|
PJSIP_H_ACCEPT_ENCODING_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_ACCEPT_LANGUAGE_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_ALERT_INFO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_ALLOW,
|
|
PJSIP_H_AUTHENTICATION_INFO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_AUTHORIZATION,
|
|
PJSIP_H_CALL_ID,
|
|
PJSIP_H_CALL_INFO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_CONTACT,
|
|
PJSIP_H_CONTENT_DISPOSITION_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_CONTENT_ENCODING_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_CONTENT_LANGUAGE_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_CONTENT_LENGTH,
|
|
PJSIP_H_CONTENT_TYPE,
|
|
PJSIP_H_CSEQ,
|
|
PJSIP_H_DATE_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_ERROR_INFO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_EXPIRES,
|
|
PJSIP_H_FROM,
|
|
PJSIP_H_IN_REPLY_TO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_MAX_FORWARDS,
|
|
PJSIP_H_MIME_VERSION_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_MIN_EXPIRES,
|
|
PJSIP_H_ORGANIZATION_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_PRIORITY_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_PROXY_AUTHENTICATE,
|
|
PJSIP_H_PROXY_AUTHORIZATION,
|
|
PJSIP_H_PROXY_REQUIRE_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_RECORD_ROUTE,
|
|
PJSIP_H_REPLY_TO_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_REQUIRE,
|
|
PJSIP_H_RETRY_AFTER,
|
|
PJSIP_H_ROUTE,
|
|
PJSIP_H_SERVER_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_SUBJECT_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_SUPPORTED,
|
|
PJSIP_H_TIMESTAMP_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_TO,
|
|
PJSIP_H_UNSUPPORTED,
|
|
PJSIP_H_USER_AGENT_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_VIA,
|
|
PJSIP_H_WARNING_UNIMP, /* N/A, use pjsip_generic_string_hdr */
|
|
PJSIP_H_WWW_AUTHENTICATE,
|
|
|
|
PJSIP_H_OTHER
|
|
|
|
} pjsip_hdr_e;
|
|
|
|
/**
|
|
* This structure provides the pointer to basic functions that are needed
|
|
* for generic header operations. All header fields will have pointer to
|
|
* this structure, so that they can be manipulated uniformly.
|
|
*/
|
|
typedef struct pjsip_hdr_vptr
|
|
{
|
|
/**
|
|
* Function to clone the header.
|
|
*
|
|
* @param pool Memory pool to allocate the new header.
|
|
* @param hdr Header to clone.
|
|
*
|
|
* @return A new instance of the header.
|
|
*/
|
|
void *(*clone)(pj_pool_t *pool, const void *hdr);
|
|
|
|
/**
|
|
* Pointer to function to shallow clone the header.
|
|
* Shallow cloning will just make a memory copy of the original header,
|
|
* thus all pointers in original header will be kept intact. Because the
|
|
* function does not need to perform deep copy, the operation should be
|
|
* faster, but the application must make sure that the original header
|
|
* is still valid throughout the lifetime of new header.
|
|
*
|
|
* @param pool Memory pool to allocate the new header.
|
|
* @param hdr The header to clone.
|
|
*/
|
|
void *(*shallow_clone)(pj_pool_t *pool, const void *hdr);
|
|
|
|
/** Pointer to function to print the header to the specified buffer.
|
|
* Returns the length of string written, or -1 if the remaining buffer
|
|
* is not enough to hold the header.
|
|
*
|
|
* @param hdr The header to print.
|
|
* @param buf The buffer.
|
|
* @param len The size of the buffer.
|
|
*
|
|
* @return The size copied to buffer, or -1 if there's not enough space.
|
|
*/
|
|
int (*print_on)(void *hdr, char *buf, pj_size_t len);
|
|
|
|
} pjsip_hdr_vptr;
|
|
|
|
|
|
/**
|
|
* Generic fields for all SIP headers are declared using this macro, to make
|
|
* sure that all headers will have exactly the same layout in their start of
|
|
* the storage. This behaves like C++ inheritance actually.
|
|
*/
|
|
#define PJSIP_DECL_HDR_MEMBER(hdr) \
|
|
/** List members. */ \
|
|
PJ_DECL_LIST_MEMBER(hdr); \
|
|
/** Header type */ \
|
|
pjsip_hdr_e type; \
|
|
/** Header name. */ \
|
|
pj_str_t name; \
|
|
/** Header short name version. */ \
|
|
pj_str_t sname; \
|
|
/** Virtual function table. */ \
|
|
pjsip_hdr_vptr *vptr
|
|
|
|
|
|
/**
|
|
* Generic SIP header structure, for generic manipulation for headers in the
|
|
* message. All header fields can be typecasted to this type.
|
|
*/
|
|
struct pjsip_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_hdr);
|
|
};
|
|
|
|
|
|
/**
|
|
* This generic function will clone any header, by calling "clone" function
|
|
* in header's virtual function table.
|
|
*
|
|
* @param pool The pool to allocate memory from.
|
|
* @param hdr The header to clone.
|
|
*
|
|
* @return A new instance copied from the original header.
|
|
*/
|
|
PJ_DECL(void*) pjsip_hdr_clone( pj_pool_t *pool, const void *hdr );
|
|
|
|
|
|
/**
|
|
* This generic function will clone any header, by calling "shallow_clone"
|
|
* function in header's virtual function table.
|
|
*
|
|
* @param pool The pool to allocate memory from.
|
|
* @param hdr The header to clone.
|
|
*
|
|
* @return A new instance copied from the original header.
|
|
*/
|
|
PJ_DECL(void*) pjsip_hdr_shallow_clone( pj_pool_t *pool, const void *hdr );
|
|
|
|
/**
|
|
* This generic function will print any header, by calling "print"
|
|
* function in header's virtual function table.
|
|
*
|
|
* @param hdr The header to print.
|
|
* @param buf The buffer.
|
|
* @param len The size of the buffer.
|
|
*
|
|
* @return The size copied to buffer, or -1 if there's not enough space.
|
|
*/
|
|
PJ_DECL(int) pjsip_hdr_print_on( void *hdr, char *buf, pj_size_t len);
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @defgroup PJSIP_MSG_LINE Request and Status Line.
|
|
* @brief Request and status line structures and manipulation.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* This structure describes SIP request line.
|
|
*/
|
|
typedef struct pjsip_request_line
|
|
{
|
|
pjsip_method method; /**< Method for this request line. */
|
|
pjsip_uri *uri; /**< URI for this request line. */
|
|
} pjsip_request_line;
|
|
|
|
|
|
/**
|
|
* This structure describes SIP status line.
|
|
*/
|
|
typedef struct pjsip_status_line
|
|
{
|
|
int code; /**< Status code. */
|
|
pj_str_t reason; /**< Reason string. */
|
|
} pjsip_status_line;
|
|
|
|
|
|
/**
|
|
* This enumeration lists standard SIP status codes according to RFC 3261.
|
|
* In addition, it also declares new status class 7xx for errors generated
|
|
* by the stack. This status class however should not get transmitted on the
|
|
* wire.
|
|
*/
|
|
typedef enum pjsip_status_code
|
|
{
|
|
PJSIP_SC_TRYING = 100,
|
|
PJSIP_SC_RINGING = 180,
|
|
PJSIP_SC_CALL_BEING_FORWARDED = 181,
|
|
PJSIP_SC_QUEUED = 182,
|
|
PJSIP_SC_PROGRESS = 183,
|
|
|
|
PJSIP_SC_OK = 200,
|
|
PJSIP_SC_ACCEPTED = 202,
|
|
|
|
PJSIP_SC_MULTIPLE_CHOICES = 300,
|
|
PJSIP_SC_MOVED_PERMANENTLY = 301,
|
|
PJSIP_SC_MOVED_TEMPORARILY = 302,
|
|
PJSIP_SC_USE_PROXY = 305,
|
|
PJSIP_SC_ALTERNATIVE_SERVICE = 380,
|
|
|
|
PJSIP_SC_BAD_REQUEST = 400,
|
|
PJSIP_SC_UNAUTHORIZED = 401,
|
|
PJSIP_SC_PAYMENT_REQUIRED = 402,
|
|
PJSIP_SC_FORBIDDEN = 403,
|
|
PJSIP_SC_NOT_FOUND = 404,
|
|
PJSIP_SC_METHOD_NOT_ALLOWED = 405,
|
|
PJSIP_SC_NOT_ACCEPTABLE = 406,
|
|
PJSIP_SC_PROXY_AUTHENTICATION_REQUIRED = 407,
|
|
PJSIP_SC_REQUEST_TIMEOUT = 408,
|
|
PJSIP_SC_GONE = 410,
|
|
PJSIP_SC_REQUEST_ENTITY_TOO_LARGE = 413,
|
|
PJSIP_SC_REQUEST_URI_TOO_LONG = 414,
|
|
PJSIP_SC_UNSUPPORTED_MEDIA_TYPE = 415,
|
|
PJSIP_SC_UNSUPPORTED_URI_SCHEME = 416,
|
|
PJSIP_SC_BAD_EXTENSION = 420,
|
|
PJSIP_SC_EXTENSION_REQUIRED = 421,
|
|
PJSIP_SC_SESSION_TIMER_TOO_SMALL = 422,
|
|
PJSIP_SC_INTERVAL_TOO_BRIEF = 423,
|
|
PJSIP_SC_TEMPORARILY_UNAVAILABLE = 480,
|
|
PJSIP_SC_CALL_TSX_DOES_NOT_EXIST = 481,
|
|
PJSIP_SC_LOOP_DETECTED = 482,
|
|
PJSIP_SC_TOO_MANY_HOPS = 483,
|
|
PJSIP_SC_ADDRESS_INCOMPLETE = 484,
|
|
PJSIP_AC_AMBIGUOUS = 485,
|
|
PJSIP_SC_BUSY_HERE = 486,
|
|
PJSIP_SC_REQUEST_TERMINATED = 487,
|
|
PJSIP_SC_NOT_ACCEPTABLE_HERE = 488,
|
|
PJSIP_SC_BAD_EVENT = 489,
|
|
PJSIP_SC_REQUEST_UPDATED = 490,
|
|
PJSIP_SC_REQUEST_PENDING = 491,
|
|
PJSIP_SC_UNDECIPHERABLE = 493,
|
|
|
|
PJSIP_SC_INTERNAL_SERVER_ERROR = 500,
|
|
PJSIP_SC_NOT_IMPLEMENTED = 501,
|
|
PJSIP_SC_BAD_GATEWAY = 502,
|
|
PJSIP_SC_SERVICE_UNAVAILABLE = 503,
|
|
PJSIP_SC_SERVER_TIMEOUT = 504,
|
|
PJSIP_SC_VERSION_NOT_SUPPORTED = 505,
|
|
PJSIP_SC_MESSAGE_TOO_LARGE = 513,
|
|
PJSIP_SC_PRECONDITION_FAILURE = 580,
|
|
|
|
PJSIP_SC_BUSY_EVERYWHERE = 600,
|
|
PJSIP_SC_DECLINE = 603,
|
|
PJSIP_SC_DOES_NOT_EXIST_ANYWHERE = 604,
|
|
PJSIP_SC_NOT_ACCEPTABLE_ANYWHERE = 606,
|
|
|
|
PJSIP_SC_TSX_TIMEOUT = PJSIP_SC_REQUEST_TIMEOUT,
|
|
/*PJSIP_SC_TSX_RESOLVE_ERROR = 702,*/
|
|
PJSIP_SC_TSX_TRANSPORT_ERROR = PJSIP_SC_SERVICE_UNAVAILABLE
|
|
|
|
} pjsip_status_code;
|
|
|
|
/**
|
|
* Get the default status text for the status code.
|
|
*
|
|
* @param status_code SIP Status Code
|
|
*
|
|
* @return textual message for the status code.
|
|
*/
|
|
PJ_DECL(const pj_str_t*) pjsip_get_status_text(int status_code);
|
|
|
|
/**
|
|
* This macro returns non-zero (TRUE) if the specified status_code is
|
|
* in the same class as the code_class.
|
|
*
|
|
* @param status_code The status code.
|
|
* @param code_class The status code in the class (for example 100, 200).
|
|
*/
|
|
#define PJSIP_IS_STATUS_IN_CLASS(status_code, code_class) \
|
|
(status_code/100 == code_class/100)
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @addtogroup PJSIP_MSG_MEDIA Media/MIME Type
|
|
* @brief Media/MIME type declaration and manipulations.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* This structure describes SIP media type, as used for example in
|
|
* Accept and Content-Type header..
|
|
*/
|
|
typedef struct pjsip_media_type
|
|
{
|
|
pj_str_t type; /**< Media type. */
|
|
pj_str_t subtype; /**< Media subtype. */
|
|
pj_str_t param; /**< Media type parameters (concatenated). */
|
|
} pjsip_media_type;
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @addtogroup PJSIP_MSG_BODY Message Body
|
|
* @brief SIP message body structures and manipulation.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Generic abstraction to message body.
|
|
* When an incoming message is parsed (pjsip_parse_msg()), the parser fills in
|
|
* all members with the appropriate value. The 'data' and 'len' member will
|
|
* describe portion of incoming packet which denotes the message body.
|
|
* When application needs to attach message body to outgoing SIP message, it
|
|
* must fill in all members of this structure.
|
|
*/
|
|
struct pjsip_msg_body
|
|
{
|
|
/** MIME content type.
|
|
* For incoming messages, the parser will fill in this member with the
|
|
* content type found in Content-Type header.
|
|
*
|
|
* For outgoing messages, application may fill in this member with
|
|
* appropriate value, because the stack will generate Content-Type header
|
|
* based on the value specified here.
|
|
*
|
|
* If the content_type is empty, no Content-Type AND Content-Length header
|
|
* will be added to the message. The stack assumes that application adds
|
|
* these headers themselves.
|
|
*/
|
|
pjsip_media_type content_type;
|
|
|
|
/** Pointer to buffer which holds the message body data.
|
|
* For incoming messages, the parser will fill in this member with the
|
|
* pointer to the body string.
|
|
*
|
|
* When sending outgoing message, this member doesn't need to point to the
|
|
* actual message body string. It can be assigned with arbitrary pointer,
|
|
* because the value will only need to be understood by the print_body()
|
|
* function. The stack itself will not try to interpret this value, but
|
|
* instead will always call the print_body() whenever it needs to get the
|
|
* actual body string.
|
|
*/
|
|
void *data;
|
|
|
|
/** The length of the data.
|
|
* For incoming messages, the parser will fill in this member with the
|
|
* actual length of message body.
|
|
*
|
|
* When sending outgoing message, again just like the "data" member, the
|
|
* "len" member doesn't need to point to the actual length of the body
|
|
* string.
|
|
*/
|
|
unsigned len;
|
|
|
|
/** Pointer to function to print this message body.
|
|
* Application must set a proper function here when sending outgoing
|
|
* message.
|
|
*
|
|
* @param msg_body This structure itself.
|
|
* @param buf The buffer.
|
|
* @param size The buffer size.
|
|
*
|
|
* @return The length of the string printed, or -1 if there is
|
|
* not enough space in the buffer to print the whole
|
|
* message body.
|
|
*/
|
|
int (*print_body)(struct pjsip_msg_body *msg_body,
|
|
char *buf, pj_size_t size);
|
|
|
|
/** Clone the data part only of this message body. Note that this only
|
|
* duplicates the data part of the body instead of the whole message
|
|
* body. If application wants to duplicate the entire message body
|
|
* structure, it must call #pjsip_msg_body_clone().
|
|
*
|
|
* @param pool Pool used to clone the data.
|
|
* @param data The data inside message body, to be cloned.
|
|
* @param len The length of the data.
|
|
*
|
|
* @return New data duplicated from the original data.
|
|
*/
|
|
void* (*clone_data)(pj_pool_t *pool, const void *data, unsigned len);
|
|
|
|
};
|
|
|
|
/**
|
|
* General purpose function to textual data in a SIP body. Attach this function
|
|
* in a SIP message body only if the data in pjsip_msg_body is a textual
|
|
* message ready to be embedded in a SIP message. If the data in the message
|
|
* body is not a textual body, then application must supply a custom function
|
|
* to print that body.
|
|
*
|
|
* @param msg_body The message body.
|
|
* @param buf Buffer to copy the message body to.
|
|
* @param size The size of the buffer.
|
|
*
|
|
* @return The length copied to the buffer, or -1.
|
|
*/
|
|
PJ_DECL(int) pjsip_print_text_body( pjsip_msg_body *msg_body,
|
|
char *buf, pj_size_t size);
|
|
|
|
/**
|
|
* General purpose function to clone textual data in a SIP body. Attach this
|
|
* function as "clone_data" member of the SIP body only if the data type
|
|
* is a text (i.e. C string, not pj_str_t), and the length indicates the
|
|
* length of the text.
|
|
*
|
|
* @param pool Pool used to clone the data.
|
|
* @param data Textual data.
|
|
* @param len The length of the string.
|
|
*
|
|
* @return New text duplicated from the original text.
|
|
*/
|
|
PJ_DECL(void*) pjsip_clone_text_data( pj_pool_t *pool, const void *data,
|
|
unsigned len);
|
|
|
|
|
|
/**
|
|
* Clone the message body in src_body to the dst_body. This will duplicate
|
|
* the contents of the message body using the \a clone_data member of the
|
|
* source message body.
|
|
*
|
|
* @param pool Pool to use to duplicate the message body.
|
|
* @param dst_body Destination message body.
|
|
* @param src_body Source message body to duplicate.
|
|
*
|
|
* @return PJ_SUCCESS on success.
|
|
*/
|
|
PJ_DECL(pj_status_t) pjsip_msg_body_copy( pj_pool_t *pool,
|
|
pjsip_msg_body *dst_body,
|
|
const pjsip_msg_body *src_body );
|
|
|
|
|
|
/**
|
|
* Create cloned message body. This will duplicate the contents of the message
|
|
* body using the \a clone_data member of the source message body.
|
|
*
|
|
* @param pool Pool to use to duplicate the message body.
|
|
* @param body Source message body to duplicate.
|
|
*
|
|
* @return The cloned message body on successfull.
|
|
*/
|
|
PJ_DECL(pjsip_msg_body*) pjsip_msg_body_clone( pj_pool_t *pool,
|
|
const pjsip_msg_body *body );
|
|
|
|
|
|
/**
|
|
* Create a text message body. Use this function to create message body when
|
|
* the content is a simple text. For non-text message body (e.g.
|
|
* pjmedia_sdp_session or pj_xml_node), application must construct the message
|
|
* manually.
|
|
*
|
|
* @param pool Pool to allocate message body and its contents.
|
|
* @param type MIME type (e.g. "text").
|
|
* @param subtype MIME subtype (e.g. "plain").
|
|
* @param text The text content to be put in the message body.
|
|
*
|
|
* @return A new message body with the specified Content-Type and
|
|
* text.
|
|
*/
|
|
PJ_DECL(pjsip_msg_body*) pjsip_msg_body_create( pj_pool_t *pool,
|
|
const pj_str_t *type,
|
|
const pj_str_t *subtype,
|
|
const pj_str_t *text );
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @defgroup PJSIP_MSG_MSG Message Structure
|
|
* @brief SIP message (request and response) structure and operations.
|
|
* @ingroup PJSIP_MSG
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Message type (request or response).
|
|
*/
|
|
typedef enum pjsip_msg_type_e
|
|
{
|
|
PJSIP_REQUEST_MSG, /**< Indicates request message. */
|
|
PJSIP_RESPONSE_MSG /**< Indicates response message. */
|
|
} pjsip_msg_type_e;
|
|
|
|
|
|
/**
|
|
* This structure describes a SIP message.
|
|
*/
|
|
struct pjsip_msg
|
|
{
|
|
/** Message type (ie request or response). */
|
|
pjsip_msg_type_e type;
|
|
|
|
/** The first line of the message can be either request line for request
|
|
* messages, or status line for response messages. It is represented here
|
|
* as a union.
|
|
*/
|
|
union
|
|
{
|
|
/** Request Line. */
|
|
struct pjsip_request_line req;
|
|
|
|
/** Status Line. */
|
|
struct pjsip_status_line status;
|
|
} line;
|
|
|
|
/** List of message headers. */
|
|
pjsip_hdr hdr;
|
|
|
|
/** Pointer to message body, or NULL if no message body is attached to
|
|
* this mesage.
|
|
*/
|
|
pjsip_msg_body *body;
|
|
};
|
|
|
|
|
|
/**
|
|
* Create new request or response message.
|
|
*
|
|
* @param pool The pool.
|
|
* @param type Message type.
|
|
* @return New message, or THROW exception if failed.
|
|
*/
|
|
PJ_DECL(pjsip_msg*) pjsip_msg_create( pj_pool_t *pool, pjsip_msg_type_e type);
|
|
|
|
|
|
/**
|
|
* Perform a deep clone of a SIP message.
|
|
*
|
|
* @param pool The pool for creating the new message.
|
|
* @param msg The message to be duplicated.
|
|
*
|
|
* @return New message, which is duplicated from the original
|
|
* message.
|
|
*/
|
|
PJ_DECL(pjsip_msg*) pjsip_msg_clone( pj_pool_t *pool, const pjsip_msg *msg);
|
|
|
|
|
|
/**
|
|
* Find a header in the message by the header type.
|
|
*
|
|
* @param msg The message.
|
|
* @param type The header type to find.
|
|
* @param start The first header field where the search should begin.
|
|
* If NULL is specified, then the search will begin from the
|
|
* first header, otherwise the search will begin at the
|
|
* specified header.
|
|
*
|
|
* @return The header field, or NULL if no header with the specified
|
|
* type is found.
|
|
*/
|
|
PJ_DECL(void*) pjsip_msg_find_hdr( const pjsip_msg *msg,
|
|
pjsip_hdr_e type, const void *start);
|
|
|
|
/**
|
|
* Find a header in the message by its name.
|
|
*
|
|
* @param msg The message.
|
|
* @param name The header name to find.
|
|
* @param start The first header field where the search should begin.
|
|
* If NULL is specified, then the search will begin from the
|
|
* first header, otherwise the search will begin at the
|
|
* specified header.
|
|
*
|
|
* @return The header field, or NULL if no header with the specified
|
|
* type is found.
|
|
*/
|
|
PJ_DECL(void*) pjsip_msg_find_hdr_by_name( const pjsip_msg *msg,
|
|
const pj_str_t *name,
|
|
const void *start);
|
|
|
|
/**
|
|
* Find and remove a header in the message.
|
|
*
|
|
* @param msg The message.
|
|
* @param hdr The header type to find.
|
|
* @param start The first header field where the search should begin,
|
|
* or NULL to search from the first header in the message.
|
|
*
|
|
* @return The header field, or NULL if not found.
|
|
*/
|
|
PJ_DECL(void*) pjsip_msg_find_remove_hdr( pjsip_msg *msg,
|
|
pjsip_hdr_e hdr, void *start);
|
|
|
|
/**
|
|
* Add a header to the message, putting it last in the header list.
|
|
*
|
|
* @param msg The message.
|
|
* @param hdr The header to add.
|
|
*
|
|
* @bug Once the header is put in a list (or message), it can not be put in
|
|
* other list (or message). Otherwise Real Bad Thing will happen.
|
|
*/
|
|
PJ_INLINE(void) pjsip_msg_add_hdr( pjsip_msg *msg, pjsip_hdr *hdr )
|
|
{
|
|
pj_list_insert_before(&msg->hdr, hdr);
|
|
}
|
|
|
|
/**
|
|
* Add header field to the message, putting it in the front of the header list.
|
|
*
|
|
* @param msg The message.
|
|
* @param hdr The header to add.
|
|
*
|
|
* @bug Once the header is put in a list (or message), it can not be put in
|
|
* other list (or message). Otherwise Real Bad Thing will happen.
|
|
*/
|
|
PJ_INLINE(void) pjsip_msg_insert_first_hdr( pjsip_msg *msg, pjsip_hdr *hdr )
|
|
{
|
|
pj_list_insert_after(&msg->hdr, hdr);
|
|
}
|
|
|
|
/**
|
|
* Print the message to the specified buffer.
|
|
*
|
|
* @param msg The message to print.
|
|
* @param buf The buffer
|
|
* @param size The size of the buffer.
|
|
*
|
|
* @return The length of the printed characters (in bytes), or NEGATIVE
|
|
* value if the message is too large for the specified buffer.
|
|
*/
|
|
PJ_DECL(pj_ssize_t) pjsip_msg_print(const pjsip_msg *msg,
|
|
char *buf, pj_size_t size);
|
|
|
|
|
|
/*
|
|
* Some usefull macros to find common headers.
|
|
*/
|
|
|
|
|
|
/**
|
|
* Find Call-ID header.
|
|
*
|
|
* @param msg The message.
|
|
* @return Call-ID header instance.
|
|
*/
|
|
#define PJSIP_MSG_CID_HDR(msg) \
|
|
((pjsip_cid_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CALL_ID, NULL))
|
|
|
|
/**
|
|
* Find CSeq header.
|
|
*
|
|
* @param msg The message.
|
|
* @return CSeq header instance.
|
|
*/
|
|
#define PJSIP_MSG_CSEQ_HDR(msg) \
|
|
((pjsip_cseq_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_CSEQ, NULL))
|
|
|
|
/**
|
|
* Find From header.
|
|
*
|
|
* @param msg The message.
|
|
* @return From header instance.
|
|
*/
|
|
#define PJSIP_MSG_FROM_HDR(msg) \
|
|
((pjsip_from_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_FROM, NULL))
|
|
|
|
/**
|
|
* Find To header.
|
|
*
|
|
* @param msg The message.
|
|
* @return To header instance.
|
|
*/
|
|
#define PJSIP_MSG_TO_HDR(msg) \
|
|
((pjsip_to_hdr*)pjsip_msg_find_hdr(msg, PJSIP_H_TO, NULL))
|
|
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* @addtogroup PJSIP_MSG_HDR
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* Generic SIP header, which contains hname and a string hvalue.
|
|
* Note that this header is not supposed to be used as 'base' class for headers.
|
|
*/
|
|
typedef struct pjsip_generic_string_hdr
|
|
{
|
|
/** Standard header field. */
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_generic_string_hdr);
|
|
/** hvalue */
|
|
pj_str_t hvalue;
|
|
} pjsip_generic_string_hdr;
|
|
|
|
|
|
/**
|
|
* Create a new instance of generic header. A generic header can have an
|
|
* arbitrary header name.
|
|
*
|
|
* @param pool The pool.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string.
|
|
* @param hvalue Optional string to be assigned as the value.
|
|
*
|
|
* @return The header, or THROW exception.
|
|
*/
|
|
PJ_DECL(pjsip_generic_string_hdr*)
|
|
pjsip_generic_string_hdr_create( pj_pool_t *pool,
|
|
const pj_str_t *hname,
|
|
const pj_str_t *hvalue);
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string later.
|
|
* @param hvalue Optional string to be assigned as the value.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_generic_string_hdr*)
|
|
pjsip_generic_string_hdr_init( pj_pool_t *pool,
|
|
void *mem,
|
|
const pj_str_t *hname,
|
|
const pj_str_t *hvalue);
|
|
|
|
|
|
/**
|
|
* Construct a generic string header without allocating memory from the pool.
|
|
* This function is useful to create a temporary header which life-time is
|
|
* very short (for example, creating the header in the stack to be passed
|
|
* as argument to a function which will copy the header).
|
|
*
|
|
* @param h The header to be initialized.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string.
|
|
* @param hvalue Optional string to be assigned as the value.
|
|
*
|
|
* @return The header, or THROW exception.
|
|
*/
|
|
PJ_DECL(void) pjsip_generic_string_hdr_init2(pjsip_generic_string_hdr *h,
|
|
pj_str_t *hname,
|
|
pj_str_t *hvalue);
|
|
|
|
|
|
/* **************************************************************************/
|
|
|
|
/**
|
|
* Generic SIP header, which contains hname and a string hvalue.
|
|
*/
|
|
typedef struct pjsip_generic_int_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_generic_int_hdr); /**< Standard header field. */
|
|
pj_int32_t ivalue; /**< ivalue */
|
|
} pjsip_generic_int_hdr;
|
|
|
|
|
|
/**
|
|
* Create a new instance of generic header. A generic header can have an
|
|
* arbitrary header name.
|
|
*
|
|
* @param pool The pool.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string.
|
|
* @param hvalue The value to be assigned to the header.
|
|
*
|
|
* @return The header, or THROW exception.
|
|
*/
|
|
PJ_DECL(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_create( pj_pool_t *pool,
|
|
const pj_str_t *hname,
|
|
int hvalue );
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string later.
|
|
* @param value Value to be assigned to the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_generic_int_hdr*) pjsip_generic_int_hdr_init( pj_pool_t *pool,
|
|
void *mem,
|
|
const pj_str_t *hname,
|
|
int value );
|
|
|
|
/* **************************************************************************/
|
|
|
|
/** Maximum elements in the header array. */
|
|
#define PJSIP_GENERIC_ARRAY_MAX_COUNT 32
|
|
|
|
/**
|
|
* Generic array of string header.
|
|
*/
|
|
typedef struct pjsip_generic_array_hdr
|
|
{
|
|
/** Standard header fields. */
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_generic_array_hdr);
|
|
|
|
/** Number of tags/elements. */
|
|
unsigned count;
|
|
|
|
/**< Tags/elements. */
|
|
pj_str_t values[PJSIP_GENERIC_ARRAY_MAX_COUNT];
|
|
|
|
} pjsip_generic_array_hdr;
|
|
|
|
/**
|
|
* Create generic array header.
|
|
*
|
|
* @param pool Pool to allocate memory from.
|
|
* @param hname Header name.
|
|
*
|
|
* @return New generic array header.
|
|
*/
|
|
PJ_DECL(pjsip_generic_array_hdr*) pjsip_generic_array_hdr_create(pj_pool_t *pool,
|
|
const pj_str_t *hname);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param hname The header name to be assigned to the header, or NULL to
|
|
* assign the header name with some string later.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_generic_array_hdr*) pjsip_generic_array_hdr_init(pj_pool_t *pool,
|
|
void *mem,
|
|
const pj_str_t *hname);
|
|
|
|
|
|
/* **************************************************************************/
|
|
|
|
/** Accept header. */
|
|
typedef pjsip_generic_array_hdr pjsip_accept_hdr;
|
|
|
|
/** Maximum fields in Accept header. */
|
|
#define PJSIP_MAX_ACCEPT_COUNT PJSIP_GENERIC_ARRAY_MAX_COUNT
|
|
|
|
/**
|
|
* Create new Accept header instance.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return New Accept header instance.
|
|
*/
|
|
PJ_DECL(pjsip_accept_hdr*) pjsip_accept_hdr_create(pj_pool_t *pool);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_accept_hdr*) pjsip_accept_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
|
|
/* **************************************************************************/
|
|
|
|
/**
|
|
* Allow header.
|
|
*/
|
|
typedef pjsip_generic_array_hdr pjsip_allow_hdr;
|
|
|
|
/**
|
|
* Create new Allow header instance.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return New Allow header instance.
|
|
*/
|
|
PJ_DECL(pjsip_allow_hdr*) pjsip_allow_hdr_create(pj_pool_t *pool);
|
|
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_allow_hdr*) pjsip_allow_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
|
|
/**
|
|
* Call-ID header.
|
|
*/
|
|
typedef struct pjsip_cid_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_cid_hdr);
|
|
pj_str_t id; /**< Call-ID string. */
|
|
} pjsip_cid_hdr;
|
|
|
|
|
|
/**
|
|
* Create new Call-ID header.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return new Call-ID header.
|
|
*/
|
|
PJ_DECL(pjsip_cid_hdr*) pjsip_cid_hdr_create( pj_pool_t *pool );
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_cid_hdr*) pjsip_cid_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Content-Length header.
|
|
*/
|
|
typedef struct pjsip_clen_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_clen_hdr);
|
|
int len; /**< Content length. */
|
|
} pjsip_clen_hdr;
|
|
|
|
/**
|
|
* Create new Content-Length header.
|
|
*
|
|
* @param pool the pool.
|
|
* @return A new Content-Length header instance.
|
|
*/
|
|
PJ_DECL(pjsip_clen_hdr*) pjsip_clen_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_clen_hdr*) pjsip_clen_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* CSeq header.
|
|
*/
|
|
typedef struct pjsip_cseq_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_cseq_hdr);
|
|
int cseq; /**< CSeq number. */
|
|
pjsip_method method; /**< CSeq method. */
|
|
} pjsip_cseq_hdr;
|
|
|
|
|
|
/** Create new CSeq header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new CSeq header instance.
|
|
*/
|
|
PJ_DECL(pjsip_cseq_hdr*) pjsip_cseq_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_cseq_hdr*) pjsip_cseq_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Contact header.
|
|
* In this library, contact header only contains single URI. If a message has
|
|
* multiple URI in the Contact header, the URI will be put in separate Contact
|
|
* headers.
|
|
*/
|
|
typedef struct pjsip_contact_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_contact_hdr);
|
|
int star; /**< The contact contains only a '*' character */
|
|
pjsip_uri *uri; /**< URI in the contact. */
|
|
int q1000; /**< The "q" value times 1000 (to avoid float) */
|
|
pj_int32_t expires; /**< Expires parameter, otherwise -1 if not present. */
|
|
pjsip_param other_param; /**< Other parameters, concatenated in a single string. */
|
|
} pjsip_contact_hdr;
|
|
|
|
|
|
/**
|
|
* Create a new Contact header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new instance of Contact header.
|
|
*/
|
|
PJ_DECL(pjsip_contact_hdr*) pjsip_contact_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_contact_hdr*) pjsip_contact_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Content-Type.
|
|
*/
|
|
typedef struct pjsip_ctype_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_ctype_hdr);
|
|
pjsip_media_type media; /**< Media type. */
|
|
} pjsip_ctype_hdr;
|
|
|
|
|
|
/**
|
|
* Create a nwe Content Type header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new Content-Type header.
|
|
*/
|
|
PJ_DECL(pjsip_ctype_hdr*) pjsip_ctype_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_ctype_hdr*) pjsip_ctype_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
/** Expires header. */
|
|
typedef pjsip_generic_int_hdr pjsip_expires_hdr;
|
|
|
|
/**
|
|
* Create a new Expires header.
|
|
*
|
|
* @param pool The pool.
|
|
* @param value The expiration value.
|
|
*
|
|
* @return A new Expires header.
|
|
*/
|
|
PJ_DECL(pjsip_expires_hdr*) pjsip_expires_hdr_create( pj_pool_t *pool,
|
|
int value);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param value The expiration value.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_expires_hdr*) pjsip_expires_hdr_init( pj_pool_t *pool,
|
|
void *mem,
|
|
int value );
|
|
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* To or From header.
|
|
*/
|
|
typedef struct pjsip_fromto_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_fromto_hdr);
|
|
pjsip_uri *uri; /**< URI in From/To header. */
|
|
pj_str_t tag; /**< Header "tag" parameter. */
|
|
pjsip_param other_param; /**< Other params, concatenated as a single string. */
|
|
} pjsip_fromto_hdr;
|
|
|
|
/** Alias for From header. */
|
|
typedef pjsip_fromto_hdr pjsip_from_hdr;
|
|
|
|
/** Alias for To header. */
|
|
typedef pjsip_fromto_hdr pjsip_to_hdr;
|
|
|
|
/**
|
|
* Create a From header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return New instance of From header.
|
|
*/
|
|
PJ_DECL(pjsip_from_hdr*) pjsip_from_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_from_hdr*) pjsip_from_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/**
|
|
* Create a To header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return New instance of To header.
|
|
*/
|
|
PJ_DECL(pjsip_to_hdr*) pjsip_to_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_to_hdr*) pjsip_to_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/**
|
|
* Convert the header to a From header.
|
|
*
|
|
* @param hdr The generic from/to header.
|
|
* @return "From" header.
|
|
*/
|
|
PJ_DECL(pjsip_from_hdr*) pjsip_fromto_hdr_set_from( pjsip_fromto_hdr *hdr );
|
|
|
|
/**
|
|
* Convert the header to a To header.
|
|
*
|
|
* @param hdr The generic from/to header.
|
|
* @return "To" header.
|
|
*/
|
|
PJ_DECL(pjsip_to_hdr*) pjsip_fromto_hdr_set_to( pjsip_fromto_hdr *hdr );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Max-Forwards header.
|
|
*/
|
|
typedef pjsip_generic_int_hdr pjsip_max_fwd_hdr;
|
|
|
|
/**
|
|
* Create new Max-Forwards header instance.
|
|
*
|
|
* @param pool The pool.
|
|
* @param value The Max-Forwards value.
|
|
*
|
|
* @return New Max-Forwards header instance.
|
|
*/
|
|
PJ_DECL(pjsip_max_fwd_hdr*)
|
|
pjsip_max_fwd_hdr_create(pj_pool_t *pool, int value);
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param value The Max-Forwards value.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_max_fwd_hdr*)
|
|
pjsip_max_fwd_hdr_init( pj_pool_t *pool, void *mem, int value );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Min-Expires header.
|
|
*/
|
|
typedef pjsip_generic_int_hdr pjsip_min_expires_hdr;
|
|
|
|
/**
|
|
* Create new Min-Expires header instance.
|
|
*
|
|
* @param pool The pool.
|
|
* @param value The Min-Expires value.
|
|
*
|
|
* @return New Min-Expires header instance.
|
|
*/
|
|
PJ_DECL(pjsip_min_expires_hdr*) pjsip_min_expires_hdr_create(pj_pool_t *pool,
|
|
int value);
|
|
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param value The Min-Expires value.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_min_expires_hdr*) pjsip_min_expires_hdr_init( pj_pool_t *pool,
|
|
void *mem,
|
|
int value );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Record-Route and Route headers.
|
|
*/
|
|
typedef struct pjsip_routing_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_routing_hdr); /**< Generic header fields. */
|
|
pjsip_name_addr name_addr; /**< The URL in the Route/Record-Route header. */
|
|
pjsip_param other_param; /**< Other parameter. */
|
|
} pjsip_routing_hdr;
|
|
|
|
/** Alias for Record-Route header. */
|
|
typedef pjsip_routing_hdr pjsip_rr_hdr;
|
|
|
|
/** Alias for Route header. */
|
|
typedef pjsip_routing_hdr pjsip_route_hdr;
|
|
|
|
|
|
/**
|
|
* Create new Record-Route header from the pool.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new instance of Record-Route header.
|
|
*/
|
|
PJ_DECL(pjsip_rr_hdr*) pjsip_rr_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_rr_hdr*) pjsip_rr_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/**
|
|
* Create new Route header from the pool.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new instance of "Route" header.
|
|
*/
|
|
PJ_DECL(pjsip_route_hdr*) pjsip_route_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_route_hdr*) pjsip_route_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/**
|
|
* Convert generic routing header to Record-Route header.
|
|
*
|
|
* @param r The generic routing header, or a "Routing" header.
|
|
* @return Record-Route header.
|
|
*/
|
|
PJ_DECL(pjsip_rr_hdr*) pjsip_routing_hdr_set_rr( pjsip_routing_hdr *r );
|
|
|
|
/**
|
|
* Convert generic routing header to "Route" header.
|
|
*
|
|
* @param r The generic routing header, or a "Record-Route" header.
|
|
* @return "Route" header.
|
|
*/
|
|
PJ_DECL(pjsip_route_hdr*) pjsip_routing_hdr_set_route( pjsip_routing_hdr *r );
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Require header.
|
|
*/
|
|
typedef pjsip_generic_array_hdr pjsip_require_hdr;
|
|
|
|
/**
|
|
* Create new Require header instance.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return New Require header instance.
|
|
*/
|
|
PJ_DECL(pjsip_require_hdr*) pjsip_require_hdr_create(pj_pool_t *pool);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure. This function
|
|
* should only be called when application uses its own memory allocation to
|
|
* allocate memory block for the specified header (e.g. in C++, when the
|
|
* header is allocated with "new" operator).
|
|
* For normal applications, they should use pjsip_xxx_hdr_create() instead,
|
|
* which allocates memory and initialize it in one go.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_require_hdr*) pjsip_require_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Retry-After header.
|
|
*/
|
|
typedef pjsip_generic_int_hdr pjsip_retry_after_hdr;
|
|
|
|
/**
|
|
* Create new Retry-After header instance.
|
|
*
|
|
* @param pool The pool.
|
|
* @param value The Retry-After value.
|
|
*
|
|
* @return New Retry-After header instance.
|
|
*/
|
|
PJ_DECL(pjsip_retry_after_hdr*) pjsip_retry_after_hdr_create(pj_pool_t *pool,
|
|
int value);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
* @param value The Retry-After value.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_retry_after_hdr*) pjsip_retry_after_hdr_init( pj_pool_t *pool,
|
|
void *mem,
|
|
int value );
|
|
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Supported header.
|
|
*/
|
|
typedef pjsip_generic_array_hdr pjsip_supported_hdr;
|
|
|
|
/**
|
|
* Create new Supported header instance.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return New Supported header instance.
|
|
*/
|
|
PJ_DECL(pjsip_supported_hdr*) pjsip_supported_hdr_create(pj_pool_t *pool);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_supported_hdr*) pjsip_supported_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* Unsupported header.
|
|
*/
|
|
typedef pjsip_generic_array_hdr pjsip_unsupported_hdr;
|
|
|
|
/**
|
|
* Create new Unsupported header instance.
|
|
*
|
|
* @param pool The pool.
|
|
*
|
|
* @return New Unsupported header instance.
|
|
*/
|
|
PJ_DECL(pjsip_unsupported_hdr*) pjsip_unsupported_hdr_create(pj_pool_t *pool);
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_unsupported_hdr*) pjsip_unsupported_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* SIP Via header.
|
|
* In this implementation, Via header can only have one element in each header.
|
|
* If a message arrives with multiple elements in a single Via, then they will
|
|
* be split up into multiple Via headers.
|
|
*/
|
|
typedef struct pjsip_via_hdr
|
|
{
|
|
PJSIP_DECL_HDR_MEMBER(struct pjsip_via_hdr);
|
|
pj_str_t transport; /**< Transport type. */
|
|
pjsip_host_port sent_by; /**< Host and optional port */
|
|
int ttl_param; /**< TTL parameter, or -1 if it's not specified. */
|
|
int rport_param; /**< "rport" parameter, 0 to specify without
|
|
port number, -1 means doesn't exist. */
|
|
pj_str_t maddr_param; /**< "maddr" parameter. */
|
|
pj_str_t recvd_param; /**< "received" parameter. */
|
|
pj_str_t branch_param; /**< "branch" parameter. */
|
|
pjsip_param other_param; /**< Other parameters, concatenated as single string. */
|
|
pj_str_t comment; /**< Comment. */
|
|
} pjsip_via_hdr;
|
|
|
|
/**
|
|
* Create a new Via header.
|
|
*
|
|
* @param pool The pool.
|
|
* @return A new "Via" header instance.
|
|
*/
|
|
PJ_DECL(pjsip_via_hdr*) pjsip_via_hdr_create( pj_pool_t *pool );
|
|
|
|
/**
|
|
* Initialize a preallocated memory with the header structure.
|
|
*
|
|
* @param pool Pool for additional memory allocation if required.
|
|
* @param mem Pre-allocated memory to be initialized as the header.
|
|
*
|
|
* @return The header instance, which points to the same memory
|
|
* location as the mem argument.
|
|
*/
|
|
PJ_DECL(pjsip_via_hdr*) pjsip_via_hdr_init( pj_pool_t *pool,
|
|
void *mem );
|
|
|
|
/* **************************************************************************/
|
|
/**
|
|
* SIP Warning header.
|
|
* In this version, Warning header is just a typedef for generic string
|
|
* header.
|
|
*/
|
|
typedef pjsip_generic_string_hdr pjsip_warning_hdr;
|
|
|
|
/**
|
|
* Create a warning header with the specified contents.
|
|
*
|
|
* @param pool Pool to allocate memory from.
|
|
* @param code Warning code, 300-399.
|
|
* @param host The host portion of the Warning header.
|
|
* @param text The warning text, which MUST not be quoted with
|
|
* double quote.
|
|
*
|
|
* @return The Warning header field.
|
|
*/
|
|
PJ_DECL(pjsip_warning_hdr*) pjsip_warning_hdr_create( pj_pool_t *pool,
|
|
int code,
|
|
const pj_str_t *host,
|
|
const pj_str_t *text);
|
|
|
|
/**
|
|
* Create a warning header and initialize the contents from the error
|
|
* message for the specified status code. The warning code will be
|
|
* set to 399.
|
|
*
|
|
* @param pool Pool to allocate memory from.
|
|
* @param host The host portion of the Warning header.
|
|
* @param status The error status code, which error text will be
|
|
* put in as the Warning text.
|
|
*
|
|
* @return The Warning header field.
|
|
*/
|
|
PJ_DECL(pjsip_warning_hdr*)
|
|
pjsip_warning_hdr_create_from_status( pj_pool_t *pool,
|
|
const pj_str_t *host,
|
|
pj_status_t status);
|
|
|
|
/* **************************************************************************/
|
|
/** Accept-Encoding header. */
|
|
typedef pjsip_generic_string_hdr pjsip_accept_encoding_hdr;
|
|
|
|
/** Create Accept-Encoding header. */
|
|
#define pjsip_accept_encoding_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Accept-Language header. */
|
|
typedef pjsip_generic_string_hdr pjsip_accept_lang_hdr;
|
|
|
|
/** Create Accept-Language header. */
|
|
#define pjsip_accept_lang_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Alert-Info header. */
|
|
typedef pjsip_generic_string_hdr pjsip_alert_info_hdr;
|
|
|
|
/** Create Alert-Info header. */
|
|
#define pjsip_alert_info_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Authentication-Info header. */
|
|
typedef pjsip_generic_string_hdr pjsip_auth_info_hdr;
|
|
|
|
/** Create Authentication-Info header. */
|
|
#define pjsip_auth_info_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Call-Info header. */
|
|
typedef pjsip_generic_string_hdr pjsip_call_info_hdr;
|
|
|
|
/** Create Call-Info header. */
|
|
#define pjsip_call_info_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Content-Disposition header. */
|
|
typedef pjsip_generic_string_hdr pjsip_content_disposition_hdr;
|
|
|
|
/** Create Content-Disposition header. */
|
|
#define pjsip_content_disposition_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Content-Encoding header. */
|
|
typedef pjsip_generic_string_hdr pjsip_content_encoding_hdr;
|
|
|
|
/** Create Content-Encoding header. */
|
|
#define pjsip_content_encoding_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Content-Language header. */
|
|
typedef pjsip_generic_string_hdr pjsip_content_lang_hdr;
|
|
|
|
/** Create Content-Language header. */
|
|
#define pjsip_content_lang_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Date header. */
|
|
typedef pjsip_generic_string_hdr pjsip_date_hdr;
|
|
|
|
/** Create Date header. */
|
|
#define pjsip_date_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Error-Info header. */
|
|
typedef pjsip_generic_string_hdr pjsip_err_info_hdr;
|
|
|
|
/** Create Error-Info header. */
|
|
#define pjsip_err_info_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** In-Reply-To header. */
|
|
typedef pjsip_generic_string_hdr pjsip_in_reply_to_hdr;
|
|
|
|
/** Create In-Reply-To header. */
|
|
#define pjsip_in_reply_to_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** MIME-Version header. */
|
|
typedef pjsip_generic_string_hdr pjsip_mime_version_hdr;
|
|
|
|
/** Create MIME-Version header. */
|
|
#define pjsip_mime_version_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Organization header. */
|
|
typedef pjsip_generic_string_hdr pjsip_organization_hdr;
|
|
|
|
/** Create Organization header. */
|
|
#define pjsip_organization_hdr_create pjsip_genric_string_hdr_create
|
|
|
|
/** Priority header. */
|
|
typedef pjsip_generic_string_hdr pjsip_priority_hdr;
|
|
|
|
/** Create Priority header. */
|
|
#define pjsip_priority_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Proxy-Require header. */
|
|
typedef pjsip_generic_string_hdr pjsip_proxy_require_hdr;
|
|
|
|
/** Reply-To header. */
|
|
typedef pjsip_generic_string_hdr pjsip_reply_to_hdr;
|
|
|
|
/** Create Reply-To header. */
|
|
#define pjsip_reply_to_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Server header. */
|
|
typedef pjsip_generic_string_hdr pjsip_server_hdr;
|
|
|
|
/** Create Server header. */
|
|
#define pjsip_server_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Subject header. */
|
|
typedef pjsip_generic_string_hdr pjsip_subject_hdr;
|
|
|
|
/** Create Subject header. */
|
|
#define pjsip_subject_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** Timestamp header. */
|
|
typedef pjsip_generic_string_hdr pjsip_timestamp_hdr;
|
|
|
|
/** Create Timestamp header. */
|
|
#define pjsip_timestamp_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
/** User-Agent header. */
|
|
typedef pjsip_generic_string_hdr pjsip_user_agent_hdr;
|
|
|
|
/** Create User-Agent header. */
|
|
#define pjsip_user_agent_hdr_create pjsip_generic_string_hdr_create
|
|
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @} PJSIP_MSG
|
|
*/
|
|
|
|
|
|
PJ_END_DECL
|
|
|
|
#endif /* __PJSIP_SIP_MSG_H__ */
|
|
|