D:/Storage/CVS_Head/h323plus/include/h450/h450pdu.h

/*
 * h450pdu.h
 *
 * H.450 Helper functions
 *
 * Open H323 Library
 *
 * Copyright (c) 2001 Norwood Systems Pty. Ltd.
 *
 * The contents of this file are subject to the Mozilla Public License
 * Version 1.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS"
 * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
 * the License for the specific language governing rights and limitations
 * under the License.
 *
 * The Original Code is Open H323 Library.
 *
 * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
 *
 * Contributor(s): ______________________________________.
 *
 * $Log: h450pdu.h,v $
 * Revision 1.1  2007/08/06 20:50:51  shorne
 * First commit of h323plus
 *
 * Revision 1.1.2.1  2006/12/23 19:02:56  shorne
 * File restructuring
 *
 * Revision 1.13  2006/06/27 12:35:03  csoutheren
 * Patch 1366328 - Support for H.450.3 divertingLegInformation2
 * Thanks to Norbert Bartalsky
 *
 * Revision 1.12  2005/11/30 13:05:01  csoutheren
 * Changed tags for Doxygen
 *
 * Revision 1.11  2005/03/10 07:01:29  csoutheren
 * Fixed problem with H.450 call identifiers not being unique across all calls on an
 *  endpoint. Thanks to Thien Nguyen
 *
 * Revision 1.10  2002/11/21 22:37:24  robertj
 * Fixed problems with unrecognized invoke APDU, thanks Andrea Bondavalli
 *
 * Revision 1.9  2002/09/16 01:14:15  robertj
 * Added #define so can select if #pragma interface/implementation is used on
 *   platform basis (eg MacOS) rather than compiler, thanks Robert Monaghan.
 *
 * Revision 1.8  2002/09/03 06:19:37  robertj
 * Normalised the multi-include header prevention ifdef/define symbol.
 *
 * Revision 1.7  2002/08/05 10:03:47  robertj
 * Cosmetic changes to normalise the usage of pragma interface/implementation.
 *
 * Revision 1.6  2002/07/04 00:40:31  robertj
 * More H.450.11 call intrusion implementation, thanks Aleksandar Todorovic
 *
 * Revision 1.5  2002/06/22 05:48:38  robertj
 * Added partial implementation for H.450.11 Call Intrusion
 *
 * Revision 1.4  2002/02/04 07:17:52  robertj
 * Added H.450.2 Consultation Transfer, thanks Norwood Systems.
 *
 * Revision 1.3  2002/01/14 00:02:40  robertj
 * Added H.450.6
 * Added extra "failure mode" parts of H.250.2.
 * Various other bug fixes.
 *   Thanks Ben Madsen of Norwood Systems
 *
 * Revision 1.2  2001/08/16 07:49:16  robertj
 * Changed the H.450 support to be more extensible. Protocol handlers
 *   are now in separate classes instead of all in H323Connection.
 *
 * Revision 1.1  2001/04/11 03:01:27  robertj
 * Added H.450.2 (call transfer), thanks a LOT to Graeme Reid & Norwood Systems
 *
 */

#ifndef __OPAL_H450PDU_H
#define __OPAL_H450PDU_H

#ifdef P_USE_PRAGMA
#pragma interface
#endif


#include "x880.h"


class H323EndPoint;
class H323Connection;
class H323TransportAddress;
class H323SignalPDU;

class H4501_EndpointAddress;
class H4501_InterpretationApdu;



class H450ServiceAPDU : public X880_ROS
{
  public:
    X880_Invoke& BuildInvoke(int invokeId, int operation);
    X880_ReturnResult& BuildReturnResult(int invokeId);
    X880_ReturnError& BuildReturnError(int invokeId, int error);
    X880_Reject& BuildReject(int invokeId);

    void BuildCallTransferInitiate(int invokeId,
                                   const PString & callIdentity,
                                   const PString & alias,
                                   const H323TransportAddress & address);

    void BuildCallTransferIdentify(int invokeId);
    void BuildCallTransferAbandon(int invokeId);
    void BuildCallTransferSetup(int invokeId,
                                const PString & callIdentity);

    void BuildCallWaiting(int invokeId, int numCallsWaiting);
    
    void BuildCallIntrusionForcedRelease(int invokeId, int CICL);
    X880_ReturnResult& BuildCallIntrusionForcedReleaseResult(int invokeId);
    void BuildCallIntrusionForcedReleaseError();
    void BuildCallIntrusionGetCIPL(int invokeId);
    void BuildCallIntrusionImpending(int invokeId);
    void BuildCallIntrusionForceRelesed(int invokeId);

    void AttachSupplementaryServiceAPDU(H323SignalPDU & pdu);
    BOOL WriteFacilityPDU(
      H323Connection & connection
    );

    static void ParseEndpointAddress(H4501_EndpointAddress & address,
                                     PString & party);
};


class H450xDispatcher;

class H450xHandler : public PObject
{
    PCLASSINFO(H450xHandler, PObject);
  public:
    H450xHandler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual void AttachToSetup(
      H323SignalPDU & pdu
    );

    virtual void AttachToAlerting(
      H323SignalPDU & pdu
    );

    virtual void AttachToConnect(
      H323SignalPDU & pdu
    );

    virtual void AttachToReleaseComplete(
      H323SignalPDU & pdu
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    ) = 0;

    virtual BOOL OnReceivedReturnResult(
      X880_ReturnResult & returnResult
    );

    virtual BOOL OnReceivedReturnError(
      int errorCode,
      X880_ReturnError & returnError
    );

    virtual BOOL OnReceivedReject(
      int problemType,
      int problemNumber
    );

    void SendReturnError(int returnError);

    void SendGeneralReject(int problem);

    void SendInvokeReject(int problem);

    void SendReturnResultReject(int problem);

    void SendReturnErrorReject(int problem);

    BOOL DecodeArguments(
      PASN_OctetString * argString,
      PASN_Object & argObject,
      int absentErrorCode
    );

    unsigned GetInvokeId() const { return currentInvokeId; }


  protected:
    H323EndPoint   & endpoint;
    H323Connection & connection;
    H450xDispatcher & dispatcher;
    unsigned          currentInvokeId;
};

PLIST(H450xHandlerList, H450xHandler);
PDICTIONARY(H450xHandlerDict, POrdinalKey, H450xHandler);


class H450xDispatcher : public PObject
{
    PCLASSINFO(H450xDispatcher, PObject);
  public:
    H450xDispatcher(
      H323Connection & connection
    );

    void AddOpCode(
      unsigned opcode,
      H450xHandler * handler
    );

    virtual void AttachToSetup(
      H323SignalPDU & pdu
    );

    virtual void AttachToAlerting(
      H323SignalPDU & pdu
    );

    virtual void AttachToConnect(
      H323SignalPDU & pdu
    );

    virtual void AttachToReleaseComplete(
      H323SignalPDU & pdu
    );

    virtual BOOL HandlePDU(
      const H323SignalPDU & pdu
    );

    virtual BOOL OnReceivedInvoke(X880_Invoke& invoke, H4501_InterpretationApdu& interpretation);

    virtual BOOL OnReceivedReturnResult(X880_ReturnResult& returnResult);

    virtual BOOL OnReceivedReturnError(X880_ReturnError& returnError);

    virtual BOOL OnReceivedReject(X880_Reject& reject);

    void SendReturnError(int invokeId, int returnError);

    void SendGeneralReject(int invokeId, int problem);

    void SendInvokeReject(int invokeId, int problem);

    void SendReturnResultReject(int invokeId, int problem);

    void SendReturnErrorReject(int invokeId, int problem);

    unsigned GetNextInvokeId() const { return ++nextInvokeId; }

  protected:
    H323Connection & connection;
    H450xHandlerList  handlers;
    H450xHandlerDict  opcodeHandler;
    mutable unsigned  nextInvokeId;             
};


class H4502Handler : public H450xHandler
{
    PCLASSINFO(H4502Handler, H450xHandler);
  public:
    H4502Handler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual void AttachToSetup(
      H323SignalPDU & pdu
    );

    virtual void AttachToAlerting(
      H323SignalPDU & pdu
    );

    virtual void AttachToConnect(
      H323SignalPDU & pdu
    );

    virtual void AttachToReleaseComplete(
      H323SignalPDU & pdu
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallTransferIdentify(
      int linkedId                            
    );

    virtual void OnReceivedCallTransferAbandon(
      int linkedId                            
    );

    virtual void OnReceivedCallTransferInitiate(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallTransferSetup(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallTransferUpdate(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedSubaddressTransfer(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallTransferComplete(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallTransferActive(
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual BOOL OnReceivedReturnResult(
      X880_ReturnResult & returnResult
    );

    void OnReceivedInitiateReturnResult();
    
    void OnReceivedSetupReturnResult();

    void OnReceivedIdentifyReturnResult(X880_ReturnResult &returnResult);

    virtual BOOL OnReceivedReturnError(
      int errorCode,
      X880_ReturnError & returnError
    );

    void OnReceivedInitiateReturnError(
      const bool timerExpiry = false 
    );

    void OnReceivedSetupReturnError(
      int errorCode,
      const bool timerExpiry = false 
    );

    void OnReceivedIdentifyReturnError(
      const bool timerExpiry = false 
    );

    void TransferCall(
      const PString & remoteParty,   
      const PString & callIdentity   
    );

    void ConsultationTransfer(
      const PString & primaryCallToken   
    );

    void HandleConsultationTransfer(
      const PString & callIdentity,  
      H323Connection& incoming       
    );

    void AwaitSetupResponse(
      const PString & token,
      const PString & identity
    );

    enum State {
      e_ctIdle,
      e_ctAwaitIdentifyResponse,
      e_ctAwaitInitiateResponse,
      e_ctAwaitSetupResponse,
      e_ctAwaitSetup,
      e_ctAwaitConnect
    };

    State GetState() const { return ctState; }

    virtual void onReceivedAdmissionReject(const int returnError);

    void HandleCallTransferFailure(
      const int returnError    
    );

    void StartctTimer(const PTimeInterval value) { ctTimer = value; }

    void StopctTimer();

    BOOL IsctTimerRunning() { return ctTimer.IsRunning(); }

    PDECLARE_NOTIFIER(PTimer, H4502Handler, OnCallTransferTimeOut);

    const H323Connection& getAssociatedConnection() const { return connection; }

    void SetAssociatedCallToken(const PString& token) { CallToken = token; }

    const PString& getTransferringCallToken() const { return transferringCallToken; }

    void SetConsultationTransferSuccess() { consultationTransfer = TRUE; }

    BOOL isConsultationTransferSuccess() { return consultationTransfer; }

  protected:
    PString transferringCallToken;    // Stores the call token for the transferring connection (if there is one)
    PString transferringCallIdentity; // Stores the call identity for the transferring call (if there is one)
    State   ctState;                  // Call Transfer state of the conneciton
    BOOL    ctResponseSent;           // Has a callTransferSetupReturnResult been sent?
    PTimer  ctTimer;                  // Call Transfer Timer - Handles all four timers CT-T1,
    PString CallToken;                // Call Token of the associated connection 
                                      // (used during a consultation transfer).
    BOOL consultationTransfer;        // Flag used to indicate whether an incoming call is involved in
                                      // a transfer through consultation.
};


class H4503Handler : public H450xHandler
{
    PCLASSINFO(H4503Handler, H450xHandler);
  public:
    H4503Handler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    );

    void OnReceivedDivertingLegInfo2(
      int linkedId,                            
      PASN_OctetString * argument 
    );

    BOOL GetRedirectingNumber(
      PString &originalCalledNr,               
      PString &lastDivertingNr ,
      int &divCounter, 
      int &origdivReason,
          int &divReason
    );

  protected:
    PString m_originalCalledNr;  // Originally called number (=> the 1st redirecting number) 
    PString m_lastDivertingNr;   // last diverting number (in the case of nultiple-call forward)
        int m_diversionCounter;
        int m_origdiversionReason;   // original diversion reason
        int m_diversionReason;       // diversion reason 
};


class H4504Handler : public H450xHandler
{
    PCLASSINFO(H4504Handler, H450xHandler);
  public:
    H4504Handler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedLocalCallHold(
      int linkedId                            
    );

    virtual void OnReceivedLocalCallRetrieve(
      int linkedId                            
    );

    virtual void OnReceivedRemoteCallHold(
      int linkedId                            
    );

    virtual void OnReceivedRemoteCallRetrieve(
      int linkedId                            
    );

    void HoldCall(
      BOOL localHold   
    );

    void RetrieveCall();

    enum State {
      e_ch_Idle,
      e_ch_NE_Held,
      e_ch_RE_Requested,
      e_ch_RE_Held,
      e_ch_RE_Retrieve_Req
    };

    State GetState() const { return holdState; }


  protected:
    State holdState;  // Call Hold state of this connection
};


class H4506Handler : public H450xHandler
{
    PCLASSINFO(H4506Handler, H450xHandler);
  public:
    H4506Handler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallWaitingIndication(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void AttachToAlerting(
      H323SignalPDU & pdu,
      unsigned numberOfCallsWaiting = 0
    );

    enum State {
      e_cw_Idle,
      e_cw_Invoked
    };

    State GetState() const { return cwState; }


  protected:
    State cwState;  // Call Waiting state of this connection
};


class H45011Handler : public H450xHandler
{
  PCLASSINFO(H45011Handler, H450xHandler);
  public:
    H45011Handler(
      H323Connection & connection,
      H450xDispatcher & dispatcher
    );

    virtual void AttachToSetup(
      H323SignalPDU & pdu
    );

    virtual void AttachToAlerting(
      H323SignalPDU & pdu
    );

    virtual void AttachToConnect(
      H323SignalPDU & pdu
    );

    virtual void AttachToReleaseComplete(
      H323SignalPDU & pdu
    );

    virtual BOOL OnReceivedInvoke(
      int opcode,
      int invokeId,                           
      int linkedId,                           
      PASN_OctetString * argument             
    );

    virtual void OnReceivedCallIntrusionRequest(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallIntrusionGetCIPL(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallIntrusionIsolate(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual BOOL OnReceivedCallIntrusionForcedRelease(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallIntrusionWOBRequest(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallIntrusionSilentMonitor(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallIntrusionNotification(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCfbOverride(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedRemoteUserAlerting(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual void OnReceivedCallWaiting(
      int linkedId,
      PASN_OctetString *argument
    );

    virtual BOOL OnReceivedReturnResult(
      X880_ReturnResult & returnResult
    );

    void OnReceivedCIRequestResult(/*X880_ReturnResult & returnResult*/);

    virtual BOOL OnReceivedReturnError(
      int errorCode,
      X880_ReturnError & returnError
    );

    BOOL OnReceivedInvokeReturnError (
      int errorCode,
      const bool timerExpiry = false 
    );

    void OnReceivedCIGetCIPLResult(
      X880_ReturnResult & returnResult
    );

    BOOL OnReceivedGetCIPLReturnError(
      int errorCode,
      const bool timerExpiry = false 
    );

    void IntrudeCall(int CICL );

    void AwaitSetupResponse(
      const PString & token,
      const PString & identity
    );

    BOOL GetRemoteCallIntrusionProtectionLevel(
      const PString & intrusionCallToken,
      unsigned intrusionCICL
    );

    void SetIntrusionImpending();

    void SetForcedReleaseAccepted();

    void SetIntrusionNotAuthorized();

    virtual BOOL OnReceivedReject(
      int problemType,
      int problemNumber
    );

    enum State {
      e_ci_Idle,
      e_ci_WaitAck,
      e_ci_GetCIPL,
      e_ci_OrigInvoked,
      e_ci_OrigIsolated,
      e_ci_DestNotify,
      e_ci_DestInvoked,
      e_ci_DestIsolated,
      e_ci_DestWOB,
      e_ci_IsolationRequest,
      e_ci_ForcedReleaseRequest,
      e_ci_WOBRequest
    };

    enum Generate{
      e_ci_gIdle,
      e_ci_gConferenceRequest,
      e_ci_gHeldRequest,
      e_ci_gSilentMonitorRequest,
      e_ci_gIsolationRequest,
      e_ci_gForcedReleaseRequest,
      e_ci_gWOBRequest
    };

    enum SendState{
      e_ci_sIdle,
      e_ci_sAttachToSetup,
      e_ci_sAttachToAlerting,
      e_ci_sAttachToConnect,
      e_ci_sAttachToReleseComplete
    };

    enum ReturnState{
      e_ci_rIdle,
      e_ci_rCallIntrusionImpending,
      e_ci_rCallIntruded,
      e_ci_rCallIsolated,
      e_ci_rCallForceReleased,
      e_ci_rCallForceReleaseResult,
      e_ci_rCallIntrusionComplete,
      e_ci_rCallIntrusionEnd,
      e_ci_rNotBusy,
      e_ci_rTempUnavailable,
      e_ci_rNotAuthorized
    };
    
    State GetState() const { return ciState; }

    void StartciTimer(const PTimeInterval value) { ciTimer = value; }

    void StopciTimer();

    BOOL IsctTimerRunning() { return ciTimer.IsRunning(); }

    PDECLARE_NOTIFIER(PTimer, H45011Handler, OnCallIntrudeTimeOut);

  protected:
    State       ciState;               // Call state of this connection
    PTimer      ciTimer;               // Call Intrusion Timer - Handles all six timers CI-T1 to CI-T6,
    PString     intrudingCallToken;
    PString     intrudingCallIdentity;
    PString     activeCallToken;
    ReturnState ciReturnState;
    SendState   ciSendState;
    Generate    ciGenerateState;
    int         ciCICL;
    unsigned    intrudingCallCICL;
};


#endif // __OPAL_H450PDU_H

---