// // // Copyright (C) 2005, 2006 SIPez LLC// Licensed to SIPfoundry under a Contributor Agreement.//// Copyright (C) 2005, 2006 SIPfoundry Inc.// Licensed by SIPfoundry under the LGPL license.// // Copyright (C) 2004, 2005 Pingtel Corp.// Licensed to SIPfoundry under a Contributor Agreement.// // $$//////////////////////////////////////////////////////////////////////////////// Author: Dan Petrie (dpetrie AT SIPez DOT com)#ifndef _SipConnection_h_#define _SipConnection_h_// SYSTEM INCLUDES//#include <...>// APPLICATION INCLUDES#include <cp/Connection.h>#include <net/SipContactDb.h>// DEFINES// MACROS// EXTERNAL FUNCTIONS// EXTERNAL VARIABLES// CONSTANTS// STRUCTS// TYPEDEFS// FORWARD DECLARATIONSclass SipUserAgent;class SipMessage;class SdpCodec;class SdpCodecFactory;//:Class short description which may consist of multiple lines (note the ':')// Class detailed description which may extend to multiple linesclass SipConnection : public Connection{    /* //////////////////////////// PUBLIC //////////////////////////////////// */public:    enum ReinviteStates    {        ACCEPT_INVITE = 0,        REINVITED,        REINVITING    };    /* ============================ CREATORS ================================== */    SipConnection(const char* outboundLineAddress,        UtlBoolean isEarlyMediaFor180Enabled = TRUE,        CpCallManager* callMgr = NULL,        CpCall* call = NULL,        CpMediaInterface* mediaInterface = NULL,        SipUserAgent* sipUA = NULL,        int offeringDelayMilliSeconds = IMMEDIATE,        int sessionReinviteTimer = 0,        int availableBehavior = RING,        const char* forwardUnconditionalUrl = NULL,        int busyBehavior = BUSY,        const char* forwardOnBusy = NULL);    //:Default constructor    virtual        ~SipConnection();    //:Destructor    /* ============================ MANIPULATORS ============================== */    virtual UtlBoolean dequeue(UtlBoolean callInFocus);        virtual UtlBoolean send(SipMessage& message,                        OsMsgQ* responseListener = NULL,                        void* responseListenerData = NULL);    virtual UtlBoolean dial(const char* dialString,        const char* callerId,        const char* callId,        const char* callController = NULL,        const char* originalCallConnection = NULL,        UtlBoolean requestQueuedCall = FALSE,        const void* pDisplay = NULL);    //! param: requestQueuedCall - indicates that the caller wishes to have the callee queue the call if busy    /// Initiate transfer on transfer controller connection in the original call.    virtual UtlBoolean originalCallTransfer(       UtlString&  transferTargetAddress,       const char* transferControllerAddress,       const char* targetCallId,       bool        holdBeforeTransfer = true                                            );    /**     * If fromAddress or toAddress are NULL it is assumed to be a blind transfer.     */        virtual UtlBoolean targetCallBlindTransfer(const char* transferTargetAddress,        const char* transferControllerAddress);    // Communicate blind transfer on transfer controller connection in    // the target call.  This is signaled by the transfer controller in the    // original call.    virtual UtlBoolean transfereeStatus(int connectionState, int response);    // Method to communicate status to original call on transferee side    virtual UtlBoolean transferControllerStatus(int connectionState, int response);    // Method to communicate status to target call on transfer    // controller side    virtual UtlBoolean answer(const void* hWnd = NULL);    virtual UtlBoolean hangUp();    virtual UtlBoolean hold();    virtual UtlBoolean offHold();    virtual UtlBoolean renegotiateCodecs();    virtual UtlBoolean accept(int forwardOnNoAnswerTimeOut);    virtual UtlBoolean reject();    virtual UtlBoolean redirect(const char* forwardAddress);    //! Change the local identity for the existing connection    /*! This sets the value used for PAssertedIdentity header in INVITE requests     *  (see RFC 3325).     *     *  \param newLocalIdentity - new identity to be used for local side in subsequent signalling     *  \param shouldSignalIdentityChangeNow - send SIP reINVITE now to indicate      *         local identity change.  FALSE means that the next reINVITE sent     *         for some other operation (e.g. on/off hold).     */    virtual UtlBoolean changeLocalIdentity(const UtlString& newLocalIdentity,                                           const UtlBoolean& shouldSignalIdentityChangeNow);    virtual UtlBoolean sendInfo(UtlString contentType, UtlString sContent);    virtual UtlBoolean processMessage(OsMsg& eventMessage,        UtlBoolean callInFocus, UtlBoolean onHook);    void setCallerId();    virtual UtlBoolean getRemoteAddress(UtlString* remoteAddress) const;    virtual UtlBoolean getRemoteAddress(UtlString* remoteAddress,        UtlBoolean leaveFieldParmetersIn) const;    static UtlBoolean processNewFinalMessage(SipUserAgent* sipUa,        OsMsg* eventMessage);    void setContactType(CONTACT_TYPE eType) ;    void setContactId(CONTACT_ID contactId) { mContactId = contactId; }    /* ============================ ACCESSORS ================================= */    virtual UtlBoolean getSession(SipSession& session);    //! Send a SIP message within the dialog of this connection    virtual UtlBoolean sendInDialog(SipMessage& message,                             OsMsgQ* responseQueue,                            void* responseListenerData);    virtual OsStatus getFromField(UtlString* fromField);    virtual OsStatus getToField(UtlString* toField);    virtual OsStatus getInvite(SipMessage* message);    int getNextCseq();    /* ============================ INQUIRY =================================== */    static UtlBoolean shouldCreateConnection(SipUserAgent& sipUa,        OsMsg& eventMessage,        SdpCodecFactory* codecFactory = NULL);    virtual UtlBoolean willHandleMessage(OsMsg& eventMessage) const;    virtual UtlBoolean isConnection(const char* callId,        const char* toTag,        const char* fromTag,        UtlBoolean  strictCompare) const;    virtual UtlBoolean isSameRemoteAddress(Url& remoteAddress) const;    virtual UtlBoolean isSameRemoteAddress(Url& remoteAddress,        UtlBoolean tagsMustMatch) const;    /* //////////////////////////// PROTECTED ///////////////////////////////// */protected:    CONTACT_TYPE selectCompatibleContactType(const SipMessage& request) ;    //: Select a compatible contact given the URI    void updateContact(Url* pContactUrl, CONTACT_TYPE eType) ;    static UtlBoolean requestShouldCreateConnection(const SipMessage* sipMsg,        SipUserAgent& sipUa,        SdpCodecFactory* codecFactory);    UtlBoolean doOffHold(UtlBoolean forceReInvite);    UtlBoolean doHangUp(const char* dialString = NULL,        const char* callerId = NULL);    void buildFromToAddresses(const char* dialString,        const char* callerId,        const char* callerDisplayName,        UtlString& fromAddress,        UtlString& goodToAddress) const;    void buildLocalContact(Url fromAddress,        UtlString& localContact) ;//for outbound call    void buildLocalContact(UtlString& localContact) ;//when getting inbound calls    UtlBoolean extendSessionReinvite();    // SIP Request handlers    UtlBoolean processRequest(const SipMessage* request,        UtlBoolean callInFocus, UtlBoolean onHook);    void processInviteRequest(const SipMessage* request);    void processReferRequest(const SipMessage* request);    void processAckRequest(const SipMessage* request);    void processByeRequest(const SipMessage* request);    void processCancelRequest(const SipMessage* request);    void processNotifyRequest(const SipMessage* request);    // SIP Response handlers    UtlBoolean processResponse(const SipMessage* response,        UtlBoolean callInFocus, UtlBoolean onHook);    void processInviteResponse(const SipMessage* request);    void processReferResponse(const SipMessage* request);    void processOptionsResponse(const SipMessage* request);    void processByeResponse(const SipMessage* request);    void processCancelResponse(const SipMessage* request);    void processNotifyResponse(const SipMessage* request);    /* //////////////////////////// PRIVATE /////////////////////////////////// */private:    SipUserAgent* sipUserAgent;    UtlString mFromTag;    SipMessage* inviteMsg;    UtlBoolean      mbCancelling;    SipMessage* mReferMessage;    UtlBoolean inviteFromThisSide;    UtlString mLastRequestMethod;    UtlString mRemoteContact; //last contact frield from the other side    Url mFromUrl; // SIP address for the local side    Url mToUrl;  //  SIP address for the remote side    UtlString mRemoteUriStr;  //  SIP uri string for the remote side    UtlString mLocalUriStr;  //  SIP uri string for the local side    UtlDList mRemotePAssertedIdentities; // SIP identities from p-Asserted-Identity header    UtlString mLocalPAssertedIdentity;    int lastLocalSequenceNumber;    int lastRemoteSequenceNumber;    int reinviteState;    UtlString mRouteField;    int mDefaultSessionReinviteTimer;    int mSessionReinviteTimer;    UtlString mAllowedRemote;  // Methods supported by the otherside    UtlBoolean mIsReferSent;   // used to determine whether to send ack when sequence number is smaller    UtlBoolean mIsAcceptSent;   // used to determine whether to accept ack when sequence number is smaller    int mHoldCompleteAction;    UtlBoolean mIsEarlyMediaFor180;    UtlString mLineId; //line identifier for incoming calls.    UtlString mLocalContact;    ///< The local Contact: field value - a URI in name-addr format.    CONTACT_TYPE mContactType ;    CONTACT_ID mContactId;    UtlBoolean getInitialSdpCodecs(const SipMessage* sdpMessage,        SdpCodecFactory& supportedCodecsArray,        int& numCodecsInCommon,        SdpCodec** &codecsInCommon,        UtlString& remoteAddress,        int& remotePort,        int& remoteRtcpPort) const;    virtual void proceedToRinging(const SipMessage* inviteMessage,        SipUserAgent* sipUserAgent,        int tagNum,        int availableBehavior);    UtlBoolean isMethodAllowed(const char* method);    void doBlindRefer();    //! Check INVITE for asserted identity change    UtlBoolean updateAssertedIds(const SipMessage& sipMessage);    SipConnection& operator=(const SipConnection& rhs);    //:Assignment operator (disabled)    SipConnection(const SipConnection& rSipConnection);    //:Copy constructor (disabled)};/* ============================ INLINE METHODS ============================ */#endif  // _SipConnection_h_