/*
 * Copyright (C) 2032 Teluu Inc. (http://www.teluu.com)
 *
 * 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 __PJSUA2_SIPTYPES_HPP__
#define __PJSUA2_SIPTYPES_HPP__

/**
 * @file pjsua2/types.hpp
 * @brief PJSUA2 Base Types
 */
#include <pjsua2/types.hpp>
#include <pjsua2/persistent.hpp>

#include <string>
#include <vector>

/** PJSUA2 API is inside pj namespace */
namespace pj
{

/**
 * @defgroup PJSUA2_SIP_Types SIP Types
 * @ingroup PJSUA2_DS
 * @{
 */

/**
 * Credential information. Credential contains information to authenticate
 * against a service.
 */
struct AuthCredInfo : public PersistentObject
{
    /**
     * The authentication scheme (e.g. "digest").
     */
    string      scheme;

    /**
     * Realm on which this credential is to be used. Use "*" to make
     * a credential that can be used to authenticate against any challenges.
     */
    string      realm;

    /**
     * Authentication user name.
     */
    string      username;

    /**
     * Type of data that is contained in the "data" field. Use 0 if the data
     * contains plain text password.
     */
    int         dataType;

    /**
     * The data, which can be a plain text password or a hashed digest.
     */
    string      data;


    /**
     * Digest algorithm type.
     */
    pjsip_auth_algorithm_type algoType;

    /*
     * Digest AKA credential information. Note that when AKA credential
     * is being used, the \a data field of this pjsip_cred_info is
     * not used, but it still must be initialized to an empty string.
     * Please see PJSIP_AUTH_AKA_API for more information.
     */

    /** Permanent subscriber key. */
    string      akaK;

    /** Operator variant key. */
    string      akaOp;

    /** Authentication Management Field */
    string      akaAmf;

public:
    /** Default constructor */
    AuthCredInfo();

    /** Construct a credential with the specified parameters */
    AuthCredInfo(const string &scheme,
                 const string &realm,
                 const string &user_name,
                 const int data_type,
                 const string data);

    /**
     * Convert from pjsip
     */
    void fromPj(const pjsip_cred_info &prm);

    /**
     * Convert to pjsip
     */
    pjsip_cred_info toPj() const;

    /**
     * Read this object from a container node.
     *
     * @param node              Container to read values from.
     */
    virtual void readObject(const ContainerNode &node) PJSUA2_THROW(Error);

    /**
     * Write this object to a container node.
     *
     * @param node              Container to write values to.
     */
    virtual void writeObject(ContainerNode &node) const PJSUA2_THROW(Error);
};


//////////////////////////////////////////////////////////////////////////////

/**
 * Socket option type.
 */
struct SockOpt {
    /**
     * The level at which the option is defined.
     */
    int                 level;

    /**
     * Option name.
     */
    int                 optName;

public:
    /** Default constructor. */
    SockOpt();

    /** Construct a socket option with the specified parameters. */
    SockOpt(int level, int optName, int optVal);

    /**
     * Set option value of type integer.
     *
     * @param opt_val           Option value.
     */
    void setOptValInt(int opt_val);

private:
    friend struct SockOptParams;

    /** Pointer to the buffer in which the option is specified. */
    void               *optVal;

    /** Buffer size of the buffer pointed by optVal. */
    int                 optLen;

    /** Option value if the type is integer. */
    int                 optValInt;
};

/** Array of socket options */
typedef std::vector<SockOpt> SockOptVector;

/**
 * Socket option parameters, to be specified in TransportConfig.
 */
struct SockOptParams : public PersistentObject
{
    /**
     * Array of socket options.
     */
    SockOptVector    sockOpts;

public:
    /** Default constructor initialises with default values */
    SockOptParams();

    /** Convert to pjsip */
    pj_sockopt_params toPj() const;

    /** Convert from pjsip */
    void fromPj(const pj_sockopt_params &prm);

    /**
     * Read this object from a container node.
     *
     * @param node              Container to read values from.
     */
    virtual void readObject(const ContainerNode &node) PJSUA2_THROW(Error);

    /**
     * Write this object to a container node.
     *
     * @param node              Container to write values to.
     */
    virtual void writeObject(ContainerNode &node) const PJSUA2_THROW(Error);
};


/**
 * TLS transport settings, to be specified in TransportConfig.
 */
struct TlsConfig : public PersistentObject
{
    /**
     * Certificate of Authority (CA) list file.
     */
    string              CaListFile;

    /**
     * Public endpoint certificate file, which will be used as client-
     * side  certificate for outgoing TLS connection, and server-side
     * certificate for incoming TLS connection.
     */
    string              certFile;

    /**
     * Optional private key of the endpoint certificate to be used.
     */
    string              privKeyFile;

    /**
     * Password to open private key.
     */
    string              password;

    /**
     * Certificate of Authority (CA) buffer. If CaListFile, certFile or
     * privKeyFile are set, this setting will be ignored.
     */
    string              CaBuf;

    /**
     * Public endpoint certificate buffer, which will be used as client-
     * side  certificate for outgoing TLS connection, and server-side
     * certificate for incoming TLS connection. If CaListFile, certFile or
     * privKeyFile are set, this setting will be ignored.
     */
    string              certBuf;

    /**
     * Optional private key buffer of the endpoint certificate to be used. 
     * If CaListFile, certFile or privKeyFile are set, this setting will 
     * be ignored.
     */
    string              privKeyBuf;

    /**
     * Lookup certificate from OS certificate store, this setting will
     * specify the field type to lookup.
     *
     * Currently only used by Windows Schannel backend, see also
     * \a pj_ssl_cert_load_from_store() for more info.
     */
    pj_ssl_cert_lookup_type certLookupType;

    /**
     * Lookup certificate from OS certificate store, this setting will
     * specify the keyword to match on the field specified in
     * \a certLookupType above.
     *
     * Currently only used by Windows Schannel backend, see also
     * \a pj_ssl_cert_load_from_store() for more info.
     */
    string              certLookupKeyword;

    /**
     * When using backend specific credentials objects, specify the backend
     * object types using this bit flag, see also \ref pj_ssl_cert_direct_type.
     */
    unsigned            credDirectType;

    /**
     * Optional backend specific private key. See also
     * \a pj_ssl_cert_load_direct().
     *
     * Currently only the OpenSSL backend is supported. This setting
     * corresponds to an OpenSSL EVP_PKEY instance. When this is set,
     * specify PJ_SSL_CERT_DIRECT_OPENSSL_EVP_PKEY flag in \a certDirectType.
     */
    Token               privKeyDirect;

    /**
     * Optional backend specific certificate. See also
     * \a pj_ssl_cert_load_direct().
     *
     * Currently only the OpenSSL backend is supported, this setting
     * corresponds to an OpenSSL X509 instance. When this is set,
     * specify PJ_SSL_CERT_DIRECT_OPENSSL_X509_CERT flag in \a certDirectType.
     */
    Token               certDirect;

    /**
     * TLS protocol method from #pjsip_ssl_method. In the future, this field
     * might be deprecated in favor of <b>proto</b> field. For now, this field 
     * is only applicable only when <b>proto</b> field is set to zero.
     *
     * Default is PJSIP_SSL_UNSPECIFIED_METHOD (0), which in turn will
     * use PJSIP_SSL_DEFAULT_METHOD, which default value is PJSIP_TLSV1_METHOD.
     */
    pjsip_ssl_method    method;

    /**
     * TLS protocol type from #pj_ssl_sock_proto. Use this field to enable 
     * specific protocol type. Use bitwise OR operation to combine the protocol 
     * type.
     *
     * Default is PJSIP_SSL_DEFAULT_PROTO.
     */
    unsigned            proto;

    /**
     * Ciphers and order preference. The Endpoint::utilSslGetAvailableCiphers()
     * can be used to check the available ciphers supported by backend.
     * If the array is empty, then default cipher list of the backend
     * will be used.
     */
    IntVector           ciphers;

    /**
     * Specifies TLS transport behavior on the server TLS certificate
     * verification result:
     * - If \a verifyServer is disabled, TLS transport will just notify
     *   the application via pjsip_tp_state_callback with state
     *   PJSIP_TP_STATE_CONNECTED regardless TLS verification result.
     * - If \a verifyServer is enabled, TLS transport will be shutdown
     *   and application will be notified with state
     *   PJSIP_TP_STATE_DISCONNECTED whenever there is any TLS verification
     *   error, otherwise PJSIP_TP_STATE_CONNECTED will be notified.
     *
     * In any cases, application can inspect pjsip_tls_state_info in the
     * callback to see the verification detail.
     *
     * Default value is false.
     */
    bool                verifyServer;

    /**
     * Specifies TLS transport behavior on the client TLS certificate
     * verification result:
     * - If \a verifyClient is disabled, TLS transport will just notify
     *   the application via pjsip_tp_state_callback with state
     *   PJSIP_TP_STATE_CONNECTED regardless TLS verification result.
     * - If \a verifyClient is enabled, TLS transport will be shutdown
     *   and application will be notified with state
     *   PJSIP_TP_STATE_DISCONNECTED whenever there is any TLS verification
     *   error, otherwise PJSIP_TP_STATE_CONNECTED will be notified.
     *
     * In any cases, application can inspect pjsip_tls_state_info in the
     * callback to see the verification detail.
     *
     * Default value is PJ_FALSE.
     */
    bool                verifyClient;

    /**
     * When acting as server (incoming TLS connections), reject incoming
     * connection if client doesn't supply a TLS certificate.
     *
     * This setting corresponds to SSL_VERIFY_FAIL_IF_NO_PEER_CERT flag.
     * Default value is PJ_FALSE.
     */
    bool                requireClientCert;

    /**
     * TLS negotiation timeout to be applied for both outgoing and incoming
     * connection, in milliseconds. If zero, the SSL negotiation doesn't
     * have a timeout.
     *
     * Default: zero
     */
    unsigned            msecTimeout;

    /**
     * QoS traffic type to be set on this transport. When application wants
     * to apply QoS tagging to the transport, it's preferable to set this
     * field rather than \a qosParam fields since this is more portable.
     *
     * Default value is PJ_QOS_TYPE_BEST_EFFORT.
     */
    pj_qos_type         qosType;

    /**
     * Set the low level QoS parameters to the transport. This is a lower
     * level operation than setting the \a qosType field and may not be
     * supported on all platforms.
     *
     * By default all settings in this structure are disabled.
     */
    pj_qos_params       qosParams;

    /**
     * Specify if the transport should ignore any errors when setting the QoS
     * traffic type/parameters.
     *
     * Default: PJ_TRUE
     */
    bool                qosIgnoreError;

    /**
     * Specify options to be set on the transport.
     *
     * By default, this is unset, which means that the underlying sockopt
     * params as returned by #pj_ssl_sock_param_default() will be used.
     */
    SockOptParams       sockOptParams;

    /**
     * Specify if the transport should ignore any errors when setting the
     * sockopt parameters.
     *
     * Default: true
     */
    bool                sockOptIgnoreError;

    /**
     * Specify if renegotiation is enabled for TLSv1.2 or earlier.
     *
     * Default: PJ_TRUE
     */
    bool                enableRenegotiation;

public:
    /** Default constructor initialises with default values */
    TlsConfig();

    /** Convert to pjsip */
    pjsip_tls_setting toPj() const;

    /** Convert from pjsip */
    void fromPj(const pjsip_tls_setting &prm);

    /**
     * Read this object from a container node.
     *
     * @param node              Container to read values from.
     */
    virtual void readObject(const ContainerNode &node) PJSUA2_THROW(Error);

    /**
     * Write this object to a container node.
     *
     * @param node              Container to write values to.
     */
    virtual void writeObject(ContainerNode &node) const PJSUA2_THROW(Error);
};


/**
 * Parameters to create a transport instance.
 */
struct TransportConfig : public PersistentObject
{
    /**
     * UDP port number to bind locally. This setting MUST be specified
     * even when default port is desired. If the value is zero, the
     * transport will be bound to any available port, and application
     * can query the port by querying the transport info.
     */
    unsigned            port;

    /**
     * Specify the port range for socket binding, relative to the start
     * port number specified in \a port. Note that this setting is only
     * applicable for media transport when the start port number is non zero.
     * Media transport is configurable via account setting, 
     * i.e: AccountMediaConfig::transportConfig, please check the media
     * transport config docs for more info.
     * 
     * Available ports are in the range of [\a port, \a port + \a portRange].
     *
     * Default value is zero.
     */
    unsigned            portRange;

    /**
     * Specify whether to randomly pick the starting port number from
     * the range of [\a port, \a port + \a port_range]. This setting is
     * used only if both port and port_range are non-zero, and only
     * applicable for the port selection of UDP and loop media transport.
     * 
     * Default is PJ_FALSE.
     */
    bool                randomizePort;

    /**
     * Optional address to advertise as the address of this transport.
     * Application can specify any address or hostname for this field,
     * for example it can point to one of the interface address in the
     * system, or it can point to the public address of a NAT router
     * where port mappings have been configured for the application.
     *
     * Note: this option can be used for both UDP and TCP as well!
     */
    string              publicAddress;

    /**
     * Optional address where the socket should be bound to. This option
     * SHOULD only be used to selectively bind the socket to particular
     * interface (instead of 0.0.0.0), and SHOULD NOT be used to set the
     * published address of a transport (the public_addr field should be
     * used for that purpose).
     *
     * Note that unlike public_addr field, the address (or hostname) here
     * MUST correspond to the actual interface address in the host, since
     * this address will be specified as bind() argument.
     */
    string              boundAddress;

    /**
     * This specifies TLS settings for TLS transport. 
     * It's only used when creating a SIP TLS transport.
     */
    TlsConfig           tlsConfig;

    /**
     * QoS traffic type to be set on this transport. When application wants
     * to apply QoS tagging to the transport, it's preferable to set this
     * field rather than \a qosParam fields since this is more portable.
     *
     * For TLS transport, this field will be ignored, the QoS traffic type
     * can be set via tlsConfig.
     *
     * Default is QoS not set.
     */
    pj_qos_type         qosType;

    /**
     * Set the low level QoS parameters to the transport. This is a lower
     * level operation than setting the \a qosType field and may not be
     * supported on all platforms.
     *
     * For TLS transport, this field will be ignored, the low level QoS
     * parameters can be set via tlsConfig.
     *
     * Default is QoS not set.
     */
    pj_qos_params       qosParams;

    /**
     * Set the low level socket options to the transport.
     *
     * For TLS transport, this field will be ignored, the socket options
     * can be set via tlsConfig.
     *
     * Default is no socket option set.
     */
    SockOptParams       sockOptParams;

public:
    /** Default constructor initialises with default values */
    TransportConfig();

    /** Convert from pjsip */
    void fromPj(const pjsua_transport_config &prm);

    /** Convert to pjsip */
    pjsua_transport_config toPj() const;

    /**
     * Read this object from a container node.
     *
     * @param node              Container to read values from.
     */
    virtual void readObject(const ContainerNode &node) PJSUA2_THROW(Error);

    /**
     * Write this object to a container node.
     *
     * @param node              Container to write values to.
     */
    virtual void writeObject(ContainerNode &node) const PJSUA2_THROW(Error);
};

/**
 * This structure describes transport information returned by
 * Endpoint::transportGetInfo() function.
 */
struct TransportInfo
{
    /** PJSUA transport identification. */
    TransportId             id;

    /** Transport type. */
    pjsip_transport_type_e  type;

    /** Transport type name. */
    string                  typeName;

    /** Transport string info/description. */
    string                  info;

    /** Transport flags (see pjsip_transport_flags_e). */
    unsigned                flags;

    /** Local/bound address. */
    SocketAddress           localAddress;

    /** Published address (or transport address name). */
    SocketAddress           localName;

    /** Current number of objects currently referencing this transport. */
    unsigned                usageCount;

public:
    /**
     * Default constructor.
     */
    TransportInfo();

    /** Construct from pjsua_transport_info */
    void fromPj(const pjsua_transport_info &info);
};

//////////////////////////////////////////////////////////////////////////////

/**
 * This structure describes an incoming SIP message. It corresponds to the
 * pjsip_rx_data structure in PJSIP library.
 */
struct SipRxData
{
    /**
     * A short info string describing the request, which normally contains
     * the request method and its CSeq.
     */
    string              info;

    /**
     * The whole message data as a string, containing both the header section
     * and message body section.
     */
    string              wholeMsg;

    /**
     * Source address of the message.
     */
    SocketAddress       srcAddress;

    /**
     * Pointer to original pjsip_rx_data. Only valid when the struct
     * is constructed from PJSIP's pjsip_rx_data.
     */
    void               *pjRxData;

public:
    /**
     * Default constructor.
     */
    SipRxData();

    /**
     * Construct from PJSIP's pjsip_rx_data
     */
    void fromPj(pjsip_rx_data &rdata);
};

/**
 * This structure describes an outgoing SIP message. It corresponds to the
 * pjsip_tx_data structure in PJSIP library.
 */
struct SipTxData
{
    /**
     * A short info string describing the request, which normally contains
     * the request method and its CSeq.
     */
    string              info;
    
    /**
     * The whole message data as a string, containing both the header section
     * and message body section.
     */
    string              wholeMsg;
    
    /**
     * Destination address of the message.
     */
    SocketAddress       dstAddress;
    
    /**
     * Pointer to original pjsip_tx_data. Only valid when the struct
     * is constructed from PJSIP's pjsip_tx_data.
     */
    void               *pjTxData;
    
public:
    /**
     * Default constructor.
     */
    SipTxData();

    /**
     * Construct from PJSIP's pjsip_tx_data
     */
    void fromPj(pjsip_tx_data &tdata);
};

/**
 * This structure describes SIP transaction object. It corresponds to the
 * pjsip_transaction structure in PJSIP library.
 */
struct SipTransaction
{
    /* Transaction identification. */
    pjsip_role_e        role;           /**< Role (UAS or UAC)      */
    string              method;         /**< The method.            */
    
    /* State and status. */
    int                 statusCode;     /**< Last status code seen. */
    string              statusText;     /**< Last reason phrase.    */
    pjsip_tsx_state_e   state;          /**< State.                 */
    
    /* Messages and timer. */
    SipTxData           lastTx;         /**< Msg kept for retrans.  */
    
    /* Original pjsip_transaction. */
    void               *pjTransaction;  /**< pjsip_transaction.     */
    
public:
    /**
     * Default constructor.
     */
    SipTransaction();

    /**
     * Construct from PJSIP's pjsip_transaction
     */
    void fromPj(pjsip_transaction &tsx);
};

/**
 * This structure describes timer event.
 */
struct TimerEvent
{
    TimerEntry          entry;          /**< The timer entry.           */
};

/**
 * This structure describes transaction state event source.
 */
struct TsxStateEventSrc
{
    SipRxData       rdata;          /**< The incoming message.      */
    SipTxData       tdata;          /**< The outgoing message.      */
    TimerEntry      timer;          /**< The timer.                 */
    pj_status_t     status;         /**< Transport error status.    */
    GenericData     data;           /**< Generic data.              */

    TsxStateEventSrc()
    : timer(NULL), status(PJ_SUCCESS), data(NULL)
    {}
};

/**
 * This structure describes transaction state changed event.
 */
struct TsxStateEvent
{
    TsxStateEventSrc    src;            /**< Event source.              */
    SipTransaction      tsx;            /**< The transaction.           */
    pjsip_tsx_state_e   prevState;      /**< Previous state.            */
    pjsip_event_id_e    type;           /**< Type of event source:
                                         *     - PJSIP_EVENT_TX_MSG
                                         *     - PJSIP_EVENT_RX_MSG,
                                         *     - PJSIP_EVENT_TRANSPORT_ERROR
                                         *     - PJSIP_EVENT_TIMER
                                         *     - PJSIP_EVENT_USER
                                         */

    TsxStateEvent();
};

/**
 * This structure describes message transmission event.
 */
struct TxMsgEvent
{
    SipTxData           tdata;          /**< The transmit data buffer.  */
};

/**
 * This structure describes transmission error event.
 */
struct TxErrorEvent
{
    SipTxData           tdata;          /**< The transmit data.         */
    SipTransaction      tsx;            /**< The transaction.           */
};

/**
 * This structure describes message arrival event.
 */
struct RxMsgEvent
{
    SipRxData           rdata;          /**< The receive data buffer.   */
};

/**
 * This structure describes user event.
 */
struct UserEvent
{
    GenericData         user1;          /**< User data 1.               */
    GenericData         user2;          /**< User data 2.               */
    GenericData         user3;          /**< User data 3.               */
    GenericData         user4;          /**< User data 4.               */
};

/**
 * The event body.
 */
struct SipEventBody
{
    /**
     * Timer event.
     */
    TimerEvent      timer;
    
    /**
     * Transaction state has changed event.
     */
    TsxStateEvent   tsxState;
    
    /**
     * Message transmission event.
     */
    TxMsgEvent      txMsg;
    
    /**
     * Transmission error event.
     */
    TxErrorEvent    txError;
    
    /**
     * Message arrival event.
     */
    RxMsgEvent      rxMsg;
    
    /**
     * User event.
     */
    UserEvent       user;
    
};

/**
 * This structure describe event descriptor to fully identify a SIP event. It
 * corresponds to the pjsip_event structure in PJSIP library.
 */
struct SipEvent
{
    /**
     * The event type, can be any value of \b pjsip_event_id_e.
     */
    pjsip_event_id_e    type;
    
    /**
     * The event body, which fields depends on the event type.
     */
    SipEventBody        body;
    
    /**
     * Pointer to its original pjsip_event. Only valid when the struct is
     * constructed from PJSIP's pjsip_event.
     */
    void               *pjEvent;
    
public:
    /**
     * Default constructor.
     */
    SipEvent();

    /**
     * Construct from PJSIP's pjsip_event
     */
    void fromPj(const pjsip_event &ev);
};

//////////////////////////////////////////////////////////////////////////////

/**
 * SIP media type containing type and subtype. For example, for
 * "application/sdp", the type is "application" and the subtype is "sdp".
 */
struct SipMediaType
{
    /** Media type. */
    string              type;

    /** Media subtype. */
    string              subType;

public:
    /**
     * Construct from PJSIP's pjsip_media_type
     */
    void fromPj(const pjsip_media_type &prm);

    /**
     * Convert to PJSIP's pjsip_media_type.
     */
    pjsip_media_type toPj() const;
};

/**
 * Simple SIP header.
 */
struct SipHeader
{
    /**
     * Header name.
     */
    string              hName;

    /**
     * Header value.
     */
    string              hValue;

public:
    /**
     * Default constructor.
     */
    SipHeader();

    /**
     * Initiaize from PJSIP header.
     */
    void fromPj(const pjsip_hdr *) PJSUA2_THROW(Error);

    /**
     * Convert to PJSIP header.
     */
    pjsip_generic_string_hdr &toPj() const;

private:
    /** Interal buffer for conversion to PJSIP header */
    mutable pjsip_generic_string_hdr    pjHdr;
};


/** Array of strings */
typedef std::vector<SipHeader> SipHeaderVector;

/**
 * This describes each multipart part.
 */
struct SipMultipartPart
{
    /**
     * Optional headers to be put in this multipart part.
     */
    SipHeaderVector     headers;

    /**
     * The MIME type of the body part of this multipart part.
     */
    SipMediaType        contentType;

    /**
     * The body part of tthis multipart part.
     */
    string              body;

public:
    SipMultipartPart();
    
    /**
     * Initiaize from PJSIP's pjsip_multipart_part.
     */
    void fromPj(const pjsip_multipart_part &prm) PJSUA2_THROW(Error);

    /**
     * Convert to PJSIP's pjsip_multipart_part.
     */
    pjsip_multipart_part& toPj() const;

private:
    /** Interal buffer for conversion to PJSIP pjsip_multipart_part */
    mutable pjsip_multipart_part        pjMpp;
    mutable pjsip_msg_body              pjMsgBody;
};

/** Array of multipart parts */
typedef std::vector<SipMultipartPart> SipMultipartPartVector;

/**
 * Additional options when sending outgoing SIP message. This corresponds to
 * pjsua_msg_data structure in PJSIP library.
 */
struct SipTxOption
{
    /**
     * Optional remote target URI (i.e. Target header). If empty (""), the
     * target will be set to the remote URI (To header). At the moment this
     * field is only used when sending initial INVITE and MESSAGE requests.
     */
    string                  targetUri;

    /**
     * Optional local URI (i.e. From header). If empty (""), the
     * \a AccountConfig::idUri is used for the From header. At the moment this
     * field is only used when sending initial INVITE and MESSAGE requests.
     */
    string                  localUri;

    /**
     * Optional contact URI to be used for this call. If empty (""), the
     * contact will be generated automatically based on the account
     * configuration. At the moment this field is only used when sending
     * initial INVITE requests.
     */
    string                  contactUri;

    /**
     * Additional message headers to be included in the outgoing message.
     *
     * Application may override Max-Forwards header value (the default is
     * #PJSIP_MAX_FORWARDS_VALUE) by adding a Max-Forwards header here.
     */
    SipHeaderVector         headers;

    /**
     * MIME type of the message body, if application specifies the messageBody
     * in this structure.
     */
    string                  contentType;

    /**
     * Optional message body to be added to the message, only when the
     * message doesn't have a body.
     */
    string                  msgBody;

    /**
     * Content type of the multipart body. If application wants to send
     * multipart message bodies, it puts the parts in multipartParts and set
     * the content type in multipartContentType. If the message already
     * contains a body, the body will be added to the multipart bodies.
     */
    SipMediaType            multipartContentType;

    /**
     * Array of multipart parts. If application wants to send multipart
     * message bodies, it puts the parts in \a parts and set the content
     * type in \a multipart_ctype. If the message already contains a body,
     * the body will be added to the multipart bodies.
     */
    SipMultipartPartVector  multipartParts;

public:
    /**
     * Check if the options are empty. If the options are set with empty
     * values, there will be no additional information sent with outgoing
     * SIP message.
     *
     * @return              True if the options are empty.
     */
    bool isEmpty() const;
    
    /**
     * Initiaize from PJSUA's pjsua_msg_data.
     */
    void fromPj(const pjsua_msg_data &prm) PJSUA2_THROW(Error);

    /**
     * Convert to PJSUA's pjsua_msg_data.
     */
    void toPj(pjsua_msg_data &msg_data) const;
};

//////////////////////////////////////////////////////////////////////////////

/**
 * This structure contains parameters for sending instance message methods,
 * e.g: Buddy::sendInstantMessage(), Call:sendInstantMessage().
 */
struct SendInstantMessageParam
{
    /**
     * MIME type. Default is "text/plain".
     */
    string      contentType;
    
    /**
     * The message content.
     */
    string      content;
    
    /**
     * List of headers etc to be included in outgoing request.
     */
    SipTxOption txOption;
    
    /**
     * User data, which will be given back when the IM callback is called.
     */
    Token       userData;
    
public:
    /**
     * Default constructor initializes with zero/empty values.
     */
    SendInstantMessageParam();
};


/**
 * This structure contains parameters for sending typing indication methods,
 * e.g: Buddy::sendTypingIndication(), Call:sendTypingIndication().
 */
struct SendTypingIndicationParam
{
    /**
     * True to indicate to remote that local person is currently typing an IM.
     */
    bool         isTyping;
    
    /**
     * List of headers etc to be included in outgoing request.
     */
    SipTxOption  txOption;
    
public:
    /**
     * Default constructor initializes with zero/empty values.
     */
    SendTypingIndicationParam();
};


/* Utilities */
#ifndef SWIG
//! @cond Doxygen_Suppress
void readIntVector( ContainerNode &node,
                    const string &array_name,
                    IntVector &v) PJSUA2_THROW(Error);
void writeIntVector(ContainerNode &node,
                    const string &array_name,
                    const IntVector &v) PJSUA2_THROW(Error);
void readQosParams( ContainerNode &node,
                    pj_qos_params &qos) PJSUA2_THROW(Error);
void writeQosParams( ContainerNode &node,
                     const pj_qos_params &qos) PJSUA2_THROW(Error);
void readSipHeaders( const ContainerNode &node,
                     const string &array_name,
                     SipHeaderVector &headers) PJSUA2_THROW(Error);
void writeSipHeaders(ContainerNode &node,
                     const string &array_name,
                     const SipHeaderVector &headers) PJSUA2_THROW(Error);
//! @endcond
#endif // SWIG

/**
 * @}  PJSUA2
 */

} // namespace pj



#endif  /* __PJSUA2_SIPTYPES_HPP__ */
