h323pdu.cxx

mgcp协议源代码。支持多种编码：g711

  H323Connection::CallEndReason reason = connection.GetCallEndReason();
  static Q931::CauseValues const Q931cause[H323Connection::NumCallEndReasons] = {
    Q931::NormalCallClearing, /// Local endpoint application cleared call
    Q931::UserBusy,           /// Local endpoint did not accept call OnIncomingCall()=FALSE
    Q931::CallRejected,       /// Local endpoint declined to answer call
    Q931::NormalCallClearing, /// Remote endpoint application cleared call
    Q931::ErrorInCauseIE,     /// Remote endpoint refused call
    Q931::NormalCallClearing, /// Remote endpoint did not answer in required time
    Q931::NormalCallClearing, /// Remote endpoint stopped calling
    Q931::ErrorInCauseIE,     /// Transport error cleared call
    Q931::NoRouteToDestination, /// Transport connection failed to establish call
    Q931::NormalCallClearing, /// Gatekeeper has cleared call
    Q931::ErrorInCauseIE,     /// Call failed as could not find user (in GK)
    Q931::ErrorInCauseIE,     /// Call failed as could not get enough bandwidth
    Q931::ErrorInCauseIE,     /// Could not find common capabilities
    Q931::Redirection,        /// Call was forwarded using FACILITY message
  };
  if (Q931cause[reason] != Q931::ErrorInCauseIE)
    q931pdu.SetCause(Q931cause[reason]);

  static unsigned const H225reason[H323Connection::NumCallEndReasons] = {
    0, /// Local endpoint application cleared call
    0, /// Local endpoint did not accept call OnIncomingCall()=FALSE
    0, /// Local endpoint declined to answer call
    0, /// Remote endpoint application cleared call
    1+H225_ReleaseCompleteReason::e_destinationRejection, /// Remote endpoint refused call
    0, /// Remote endpoint did not answer in required time
    0, /// Remote endpoint stopped calling
    1+H225_ReleaseCompleteReason::e_undefinedReason, /// Transport error cleared call
    1+H225_ReleaseCompleteReason::e_unreachableDestination, /// Transport connection failed to establish call
    0, /// Gatekeeper has cleared call
    1+H225_ReleaseCompleteReason::e_calledPartyNotRegistered, /// Call failed as could not find user (in GK)
    1+H225_ReleaseCompleteReason::e_noBandwidth, /// Call failed as could not get enough bandwidth
    1+H225_ReleaseCompleteReason::e_undefinedReason, /// Could not find common capabilities
    1+H225_ReleaseCompleteReason::e_facilityCallDeflection, /// Call was forwarded using FACILITY message
  };
  if (H225reason[reason] != 0) {
    release.IncludeOptionalField(H225_ReleaseComplete_UUIE::e_reason);
    release.m_reason.SetTag(H225reason[reason]-1);
  }

  return release;
}


H225_Connect_UUIE & H323SignalPDU::BuildConnect(const H323Connection & connection)
{
  q931pdu.BuildConnect(connection.GetCallReference());
  SetQ931Fields(connection);

  m_h323_uu_pdu.m_h323_message_body.SetTag(H225_H323_UU_PDU_h323_message_body::e_connect);
  H225_Connect_UUIE & connect = m_h323_uu_pdu.m_h323_message_body;

  connect.m_protocolIdentifier.SetValue(H225_ProtocolID);
  connect.m_callIdentifier.m_guid = connection.GetCallIdentifier();
  connect.m_conferenceID = connection.GetConferenceIdentifier();

  connection.GetEndPoint().SetEndpointTypeInfo(connect.m_destinationInfo);

  return connect;
}


H225_Connect_UUIE & H323SignalPDU::BuildConnect(const H323Connection & connection,
                                                const PIPSocket::Address & h245Address,
                                                WORD port)
{
  H225_Connect_UUIE & connect = BuildConnect(connection);

  // indicate we are including the optional H245 address in the PDU
  connect.IncludeOptionalField(H225_Connect_UUIE::e_h245Address);

  // convert IP address into the correct H245 type
  connect.m_h245Address.SetTag(H225_TransportAddress::e_ipAddress);
  H225_TransportAddress_ipAddress & ipAddress = connect.m_h245Address;
  ipAddress.m_ip.SetSize(4);
  ipAddress.m_ip[0] = h245Address.Byte1();
  ipAddress.m_ip[1] = h245Address.Byte2();
  ipAddress.m_ip[2] = h245Address.Byte3();
  ipAddress.m_ip[3] = h245Address.Byte4();
  ipAddress.m_port  = port;

  return connect;
}


H225_Setup_UUIE & H323SignalPDU::BuildSetup(const H323Connection & connection)
{
  H323EndPoint & endpoint = connection.GetEndPoint();

  q931pdu.BuildSetup(connection.GetCallReference());
  SetQ931Fields(connection, TRUE);

  m_h323_uu_pdu.m_h323_message_body.SetTag(H225_H323_UU_PDU_h323_message_body::e_setup);
  H225_Setup_UUIE & setup = m_h323_uu_pdu.m_h323_message_body;
  setup.m_protocolIdentifier.SetValue(H225_ProtocolID);

  setup.IncludeOptionalField(H225_Setup_UUIE::e_sourceAddress);
  H323SetAliasAddresses(endpoint.GetAliasNames(), setup.m_sourceAddress);

  setup.m_conferenceID = H323GloballyUniqueID();
  setup.m_conferenceGoal.SetTag(H225_Setup_UUIE_conferenceGoal::e_create);
  setup.m_callType.SetTag(H225_CallType::e_pointToPoint);

  setup.m_callIdentifier.m_guid = H323GloballyUniqueID();
  setup.m_mediaWaitForConnect = FALSE;
  setup.m_canOverlapSend = FALSE;

  PString destAlias = connection.GetRemotePartyName();
  if (!destAlias) {
    setup.IncludeOptionalField(H225_Setup_UUIE::e_destinationAddress);
    setup.m_destinationAddress.SetSize(1);

    // Try and encode it as a phone number
    H323SetAliasAddress(destAlias, setup.m_destinationAddress[0]);
    if (setup.m_destinationAddress[0].GetTag() == H225_AliasAddress::e_e164)
      q931pdu.SetCalledPartyNumber(destAlias);
  }

  endpoint.SetEndpointTypeInfo(setup.m_sourceInfo);

  return setup;
}


H225_Setup_UUIE & H323SignalPDU::BuildSetup(const H323Connection & connection,
                                            const PIPSocket::Address & destAddr,
                                            WORD port)
{
  H225_Setup_UUIE & setup = BuildSetup(connection);

  setup.IncludeOptionalField(H225_Setup_UUIE::e_destCallSignalAddress);
  setup.m_destCallSignalAddress.SetTag(H225_TransportAddress::e_ipAddress);
  H225_TransportAddress_ipAddress & addr = setup.m_destCallSignalAddress;
  addr.m_ip[0] = destAddr.Byte1();
  addr.m_ip[1] = destAddr.Byte2();
  addr.m_ip[2] = destAddr.Byte3();
  addr.m_ip[3] = destAddr.Byte4();
  addr.m_port = port;

  return setup;
}


void H323SignalPDU::BuildStatus(int callRef, BOOL fromDest)
{
  q931pdu.BuildStatus(callRef, fromDest);
  m_h323_uu_pdu.m_h323_message_body.SetTag(UINT_MAX);
}


void H323SignalPDU::BuildQ931()
{
  // Encode the H225 PDu into the Q931 PDU as User-User data
  PPER_Stream strm;
  Encode(strm);
  strm.CompleteEncoding();
  q931pdu.SetIE(Q931::UserUserIE, strm);
}


void H323SignalPDU::PrintOn(ostream & strm) const
{
  int indent = strm.precision() + 2;
  strm << "{\n"
       << setw(indent+10) << "q931pdu = " << setprecision(indent) << q931pdu << '\n'
       << setw(indent+10) << "h225pdu = " << setprecision(indent);
  H225_H323_UserInformation::PrintOn(strm);
  strm << '\n'
       << setw(indent-1) << "}";
}


BOOL H323SignalPDU::Read(H323Transport & transport)
{
  PBYTEArray rawData;
  if (!transport.ReadPDU(rawData)) {
#if PTRACING
    if (transport.GetErrorCode() != PChannel::Timeout)
      PTRACE(1, "H225\tRead error: " << transport.GetErrorText());
#endif
    return FALSE;
  }

  PTRACE(4, "H225\tReceived raw data:\n" << hex << setfill('0')
                                         << setprecision(2) << rawData
                                         << dec << setfill(' '));

  if (!q931pdu.Decode(rawData)) {
    PTRACE(1, "H225\tParse error of Q931 PDU");
    return FALSE;
  }

  if (!q931pdu.HasIE(Q931::UserUserIE)) {
    m_h323_uu_pdu.m_h323_message_body.SetTag(H225_H323_UU_PDU_h323_message_body::e_empty);
    PTRACE(1, "H225\tNo Q931 User-User Information Element");
    PTRACE(4, "H225\tReceived Q.931 PDU:\n  " << setprecision(2) << q931pdu);
    return TRUE;
  }

  PPER_Stream strm = q931pdu.GetIE(Q931::UserUserIE);
  if (!Decode(strm)) {
    m_h323_uu_pdu.m_h323_message_body.SetTag(H225_H323_UU_PDU_h323_message_body::e_empty);
    PTRACE(1, "H225\tRead error: PER decode failure if Q.931 User-User Information Element");
    PTRACE(4, "H225\tPartial PDU:\n  " << setprecision(2) << *this);
    return TRUE;
  }

#if PTRACING
  if (PTrace::CanTrace(4))
    PTRACE(4, "H225\tReceived PDU:\n  " << setprecision(2) << *this);
  else
    PTRACE(3, "H225\tReceived PDU: " << m_h323_uu_pdu.m_h323_message_body.GetTagName());
#endif
  return TRUE;
}


BOOL H323SignalPDU::Write(H323Transport & transport)
{
  if (!q931pdu.HasIE(Q931::UserUserIE) && m_h323_uu_pdu.m_h323_message_body.IsValid())
    BuildQ931();

  PBYTEArray rawData;
  if (!q931pdu.Encode(rawData))
    return FALSE;
  
#if PTRACING
  if (PTrace::CanTrace(4))
    PTRACE(4, "H225\tSending PDU:\n  " << setprecision(2) << *this << '\n'
                                       << hex << setfill('0')
                                       << setprecision(2) << rawData
                                       << dec << setfill(' '));
  else
    PTRACE(3, "H225\tSending PDU: " << m_h323_uu_pdu.m_h323_message_body.GetTagName());
#endif

  return transport.WritePDU(rawData);
}


BOOL H323SignalPDU::GetDestinationE164(PString & number) const
{
  if (GetQ931().GetCalledPartyNumber(number))
    return TRUE;

  const H225_Setup_UUIE & setup = m_h323_uu_pdu.m_h323_message_body;
  if (!setup.HasOptionalField(H225_Setup_UUIE::e_destinationAddress))
    return FALSE;

  PINDEX i;
  for (i = 0; i < setup.m_destinationAddress.GetSize(); i++) {
    if (setup.m_destinationAddress[i].GetTag() == H225_AliasAddress::e_e164) {
      number = (PASN_IA5String &)setup.m_destinationAddress[i];
      return TRUE;
    }
  }

  for (i = 0; i < setup.m_destinationAddress.GetSize(); i++) {
    PString str = H323GetAliasAddressString(setup.m_destinationAddress[i]);
    if (IsE164(str)) {
      number = str;
      return TRUE;
    }
  }

  return FALSE;
}


void H323SignalPDU::SetQ931Fields(const H323Connection & connection, BOOL insertPartyNumbers)
{
  PINDEX i;
  const PStringList & aliases = connection.GetEndPoint().GetAliasNames();

  PString number;
  PString localName = connection.GetLocalPartyName();
  if (IsE164(localName)) {
    number = localName;
    for (i = 0; i < aliases.GetSize(); i++) {
      if (!IsE164(aliases[i])) {
        q931pdu.SetDisplayName(aliases[i]);
        break;
      }
    }
  }
  else {
    q931pdu.SetDisplayName(localName);
    for (i = 0; i < aliases.GetSize(); i++) {
      if (IsE164(aliases[i])) {
        number = aliases[i];
        break;
      }
    }
  }

  if (insertPartyNumbers) {
    PString otherNumber = connection.GetRemotePartyNumber();
    if (otherNumber.IsEmpty()) {
      PString otherName = connection.GetRemotePartyName();
      if (IsE164(otherName))
        otherNumber = otherName;
    }

    if (connection.HadAnsweredCall()) {
      if (!number)
        q931pdu.SetCalledPartyNumber(number);
      if (!otherNumber)
        q931pdu.SetCallingPartyNumber(otherNumber);
    }
    else {
      if (!number)
        q931pdu.SetCallingPartyNumber(number);
      if (!otherNumber)
        q931pdu.SetCalledPartyNumber(otherNumber);
    }
  }

  unsigned ring = connection.GetDistinctiveRing();
  if (ring != 0)
    q931pdu.SetSignalInfo((Q931::SignalInfo)(ring + Q931::SignalAlertingPattern0));
}


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

H245_RequestMessage & H323ControlPDU::Build(H245_RequestMessage::Choices request)
{
  SetTag(e_request);
  H245_RequestMessage & msg = *this;
  msg.SetTag(request);
  return msg;
}


H245_ResponseMessage & H323ControlPDU::Build(H245_ResponseMessage::Choices response)
{
  SetTag(e_response);
  H245_ResponseMessage & resp = *this;
  resp.SetTag(response);
  return resp;
}


H245_CommandMessage & H323ControlPDU::Build(H245_CommandMessage::Choices command)
{
  SetTag(e_command);
  H245_CommandMessage & cmd = *this;
  cmd.SetTag(command);
  return cmd;
}


H245_IndicationMessage & H323ControlPDU::Build(H245_IndicationMessage::Choices indication)
{
  SetTag(e_indication);
  H245_IndicationMessage & ind = *this;
  ind.SetTag(indication);
  return ind;
}


H245_MasterSlaveDetermination & 
      H323ControlPDU::BuildMasterSlaveDetermination(unsigned terminalType,
                                                    unsigned statusDeterminationNumber)
{
  H245_MasterSlaveDetermination & msd = Build(H245_RequestMessage::e_masterSlaveDetermination);
  msd.m_terminalType = terminalType;
  msd.m_statusDeterminationNumber = statusDeterminationNumber;
  return msd;
}


H245_MasterSlaveDeterminationAck &
      H323ControlPDU::BuildMasterSlaveDeterminationAck(BOOL isMaster)
{
  H245_MasterSlaveDeterminationAck & msda = Build(H245_ResponseMessage::e_masterSlaveDeterminationAck);
  msda.m_decision.SetTag(isMaster
                            ? H245_MasterSlaveDeterminationAck_decision::e_slave
                            : H245_MasterSlaveDeterminationAck_decision::e_master);
  return msda;
}


H245_MasterSlaveDeterminationReject &
      H323ControlPDU::BuildMasterSlaveDeterminationReject(unsigned cause)
{
  H245_MasterSlaveDeterminationReject & msdr = Build(H245_ResponseMessage::e_masterSlaveDeterminationReject);
  msdr.m_cause.SetTag(cause);
  return msdr;
}


H245_TerminalCapabilitySet &
      H323ControlPDU::BuildTerminalCapabilitySet(const H323Connection & connection,
                                                 unsigned sequenceNumber)
{
  H245_TerminalCapabilitySet & cap = Build(H245_RequestMessage::e_terminalCapabilitySet);

  cap.m_sequenceNumber = sequenceNumber;
  cap.m_protocolIdentifier = H245_ProtocolID;

  cap.IncludeOptionalField(H245_TerminalCapabilitySet::e_multiplexCapability);
  cap.m_multiplexCapability.SetTag(H245_MultiplexCapability::e_h2250Capability);
  H245_H2250Capability & h225_0 = cap.m_multiplexCapability;
  h225_0.m_maximumAudioDelayJitter = connection.GetEndPoint().GetMaxAudioDelayJitter();
  h225_0.m_receiveMultipointCapability.m_mediaDistributionCapability.SetSize(1);
  h225_0.m_transmitMultipointCapability.m_mediaDistributionCapability.SetSize(1);
  h225_0.m_receiveAndTransmitMultipointCapability.m_mediaDistributionCapability.SetSize(1);

  // Set the table of capabilities
  connection.GetLocalCapabilities().BuildPDU(cap);

  return cap;
}


H245_TerminalCapabilitySetAck &
      H323ControlPDU::BuildTerminalCapabilitySetAck(unsigned sequenceNumber)
{
  H245_TerminalCapabilitySetAck & cap = Build(H245_ResponseMessage::e_terminalCapabilitySetAck);
  cap.m_sequenceNumber = sequenceNumber;
  return cap;
}


H245_TerminalCapabilitySetReject &
      H323ControlPDU::BuildTerminalCapabilitySetReject(unsigned sequenceNumber,
                                                       unsigned cause)
{
  H245_TerminalCapabilitySetReject & cap = Build(H245_ResponseMessage::e_terminalCapabilitySetReject);
  cap.m_sequenceNumber = sequenceNumber;
  cap.m_cause.SetTag(cause);