home *** CD-ROM | disk | FTP | other *** search
/ ftp.muug.mb.ca / 2014.06.ftp.muug.mb.ca.tar / ftp.muug.mb.ca / pub / openh323.tar.gz / openh323.tar / openh323 / src / h450pdu.cxx < prev    next >
C/C++ Source or Header  |  2003-07-15  |  72KB  |  2,489 lines
  1. /*
  2.  * h450pdu.cxx
  3.  *
  4.  * H.450 Helper functions
  5.  *
  6.  * Open H323 Library
  7.  *
  8.  * Copyright (c) 2001 Norwood Systems Pty. Ltd.
  9.  *
  10.  * The contents of this file are subject to the Mozilla Public License
  11.  * Version 1.0 (the "License"); you may not use this file except in
  12.  * compliance with the License. You may obtain a copy of the License at
  13.  * http://www.mozilla.org/MPL/
  14.  *
  15.  * Software distributed under the License is distributed on an "AS IS"
  16.  * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
  17.  * the License for the specific language governing rights and limitations
  18.  * under the License.
  19.  *
  20.  * The Original Code is Open H323 Library.
  21.  *
  22.  * The Initial Developer of the Original Code is Equivalence Pty. Ltd.
  23.  *
  24.  * Contributor(s): ______________________________________.
  25.  *
  26.  * $Log: h450pdu.cxx,v $
  27.  * Revision 1.20  2003/07/15 11:22:07  csoutheren
  28.  * Improved handling of alias addresses thanks to Federico Pinna
  29.  *
  30.  * Revision 1.19  2002/11/21 22:37:47  robertj
  31.  * Fixed problems with unrecognized invoke APDU, thanks Andrea Bondavalli
  32.  *
  33.  * Revision 1.18  2002/10/01 06:47:39  robertj
  34.  * Fixed GNU compiler warning
  35.  *
  36.  * Revision 1.17  2002/09/25 05:21:11  robertj
  37.  * Fixed warning on no trace version.
  38.  *
  39.  * Revision 1.16  2002/08/05 10:03:47  robertj
  40.  * Cosmetic changes to normalise the usage of pragma interface/implementation.
  41.  *
  42.  * Revision 1.15  2002/07/04 00:40:34  robertj
  43.  * More H.450.11 call intrusion implementation, thanks Aleksandar Todorovic
  44.  *
  45.  * Revision 1.14  2002/06/25 09:56:07  robertj
  46.  * Fixed GNU warnings
  47.  *
  48.  * Revision 1.13  2002/06/22 05:48:42  robertj
  49.  * Added partial implementation for H.450.11 Call Intrusion
  50.  *
  51.  * Revision 1.12  2002/06/13 06:13:28  robertj
  52.  * Added trace dumps for outgoing H.450 supplementary service APDU's.
  53.  *
  54.  * Revision 1.11  2002/02/04 07:17:56  robertj
  55.  * Added H.450.2 Consultation Transfer, thanks Norwood Systems.
  56.  *
  57.  * Revision 1.10  2002/01/14 00:03:01  robertj
  58.  * Added H.450.6
  59.  * Added extra "failure mode" parts of H.250.2.
  60.  * Various other bug fixes.
  61.  *   Thanks Ben Madsen of Norwood Systems
  62.  *
  63.  * Revision 1.9  2001/11/19 07:40:44  robertj
  64.  * Fixed problem with error detection & state change in Call Transfer, thanks Graeme Reid
  65.  *
  66.  * Revision 1.8  2001/08/27 03:59:16  robertj
  67.  * Fixed GNU warnings.
  68.  *
  69.  * Revision 1.7  2001/08/16 07:49:19  robertj
  70.  * Changed the H.450 support to be more extensible. Protocol handlers
  71.  *   are now in separate classes instead of all in H323Connection.
  72.  *
  73.  * Revision 1.6  2001/08/06 03:08:57  robertj
  74.  * Fission of h323.h to h323ep.h & h323con.h, h323.h now just includes files.
  75.  *
  76.  * Revision 1.5  2001/06/14 06:25:16  robertj
  77.  * Added further H.225 PDU build functions.
  78.  * Moved some functionality from connection to PDU class.
  79.  *
  80.  * Revision 1.4  2001/06/05 03:14:41  robertj
  81.  * Upgraded H.225 ASN to v4 and H.245 ASN to v7.
  82.  *
  83.  * Revision 1.3  2001/05/09 04:59:04  robertj
  84.  * Bug fixes in H.450.2, thanks Klein Stefan.
  85.  *
  86.  * Revision 1.2  2001/04/20 02:16:53  robertj
  87.  * Removed GNU C++ warnings.
  88.  *
  89.  * Revision 1.1  2001/04/11 03:01:29  robertj
  90.  * Added H.450.2 (call transfer), thanks a LOT to Graeme Reid & Norwood Systems
  91.  *
  92.  */
  93.  
  94. #include <ptlib.h>
  95.  
  96. #ifdef __GNUC__
  97. #pragma implementation "h450pdu.h"
  98. #endif
  99.  
  100. #include "h450pdu.h"
  101.  
  102. #include "h4501.h"
  103. #include "h4502.h"
  104. #include "h4504.h"
  105. #include "h4506.h"
  106. #include "h45010.h"
  107. #include "h45011.h"
  108. #include "h323pdu.h"
  109. #include "h323ep.h"
  110. #include "h323con.h"
  111.  
  112.  
  113. X880_Invoke& H450ServiceAPDU::BuildInvoke(int invokeId, int operation)
  114. {
  115.   SetTag(X880_ROS::e_invoke);
  116.   X880_Invoke& invoke = (X880_Invoke&) *this;
  117.  
  118.   invoke.m_invokeId = invokeId;
  119.  
  120.   invoke.m_opcode.SetTag(X880_Code::e_local);
  121.   PASN_Integer& opcode = (PASN_Integer&) invoke.m_opcode;
  122.   opcode.SetValue(operation);
  123.  
  124.   return invoke;
  125. }
  126.  
  127.  
  128. X880_ReturnResult& H450ServiceAPDU::BuildReturnResult(int invokeId)
  129. {
  130.   SetTag(X880_ROS::e_returnResult);
  131.   X880_ReturnResult& returnResult = (X880_ReturnResult&) *this;
  132.  
  133.   returnResult.m_invokeId = invokeId;
  134.  
  135.   return returnResult;
  136. }
  137.  
  138.  
  139. X880_ReturnError& H450ServiceAPDU::BuildReturnError(int invokeId, int error)
  140. {
  141.   SetTag(X880_ROS::e_returnError);
  142.   X880_ReturnError& returnError = (X880_ReturnError&) *this;
  143.  
  144.   returnError.m_invokeId = invokeId;
  145.  
  146.   returnError.m_errorCode.SetTag(X880_Code::e_local);
  147.   PASN_Integer& errorCode = (PASN_Integer&) returnError.m_errorCode;
  148.   errorCode.SetValue(error);
  149.  
  150.   return returnError;
  151. }
  152.  
  153.  
  154. X880_Reject& H450ServiceAPDU::BuildReject(int invokeId)
  155. {
  156.   SetTag(X880_ROS::e_reject);
  157.   X880_Reject& reject = (X880_Reject&) *this;
  158.  
  159.   reject.m_invokeId = invokeId;
  160.  
  161.   return reject;
  162. }
  163.  
  164.  
  165. void H450ServiceAPDU::BuildCallTransferInitiate(int invokeId,
  166.                                                 const PString & callIdentity,
  167.                                                 const PString & alias,
  168.                                                 const H323TransportAddress & address)
  169. {
  170.   X880_Invoke& invoke = BuildInvoke(invokeId, H4502_CallTransferOperation::e_callTransferInitiate);
  171.  
  172.   H4502_CTInitiateArg argument;
  173.  
  174.   argument.m_callIdentity = callIdentity;
  175.  
  176.   H4501_ArrayOf_AliasAddress& aliasAddress = argument.m_reroutingNumber.m_destinationAddress;
  177.  
  178.   // We have to have at least a destination transport address or alias.
  179.   if (!alias.IsEmpty() && !address.IsEmpty()) {
  180.     aliasAddress.SetSize(2);
  181.  
  182.     // Set the alias
  183.     aliasAddress[1].SetTag(H225_AliasAddress::e_dialedDigits);
  184.     H323SetAliasAddress(alias, aliasAddress[1]);
  185.  
  186.     // Set the transport
  187.     aliasAddress[0].SetTag(H225_AliasAddress::e_transportID);
  188.     H225_TransportAddress& cPartyTransport = (H225_TransportAddress&) aliasAddress[0];
  189.     address.SetPDU(cPartyTransport);
  190.   }
  191.   else {
  192.     aliasAddress.SetSize(1);
  193.     if (alias.IsEmpty()) {
  194.       // Set the transport, no alias present
  195.       aliasAddress[0].SetTag(H225_AliasAddress::e_transportID);
  196.       H225_TransportAddress& cPartyTransport = (H225_TransportAddress&) aliasAddress[0];
  197.       address.SetPDU(cPartyTransport);
  198.     }
  199.     else {
  200.       // Set the alias, no transport
  201.       aliasAddress[0].SetTag(H225_AliasAddress::e_dialedDigits);
  202.       H323SetAliasAddress(alias, aliasAddress[0]);
  203.     }
  204.   }
  205.  
  206.   PTRACE(4, "H4502\tSending supplementary service PDU argument:\n  "
  207.          << setprecision(2) << argument);
  208.  
  209.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  210.   invoke.m_argument.EncodeSubType(argument);
  211. }
  212.  
  213.  
  214. void H450ServiceAPDU::BuildCallTransferSetup(int invokeId,
  215.                                              const PString & callIdentity)
  216. {
  217.   X880_Invoke& invoke = BuildInvoke(invokeId, H4502_CallTransferOperation::e_callTransferSetup);
  218.  
  219.   H4502_CTSetupArg argument;
  220.  
  221.   argument.m_callIdentity = callIdentity;
  222.  
  223.   PTRACE(4, "H4502\tSending supplementary service PDU argument:\n  "
  224.          << setprecision(2) << argument);
  225.  
  226.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  227.   invoke.m_argument.EncodeSubType(argument);
  228. }
  229.  
  230.  
  231. void H450ServiceAPDU::BuildCallTransferIdentify(int invokeId)
  232. {
  233.   X880_Invoke invoke = BuildInvoke(invokeId, H4502_CallTransferOperation::e_callTransferIdentify);
  234. }
  235.  
  236.  
  237. void H450ServiceAPDU::BuildCallTransferAbandon(int invokeId)
  238. {
  239.   X880_Invoke invoke = BuildInvoke(invokeId, H4502_CallTransferOperation::e_callTransferAbandon);
  240. }
  241.  
  242.  
  243. void H450ServiceAPDU::BuildCallWaiting(int invokeId, int numCallsWaiting)
  244. {
  245.   X880_Invoke& invoke = BuildInvoke(invokeId, H4506_CallWaitingOperations::e_callWaiting);
  246.  
  247.   H4506_CallWaitingArg argument;
  248.  
  249.   argument.IncludeOptionalField(H4506_CallWaitingArg::e_nbOfAddWaitingCalls);
  250.   argument.m_nbOfAddWaitingCalls = numCallsWaiting;
  251.  
  252.   PTRACE(4, "H4502\tSending supplementary service PDU argument:\n  "
  253.          << setprecision(2) << argument);
  254.   
  255.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  256.   invoke.m_argument.EncodeSubType(argument);
  257. }
  258.  
  259.  
  260. void H450ServiceAPDU::BuildCallIntrusionForcedRelease(int invokeId,
  261.                                                       int CICL)
  262. {
  263.   X880_Invoke& invoke = BuildInvoke(invokeId, H45011_H323CallIntrusionOperations::e_callIntrusionForcedRelease);
  264.  
  265.   H45011_CIFrcRelArg argument;
  266.  
  267.   argument.m_ciCapabilityLevel = CICL;
  268.  
  269.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  270.   invoke.m_argument.EncodeSubType(argument);
  271. }
  272.  
  273.  
  274. X880_ReturnResult& H450ServiceAPDU::BuildCallIntrusionForcedReleaseResult(int invokeId)
  275. {
  276.   PTRACE(1 ,"H450.11\tH450ServiceAPDU::BuildCallIntrusionForcedReleaseResult BEGIN");
  277.   
  278.   X880_ReturnResult& result = BuildReturnResult(invokeId);
  279.   result.IncludeOptionalField(X880_ReturnResult::e_result);
  280.   result.m_result.m_opcode.SetTag(X880_Code::e_local);
  281.   PASN_Integer& operation = (PASN_Integer&) result.m_result.m_opcode;
  282.   operation.SetValue(H45011_H323CallIntrusionOperations::e_callIntrusionForcedRelease);
  283.  
  284.   H45011_CIFrcRelOptRes ciCIPLRes;
  285.  
  286.   PPER_Stream resultStream;
  287.   ciCIPLRes.Encode(resultStream);
  288.   resultStream.CompleteEncoding();
  289.   result.m_result.m_result.SetValue(resultStream);
  290.   PTRACE(4 ,"H450.11\tH450ServiceAPDU::BuildCallIntrusionForcedReleaseResult END");
  291.  
  292.   return result;
  293. }
  294.  
  295.  
  296. void H450ServiceAPDU::BuildCallIntrusionForcedReleaseError()
  297. {
  298. /**
  299.   TBD
  300. */
  301. }
  302.  
  303.  
  304. void H450ServiceAPDU::BuildCallIntrusionGetCIPL(int invokeId)
  305. {
  306.   PTRACE(4, "H450.11\tBuildCallIntrusionGetCIPL invokeId=" << invokeId);
  307.   X880_Invoke invoke = BuildInvoke(invokeId, H45011_H323CallIntrusionOperations::e_callIntrusionGetCIPL);
  308. }
  309.  
  310.  
  311. void H450ServiceAPDU::BuildCallIntrusionImpending(int invokeId)
  312. {
  313.   PTRACE(4, "H450.11\tBuildCallIntrusionImpending invokeId=" << invokeId);
  314.   X880_Invoke& invoke = BuildInvoke(invokeId, H45011_H323CallIntrusionOperations::e_callIntrusionNotification);
  315.  
  316.   H45011_CINotificationArg argument;
  317.  
  318.   argument.m_ciStatusInformation = H45011_CIStatusInformation::e_callIntrusionImpending;
  319.  
  320.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  321.   invoke.m_argument.EncodeSubType(argument);
  322. }
  323.  
  324.  
  325. void H450ServiceAPDU::BuildCallIntrusionForceRelesed(int invokeId)
  326. {
  327.   PTRACE(4, "H450.11\tBuildCallIntrusionForceRelesed invokeId=" << invokeId);
  328.   X880_Invoke& invoke = BuildInvoke(invokeId, H45011_H323CallIntrusionOperations::e_callIntrusionNotification);
  329.  
  330.   H45011_CINotificationArg argument;
  331.  
  332.   argument.m_ciStatusInformation = H45011_CIStatusInformation::e_callForceReleased;
  333.  
  334.   invoke.IncludeOptionalField(X880_Invoke::e_argument);
  335.   invoke.m_argument.EncodeSubType(argument);
  336. }
  337.  
  338.  
  339. void H450ServiceAPDU::AttachSupplementaryServiceAPDU(H323SignalPDU & pdu)
  340. {
  341.   H4501_SupplementaryService supplementaryService;
  342.  
  343.   // Create an H.450.1 supplementary service object
  344.   // and store the H450ServiceAPDU in the ROS array.
  345.   supplementaryService.m_serviceApdu.SetTag(H4501_ServiceApdus::e_rosApdus);
  346.   H4501_ArrayOf_ROS & operations = (H4501_ArrayOf_ROS &)supplementaryService.m_serviceApdu;
  347.   operations.SetSize(1);
  348.   operations[0] = *this;
  349.  
  350.   PTRACE(4, "H4501\tSending supplementary service PDU:\n  "
  351.          << setprecision(2) << supplementaryService);
  352.  
  353.   // Add the H.450 PDU to the H.323 User-to-User PDU as an OCTET STRING
  354.   pdu.m_h323_uu_pdu.IncludeOptionalField(H225_H323_UU_PDU::e_h4501SupplementaryService);
  355.   pdu.m_h323_uu_pdu.m_h4501SupplementaryService.SetSize(1);
  356.   pdu.m_h323_uu_pdu.m_h4501SupplementaryService[0].EncodeSubType(supplementaryService);
  357. }
  358.  
  359.  
  360. BOOL H450ServiceAPDU::WriteFacilityPDU(H323Connection & connection)
  361. {
  362.   H323SignalPDU facilityPDU;
  363.   facilityPDU.BuildFacility(connection, TRUE);
  364.  
  365.   AttachSupplementaryServiceAPDU(facilityPDU);
  366.  
  367.   return connection.WriteSignalPDU(facilityPDU);
  368. }
  369.  
  370.  
  371. void H450ServiceAPDU::ParseEndpointAddress(H4501_EndpointAddress& endpointAddress,
  372.                                            PString& remoteParty)
  373. {
  374.   H4501_ArrayOf_AliasAddress& destinationAddress = endpointAddress.m_destinationAddress;
  375.  
  376.   PString alias;
  377.   H323TransportAddress transportAddress;
  378.  
  379.   for (PINDEX i = 0; i < destinationAddress.GetSize(); i++) {
  380.     H225_AliasAddress& aliasAddress = destinationAddress[i];
  381.  
  382.     if (aliasAddress.GetTag() == H225_AliasAddress::e_transportID)
  383.       transportAddress = (H225_TransportAddress &)aliasAddress;
  384.     else
  385.       alias = ::H323GetAliasAddressString(aliasAddress);
  386.   }
  387.  
  388.   if (alias.IsEmpty()) {
  389.     remoteParty = transportAddress;
  390.   }
  391.   else if (transportAddress.IsEmpty()) {
  392.     remoteParty = alias;
  393.   }
  394.   else {
  395.     remoteParty = alias + '@' + transportAddress;
  396.   }
  397. }
  398.  
  399.  
  400. /////////////////////////////////////////////////////////////////////////////
  401.  
  402. H450xDispatcher::H450xDispatcher(H323Connection & conn)
  403.   : connection(conn)
  404. {
  405.   opcodeHandler.DisallowDeleteObjects();
  406.  
  407.   nextInvokeId = 0;
  408. }
  409.  
  410.  
  411. void H450xDispatcher::AddOpCode(unsigned opcode, H450xHandler * handler)
  412. {
  413.   PAssertNULL(handler);
  414.   if (handlers.GetObjectsIndex(handler) == P_MAX_INDEX)
  415.     handlers.Append(handler);
  416.  
  417.   opcodeHandler.SetAt(opcode, handler);
  418. }
  419.  
  420.  
  421. void H450xDispatcher::AttachToSetup(H323SignalPDU & pdu)
  422. {
  423.   for (PINDEX i = 0; i < handlers.GetSize(); i++)
  424.     handlers[i].AttachToSetup(pdu);
  425. }
  426.  
  427.  
  428. void H450xDispatcher::AttachToAlerting(H323SignalPDU & pdu)
  429. {
  430.   for (PINDEX i = 0; i < handlers.GetSize(); i++)
  431.     handlers[i].AttachToAlerting(pdu);
  432. }
  433.  
  434.  
  435. void H450xDispatcher::AttachToConnect(H323SignalPDU & pdu)
  436. {
  437.   for (PINDEX i = 0; i < handlers.GetSize(); i++)
  438.     handlers[i].AttachToConnect(pdu);
  439. }
  440.  
  441.  
  442. void H450xDispatcher::AttachToReleaseComplete(H323SignalPDU & pdu)
  443. {
  444.   for (PINDEX i = 0; i < handlers.GetSize(); i++)
  445.     handlers[i].AttachToReleaseComplete(pdu);
  446. }
  447.  
  448.  
  449. BOOL H450xDispatcher::HandlePDU(const H323SignalPDU & pdu)
  450. {
  451. BOOL result = TRUE;
  452.   for (PINDEX i = 0; i < pdu.m_h323_uu_pdu.m_h4501SupplementaryService.GetSize(); i++) {
  453.     H4501_SupplementaryService supplementaryService;
  454.  
  455.     // Decode the supplementary service PDU from the PPER Stream
  456.     if (pdu.m_h323_uu_pdu.m_h4501SupplementaryService[i].DecodeSubType(supplementaryService)) {
  457.       PTRACE(4, "H4501\tReceived supplementary service PDU:\n  "
  458.              << setprecision(2) << supplementaryService);
  459.     }
  460.     else {
  461.       PTRACE(1, "H4501\tInvalid supplementary service PDU decode:\n  "
  462.              << setprecision(2) << supplementaryService);
  463.       continue;
  464.     }
  465.  
  466.     H4501_InterpretationApdu & interpretation = supplementaryService.m_interpretationApdu;
  467.  
  468.     if (supplementaryService.m_serviceApdu.GetTag() == H4501_ServiceApdus::e_rosApdus) {
  469.       H4501_ArrayOf_ROS& operations = (H4501_ArrayOf_ROS&) supplementaryService.m_serviceApdu;
  470.  
  471.       for (PINDEX j = 0; j < operations.GetSize(); j ++) {
  472.         X880_ROS& operation = operations[j];
  473.  
  474.         PTRACE(3, "H4501\tX880 ROS " << operation.GetTagName());
  475.  
  476.         switch (operation.GetTag()) {
  477.           case X880_ROS::e_invoke:
  478.             result = OnReceivedInvoke((X880_Invoke &)operation, interpretation);
  479.             break;
  480.  
  481.           case X880_ROS::e_returnResult:
  482.             result = OnReceivedReturnResult((X880_ReturnResult &)operation);
  483.             break;
  484.  
  485.           case X880_ROS::e_returnError:
  486.             result = OnReceivedReturnError((X880_ReturnError &)operation);
  487.             break;
  488.  
  489.           case X880_ROS::e_reject:
  490.             result = OnReceivedReject((X880_Reject &)operation);
  491.             break;
  492.  
  493.           default :
  494.             break;
  495.         }
  496.       }
  497.     }
  498.   }
  499.   return result;
  500. }
  501.  
  502. BOOL H450xDispatcher::OnReceivedInvoke(X880_Invoke & invoke, H4501_InterpretationApdu & interpretation)
  503. {
  504.   BOOL result = TRUE;
  505.   // Get the invokeId
  506.   int invokeId = invoke.m_invokeId.GetValue();
  507.  
  508.   // Get the linkedId if present
  509.   int linkedId = -1;
  510.   if (invoke.HasOptionalField(X880_Invoke::e_linkedId)) {
  511.     linkedId = invoke.m_linkedId.GetValue();
  512.   }
  513.  
  514.   // Get the argument if present
  515.   PASN_OctetString * argument = NULL;
  516.   if (invoke.HasOptionalField(X880_Invoke::e_argument)) {
  517.     argument = &invoke.m_argument;
  518.   }
  519.  
  520.   // Get the opcode
  521.   if (invoke.m_opcode.GetTag() == X880_Code::e_local) {
  522.     int opcode = ((PASN_Integer&) invoke.m_opcode).GetValue();
  523.     if (!opcodeHandler.Contains(opcode)) {
  524.       PTRACE(2, "H4501\tInvoke of unsupported local opcode:\n  " << invoke);      
  525.       if (interpretation.GetTag() != H4501_InterpretationApdu::e_discardAnyUnrecognizedInvokePdu)
  526.         SendInvokeReject(invokeId, 1 /*X880_InvokeProblem::e_unrecognisedOperation*/);
  527.       if (interpretation.GetTag() == H4501_InterpretationApdu::e_clearCallIfAnyInvokePduNotRecognized)
  528.         result = FALSE;
  529.     }
  530.     else
  531.       result = opcodeHandler[opcode].OnReceivedInvoke(opcode, invokeId, linkedId, argument);
  532.   }
  533.   else {
  534.     if (interpretation.GetTag() != H4501_InterpretationApdu::e_discardAnyUnrecognizedInvokePdu)
  535.       SendInvokeReject(invokeId, 1 /*X880_InvokeProblem::e_unrecognisedOperation*/);
  536.     PTRACE(2, "H4501\tInvoke of unsupported global opcode:\n  " << invoke);
  537.     if (interpretation.GetTag() == H4501_InterpretationApdu::e_clearCallIfAnyInvokePduNotRecognized)
  538.       result = FALSE;
  539.   }
  540.   return result;
  541. }
  542.  
  543.  
  544. BOOL H450xDispatcher::OnReceivedReturnResult(X880_ReturnResult & returnResult)
  545. {
  546.   unsigned invokeId = returnResult.m_invokeId.GetValue();
  547.  
  548.   for (PINDEX i = 0; i < handlers.GetSize(); i++) {
  549.     if (handlers[i].GetInvokeId() == invokeId) {
  550.       handlers[i].OnReceivedReturnResult(returnResult);
  551.       break;
  552.     }
  553.   }
  554.   return TRUE;
  555. }
  556.  
  557.  
  558. BOOL H450xDispatcher::OnReceivedReturnError(X880_ReturnError & returnError)
  559. {
  560.   BOOL result=TRUE;
  561.   unsigned invokeId = returnError.m_invokeId.GetValue();
  562.   int errorCode = 0;
  563.  
  564.   if (returnError.m_errorCode.GetTag() == X880_Code::e_local)
  565.     errorCode = ((PASN_Integer&) returnError.m_errorCode).GetValue();
  566.  
  567.   for (PINDEX i = 0; i < handlers.GetSize(); i++) {
  568.     if (handlers[i].GetInvokeId() == invokeId) {
  569.       result = handlers[i].OnReceivedReturnError(errorCode, returnError);
  570.       break;
  571.     }
  572.   }
  573.   return result;
  574. }
  575.  
  576.  
  577. BOOL H450xDispatcher::OnReceivedReject(X880_Reject & reject)
  578. {
  579.   int problem = 0;
  580.  
  581.   switch (reject.m_problem.GetTag()) {
  582.     case X880_Reject_problem::e_general:
  583.     {
  584.       X880_GeneralProblem & generalProblem = reject.m_problem;
  585.       problem = generalProblem.GetValue();
  586.     }
  587.     break;
  588.  
  589.     case X880_Reject_problem::e_invoke:
  590.     {
  591.       X880_InvokeProblem & invokeProblem = reject.m_problem;
  592.       problem = invokeProblem.GetValue();
  593.     }
  594.     break;
  595.  
  596.     case X880_Reject_problem::e_returnResult:
  597.     {
  598.       X880_ReturnResultProblem & returnResultProblem = reject.m_problem;
  599.       problem = returnResultProblem.GetValue();
  600.     }
  601.     break;
  602.  
  603.     case X880_Reject_problem::e_returnError:
  604.     {
  605.       X880_ReturnErrorProblem & returnErrorProblem = reject.m_problem;
  606.       problem = returnErrorProblem.GetValue();
  607.     }
  608.     break;
  609.  
  610.     default:
  611.       break;
  612.   }
  613.  
  614.  
  615.   unsigned invokeId = reject.m_invokeId;
  616.   for (PINDEX i = 0; i < handlers.GetSize(); i++) {
  617.     if (handlers[i].GetInvokeId() == invokeId) {
  618.       handlers[i].OnReceivedReject(reject.m_problem.GetTag(), problem);
  619.       break;
  620.     }
  621.   }
  622.   return TRUE;
  623. }
  624.  
  625.  
  626. void H450xDispatcher::SendReturnError(int invokeId, int returnError)
  627. {
  628.   H450ServiceAPDU serviceAPDU;
  629.  
  630.   serviceAPDU.BuildReturnError(invokeId, returnError);
  631.  
  632.   serviceAPDU.WriteFacilityPDU(connection);
  633. }
  634.  
  635.  
  636. void H450xDispatcher::SendGeneralReject(int invokeId, int problem)
  637. {
  638.   H450ServiceAPDU serviceAPDU;
  639.  
  640.   X880_Reject & reject = serviceAPDU.BuildReject(invokeId);
  641.   reject.m_problem.SetTag(X880_Reject_problem::e_general);
  642.   X880_GeneralProblem & generalProblem = (X880_GeneralProblem &) reject.m_problem;
  643.   generalProblem = problem;
  644.  
  645.   serviceAPDU.WriteFacilityPDU(connection);
  646. }
  647.  
  648.  
  649. void H450xDispatcher::SendInvokeReject(int invokeId, int problem)
  650. {
  651.   H450ServiceAPDU serviceAPDU;
  652.  
  653.   X880_Reject & reject = serviceAPDU.BuildReject(invokeId);
  654.   reject.m_problem.SetTag(X880_Reject_problem::e_invoke);
  655.   X880_InvokeProblem & invokeProblem = (X880_InvokeProblem &) reject.m_problem;
  656.   invokeProblem = problem;
  657.  
  658.   serviceAPDU.WriteFacilityPDU(connection);
  659. }
  660.  
  661.  
  662. void H450xDispatcher::SendReturnResultReject(int invokeId, int problem)
  663. {
  664.   H450ServiceAPDU serviceAPDU;
  665.  
  666.   X880_Reject & reject = serviceAPDU.BuildReject(invokeId);
  667.   reject.m_problem.SetTag(X880_Reject_problem::e_returnResult);
  668.   X880_ReturnResultProblem & returnResultProblem = reject.m_problem;
  669.   returnResultProblem = problem;
  670.  
  671.   serviceAPDU.WriteFacilityPDU(connection);
  672. }
  673.  
  674.  
  675. void H450xDispatcher::SendReturnErrorReject(int invokeId, int problem)
  676. {
  677.   H450ServiceAPDU serviceAPDU;
  678.  
  679.   X880_Reject & reject = serviceAPDU.BuildReject(invokeId);
  680.   reject.m_problem.SetTag(X880_Reject_problem::e_returnError);
  681.   X880_ReturnErrorProblem & returnErrorProblem = reject.m_problem;
  682.   returnErrorProblem = problem;
  683.  
  684.   serviceAPDU.WriteFacilityPDU(connection);
  685. }
  686.  
  687.  
  688. /////////////////////////////////////////////////////////////////////////////
  689.  
  690. H450xHandler::H450xHandler(H323Connection & conn, H450xDispatcher & disp)
  691.   : endpoint(conn.GetEndPoint()),
  692.     connection(conn),
  693.     dispatcher(disp)
  694. {
  695.   currentInvokeId = 0;
  696. }
  697.  
  698.  
  699. void H450xHandler::AttachToSetup(H323SignalPDU &)
  700. {
  701. }
  702.  
  703.  
  704. void H450xHandler::AttachToAlerting(H323SignalPDU &)
  705. {
  706. }
  707.  
  708.  
  709. void H450xHandler::AttachToConnect(H323SignalPDU &)
  710. {
  711. }
  712.  
  713.  
  714. void H450xHandler::AttachToReleaseComplete(H323SignalPDU &)
  715. {
  716. }
  717.  
  718.  
  719. BOOL H450xHandler::OnReceivedReturnResult(X880_ReturnResult & /*returnResult*/)
  720. {
  721.   return TRUE;
  722. }
  723.  
  724.  
  725. BOOL H450xHandler::OnReceivedReturnError(int /*errorCode*/,
  726.                                         X880_ReturnError & /*returnError*/)
  727. {
  728.   return TRUE;
  729. }
  730.  
  731.  
  732. BOOL H450xHandler::OnReceivedReject(int /*problemType*/,
  733.                                    int /*problemNumber*/)
  734. {
  735.   return TRUE;
  736. }
  737.  
  738.  
  739. void H450xHandler::SendReturnError(int returnError)
  740. {
  741.   dispatcher.SendReturnError(currentInvokeId, returnError);
  742.   currentInvokeId = 0;
  743. }
  744.  
  745.  
  746. void H450xHandler::SendGeneralReject(int problem)
  747. {
  748.   dispatcher.SendGeneralReject(currentInvokeId, problem);
  749.   currentInvokeId = 0;
  750. }
  751.  
  752.  
  753. void H450xHandler::SendInvokeReject(int problem)
  754. {
  755.   dispatcher.SendInvokeReject(currentInvokeId, problem);
  756.   currentInvokeId = 0;
  757. }
  758.  
  759.  
  760. void H450xHandler::SendReturnResultReject(int problem)
  761. {
  762.   dispatcher.SendReturnResultReject(currentInvokeId, problem);
  763.   currentInvokeId = 0;
  764. }
  765.  
  766.  
  767. void H450xHandler::SendReturnErrorReject(int problem)
  768. {
  769.   dispatcher.SendReturnErrorReject(currentInvokeId, problem);
  770.   currentInvokeId = 0;
  771. }
  772.  
  773.  
  774. BOOL H450xHandler::DecodeArguments(PASN_OctetString * argString,
  775.                                   PASN_Object & argObject,
  776.                                   int absentErrorCode)
  777. {
  778.   if (argString == NULL) {
  779.     if (absentErrorCode >= 0)
  780.       SendReturnError(absentErrorCode);
  781.     return FALSE;
  782.   }
  783.  
  784.   PPER_Stream argStream(*argString);
  785.   if (argObject.Decode(argStream)) {
  786.     PTRACE(4, "H4501\tSupplementary service argument:\n  "
  787.            << setprecision(2) << argObject);
  788.     return TRUE;
  789.   }
  790.  
  791.   PTRACE(1, "H4501\tInvalid supplementary service argument:\n  "
  792.          << setprecision(2) << argObject);
  793.   return FALSE;
  794. }
  795.  
  796.  
  797. /////////////////////////////////////////////////////////////////////////////
  798.  
  799. H4502Handler::H4502Handler(H323Connection & conn, H450xDispatcher & disp)
  800.   : H450xHandler(conn, disp)
  801. {
  802.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferIdentify, this);
  803.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferAbandon, this);
  804.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferInitiate, this);
  805.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferSetup, this);
  806.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferUpdate, this);
  807.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_subaddressTransfer, this);
  808.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferComplete, this);
  809.   dispatcher.AddOpCode(H4502_CallTransferOperation::e_callTransferActive, this);
  810.  
  811.   transferringCallToken = "";
  812.   ctState = e_ctIdle;
  813.   ctResponseSent = FALSE;
  814.   CallToken = PString();
  815.   nextCallIdentity = 0;
  816.   consultationTransfer = FALSE;
  817.  
  818.   ctTimer.SetNotifier(PCREATE_NOTIFIER(OnCallTransferTimeOut));
  819. }
  820.  
  821.  
  822. void H4502Handler::AttachToSetup(H323SignalPDU & pdu)
  823. {
  824.   // Do we need to attach a call transfer setup invoke APDU?
  825.   if (ctState != e_ctAwaitSetupResponse)
  826.     return;
  827.  
  828.   H450ServiceAPDU serviceAPDU;
  829.  
  830.   // Store the outstanding invokeID associated with this connection
  831.   currentInvokeId = dispatcher.GetNextInvokeId();
  832.  
  833.   // Use the call identity from the ctInitiateArg
  834.   serviceAPDU.BuildCallTransferSetup(currentInvokeId, transferringCallIdentity);
  835.  
  836.   serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  837. }
  838.  
  839.  
  840. void H4502Handler::AttachToAlerting(H323SignalPDU & pdu)
  841. {
  842.   // Do we need to send a callTransferSetup return result APDU?
  843.   if (currentInvokeId == 0 || ctResponseSent)
  844.     return;
  845.  
  846.   H450ServiceAPDU serviceAPDU;
  847.   serviceAPDU.BuildReturnResult(currentInvokeId);
  848.   serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  849.   ctResponseSent = TRUE;
  850.   currentInvokeId = 0;
  851. }
  852.  
  853.  
  854. void H4502Handler::AttachToConnect(H323SignalPDU & pdu)
  855. {
  856.   // Do we need to include a ctInitiateReturnResult APDU in our Release Complete Message?
  857.   if (currentInvokeId == 0 || ctResponseSent)
  858.     return;
  859.  
  860.   H450ServiceAPDU serviceAPDU;
  861.   serviceAPDU.BuildReturnResult(currentInvokeId);
  862.   serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  863.   ctResponseSent = TRUE;
  864.   currentInvokeId = 0;
  865. }
  866.  
  867.  
  868. void H4502Handler::AttachToReleaseComplete(H323SignalPDU & pdu)
  869. {
  870.   // Do we need to include a ctInitiateReturnResult APDU in our Release Complete Message?
  871.   if (currentInvokeId == 0)
  872.     return;
  873.  
  874.   // If the SETUP message we received from the other end had a callTransferSetup APDU
  875.   // in it, then we need to send back a RELEASE COMPLETE PDU with a callTransferSetup 
  876.   // ReturnError.
  877.   // Else normal call - clear it down
  878.   H450ServiceAPDU serviceAPDU;
  879.  
  880.   if (ctResponseSent) {
  881.     serviceAPDU.BuildReturnResult(currentInvokeId);
  882.     ctResponseSent = FALSE;
  883.     currentInvokeId = 0;
  884.   }
  885.   else {
  886.     serviceAPDU.BuildReturnError(currentInvokeId, H4501_GeneralErrorList::e_notAvailable);
  887.     ctResponseSent = TRUE;
  888.     currentInvokeId = 0;
  889.   }
  890.  
  891.   serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  892. }
  893.  
  894.  
  895. BOOL H4502Handler::OnReceivedInvoke(int opcode,
  896.                                     int invokeId,
  897.                                     int linkedId,
  898.                                     PASN_OctetString * argument)
  899. {
  900.   currentInvokeId = invokeId;
  901.  
  902.   switch (opcode) {
  903.     case H4502_CallTransferOperation::e_callTransferIdentify:
  904.       OnReceivedCallTransferIdentify(linkedId);
  905.       break;
  906.  
  907.     case H4502_CallTransferOperation::e_callTransferAbandon:
  908.       OnReceivedCallTransferAbandon(linkedId);
  909.       break;
  910.  
  911.     case H4502_CallTransferOperation::e_callTransferInitiate:
  912.       OnReceivedCallTransferInitiate(linkedId, argument);
  913.       break;
  914.  
  915.     case H4502_CallTransferOperation::e_callTransferSetup:
  916.       OnReceivedCallTransferSetup(linkedId, argument);
  917.       break;
  918.  
  919.     case H4502_CallTransferOperation::e_callTransferUpdate:
  920.       OnReceivedCallTransferUpdate(linkedId, argument);
  921.       break;
  922.  
  923.     case H4502_CallTransferOperation::e_subaddressTransfer:
  924.       OnReceivedSubaddressTransfer(linkedId, argument);
  925.       break;
  926.  
  927.     case H4502_CallTransferOperation::e_callTransferComplete:
  928.       OnReceivedCallTransferComplete(linkedId, argument);
  929.       break;
  930.  
  931.     case H4502_CallTransferOperation::e_callTransferActive:
  932.       OnReceivedCallTransferActive(linkedId, argument);
  933.       break;
  934.  
  935.     default:
  936.       currentInvokeId = 0;
  937.       return FALSE;
  938.   }
  939.  
  940.   return TRUE;
  941. }
  942.  
  943.  
  944. void H4502Handler::OnReceivedCallTransferIdentify(int /*linkedId*/)
  945. {
  946.   if (!endpoint.OnCallTransferIdentify(connection))
  947.     SendReturnError(H4501_GeneralErrorList::e_notAvailable);
  948.   
  949.   // Send a FACILITY message with a callTransferIdentify return result
  950.   // Supplementary Service PDU to the transferring endpoint.
  951.   H450ServiceAPDU serviceAPDU;
  952.  
  953.   X880_ReturnResult& result = serviceAPDU.BuildReturnResult(currentInvokeId);
  954.   result.IncludeOptionalField(X880_ReturnResult::e_result);
  955.   result.m_result.m_opcode.SetTag(X880_Code::e_local);
  956.   PASN_Integer& operation = (PASN_Integer&) result.m_result.m_opcode;
  957.   operation.SetValue(H4502_CallTransferOperation::e_callTransferIdentify);
  958.  
  959.   H4502_CTIdentifyRes ctIdentifyResult;
  960.  
  961.   // Restrict the generated value to 4 digits (13 bits)
  962.   unsigned int id = GetNextCallIdentityValue() & 0x1FFF;
  963.   PString pstrId(PString::Unsigned, id);
  964.   ctIdentifyResult.m_callIdentity = pstrId;
  965.  
  966.   // Store the callIdentity of this connection in the dictionary
  967.   endpoint.GetCallIdentityDictionary().SetAt(pstrId, &connection);
  968.  
  969.   H4501_ArrayOf_AliasAddress& aliasAddress = ctIdentifyResult.m_reroutingNumber.m_destinationAddress;
  970.  
  971.   PString localName = connection.GetLocalPartyName();
  972.   if (localName.IsEmpty()) 
  973.     aliasAddress.SetSize(1);
  974.   else {
  975.     aliasAddress.SetSize(2);
  976.     aliasAddress[1].SetTag(H225_AliasAddress::e_dialedDigits);
  977.     H323SetAliasAddress(localName, aliasAddress[1]);  // Will encode as h323-Id if not E.164
  978.   }
  979.  
  980.   H323TransportAddress address;
  981.   address = connection.GetSignallingChannel()->GetLocalAddress();
  982.  
  983.   aliasAddress[0].SetTag(H225_AliasAddress::e_transportID);
  984.   H225_TransportAddress& cPartyTransport = (H225_TransportAddress&) aliasAddress[0];
  985.   address.SetPDU(cPartyTransport);
  986.  
  987.   PPER_Stream resultStream;
  988.   ctIdentifyResult.Encode(resultStream);
  989.   resultStream.CompleteEncoding();
  990.   result.m_result.m_result.SetValue(resultStream);
  991.  
  992.   serviceAPDU.WriteFacilityPDU(connection);
  993.  
  994.   ctState = e_ctAwaitSetup;
  995.  
  996.   // start timer CT-T2
  997.   PTRACE(4, "H450.2\tStarting timer CT-T2");
  998.   StartctTimer(endpoint.GetCallTransferT2());
  999. }
  1000.  
  1001.  
  1002. void H4502Handler::OnReceivedCallTransferAbandon(int /*linkedId*/)
  1003. {
  1004.   switch (ctState) {
  1005.     case e_ctAwaitSetup:
  1006.       {
  1007.         // Stop Timer CT-T2 and enter state e_ctIdle
  1008.         StopctTimer();
  1009.         PTRACE(4, "H4502\tStopping timer CT-T2");
  1010.  
  1011.         currentInvokeId = 0;
  1012.         ctState = e_ctIdle;
  1013.       }
  1014.       break;
  1015.  
  1016.     default:
  1017.       break;
  1018.   }
  1019. }
  1020.  
  1021.  
  1022. void H4502Handler::OnReceivedCallTransferInitiate(int /*linkedId*/,
  1023.                                                   PASN_OctetString * argument)
  1024. {
  1025.   // TBD: Check Call Hold status. If call is held, it must first be 
  1026.   // retrieved before being transferred. -- dcassel 4/01
  1027.  
  1028.   H4502_CTInitiateArg ctInitiateArg;
  1029.   if (!DecodeArguments(argument, ctInitiateArg,
  1030.                        H4502_CallTransferErrors::e_invalidReroutingNumber))
  1031.     return;
  1032.  
  1033.   ctResponseSent = TRUE;
  1034.  
  1035.   PString remoteParty;
  1036.   H450ServiceAPDU::ParseEndpointAddress(ctInitiateArg.m_reroutingNumber, remoteParty);
  1037.  
  1038.   PString newToken;
  1039.   if (!endpoint.OnCallTransferInitiate(connection, remoteParty) ||
  1040.        endpoint.SetupTransfer(connection.GetCallToken(),
  1041.                               ctInitiateArg.m_callIdentity.GetValue(),
  1042.                               remoteParty, newToken) == NULL)
  1043.     SendReturnError(H4502_CallTransferErrors::e_establishmentFailure);
  1044. }
  1045.  
  1046.  
  1047. void H4502Handler::OnReceivedCallTransferSetup(int /*linkedId*/,
  1048.                                                PASN_OctetString * argument)
  1049. {
  1050.   H4502_CTSetupArg ctSetupArg;
  1051.   if (!DecodeArguments(argument, ctSetupArg,
  1052.                        H4502_CallTransferErrors::e_unrecognizedCallIdentity))
  1053.     return;
  1054.  
  1055.   // Get the Transferring User's details if present
  1056.   PString transferringParty;
  1057.   if (ctSetupArg.HasOptionalField(H4502_CTSetupArg::e_transferringNumber)) {
  1058.     H450ServiceAPDU::ParseEndpointAddress(ctSetupArg.m_transferringNumber, transferringParty);
  1059.   }
  1060.  
  1061.   PString callIdentity;
  1062.   callIdentity = ctSetupArg.m_callIdentity;
  1063.  
  1064.   if (callIdentity.IsEmpty()) { // Blind Transfer
  1065.     switch (ctState) {
  1066.       case e_ctIdle:
  1067.         ctState = e_ctAwaitSetupResponse;
  1068.         break;
  1069.  
  1070.       // Wrong State
  1071.       default :
  1072.         break;
  1073.     }
  1074.   }
  1075.   else { // Transfer through Consultation
  1076.     
  1077.     // We need to check that the call identity and destination address information match those in the 
  1078.     // second call.  For the time being we just check that the call identities match as there does not 
  1079.     // appear to be an elegant solution to compare the destination address information.
  1080.  
  1081.     // Get this callIdentity from our dictionary (if present)
  1082.     H323Connection *secondaryCall = endpoint.GetCallIdentityDictionary().GetAt(callIdentity);
  1083.   
  1084.     if (secondaryCall != NULL)
  1085.       secondaryCall->HandleConsultationTransfer(callIdentity, connection);
  1086.     else  // Mismatched callIdentity
  1087.       SendReturnError(H4502_CallTransferErrors::e_unrecognizedCallIdentity);
  1088.   }
  1089. }
  1090.  
  1091.  
  1092. void H4502Handler::OnReceivedCallTransferUpdate(int /*linkedId*/,
  1093.                                                 PASN_OctetString * argument)
  1094. {
  1095.   H4502_CTUpdateArg ctUpdateArg;
  1096.   if (!DecodeArguments(argument, ctUpdateArg, -1))
  1097.     return;
  1098.  
  1099. }
  1100.  
  1101.  
  1102. void H4502Handler::OnReceivedSubaddressTransfer(int /*linkedId*/,
  1103.                                                 PASN_OctetString * argument)
  1104. {
  1105.   H4502_SubaddressTransferArg subaddressTransferArg;
  1106.   if (!DecodeArguments(argument, subaddressTransferArg, -1))
  1107.     return;
  1108.  
  1109. }
  1110.  
  1111.  
  1112. void H4502Handler::OnReceivedCallTransferComplete(int /*linkedId*/,
  1113.                                                   PASN_OctetString * argument)
  1114. {
  1115.   H4502_CTCompleteArg ctCompleteArg;
  1116.   if (!DecodeArguments(argument, ctCompleteArg, -1))
  1117.     return;
  1118.  
  1119. }
  1120.  
  1121.  
  1122. void H4502Handler::OnReceivedCallTransferActive(int /*linkedId*/,
  1123.                                                 PASN_OctetString * argument)
  1124. {
  1125.   H4502_CTActiveArg ctActiveArg;
  1126.   if (!DecodeArguments(argument, ctActiveArg, -1))
  1127.     return;
  1128.  
  1129. }
  1130.  
  1131.  
  1132. BOOL H4502Handler::OnReceivedReturnResult(X880_ReturnResult & returnResult)
  1133. {
  1134.   if (currentInvokeId == returnResult.m_invokeId.GetValue()) {
  1135.     switch (ctState) {
  1136.       case e_ctAwaitInitiateResponse:
  1137.         OnReceivedInitiateReturnResult(); 
  1138.         break;
  1139.  
  1140.       case e_ctAwaitSetupResponse:
  1141.         OnReceivedSetupReturnResult();
  1142.         break;
  1143.  
  1144.       case e_ctAwaitIdentifyResponse:
  1145.         OnReceivedIdentifyReturnResult(returnResult);
  1146.         break;
  1147.  
  1148.       default :
  1149.         break;
  1150.     }
  1151.   }
  1152.   return TRUE;
  1153. }
  1154.  
  1155.  
  1156. void H4502Handler::OnReceivedInitiateReturnResult()
  1157. {
  1158.   // stop timer CT-T3
  1159.   StopctTimer();
  1160.   PTRACE(4, "H4502\tStopping timer CT-T3");
  1161.   ctState = e_ctIdle;
  1162.   currentInvokeId = 0;
  1163.  
  1164.   // clear the primary and secondary call if not already cleared,
  1165. }
  1166.  
  1167.  
  1168. void H4502Handler::OnReceivedSetupReturnResult()
  1169. {
  1170.   // stop timer CT-T4
  1171.   StopctTimer();
  1172.   PTRACE(4, "H4502\tStopping timer CT-T4");
  1173.   ctState = e_ctIdle;
  1174.   currentInvokeId = 0;
  1175.  
  1176.   // Clear the primary call
  1177.   endpoint.ClearCall(transferringCallToken, H323Connection::EndedByCallForwarded);
  1178. }
  1179.  
  1180.  
  1181. void H4502Handler::OnReceivedIdentifyReturnResult(X880_ReturnResult &returnResult)
  1182. {
  1183.   // stop timer CT-T1
  1184.   StopctTimer();
  1185.   PTRACE(4, "H4502\tStopping timer CT-T1");
  1186.  
  1187.   // Have received response.
  1188.   ctState = e_ctIdle;
  1189.  
  1190.   // Get the return result if present
  1191.   PASN_OctetString * result = NULL;
  1192.   if (returnResult.HasOptionalField(X880_ReturnResult::e_result)) {
  1193.     result = &returnResult.m_result.m_result;
  1194.  
  1195.     // Extract the C Party Details
  1196.     H4502_CTIdentifyRes ctIdentifyResult;
  1197.  
  1198.     PPER_Stream resultStream(*result);
  1199.     ctIdentifyResult.Decode(resultStream);
  1200.     PString callIdentity = ctIdentifyResult.m_callIdentity.GetValue();
  1201.  
  1202.     PString remoteParty;
  1203.     H450ServiceAPDU::ParseEndpointAddress(ctIdentifyResult.m_reroutingNumber, remoteParty);
  1204.  
  1205.     // Store the secondary call token on the primary connection so we can send a 
  1206.     // callTransferAbandon invoke APDU on the secondary call at a later stage if we 
  1207.     // get back a callTransferInitiateReturnError
  1208.     H323Connection* primaryConnection = endpoint.FindConnectionWithLock(CallToken);
  1209.  
  1210.     if (primaryConnection != NULL) {
  1211.       primaryConnection->SetAssociatedCallToken(connection.GetCallToken());
  1212.  
  1213.       // Send a callTransferInitiate invoke APDU in a FACILITY message
  1214.       // to the transferred endpoint on the primary call
  1215.       endpoint.TransferCall(primaryConnection->GetCallToken(), remoteParty, callIdentity);
  1216.     }
  1217.   }
  1218. }
  1219.  
  1220.  
  1221. BOOL H4502Handler::OnReceivedReturnError(int errorCode, X880_ReturnError &returnError)
  1222. {
  1223.   if (currentInvokeId == returnError.m_invokeId.GetValue()) {
  1224.     switch (ctState) {
  1225.       case e_ctAwaitInitiateResponse:
  1226.         OnReceivedInitiateReturnError();
  1227.         break;
  1228.  
  1229.       case e_ctAwaitSetupResponse:
  1230.         OnReceivedSetupReturnError(errorCode);
  1231.         break;
  1232.  
  1233.       case e_ctAwaitIdentifyResponse:
  1234.         OnReceivedIdentifyReturnError();
  1235.         break;
  1236.  
  1237.       default :
  1238.         break;
  1239.     }
  1240.   }
  1241.   return TRUE;
  1242. }
  1243.  
  1244.  
  1245. void H4502Handler::OnReceivedInitiateReturnError(const bool timerExpiry)
  1246. { 
  1247.   if (!timerExpiry) {
  1248.     // stop timer CT-T3
  1249.     StopctTimer();
  1250.     PTRACE(4, "H4502\tStopping timer CT-T3");
  1251.   }
  1252.   else
  1253.     PTRACE(4, "H4502\tTimer CT-T3 has expired on the Transferring Endpoint awaiting a response to a callTransferInitiate APDU.");
  1254.  
  1255.   currentInvokeId = 0;
  1256.   ctState = e_ctIdle;
  1257.  
  1258.  
  1259.   // Send a callTransferAbandon invoke APDU in a FACILITY message on the secondary call
  1260.   // (if it exists) and enter state CT-Idle.
  1261.   H323Connection* secondaryConnection = endpoint.FindConnectionWithLock(CallToken);
  1262.  
  1263.   if (secondaryConnection != NULL) {
  1264.     H450ServiceAPDU serviceAPDU;
  1265.  
  1266.     serviceAPDU.BuildCallTransferAbandon(dispatcher.GetNextInvokeId());
  1267.     serviceAPDU.WriteFacilityPDU(*secondaryConnection);
  1268.     secondaryConnection->Unlock();
  1269.   }
  1270. }
  1271.  
  1272.  
  1273. void H4502Handler::OnReceivedSetupReturnError(int errorCode,
  1274.                                               const bool timerExpiry)
  1275. {
  1276.   ctState = e_ctIdle;
  1277.   currentInvokeId = 0;
  1278.   
  1279.   if (!timerExpiry) {
  1280.     // stop timer CT-T4 if it is running
  1281.     StopctTimer();
  1282.     PTRACE(4, "H4502\tStopping timer CT-T4");  
  1283.   }
  1284.   else {
  1285.     PTRACE(3, "H4502\tTimer CT-T4 has expired on the Transferred Endpoint awaiting a response to a callTransferSetup APDU.");
  1286.  
  1287.     // Clear the transferred call.
  1288.     endpoint.ClearCall(connection.GetCallToken());
  1289.   }
  1290.  
  1291.   // Send a facility message to the transferring endpoint
  1292.   // containing a call transfer initiate return error
  1293.   H323Connection* primaryConnection = endpoint.FindConnectionWithLock(transferringCallToken);
  1294.  
  1295.   if (primaryConnection != NULL) {
  1296.     primaryConnection->HandleCallTransferFailure(errorCode);
  1297.     primaryConnection->Unlock();
  1298.   }
  1299. }
  1300.  
  1301.  
  1302. void H4502Handler::OnReceivedIdentifyReturnError(const bool timerExpiry)
  1303. {
  1304.   // The transferred-to user cannot participate in our transfer request
  1305.   ctState = e_ctIdle;
  1306.   currentInvokeId = 0;
  1307.  
  1308.   if (!timerExpiry) {
  1309.     // stop timer CT-T1
  1310.     StopctTimer();
  1311.     PTRACE(4, "H4502\tStopping timer CT-T1");
  1312.   }
  1313.   else {
  1314.     PTRACE(4, "H4502\tTimer CT-T1 has expired on the Transferring Endpoint awaiting a response to a callTransferIdentify APDU.");
  1315.  
  1316.     // send a callTransferAbandon invoke APDU in a FACILITY message on the secondary call
  1317.     // and enter state CT-Idle.
  1318.     connection.Lock();
  1319.  
  1320.     H450ServiceAPDU serviceAPDU;
  1321.  
  1322.     serviceAPDU.BuildCallTransferAbandon(dispatcher.GetNextInvokeId());
  1323.     serviceAPDU.WriteFacilityPDU(connection);
  1324.  
  1325.     connection.Unlock();
  1326.   }
  1327. }
  1328.  
  1329. void H4502Handler::TransferCall(const PString & remoteParty,
  1330.                                 const PString & callIdentity)
  1331. {
  1332.   currentInvokeId = dispatcher.GetNextInvokeId();
  1333.  
  1334.   // Send a FACILITY message with a callTransferInitiate Invoke
  1335.   // Supplementary Service PDU to the transferred endpoint.
  1336.   H450ServiceAPDU serviceAPDU;
  1337.  
  1338.   PString alias;
  1339.   H323TransportAddress address;
  1340.   endpoint.ParsePartyName(remoteParty, alias, address);
  1341.  
  1342.   serviceAPDU.BuildCallTransferInitiate(currentInvokeId, callIdentity, alias, address);
  1343.   serviceAPDU.WriteFacilityPDU(connection);
  1344.  
  1345.   ctState = e_ctAwaitInitiateResponse;
  1346.  
  1347.   // start timer CT-T3
  1348.   PTRACE(4, "H4502\tStarting timer CT-T3");
  1349.   StartctTimer(connection.GetEndPoint().GetCallTransferT3());
  1350. }
  1351.  
  1352.  
  1353. void H4502Handler::ConsultationTransfer(const PString & primaryCallToken)
  1354. {
  1355.   currentInvokeId = dispatcher.GetNextInvokeId();
  1356.  
  1357.   // Store the call token of the primary call on the secondary call.
  1358.   SetAssociatedCallToken(primaryCallToken);
  1359.  
  1360.   // Send a FACILITY message with a callTransferIdentify Invoke
  1361.   // Supplementary Service PDU to the transferred-to endpoint.
  1362.   H450ServiceAPDU serviceAPDU;
  1363.  
  1364.   serviceAPDU.BuildCallTransferIdentify(currentInvokeId);
  1365.   serviceAPDU.WriteFacilityPDU(connection);
  1366.  
  1367.   ctState = e_ctAwaitIdentifyResponse;
  1368.  
  1369.   // start timer CT-T1
  1370.   PTRACE(4, "H4502\tStarting timer CT-T1");
  1371.   StartctTimer(endpoint.GetCallTransferT1());
  1372. }
  1373.  
  1374.  
  1375. void H4502Handler::HandleConsultationTransfer(const PString & callIdentity,
  1376.                                               H323Connection& incoming)
  1377. {
  1378.   switch (ctState) {
  1379.     case e_ctAwaitSetup:
  1380.       {
  1381.         // Remove this callIdentity, connection pair from our dictionary as we no longer need it
  1382.         endpoint.GetCallIdentityDictionary().DisallowDeleteObjects();
  1383.         endpoint.GetCallIdentityDictionary().RemoveAt(callIdentity);
  1384.  
  1385.         // Stop timer CT-T2
  1386.         StopctTimer();
  1387.         PTRACE(4, "H4502\tStopping timer CT-T2");
  1388.  
  1389.         PTRACE(4, "H450.2\tConsultation Transfer successful, clearing secondary call");
  1390.  
  1391.         incoming.OnConsultationTransferSuccess(connection);
  1392.  
  1393.         currentInvokeId = 0;
  1394.         ctState = e_ctIdle;
  1395.  
  1396.         endpoint.ClearCall(connection.GetCallToken());
  1397.       }
  1398.       break;
  1399.  
  1400.     // Wrong Call Transfer State
  1401.     default :
  1402.       break;
  1403.  
  1404.   }
  1405. }
  1406.  
  1407.  
  1408. void H4502Handler::AwaitSetupResponse(const PString & token,
  1409.                                       const PString & identity)
  1410. {
  1411.   transferringCallToken = token;
  1412.   transferringCallIdentity = identity;
  1413.   ctState = e_ctAwaitSetupResponse;
  1414.  
  1415.   // start timer CT-T4
  1416.   PTRACE(4, "H450.2\tStarting timer CT-T4");
  1417.   StartctTimer(connection.GetEndPoint().GetCallTransferT4());
  1418. }
  1419.  
  1420.  
  1421. void H4502Handler::onReceivedAdmissionReject(const int returnError)
  1422. {
  1423.   if (ctState == e_ctAwaitSetupResponse) {
  1424.     ctState = e_ctIdle;
  1425.  
  1426.     // Stop timer CT-T4 if it is running
  1427.     StopctTimer();
  1428.     PTRACE(3, "H4502\tStopping timer CT-T4");
  1429.  
  1430.     // Send a FACILITY message back to the transferring party on the primary connection
  1431.     H323Connection * primaryConnection = endpoint.FindConnectionWithLock(transferringCallToken);
  1432.  
  1433.     if (primaryConnection != NULL) {
  1434.       PTRACE(3, "H4502\tReceived an Admission Reject at the Transferred Endpoint - aborting the transfer.");
  1435.       primaryConnection->HandleCallTransferFailure(returnError);
  1436.       primaryConnection->Unlock();
  1437.     }
  1438.   }
  1439. }
  1440.  
  1441.  
  1442. void H4502Handler::HandleCallTransferFailure(const int returnError)
  1443. {
  1444.   SendReturnError(returnError);
  1445. }
  1446.  
  1447.  
  1448. void H4502Handler::StopctTimer()
  1449. {
  1450.   if (ctTimer.IsRunning())
  1451.     ctTimer.Stop();
  1452. }
  1453.  
  1454.  
  1455. void H4502Handler::OnCallTransferTimeOut(PTimer &, INT)
  1456. {
  1457.   switch (ctState) {
  1458.     // CT-T3 Timeout
  1459.     case e_ctAwaitInitiateResponse:
  1460.       OnReceivedInitiateReturnError(true);
  1461.       break;
  1462.  
  1463.     // CT-T1 Timeout
  1464.     case e_ctAwaitIdentifyResponse:
  1465.       OnReceivedIdentifyReturnError(true);
  1466.       break;
  1467.  
  1468.     // CT-T2 Timeout
  1469.     case e_ctAwaitSetup:
  1470.       {
  1471.         // Abort the call transfer
  1472.         ctState = e_ctIdle;
  1473.         currentInvokeId = 0;
  1474.         PTRACE(4, "H450.2\tTimer CT-T2 has expired on the Transferred-to endpoint awaiting a callTransferSetup APDU.");  
  1475.       }
  1476.       break;
  1477.  
  1478.     // CT-T4 Timeout
  1479.     case e_ctAwaitSetupResponse:
  1480.       OnReceivedSetupReturnError(H4502_CallTransferErrors::e_establishmentFailure, true);
  1481.       break;
  1482.  
  1483.     default:
  1484.       break;
  1485.   }
  1486. }
  1487.  
  1488.  
  1489. /////////////////////////////////////////////////////////////////////////////
  1490.  
  1491. H4504Handler::H4504Handler(H323Connection & conn, H450xDispatcher & disp)
  1492.   : H450xHandler(conn, disp)
  1493. {
  1494.   dispatcher.AddOpCode(H4504_CallHoldOperation::e_holdNotific, this);
  1495.   dispatcher.AddOpCode(H4504_CallHoldOperation::e_retrieveNotific, this);
  1496.   dispatcher.AddOpCode(H4504_CallHoldOperation::e_remoteHold, this);
  1497.   dispatcher.AddOpCode(H4504_CallHoldOperation::e_remoteRetrieve, this);
  1498.  
  1499.   holdState = e_ch_Idle;
  1500. }
  1501.  
  1502.  
  1503. BOOL H4504Handler::OnReceivedInvoke(int opcode,
  1504.                                     int invokeId,
  1505.                                     int linkedId,
  1506.                                     PASN_OctetString *)
  1507. {
  1508.   currentInvokeId = invokeId;
  1509.  
  1510.   switch (opcode) {
  1511.     case H4504_CallHoldOperation::e_holdNotific:
  1512.       OnReceivedLocalCallHold(linkedId);
  1513.       break;
  1514.  
  1515.     case H4504_CallHoldOperation::e_retrieveNotific:
  1516.       OnReceivedLocalCallRetrieve(linkedId);
  1517.       break;
  1518.  
  1519.     case H4504_CallHoldOperation::e_remoteHold:
  1520.       OnReceivedRemoteCallHold(linkedId);
  1521.       break;
  1522.  
  1523.     case H4504_CallHoldOperation::e_remoteRetrieve:
  1524.       OnReceivedRemoteCallRetrieve(linkedId);
  1525.       break;
  1526.  
  1527.     default:
  1528.       currentInvokeId = 0;
  1529.       return FALSE;
  1530.   }
  1531.  
  1532.   return TRUE;
  1533. }
  1534.  
  1535.  
  1536. void H4504Handler::OnReceivedLocalCallHold(int /*linkedId*/)
  1537. {
  1538.   PTRACE(4, "H4504\tReceived a holdNotific Invoke APDU from the remote endpoint.");  
  1539.   // Optionally close our transmit channel.
  1540. }
  1541.  
  1542.  
  1543. void H4504Handler::OnReceivedLocalCallRetrieve(int /*linkedId*/)
  1544. {
  1545.   PTRACE(4, "H4504\tReceived a retrieveNotific Invoke APDU from the remote endpoint.");
  1546.   // Re-open our transmit channel if we previously closed it.
  1547. }
  1548.  
  1549.  
  1550. void H4504Handler::OnReceivedRemoteCallHold(int /*linkedId*/)
  1551. {
  1552.     // TBD
  1553. }
  1554.  
  1555.  
  1556. void H4504Handler::OnReceivedRemoteCallRetrieve(int /*linkedId*/)
  1557. {
  1558.     // TBD
  1559. }
  1560.  
  1561.  
  1562. void H4504Handler::HoldCall(BOOL localHold)
  1563. {
  1564.   // TBD: Implement Remote Hold. This implementation only does 
  1565.   // local hold. -- dcassel 4/01. 
  1566.   if (!localHold)
  1567.     return;
  1568.   
  1569.   // Send a FACILITY message with a callNotific Invoke
  1570.   // Supplementary Service PDU to the held endpoint.
  1571.   PTRACE(4, "H4504\tTransmitting a holdNotific Invoke APDU to the remote endpoint.");
  1572.  
  1573.   H450ServiceAPDU serviceAPDU;
  1574.  
  1575.   currentInvokeId = dispatcher.GetNextInvokeId();
  1576.   serviceAPDU.BuildInvoke(currentInvokeId, H4504_CallHoldOperation::e_holdNotific);
  1577.   serviceAPDU.WriteFacilityPDU(connection);
  1578.   
  1579.   // Update hold state
  1580.   holdState = e_ch_NE_Held;
  1581. }
  1582.  
  1583.  
  1584. void H4504Handler::RetrieveCall()
  1585. {
  1586.   // TBD: Implement Remote Hold. This implementation only does
  1587.  
  1588.   // Send a FACILITY message with a retrieveNotific Invoke
  1589.   // Supplementary Service PDU to the held endpoint.
  1590.   PTRACE(4, "H4504\tTransmitting a retrieveNotific Invoke APDU to the remote endpoint.");
  1591.  
  1592.   H450ServiceAPDU serviceAPDU;
  1593.  
  1594.   currentInvokeId = dispatcher.GetNextInvokeId();
  1595.   serviceAPDU.BuildInvoke(currentInvokeId, H4504_CallHoldOperation::e_retrieveNotific);
  1596.   serviceAPDU.WriteFacilityPDU(connection);
  1597.   
  1598.   // Update hold state
  1599.   holdState = e_ch_Idle;
  1600. }
  1601.  
  1602.  
  1603. /////////////////////////////////////////////////////////////////////////////
  1604.  
  1605. H4506Handler::H4506Handler(H323Connection & conn, H450xDispatcher & disp)
  1606.   : H450xHandler(conn, disp)
  1607. {
  1608.   dispatcher.AddOpCode(H4506_CallWaitingOperations::e_callWaiting, this);
  1609.  
  1610.   cwState = e_cw_Idle;
  1611. }
  1612.  
  1613.  
  1614. BOOL H4506Handler::OnReceivedInvoke(int opcode,
  1615.                                     int invokeId,
  1616.                                     int linkedId,
  1617.                                     PASN_OctetString *argument)
  1618. {
  1619.   currentInvokeId = invokeId;
  1620.  
  1621.   switch (opcode) {
  1622.     case H4506_CallWaitingOperations::e_callWaiting:
  1623.       OnReceivedCallWaitingIndication(linkedId, argument);
  1624.       break;
  1625.  
  1626.     default:
  1627.       currentInvokeId = 0;
  1628.       return FALSE;
  1629.   }
  1630.  
  1631.   return TRUE;
  1632. }
  1633.  
  1634.  
  1635. void H4506Handler::OnReceivedCallWaitingIndication(int /*linkedId*/,
  1636.                                                    PASN_OctetString *argument)
  1637. {
  1638.   H4506_CallWaitingArg cwArg;
  1639.  
  1640.   if(!DecodeArguments(argument, cwArg, -1))
  1641.     return;
  1642.  
  1643.   connection.SetRemotCallWaiting(cwArg.m_nbOfAddWaitingCalls.GetValue());
  1644.   return;
  1645. }
  1646.  
  1647.  
  1648. void H4506Handler::AttachToAlerting(H323SignalPDU & pdu,
  1649.                                     unsigned numberOfCallsWaiting)
  1650. {
  1651.   PTRACE(4, "H450.6\tAttaching a Call Waiting Invoke PDU to this Alerting message.");
  1652.   
  1653.   H450ServiceAPDU serviceAPDU;
  1654.  
  1655.   // Store the call waiting invokeID associated with this connection
  1656.   currentInvokeId = dispatcher.GetNextInvokeId();
  1657.  
  1658.   serviceAPDU.BuildCallWaiting(currentInvokeId, numberOfCallsWaiting);
  1659.   serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  1660.  
  1661.   cwState = e_cw_Invoked;
  1662. }
  1663.  
  1664.  
  1665. /////////////////////////////////////////////////////////////////////////////
  1666.  
  1667. H45011Handler::H45011Handler(H323Connection & conn, H450xDispatcher & disp)
  1668.   : H450xHandler(conn, disp)
  1669. {
  1670.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionRequest, this);
  1671.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionGetCIPL, this);
  1672.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionIsolate, this);
  1673.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionForcedRelease, this);
  1674.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionWOBRequest, this);
  1675.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionSilentMonitor, this);
  1676.   dispatcher.AddOpCode(H45011_H323CallIntrusionOperations::e_callIntrusionNotification, this);
  1677.  
  1678.   dispatcher.AddOpCode(H45010_H323CallOfferOperations::e_cfbOverride, this);
  1679.   dispatcher.AddOpCode(H45010_H323CallOfferOperations::e_remoteUserAlerting, this);
  1680.  
  1681.   dispatcher.AddOpCode(H4506_CallWaitingOperations::e_callWaiting, this);
  1682.  
  1683.   ciState = e_ci_Idle;
  1684.   ciSendState = e_ci_sIdle;
  1685.   ciReturnState = e_ci_rIdle;
  1686.   ciTimer.SetNotifier(PCREATE_NOTIFIER(OnCallIntrudeTimeOut));
  1687. }
  1688.  
  1689.  
  1690. BOOL H45011Handler::OnReceivedInvoke(int opcode,
  1691.                                     int invokeId,
  1692.                                     int linkedId,
  1693.                                     PASN_OctetString * argument)
  1694. {
  1695.   BOOL result = TRUE;
  1696.   currentInvokeId = invokeId;
  1697.  
  1698.   switch (opcode) {
  1699.     case H45011_H323CallIntrusionOperations::e_callIntrusionRequest:
  1700.       OnReceivedCallIntrusionRequest(linkedId, argument);
  1701.       break;
  1702.  
  1703.     case H45011_H323CallIntrusionOperations::e_callIntrusionGetCIPL:
  1704.       OnReceivedCallIntrusionGetCIPL(linkedId, argument);
  1705.       break;
  1706.  
  1707.     case H45011_H323CallIntrusionOperations::e_callIntrusionIsolate:
  1708.       OnReceivedCallIntrusionIsolate(linkedId, argument);
  1709.       break;
  1710.  
  1711.     case H45011_H323CallIntrusionOperations::e_callIntrusionForcedRelease:
  1712.       result = OnReceivedCallIntrusionForcedRelease(linkedId, argument);
  1713.       break;
  1714.  
  1715.     case H45011_H323CallIntrusionOperations::e_callIntrusionWOBRequest:
  1716.       OnReceivedCallIntrusionWOBRequest(linkedId, argument);
  1717.       break;
  1718.  
  1719.     case H45011_H323CallIntrusionOperations::e_callIntrusionSilentMonitor:
  1720.       OnReceivedCallIntrusionSilentMonitor(linkedId, argument);
  1721.       break;
  1722.  
  1723.     case H45011_H323CallIntrusionOperations::e_callIntrusionNotification:
  1724.       OnReceivedCallIntrusionNotification(linkedId, argument);
  1725.       break;
  1726.  
  1727.     case H45010_H323CallOfferOperations::e_cfbOverride:
  1728.       OnReceivedCfbOverride(linkedId, argument);
  1729.       break;
  1730.  
  1731.     case H45010_H323CallOfferOperations::e_remoteUserAlerting:
  1732.       OnReceivedRemoteUserAlerting(linkedId, argument);
  1733.       break;
  1734.  
  1735.     case H4506_CallWaitingOperations::e_callWaiting:
  1736.       OnReceivedCallWaiting(linkedId, argument);
  1737.       break;
  1738.     
  1739.     default:
  1740.       currentInvokeId = 0;
  1741.       return FALSE;
  1742.   }
  1743.  
  1744.   return result;
  1745. }
  1746.  
  1747.  
  1748. void H45011Handler::AttachToSetup(H323SignalPDU & pdu)
  1749. {
  1750.   // Do we need to attach a call transfer setup invoke APDU?
  1751.   if (ciSendState != e_ci_sAttachToSetup)
  1752.     return;
  1753.  
  1754.   H450ServiceAPDU serviceAPDU;
  1755.  
  1756.   // Store the outstanding invokeID associated with this connection
  1757.   currentInvokeId = dispatcher.GetNextInvokeId();
  1758.   PTRACE(4, "H450.11\tAttachToSetup Invoke ID=" << currentInvokeId);
  1759.  
  1760.   switch (ciGenerateState){
  1761.     case e_ci_gConferenceRequest:
  1762.       break;
  1763.     case e_ci_gHeldRequest:
  1764.       break;
  1765.     case e_ci_gSilentMonitorRequest:
  1766.       break;
  1767.     case e_ci_gIsolationRequest:
  1768.       break;
  1769.     case e_ci_gForcedReleaseRequest:
  1770.       serviceAPDU.BuildCallIntrusionForcedRelease(currentInvokeId, ciCICL);
  1771.       break;
  1772.     case e_ci_gWOBRequest:
  1773.       break;
  1774.     default:
  1775.       break;
  1776.   }
  1777.   
  1778.   if(ciGenerateState != e_ci_gIdle){
  1779.     // Use the call identity from the ctInitiateArg
  1780.     serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  1781.     // start timer CT-T1
  1782.     PTRACE(4, "H450.11\tStarting timer CI-T1");
  1783.     StartciTimer(connection.GetEndPoint().GetCallIntrusionT1());
  1784.     ciState = e_ci_WaitAck;
  1785.   }
  1786.  
  1787.   ciSendState = e_ci_sIdle;
  1788.   ciGenerateState = e_ci_gIdle;
  1789. }
  1790.  
  1791.  
  1792. void H45011Handler::AttachToAlerting(H323SignalPDU & pdu)
  1793. {
  1794.   if (ciSendState != e_ci_sAttachToAlerting)
  1795.     return;
  1796.  
  1797.   PTRACE(4, "H450.11\tAttachToAlerting Invoke ID=" << currentInvokeId);
  1798.  
  1799.   // Store the outstanding invokeID associated with this connection
  1800.   currentInvokeId = dispatcher.GetNextInvokeId();
  1801.   PTRACE(4, "H450.11\tAttachToAlerting Invoke ID=" << currentInvokeId);
  1802.   if(ciReturnState!=e_ci_rIdle){
  1803.     H450ServiceAPDU serviceAPDU;
  1804.     switch (ciReturnState){
  1805.       case e_ci_rCallIntrusionImpending:
  1806.         serviceAPDU.BuildCallIntrusionImpending(currentInvokeId);
  1807.         PTRACE(4, "H450.11\tReturned e_ci_rCallIntrusionImpending");
  1808.         break;
  1809.       case e_ci_rCallIntruded:
  1810.         break;
  1811.       case e_ci_rCallIsolated:
  1812.         break;
  1813.       case e_ci_rCallForceReleased:
  1814.         break;
  1815.       case e_ci_rCallForceReleaseResult:
  1816.         serviceAPDU.BuildCallIntrusionForcedReleaseResult(currentInvokeId);
  1817.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionForced Release Result");
  1818.         break;
  1819.       case e_ci_rCallIntrusionComplete:
  1820.         break;
  1821.       case e_ci_rCallIntrusionEnd:
  1822.         break;
  1823.       case e_ci_rNotBusy:
  1824.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notBusy);
  1825.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notBusy");
  1826.         break;
  1827.       case e_ci_rTempUnavailable:
  1828.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_temporarilyUnavailable");
  1829.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_temporarilyUnavailable);
  1830.         break;
  1831.       case e_ci_rNotAuthorized:
  1832.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notAuthorized");
  1833.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notAuthorized);
  1834.         break;
  1835.       default :
  1836.         break;
  1837.     }
  1838.     serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  1839.   }
  1840.  
  1841.   ciState = e_ci_Idle;
  1842.   ciSendState = e_ci_sIdle;
  1843.   ciReturnState = e_ci_rIdle;
  1844. }
  1845.  
  1846.  
  1847. void H45011Handler::AttachToConnect(H323SignalPDU & pdu)
  1848. {
  1849.   if ((currentInvokeId == 0) || (ciSendState != e_ci_sAttachToConnect))
  1850.     return;
  1851.  
  1852.   currentInvokeId = dispatcher.GetNextInvokeId();
  1853.   PTRACE(4, "H450.11\tAttachToConnect Invoke ID=" << currentInvokeId);
  1854.   if(ciReturnState!=e_ci_rIdle){
  1855.     H450ServiceAPDU serviceAPDU;
  1856.     switch (ciReturnState){
  1857.       case e_ci_rCallIntrusionImpending:
  1858.         break;
  1859.       case e_ci_rCallIntruded:
  1860.         break;
  1861.       case e_ci_rCallIsolated:
  1862.         break;
  1863.       case e_ci_rCallForceReleased:
  1864.         break;
  1865.       case e_ci_rCallForceReleaseResult:
  1866.         serviceAPDU.BuildCallIntrusionForcedReleaseResult(currentInvokeId);
  1867.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionForced Release Result");
  1868.         break;
  1869.       case e_ci_rCallIntrusionComplete:
  1870.         break;
  1871.       case e_ci_rCallIntrusionEnd:
  1872.         break;
  1873.       case e_ci_rNotBusy:
  1874.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notBusy);
  1875.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notBusy");
  1876.         break;
  1877.       case e_ci_rTempUnavailable:
  1878.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_temporarilyUnavailable");
  1879.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_temporarilyUnavailable);
  1880.         break;
  1881.       case e_ci_rNotAuthorized:
  1882.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notAuthorized");
  1883.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notAuthorized);
  1884.         break;
  1885.       default :
  1886.         break;
  1887.     }
  1888.  
  1889.     serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  1890.   }
  1891.  
  1892.  
  1893.   ciState = e_ci_Idle;
  1894.   ciSendState = e_ci_sIdle;
  1895.   ciReturnState = e_ci_rIdle;
  1896.   currentInvokeId = 0;
  1897. }
  1898.  
  1899.  
  1900.  
  1901. void H45011Handler::AttachToReleaseComplete(H323SignalPDU & pdu)
  1902. {
  1903.   // Do we need to attach a call transfer setup invoke APDU?
  1904.   if (ciSendState != e_ci_sAttachToReleseComplete)
  1905.     return;
  1906.  
  1907.   PTRACE(4, "H450.11\tAttachToSetup Invoke ID=" << currentInvokeId);
  1908.   if(ciReturnState!=e_ci_rIdle){
  1909.     H450ServiceAPDU serviceAPDU;
  1910.     switch (ciReturnState){
  1911.       case e_ci_rNotBusy:
  1912.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notBusy);
  1913.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notBusy");
  1914.         break;
  1915.       case e_ci_rTempUnavailable:
  1916.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_temporarilyUnavailable");
  1917.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_temporarilyUnavailable);
  1918.         break;
  1919.       case e_ci_rNotAuthorized:
  1920.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionErrors::e_notAuthorized");
  1921.         serviceAPDU.BuildReturnError(currentInvokeId, H45011_CallIntrusionErrors::e_notAuthorized);
  1922.         break;
  1923.       case e_ci_rCallForceReleased:
  1924.         PTRACE(4, "H450.11\tReturned H45011_CallIntrusionForceRelease::e_ci_rCallForceReleased");
  1925.         serviceAPDU.BuildCallIntrusionForceRelesed(currentInvokeId);
  1926.         break;
  1927.       default :
  1928.         break;
  1929.     }
  1930.     serviceAPDU.AttachSupplementaryServiceAPDU(pdu);
  1931.   }
  1932.  
  1933.   ciState = e_ci_Idle;
  1934.   ciSendState = e_ci_sIdle;
  1935.   ciReturnState = e_ci_rIdle;
  1936. }
  1937.  
  1938.  
  1939. void H45011Handler::OnReceivedCallIntrusionRequest(int /*linkedId*/,
  1940.                                                    PASN_OctetString *argument)
  1941. {
  1942.  
  1943.   H45011_CIRequestArg ciArg;
  1944.  
  1945.   if(!DecodeArguments(argument, ciArg, -1))
  1946.     return;
  1947. /*
  1948.   TBD
  1949. */
  1950.   return;
  1951. }
  1952.  
  1953.  
  1954. void H45011Handler::OnReceivedCallIntrusionGetCIPL(int /*linkedId*/,
  1955.                                                    PASN_OctetString *argument)
  1956. {
  1957.   PTRACE(4, "H450.11\tReceived GetCIPL Invoke");
  1958.  
  1959.   H45011_CIGetCIPLOptArg ciArg;
  1960.  
  1961.   // !!!!!!!!
  1962.   DecodeArguments(argument, ciArg, -1);
  1963. /*  if(!DecodeArguments(argument, ciArg, -1))
  1964.     return;
  1965. */
  1966.   
  1967.  
  1968.   // Send a FACILITY message with a callTransferIdentify return result
  1969.   // Supplementary Service PDU to the transferring endpoint.
  1970.   H450ServiceAPDU serviceAPDU;
  1971.  
  1972.   X880_ReturnResult& result = serviceAPDU.BuildReturnResult(currentInvokeId);
  1973.   result.IncludeOptionalField(X880_ReturnResult::e_result);
  1974.   result.m_result.m_opcode.SetTag(X880_Code::e_local);
  1975.   PASN_Integer& operation = (PASN_Integer&) result.m_result.m_opcode;
  1976.   operation.SetValue(H45011_H323CallIntrusionOperations::e_callIntrusionGetCIPL);
  1977.  
  1978.   H45011_CIGetCIPLRes ciCIPLRes;
  1979.  
  1980.   ciCIPLRes.m_ciProtectionLevel = endpoint.GetCallIntrusionProtectionLevel();
  1981.   ciCIPLRes.IncludeOptionalField(H45011_CIGetCIPLRes::e_silentMonitoringPermitted);
  1982.   ciCIPLRes.m_silentMonitoringPermitted = FALSE;
  1983.  
  1984.   PPER_Stream resultStream;
  1985.   ciCIPLRes.Encode(resultStream);
  1986.   resultStream.CompleteEncoding();
  1987.   result.m_result.m_result.SetValue(resultStream);
  1988.  
  1989.   serviceAPDU.WriteFacilityPDU(connection);
  1990.   PTRACE(4, "H450.11\tSent GetCIPL Result CIPL=" << ciCIPLRes.m_ciProtectionLevel);
  1991. /*
  1992.   TBD
  1993. */
  1994.   return;
  1995. }
  1996.  
  1997.  
  1998. void H45011Handler::OnReceivedCallIntrusionIsolate(int /*linkedId*/,
  1999.                                                    PASN_OctetString *argument)
  2000. {
  2001.  
  2002.   H45011_CIIsOptArg ciArg;
  2003.  
  2004.   if(!DecodeArguments(argument, ciArg, -1))
  2005.     return;
  2006. /*
  2007.   TBD
  2008. */
  2009.   return;
  2010. }
  2011.  
  2012.  
  2013. BOOL H45011Handler::OnReceivedCallIntrusionForcedRelease(int /*linkedId*/,
  2014.                                                          PASN_OctetString *argument)
  2015. {
  2016.   BOOL result = TRUE;
  2017.   PTRACE(4, "H450.11\tReceived ForcedRelease Invoke");
  2018.  
  2019.   H45011_CIFrcRelArg ciArg;
  2020.  
  2021.   if(!DecodeArguments(argument, ciArg, -1))
  2022.     return FALSE;
  2023.  
  2024.   PStringList tokens = endpoint.GetAllConnections();
  2025.  
  2026.   if(tokens.GetSize() >1) {
  2027.     for (PINDEX i = 0; i < tokens.GetSize(); i++) {
  2028.       if(endpoint.HasConnection(tokens[i])){
  2029.         H323Connection* conn = endpoint.FindConnectionWithLock(tokens[i]);
  2030.         if (conn != NULL){
  2031.           if (conn->IsEstablished()){
  2032.             if((conn->GetLocalCallIntrusionProtectionLevel() < ciArg.m_ciCapabilityLevel)){
  2033.               activeCallToken = conn->GetCallToken();
  2034.               intrudingCallToken = connection.GetCallToken();
  2035.               conn->GetRemoteCallIntrusionProtectionLevel(connection.GetCallToken (), (unsigned)ciArg.m_ciCapabilityLevel);
  2036.               result = TRUE;
  2037.               conn->Unlock ();
  2038.               break;
  2039.             }
  2040.             else
  2041.               result = FALSE;
  2042.           }
  2043.           conn->Unlock ();
  2044.         }
  2045.       }
  2046.     }
  2047.     if(result){
  2048.       ciSendState = e_ci_sAttachToConnect;
  2049.       ciReturnState = e_ci_rCallForceReleaseResult;
  2050.       connection.SetCallIntrusion ();
  2051.     }
  2052.     else {
  2053.       ciSendState = e_ci_sAttachToReleseComplete;
  2054.       ciReturnState = e_ci_rNotAuthorized;
  2055.       connection.ClearCall(H323Connection::EndedByLocalBusy);
  2056.     }
  2057.   }
  2058.   else{
  2059.     ciSendState = e_ci_sAttachToAlerting;
  2060.     ciReturnState = e_ci_rNotBusy;
  2061.   }
  2062.  
  2063.   return result;
  2064. }
  2065.  
  2066.  
  2067. void H45011Handler::OnReceivedCallIntrusionWOBRequest(int /*linkedId*/,
  2068.                                                       PASN_OctetString *argument)
  2069. {
  2070.  
  2071.   H45011_CIWobOptArg ciArg;
  2072.  
  2073.   if(!DecodeArguments(argument, ciArg, -1))
  2074.     return;
  2075. /*
  2076.   TBD
  2077. */
  2078.   return;
  2079. }
  2080.  
  2081.  
  2082. void H45011Handler::OnReceivedCallIntrusionSilentMonitor(int /*linkedId*/,
  2083.                                                          PASN_OctetString *argument)
  2084. {
  2085.  
  2086.   H45011_CISilentArg ciArg;
  2087.  
  2088.   if(!DecodeArguments(argument, ciArg, -1))
  2089.     return;
  2090. /*
  2091.   TBD
  2092. */
  2093.   return;
  2094. }
  2095.  
  2096.  
  2097. void H45011Handler::OnReceivedCallIntrusionNotification(int /*linkedId*/,
  2098.                                                         PASN_OctetString *argument)
  2099. {
  2100.  
  2101.   H45011_CINotificationArg ciArg;
  2102.  
  2103.   if(!DecodeArguments(argument, ciArg, -1))
  2104.     return;
  2105. /*
  2106.   TBD
  2107. */
  2108.   return;
  2109. }
  2110.  
  2111.  
  2112. void H45011Handler::OnReceivedCfbOverride(int /*linkedId*/,
  2113.                                           PASN_OctetString *argument)
  2114. {
  2115.  
  2116.   H45010_CfbOvrOptArg ciArg;
  2117.  
  2118.   if(!DecodeArguments(argument, ciArg, -1))
  2119.     return;
  2120. /*
  2121.   TBD
  2122. */
  2123.   return;
  2124. }
  2125.  
  2126.  
  2127. void H45011Handler::OnReceivedRemoteUserAlerting(int /*linkedId*/,
  2128.                                                  PASN_OctetString *argument)
  2129. {
  2130.  
  2131.   H45010_RUAlertOptArg ciArg;
  2132.  
  2133.   if(!DecodeArguments(argument, ciArg, -1))
  2134.     return;
  2135. /*
  2136.   TBD
  2137. */
  2138.   return;
  2139. }
  2140.  
  2141.  
  2142. void H45011Handler::OnReceivedCallWaiting(int /*linkedId*/,
  2143.                                           PASN_OctetString *argument)
  2144. {
  2145.  
  2146.   H4506_CallWaitingArg ciArg;
  2147.  
  2148.   if(!DecodeArguments(argument, ciArg, -1))
  2149.     return;
  2150. /*
  2151.   TBD
  2152. */
  2153.   return;
  2154. }
  2155.  
  2156.  
  2157. BOOL H45011Handler::OnReceivedReturnResult(X880_ReturnResult & returnResult)
  2158. {
  2159.   PTRACE(4, "H450.11\tReceived Return Result");
  2160.   if (currentInvokeId == returnResult.m_invokeId.GetValue()) {
  2161.     PTRACE(4, "H450.11\tReceived Return Result Invoke ID=" << currentInvokeId);
  2162.     switch (ciState) {
  2163.       case e_ci_WaitAck:
  2164.         OnReceivedCIRequestResult(); 
  2165.         break;
  2166.       case e_ci_GetCIPL:
  2167.         OnReceivedCIGetCIPLResult(returnResult); 
  2168.         break;
  2169.       default :
  2170.         break;
  2171.     }
  2172.   }
  2173.   return TRUE;
  2174. }
  2175.  
  2176.  
  2177. void H45011Handler::OnReceivedCIRequestResult()
  2178. {
  2179.   PTRACE(4, "H450.11\tOnReceivedCIRequestResult");
  2180.   // stop timer CI-T1
  2181.   PTRACE(4, "H450.11\tTrying to stop timer CI-T1");
  2182.   StopciTimer();
  2183. }
  2184.  
  2185.  
  2186. void H45011Handler::OnReceivedCIGetCIPLResult(X880_ReturnResult & returnResult)
  2187. {
  2188.   PTRACE(4, "H450.11\tOnReceivedCIRequestResult");
  2189.   // Get the return result if present
  2190.   PASN_OctetString * result = NULL;
  2191.   if (returnResult.HasOptionalField(X880_ReturnResult::e_result)) {
  2192.     result = &returnResult.m_result.m_result;
  2193.  
  2194.     // Extract the C Party Details
  2195.     H45011_CIGetCIPLRes ciGetCIPLResult;
  2196.  
  2197.     PPER_Stream resultStream(*result);
  2198.     ciGetCIPLResult.Decode(resultStream);
  2199.  
  2200.     PTRACE(4 ,"H450.11\tReceived CIPL=" << ciGetCIPLResult.m_ciProtectionLevel );
  2201.  
  2202.     if (intrudingCallCICL > ciGetCIPLResult.m_ciProtectionLevel){
  2203.  
  2204.       // Send ciNotification.inv (ciImpending) To C
  2205.       connection.Lock();
  2206.       H450ServiceAPDU serviceAPDU;
  2207.       currentInvokeId = dispatcher.GetNextInvokeId();
  2208.       serviceAPDU.BuildCallIntrusionImpending(currentInvokeId);
  2209.       serviceAPDU.WriteFacilityPDU(connection);
  2210.       connection.Unlock();
  2211.  
  2212.       // Send ciNotification.inv (ciImpending) to  intruding (A)
  2213.       H323Connection* conn = endpoint.FindConnectionWithLock(intrudingCallToken);
  2214.       conn->SetIntrusionImpending ();
  2215.  
  2216.       //Send Ringing to intruding (A)
  2217.       conn->AnsweringCall (conn->AnswerCallPending);
  2218.  
  2219.       // MUST RETURN ciNotification.inv (callForceRelesed) to active call (C) when releasing call !!!!!!
  2220.       ciSendState = e_ci_sAttachToReleseComplete;
  2221.       ciReturnState = e_ci_rCallForceReleased;
  2222.       
  2223.       //Send Forced Release Accepted when Answering call to intruding (A)
  2224.       conn->SetForcedReleaseAccepted();
  2225.       conn->Unlock ();
  2226.     }
  2227.     else {
  2228.       PTRACE(4 ,"H450.11\tCICL<CIPL -> Clear Call");
  2229.       // Clear Call with intruding (A)
  2230.       H323Connection* conn = endpoint.FindConnectionWithLock(intrudingCallToken);
  2231.       conn->SetIntrusionNotAuthorized();
  2232.       endpoint.ClearCall (intrudingCallToken);
  2233.     }
  2234.   }
  2235.  
  2236.   // stop timer CI-T5
  2237.   PTRACE(4, "H450.11\tTrying to stop timer CI-T5");
  2238.   StopciTimer();
  2239. }
  2240.  
  2241.  
  2242. BOOL H45011Handler::OnReceivedReturnError(int errorCode, X880_ReturnError &returnError)
  2243. {
  2244.   BOOL result = TRUE;
  2245.   PTRACE(4, "H450.11\tReceived Return Error CODE=" <<errorCode << ", InvokeId=" <<returnError.m_invokeId.GetValue());
  2246.   if (currentInvokeId == returnError.m_invokeId.GetValue()) {
  2247.     switch (ciState) {
  2248.       case e_ci_WaitAck:
  2249.         result = OnReceivedInvokeReturnError(errorCode);
  2250.         break;
  2251.       case e_ci_GetCIPL:
  2252.         result = OnReceivedGetCIPLReturnError(errorCode);
  2253.         break;
  2254.       default :
  2255.         break;
  2256.     }
  2257.   }
  2258.   return result;
  2259. }
  2260.  
  2261.  
  2262. BOOL H45011Handler::OnReceivedInvokeReturnError(int errorCode, const bool timerExpiry)
  2263. {
  2264.   BOOL result = FALSE;
  2265.   PTRACE(4, "H450.11\tOnReceivedInvokeReturnError CODE =" << errorCode);
  2266.   if (!timerExpiry) {
  2267.     // stop timer CI-T1
  2268.     StopciTimer();
  2269.     PTRACE(4, "H450.11\tStopping timer CI-T1");
  2270.   }
  2271.   else
  2272.     PTRACE(4, "H450.11\tTimer CI-T1 has expired awaiting a response to a callIntrusionInvoke return result.");
  2273.  
  2274.   currentInvokeId = 0;
  2275.   ciState = e_ci_Idle;
  2276.   ciSendState = e_ci_sIdle;
  2277.  
  2278.   switch(errorCode){
  2279.     case H45011_CallIntrusionErrors::e_notBusy :
  2280.       PTRACE(4, "H450.11\tH45011_CallIntrusionErrors::e_notBusy");
  2281.       result = TRUE;
  2282.       break;
  2283.     case H45011_CallIntrusionErrors::e_temporarilyUnavailable :
  2284.       PTRACE(4, "H450.11\tH45011_CallIntrusionErrors::e_temporarilyUnavailable");
  2285.       break;
  2286.     case H45011_CallIntrusionErrors::e_notAuthorized :
  2287.       PTRACE(4, "H450.11\tH45011_CallIntrusionErrors::e_notAuthorized");
  2288.       result = TRUE;
  2289.       break;
  2290.     default:
  2291.       PTRACE(4, "H450.11\tH45011_CallIntrusionErrors::DEFAULT");
  2292.       break;
  2293.   }
  2294.   return result;
  2295. }
  2296.  
  2297.  
  2298. #if PTRACING
  2299. #define PTRACE_errorCode errorCode
  2300. #else
  2301. #define PTRACE_errorCode
  2302. #endif
  2303.  
  2304. BOOL H45011Handler::OnReceivedGetCIPLReturnError(int PTRACE_errorCode,
  2305.                                                  const bool timerExpiry)
  2306. {
  2307.   PTRACE(4, "H450.11\tOnReceivedGetCIPLReturnError ErrorCode=" << PTRACE_errorCode);
  2308.   if(!timerExpiry){
  2309.     if (ciTimer.IsRunning()){
  2310.       ciTimer.Stop();
  2311.       PTRACE(4, "H450.11\tStopping timer CI-TX");
  2312.     }
  2313.   }
  2314.  
  2315.   // Send ciNotification.inv (ciImpending) to active call (C)
  2316.   connection.Lock();
  2317.   H450ServiceAPDU serviceAPDU;
  2318.   currentInvokeId = dispatcher.GetNextInvokeId();
  2319.   serviceAPDU.BuildCallIntrusionImpending(currentInvokeId);
  2320.   serviceAPDU.WriteFacilityPDU(connection);
  2321.   connection.Unlock();
  2322.  
  2323.   // Send ciNotification.inv (ciImpending) to intruding (A)
  2324.   H323Connection* conn = endpoint.FindConnectionWithLock(intrudingCallToken);
  2325.   conn->SetIntrusionImpending ();
  2326.  
  2327.   //Send Ringing to intruding (A)
  2328.   conn->AnsweringCall (conn->AnswerCallPending);
  2329.  
  2330.   ciSendState = e_ci_sAttachToReleseComplete;
  2331.   ciReturnState = e_ci_rCallForceReleased;
  2332.       
  2333.   //Forced Release Accepted to send when Answering call to intruding (A)
  2334.   conn->SetForcedReleaseAccepted();
  2335.   conn->Unlock ();
  2336.  
  2337.   return FALSE;
  2338. }
  2339.  
  2340.  
  2341. void H45011Handler::IntrudeCall(int CICL)
  2342. {
  2343.   ciSendState = e_ci_sAttachToSetup;
  2344.   ciGenerateState = e_ci_gForcedReleaseRequest;
  2345.   ciCICL = CICL;
  2346. }
  2347.  
  2348.  
  2349. void H45011Handler::AwaitSetupResponse(const PString & token,
  2350.                                       const PString & identity)
  2351. {
  2352.   intrudingCallToken = token;
  2353.   intrudingCallIdentity = identity;
  2354.   ciState = e_ci_WaitAck;
  2355.  
  2356. }
  2357.  
  2358.  
  2359. BOOL H45011Handler::GetRemoteCallIntrusionProtectionLevel(const PString & token,
  2360.                                                           unsigned intrusionCICL)
  2361. {
  2362.   if (!connection.Lock())
  2363.     return FALSE;
  2364.  
  2365.   intrudingCallToken = token;
  2366.   intrudingCallCICL = intrusionCICL;
  2367.  
  2368.   H450ServiceAPDU serviceAPDU;
  2369.  
  2370.   currentInvokeId = dispatcher.GetNextInvokeId();
  2371.  
  2372.   serviceAPDU.BuildCallIntrusionGetCIPL(currentInvokeId);
  2373.  
  2374.   connection.Unlock();
  2375.  
  2376.   if (!serviceAPDU.WriteFacilityPDU(connection))
  2377.     return FALSE;
  2378.  
  2379.   PTRACE(4, "H450.11\tStarting timer CI-T5");
  2380.   StartciTimer(connection.GetEndPoint().GetCallIntrusionT5());
  2381.   ciState = e_ci_GetCIPL;
  2382.   return TRUE;
  2383. }
  2384.  
  2385.  
  2386. void H45011Handler::SetIntrusionNotAuthorized()
  2387. {
  2388.   ciSendState = e_ci_sAttachToReleseComplete;
  2389.   ciReturnState = e_ci_rNotAuthorized;
  2390. }
  2391.  
  2392.  
  2393. void H45011Handler::SetIntrusionImpending()
  2394. {
  2395.   ciSendState = e_ci_sAttachToAlerting;
  2396.   ciReturnState = e_ci_rCallIntrusionImpending;
  2397. }
  2398.  
  2399.  
  2400. void H45011Handler::SetForcedReleaseAccepted()
  2401. {
  2402.   ciSendState = e_ci_sAttachToConnect;
  2403.   ciReturnState = e_ci_rCallForceReleaseResult;
  2404.   ciState = e_ci_DestNotify;
  2405.  
  2406.   StartciTimer(connection.GetEndPoint().GetCallIntrusionT6());
  2407. }
  2408.  
  2409.  
  2410. void H45011Handler::StopciTimer()
  2411. {
  2412.   if (ciTimer.IsRunning()){
  2413.     ciTimer.Stop();
  2414.     PTRACE(4, "H450.11\tStopping timer CI-TX");
  2415.   }
  2416. }
  2417.  
  2418.  
  2419. void H45011Handler::OnCallIntrudeTimeOut(PTimer &, INT)
  2420. {
  2421.   switch (ciState) {
  2422.     // CI-T1 Timeout
  2423.     case e_ci_WaitAck:
  2424.       PTRACE(4, "H450.11\tTimer CI-T1 has expired");
  2425.       OnReceivedInvokeReturnError(0,true);
  2426.       break;
  2427.     case e_ci_GetCIPL:
  2428.       PTRACE(4, "H450.11\tTimer CI-T5 has expired");
  2429.       OnReceivedGetCIPLReturnError(0,true);
  2430.       break;
  2431.     case e_ci_DestNotify:
  2432.       {
  2433.         PTRACE(4, "H450.11\tOnCallIntrudeTimeOut Timer CI-T6 has expired");
  2434.         // Clear the active call (call with C)
  2435.        PSyncPoint sync;
  2436.        endpoint.ClearCallSynchronous(activeCallToken, H323Connection::EndedByLocalUser, &sync);
  2437.         // Answer intruding call (call with A)
  2438.         PTRACE(4, "H450.11\tOnCallIntrudeTimeOut Trying to answer Call");
  2439.         if(endpoint.HasConnection(intrudingCallToken)){
  2440.           H323Connection* conn = endpoint.FindConnectionWithLock(intrudingCallToken);
  2441.           conn->AnsweringCall (conn->AnswerCallNow);
  2442.           conn->Unlock ();
  2443.         }
  2444.       }
  2445.       break;
  2446.     default:
  2447.       break;
  2448.   }
  2449. }
  2450.  
  2451.  
  2452. #if PTRACING
  2453. #define PTRACE_problemType   problemType
  2454. #define PTRACE_problemNumber problemNumber
  2455. #else
  2456. #define PTRACE_problemType
  2457. #define PTRACE_problemNumber
  2458. #endif
  2459.  
  2460. BOOL H45011Handler::OnReceivedReject(int PTRACE_problemType, int PTRACE_problemNumber)
  2461. {
  2462.   PTRACE(4, "H450.11\tH45011Handler::OnReceivedReject - problemType= "
  2463.          << PTRACE_problemType << ", problemNumber= " << PTRACE_problemNumber);
  2464.  
  2465.   if (ciTimer.IsRunning()){
  2466.     ciTimer.Stop();
  2467.     PTRACE(4, "H450.11\tStopping timer CI-TX");
  2468.   }
  2469.  
  2470.   switch (ciState) {
  2471.     case e_ci_GetCIPL:
  2472.     {
  2473.       H323Connection* conn = endpoint.FindConnectionWithLock(intrudingCallToken);
  2474.       conn->SetIntrusionImpending ();
  2475.  
  2476.       //Send Ringing to  intruding (A)
  2477.       conn->AnsweringCall (conn->AnswerCallPending);
  2478.       conn->SetForcedReleaseAccepted();  
  2479.       conn->Unlock ();
  2480.       break;
  2481.     }
  2482.  
  2483.     default:
  2484.       break;
  2485.   }
  2486.   ciState = e_ci_Idle;
  2487.   return TRUE;
  2488. };
  2489.