diff --git a/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.cpp b/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.cpp new file mode 100644 index 00000000..f4771037 --- /dev/null +++ b/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.cpp @@ -0,0 +1,140 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +#include "Defines.h" +#include "p25/lc/tsbk/IOSP_TELE_INT_ANS.h" + +using namespace p25; +using namespace p25::defines; +using namespace p25::lc; +using namespace p25::lc::tsbk; + +#include + +// --------------------------------------------------------------------------- +// Public Class Members +// --------------------------------------------------------------------------- + +/* Initializes a new instance of the IOSP_TELE_INT_ANS class. */ + +IOSP_TELE_INT_ANS::IOSP_TELE_INT_ANS() : TSBK(), + m_digits() +{ + m_lco = TSBKO::IOSP_TELE_INT_ANS; +} + +/* Decode a trunking signalling block. */ + +bool IOSP_TELE_INT_ANS::decode(const uint8_t* data, bool rawTSBK) +{ + assert(data != nullptr); + + uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U]; + ::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES); + + bool ret = TSBK::decode(data, tsbk, rawTSBK); + if (!ret) + return false; + + ulong64_t tsbkValue = TSBK::toValue(tsbk); + + // the ISP and OSP share an opcode but not a layout, so both are decoded; the trailing + // subscriber unit address is the source (ISP) or target (OSP) and is stored as both + m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag (ISP) + m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag (ISP) + m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority (ISP) + m_response = (uint8_t)((tsbkValue >> 48) & 0xFFU); // Answer Response (ISP) + + // a $F digit escapes the next digit ($0 - $3 = A - D, $F = null filler) + m_digits = ""; + for (uint32_t i = 0U; i < MAX_DIGITS; i++) { + uint8_t digit = (uint8_t)((tsbkValue >> (60U - (i * 4U))) & 0x0FU); // Digits 1 - 10 (OSP) + if (digit <= 0x09U) { + m_digits += (char)('0' + digit); + } + else if (digit == 0x0AU) { + m_digits += '*'; + } + else if (digit == 0x0BU) { + m_digits += '#'; + } + else if (digit == 0x0FU) { + if (i + 1U >= MAX_DIGITS) + break; + + uint8_t escaped = (uint8_t)((tsbkValue >> (60U - ((i + 1U) * 4U))) & 0x0FU); + if (escaped > 0x03U) + break; + + m_digits += (char)('A' + escaped); + i++; + } + } + + m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source (ISP) / Target (OSP) Radio Address + m_dstId = m_srcId; + + return true; +} + +/* Encode a trunking signalling block. */ + +void IOSP_TELE_INT_ANS::encode(uint8_t* data, bool rawTSBK, bool noTrellis) +{ + assert(data != nullptr); + + uint8_t digits[MAX_DIGITS]; + ::memset(digits, 0x0FU, MAX_DIGITS); // Null Filler + + uint32_t count = 0U; + for (char c : m_digits) { + if (c >= '0' && c <= '9' && count < MAX_DIGITS) { + digits[count++] = (uint8_t)(c - '0'); + } + else if (c == '*' && count < MAX_DIGITS) { + digits[count++] = 0x0AU; + } + else if (c == '#' && count < MAX_DIGITS) { + digits[count++] = 0x0BU; + } + else if (c >= 'A' && c <= 'D' && count + 1U < MAX_DIGITS) { + digits[count++] = 0x0FU; + digits[count++] = (uint8_t)(c - 'A'); + } + } + + ulong64_t tsbkValue = 0U; + for (uint32_t i = 0U; i < MAX_DIGITS; i++) + tsbkValue = (tsbkValue << 4) + digits[i]; // Digits 1 - 10 + tsbkValue = (tsbkValue << 24) + m_dstId; // Target Radio Address + + std::unique_ptr tsbk = TSBK::fromValue(tsbkValue); + TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis); +} + +/* Returns a string that represents the current TSBK. */ + +std::string IOSP_TELE_INT_ANS::toString(bool isp) +{ + return (isp) ? std::string("TSBKO, IOSP_TELE_INT_ANS (Telephone Interconnect Answer Response)") : + std::string("TSBKO, IOSP_TELE_INT_ANS (Telephone Interconnect Answer Request)"); +} + +// --------------------------------------------------------------------------- +// Private Class Members +// --------------------------------------------------------------------------- + +/* Internal helper to copy the the class. */ + +void IOSP_TELE_INT_ANS::copy(const IOSP_TELE_INT_ANS& data) +{ + TSBK::copy(data); + + m_digits = data.m_digits; +} diff --git a/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.h b/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.h new file mode 100644 index 00000000..57a4a8dd --- /dev/null +++ b/src/common/p25/lc/tsbk/IOSP_TELE_INT_ANS.h @@ -0,0 +1,82 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +/** + * @file IOSP_TELE_INT_ANS.h + * @ingroup p25_tsbk + * @file IOSP_TELE_INT_ANS.cpp + * @ingroup p25_tsbk + */ +#if !defined(__P25_LC_TSBK__IOSP_TELE_INT_ANS_H__) +#define __P25_LC_TSBK__IOSP_TELE_INT_ANS_H__ + +#include "common/Defines.h" +#include "common/p25/lc/TSBK.h" + +namespace p25 +{ + namespace lc + { + namespace tsbk + { + // --------------------------------------------------------------------------- + // Class Declaration + // --------------------------------------------------------------------------- + + /** + * @brief Implements TELE INT ANS RSP - Telephone Interconnect Answer Response (ISP) and + * TELE INT ANS REQ - Telephone Interconnect Answer Request (OSP) + * @ingroup p25_tsbk + */ + class DVM_COMMON_API IOSP_TELE_INT_ANS : public TSBK { + public: + /** + * @brief Maximum number of digits carried by the OSP. + */ + static const uint32_t MAX_DIGITS = 10U; + + /** + * @brief Initializes a new instance of the IOSP_TELE_INT_ANS class. + */ + IOSP_TELE_INT_ANS(); + + /** + * @brief Decode a trunking signalling block. + * @param[in] data Buffer containing a TSBK to decode. + * @param rawTSBK Flag indicating whether or not the passed buffer is raw. + * @returns bool True, if TSBK decoded, otherwise false. + */ + bool decode(const uint8_t* data, bool rawTSBK = false) override; + /** + * @brief Encode a trunking signalling block. + * @param[out] data Buffer to encode a TSBK. + * @param rawTSBK Flag indicating whether or not the output buffer is raw. + * @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded. + */ + void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override; + + /** + * @brief Returns a string that represents the current TSBK. + * @returns std::string String representation of the TSBK. + */ + std::string toString(bool isp = false) override; + + public: + /** + * @brief Telephone digits presented to the called unit (OSP only); 0-9, '*', '#' and A-D. + */ + DECLARE_PROPERTY(std::string, digits, Digits); + + DECLARE_COPY(IOSP_TELE_INT_ANS); + }; + } // namespace tsbk + } // namespace lc +} // namespace p25 + +#endif // __P25_LC_TSBK__IOSP_TELE_INT_ANS_H__ diff --git a/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.cpp b/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.cpp new file mode 100644 index 00000000..09a34a01 --- /dev/null +++ b/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.cpp @@ -0,0 +1,93 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +#include "Defines.h" +#include "p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h" + +using namespace p25; +using namespace p25::defines; +using namespace p25::lc; +using namespace p25::lc::tsbk; + +#include + +// --------------------------------------------------------------------------- +// Public Class Members +// --------------------------------------------------------------------------- + +/* Initializes a new instance of the ISP_TELE_INT_PSTN_REQ class. */ + +ISP_TELE_INT_PSTN_REQ::ISP_TELE_INT_PSTN_REQ() : TSBK(), + m_pstnAddress(0U) +{ + m_lco = TSBKO::ISP_TELE_INT_PSTN_REQ; +} + +/* Decode a trunking signalling block. */ + +bool ISP_TELE_INT_PSTN_REQ::decode(const uint8_t* data, bool rawTSBK) +{ + assert(data != nullptr); + + uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U]; + ::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES); + + bool ret = TSBK::decode(data, tsbk, rawTSBK); + if (!ret) + return false; + + ulong64_t tsbkValue = TSBK::toValue(tsbk); + + m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag + m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag + m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority + m_pstnAddress = (uint8_t)((tsbkValue >> 24) & 0xFFU); // PSTN Address + m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source Radio Address + + return true; +} + +/* Encode a trunking signalling block. */ + +void ISP_TELE_INT_PSTN_REQ::encode(uint8_t* data, bool rawTSBK, bool noTrellis) +{ + assert(data != nullptr); + + ulong64_t tsbkValue = 0U; + + tsbkValue = + (m_emergency ? 0x80U : 0x00U) + // Emergency Flag + (m_encrypted ? 0x40U : 0x00U) + // Encrypted Flag + (m_priority & 0x07U); // Priority + tsbkValue = (tsbkValue << 32) + m_pstnAddress; // Reserved + PSTN Address + tsbkValue = (tsbkValue << 24) + m_srcId; // Source Radio Address + + std::unique_ptr tsbk = TSBK::fromValue(tsbkValue); + TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis); +} + +/* Returns a string that represents the current TSBK. */ + +std::string ISP_TELE_INT_PSTN_REQ::toString(bool isp) +{ + return std::string("TSBKO, ISP_TELE_INT_PSTN_REQ (Telephone Interconnect Request - Implicit)"); +} + +// --------------------------------------------------------------------------- +// Private Class Members +// --------------------------------------------------------------------------- + +/* Internal helper to copy the the class. */ + +void ISP_TELE_INT_PSTN_REQ::copy(const ISP_TELE_INT_PSTN_REQ& data) +{ + TSBK::copy(data); + + m_pstnAddress = data.m_pstnAddress; +} diff --git a/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h b/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h new file mode 100644 index 00000000..cdae8731 --- /dev/null +++ b/src/common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +/** + * @file ISP_TELE_INT_PSTN_REQ.h + * @ingroup p25_tsbk + * @file ISP_TELE_INT_PSTN_REQ.cpp + * @ingroup p25_tsbk + */ +#if !defined(__P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__) +#define __P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__ + +#include "common/Defines.h" +#include "common/p25/lc/TSBK.h" + +namespace p25 +{ + namespace lc + { + namespace tsbk + { + // --------------------------------------------------------------------------- + // Class Declaration + // --------------------------------------------------------------------------- + + /** + * @brief Implements TELE INT PSTN REQ - Telephone Interconnect Request - Implicit Dialing (ISP) + * @ingroup p25_tsbk + */ + class DVM_COMMON_API ISP_TELE_INT_PSTN_REQ : public TSBK { + public: + /** + * @brief Initializes a new instance of the ISP_TELE_INT_PSTN_REQ class. + */ + ISP_TELE_INT_PSTN_REQ(); + + /** + * @brief Decode a trunking signalling block. + * @param[in] data Buffer containing a TSBK to decode. + * @param rawTSBK Flag indicating whether or not the passed buffer is raw. + * @returns bool True, if TSBK decoded, otherwise false. + */ + bool decode(const uint8_t* data, bool rawTSBK = false) override; + /** + * @brief Encode a trunking signalling block. + * @param[out] data Buffer to encode a TSBK. + * @param rawTSBK Flag indicating whether or not the output buffer is raw. + * @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded. + */ + void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override; + + /** + * @brief Returns a string that represents the current TSBK. + * @returns std::string String representation of the TSBK. + */ + std::string toString(bool isp = false) override; + + public: + /** + * @brief PSTN address; an index into the preset telephone number table held by the infrastructure. + */ + DECLARE_PROPERTY(uint8_t, pstnAddress, PSTNAddress); + + DECLARE_COPY(ISP_TELE_INT_PSTN_REQ); + }; + } // namespace tsbk + } // namespace lc +} // namespace p25 + +#endif // __P25_LC_TSBK__ISP_TELE_INT_PSTN_REQ_H__ diff --git a/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.cpp b/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.cpp new file mode 100644 index 00000000..ea549c9d --- /dev/null +++ b/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.cpp @@ -0,0 +1,103 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +#include "Defines.h" +#include "p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h" + +using namespace p25; +using namespace p25::defines; +using namespace p25::lc; +using namespace p25::lc::tsbk; + +#include + +// --------------------------------------------------------------------------- +// Public Class Members +// --------------------------------------------------------------------------- + +/* Initializes a new instance of the OSP_TELE_INT_VCH_GRANT class. */ + +OSP_TELE_INT_VCH_GRANT::OSP_TELE_INT_VCH_GRANT() : TSBK(), + m_callTimer(0U) +{ + m_lco = TSBKO::IOSP_TELE_INT_DIAL; +} + +/* Decode a trunking signalling block. */ + +bool OSP_TELE_INT_VCH_GRANT::decode(const uint8_t* data, bool rawTSBK) +{ + assert(data != nullptr); + + uint8_t tsbk[P25_TSBK_LENGTH_BYTES + 1U]; + ::memset(tsbk, 0x00U, P25_TSBK_LENGTH_BYTES); + + bool ret = TSBK::decode(data, tsbk, rawTSBK); + if (!ret) + return false; + + ulong64_t tsbkValue = TSBK::toValue(tsbk); + + m_emergency = (((tsbkValue >> 56) & 0xFFU) & 0x80U) == 0x80U; // Emergency Flag + m_encrypted = (((tsbkValue >> 56) & 0xFFU) & 0x40U) == 0x40U; // Encryption Flag + m_priority = (((tsbkValue >> 56) & 0xFFU) & 0x07U); // Priority + m_grpVchId = ((tsbkValue >> 52) & 0x0FU); // Channel ID + m_grpVchNo = ((tsbkValue >> 40) & 0xFFFU); // Channel Number + m_callTimer = (uint16_t)((tsbkValue >> 24) & 0xFFFFU); // Call Timer + m_srcId = (uint32_t)(tsbkValue & 0xFFFFFFU); // Source/Target Radio Address + m_dstId = m_srcId; + + return true; +} + +/* Encode a trunking signalling block. */ + +void OSP_TELE_INT_VCH_GRANT::encode(uint8_t* data, bool rawTSBK, bool noTrellis) +{ + assert(data != nullptr); + + ulong64_t tsbkValue = 0U; + + tsbkValue = + (m_emergency ? 0x80U : 0x00U) + // Emergency Flag + (m_encrypted ? 0x40U : 0x00U) + // Encrypted Flag + (m_priority & 0x07U); // Priority + if (m_grpVchId != 0U) { + tsbkValue = (tsbkValue << 4) + m_grpVchId; // Channel ID + } + else { + tsbkValue = (tsbkValue << 4) + s_siteData.channelId(); // Channel ID + } + tsbkValue = (tsbkValue << 12) + m_grpVchNo; // Channel Number + tsbkValue = (tsbkValue << 16) + m_callTimer; // Call Timer + tsbkValue = (tsbkValue << 24) + m_srcId; // Source/Target Radio Address + + std::unique_ptr tsbk = TSBK::fromValue(tsbkValue); + TSBK::encode(data, tsbk.get(), rawTSBK, noTrellis); +} + +/* Returns a string that represents the current TSBK. */ + +std::string OSP_TELE_INT_VCH_GRANT::toString(bool isp) +{ + return std::string("TSBKO, OSP_TELE_INT_VCH_GRANT (Telephone Interconnect Voice Channel Grant)"); +} + +// --------------------------------------------------------------------------- +// Private Class Members +// --------------------------------------------------------------------------- + +/* Internal helper to copy the the class. */ + +void OSP_TELE_INT_VCH_GRANT::copy(const OSP_TELE_INT_VCH_GRANT& data) +{ + TSBK::copy(data); + + m_callTimer = data.m_callTimer; +} diff --git a/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h b/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h new file mode 100644 index 00000000..8e54ce85 --- /dev/null +++ b/src/common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h @@ -0,0 +1,76 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Common Library + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +/** + * @file OSP_TELE_INT_VCH_GRANT.h + * @ingroup p25_tsbk + * @file OSP_TELE_INT_VCH_GRANT.cpp + * @ingroup p25_tsbk + */ +#if !defined(__P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__) +#define __P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__ + +#include "common/Defines.h" +#include "common/p25/lc/TSBK.h" + +namespace p25 +{ + namespace lc + { + namespace tsbk + { + // --------------------------------------------------------------------------- + // Class Declaration + // --------------------------------------------------------------------------- + + /** + * @brief Implements TELE INT VCH GRANT - Telephone Interconnect Voice Channel Grant (OSP) + * @ingroup p25_tsbk + */ + class DVM_COMMON_API OSP_TELE_INT_VCH_GRANT : public TSBK { + public: + /** + * @brief Initializes a new instance of the OSP_TELE_INT_VCH_GRANT class. + */ + OSP_TELE_INT_VCH_GRANT(); + + /** + * @brief Decode a trunking signalling block. + * @param[in] data Buffer containing a TSBK to decode. + * @param rawTSBK Flag indicating whether or not the passed buffer is raw. + * @returns bool True, if TSBK decoded, otherwise false. + */ + bool decode(const uint8_t* data, bool rawTSBK = false) override; + /** + * @brief Encode a trunking signalling block. + * @param[out] data Buffer to encode a TSBK. + * @param rawTSBK Flag indicating whether or not the output buffer is raw. + * @param noTrellis Flag indicating whether or not the encoded data should be Trellis encoded. + */ + void encode(uint8_t* data, bool rawTSBK = false, bool noTrellis = false) override; + + /** + * @brief Returns a string that represents the current TSBK. + * @returns std::string String representation of the TSBK. + */ + std::string toString(bool isp = false) override; + + public: + /** + * @brief Call timer, in 100ms units (0 = no timer). + */ + DECLARE_PROPERTY(uint16_t, callTimer, CallTimer); + + DECLARE_COPY(OSP_TELE_INT_VCH_GRANT); + }; + } // namespace tsbk + } // namespace lc +} // namespace p25 + +#endif // __P25_LC_TSBK__OSP_TELE_INT_VCH_GRANT_H__ diff --git a/src/common/p25/lc/tsbk/TSBKFactory.cpp b/src/common/p25/lc/tsbk/TSBKFactory.cpp index 200f9446..e19ba5e3 100644 --- a/src/common/p25/lc/tsbk/TSBKFactory.cpp +++ b/src/common/p25/lc/tsbk/TSBKFactory.cpp @@ -175,6 +175,12 @@ std::unique_ptr TSBKFactory::createTSBK(const uint8_t* data, bool rawTSBK) return decode(new OSP_UU_VCH_GRANT_UPD(), data, rawTSBK); case TSBKO::IOSP_UU_ANS: return decode(new IOSP_UU_ANS(), data, rawTSBK); + case TSBKO::IOSP_TELE_INT_DIAL: + return decode(new OSP_TELE_INT_VCH_GRANT(), data, rawTSBK); + case TSBKO::ISP_TELE_INT_PSTN_REQ: + return decode(new ISP_TELE_INT_PSTN_REQ(), data, rawTSBK); + case TSBKO::IOSP_TELE_INT_ANS: + return decode(new IOSP_TELE_INT_ANS(), data, rawTSBK); case TSBKO::ISP_SNDCP_CH_REQ: return decode(new ISP_SNDCP_CH_REQ(), data, rawTSBK); case TSBKO::ISP_SNDCP_REC_REQ: diff --git a/src/common/p25/lc/tsbk/TSBKFactory.h b/src/common/p25/lc/tsbk/TSBKFactory.h index 5614a357..24ec0d9c 100644 --- a/src/common/p25/lc/tsbk/TSBKFactory.h +++ b/src/common/p25/lc/tsbk/TSBKFactory.h @@ -38,6 +38,7 @@ #include "common/p25/lc/tsbk/IOSP_MSG_UPDT.h" #include "common/p25/lc/tsbk/IOSP_RAD_MON.h" #include "common/p25/lc/tsbk/IOSP_STS_UPDT.h" +#include "common/p25/lc/tsbk/IOSP_TELE_INT_ANS.h" #include "common/p25/lc/tsbk/IOSP_U_REG.h" #include "common/p25/lc/tsbk/IOSP_UU_ANS.h" #include "common/p25/lc/tsbk/IOSP_UU_VCH.h" @@ -50,6 +51,7 @@ #include "common/p25/lc/tsbk/ISP_LOC_REG_REQ.h" #include "common/p25/lc/tsbk/ISP_SNDCP_CH_REQ.h" #include "common/p25/lc/tsbk/ISP_SNDCP_REC_REQ.h" +#include "common/p25/lc/tsbk/ISP_TELE_INT_PSTN_REQ.h" #include "common/p25/lc/tsbk/ISP_U_DEREG_REQ.h" #include "common/p25/lc/tsbk/OSP_ADJ_STS_BCAST.h" #include "common/p25/lc/tsbk/OSP_AUTH_FNE_RESP.h" @@ -75,6 +77,7 @@ #include "common/p25/lc/tsbk/OSP_SNDCP_CH_GNT.h" #include "common/p25/lc/tsbk/OSP_SYNC_BCAST.h" #include "common/p25/lc/tsbk/OSP_SYS_SRV_BCAST.h" +#include "common/p25/lc/tsbk/OSP_TELE_INT_VCH_GRANT.h" #include "common/p25/lc/tsbk/OSP_TIME_DATE_ANN.h" #include "common/p25/lc/tsbk/OSP_TSBK_RAW.h" #include "common/p25/lc/tsbk/OSP_U_DEREG_ACK.h" diff --git a/tests/p25/TSBK_TeleInt_Tests.cpp b/tests/p25/TSBK_TeleInt_Tests.cpp new file mode 100644 index 00000000..62ac9a1e --- /dev/null +++ b/tests/p25/TSBK_TeleInt_Tests.cpp @@ -0,0 +1,151 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Digital Voice Modem - Test Suite + * GPLv2 Open Source. Use is subject to license terms. + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright (C) 2026 Charles Bricker, K3NOP + * + */ +#include "host/Defines.h" +#include "common/p25/lc/tsbk/TSBKFactory.h" +#include "common/p25/P25Defines.h" +#include "common/edac/CRC.h" + +using namespace p25; +using namespace p25::defines; +using namespace p25::lc; +using namespace p25::lc::tsbk; + +#include + +TEST_CASE("TSBK Telephone Interconnect", "[p25][tsbk]") { + SECTION("OSP_TELE_INT_VCH_GRANT_Layout") { + OSP_TELE_INT_VCH_GRANT osp; + osp.setPriority(4U); + osp.setGrpVchId(1U); + osp.setGrpVchNo(0x123U); + osp.setCallTimer(600U); + osp.setSrcId(0x123456U); + + uint8_t raw[P25_TSBK_LENGTH_BYTES]; + osp.encode(raw, true, true); + + REQUIRE((raw[0U] & 0x3FU) == TSBKO::IOSP_TELE_INT_DIAL); + REQUIRE(raw[2U] == 0x04U); // Service Options + REQUIRE(raw[3U] == 0x11U); // Channel ID + Channel Number (MSB) + REQUIRE(raw[4U] == 0x23U); // Channel Number (LSB) + REQUIRE(raw[5U] == 0x02U); // Call Timer (MSB) + REQUIRE(raw[6U] == 0x58U); // Call Timer (LSB) + REQUIRE(raw[7U] == 0x12U); // Address + REQUIRE(raw[8U] == 0x34U); + REQUIRE(raw[9U] == 0x56U); + + std::unique_ptr tsbk = TSBKFactory::createTSBK(raw, true); + REQUIRE(tsbk != nullptr); + + OSP_TELE_INT_VCH_GRANT* decoded = dynamic_cast(tsbk.get()); + REQUIRE(decoded != nullptr); + REQUIRE(decoded->getPriority() == 4U); + REQUIRE(decoded->getGrpVchId() == 1U); + REQUIRE(decoded->getGrpVchNo() == 0x123U); + REQUIRE(decoded->getCallTimer() == 600U); + REQUIRE(decoded->getSrcId() == 0x123456U); + REQUIRE(decoded->getDstId() == 0x123456U); + } + + SECTION("ISP_TELE_INT_PSTN_REQ_Layout") { + ISP_TELE_INT_PSTN_REQ isp; + isp.setEmergency(true); + isp.setPSTNAddress(0x07U); + isp.setSrcId(0x00ABCDU); + + uint8_t raw[P25_TSBK_LENGTH_BYTES]; + isp.encode(raw, true, true); + + REQUIRE((raw[0U] & 0x3FU) == TSBKO::ISP_TELE_INT_PSTN_REQ); + REQUIRE(raw[2U] == 0x80U); // Service Options + REQUIRE(raw[3U] == 0x00U); // Reserved + REQUIRE(raw[4U] == 0x00U); + REQUIRE(raw[5U] == 0x00U); + REQUIRE(raw[6U] == 0x07U); // PSTN Address + REQUIRE(raw[7U] == 0x00U); // Source Address + REQUIRE(raw[8U] == 0xABU); + REQUIRE(raw[9U] == 0xCDU); + + std::unique_ptr tsbk = TSBKFactory::createTSBK(raw, true); + REQUIRE(tsbk != nullptr); + + ISP_TELE_INT_PSTN_REQ* decoded = dynamic_cast(tsbk.get()); + REQUIRE(decoded != nullptr); + REQUIRE(decoded->getEmergency() == true); + REQUIRE(decoded->getPSTNAddress() == 0x07U); + REQUIRE(decoded->getSrcId() == 0x00ABCDU); + } + + SECTION("IOSP_TELE_INT_ANS_Request_Layout") { + IOSP_TELE_INT_ANS osp; + osp.setDigits("5551234"); + osp.setDstId(0x000064U); + + uint8_t raw[P25_TSBK_LENGTH_BYTES]; + osp.encode(raw, true, true); + + REQUIRE((raw[0U] & 0x3FU) == TSBKO::IOSP_TELE_INT_ANS); + REQUIRE(raw[2U] == 0x55U); // Digits 1 - 2 + REQUIRE(raw[3U] == 0x51U); // Digits 3 - 4 + REQUIRE(raw[4U] == 0x23U); // Digits 5 - 6 + REQUIRE(raw[5U] == 0x4FU); // Digit 7 + Null Filler + REQUIRE(raw[6U] == 0xFFU); // Null Filler + REQUIRE(raw[7U] == 0x00U); // Target Address + REQUIRE(raw[8U] == 0x00U); + REQUIRE(raw[9U] == 0x64U); + + std::unique_ptr tsbk = TSBKFactory::createTSBK(raw, true); + REQUIRE(tsbk != nullptr); + + IOSP_TELE_INT_ANS* decoded = dynamic_cast(tsbk.get()); + REQUIRE(decoded != nullptr); + REQUIRE(decoded->getDigits() == "5551234"); + REQUIRE(decoded->getDstId() == 0x000064U); + } + + SECTION("IOSP_TELE_INT_ANS_Request_ExtendedDigits") { + IOSP_TELE_INT_ANS osp; + osp.setDigits("12A*#"); + osp.setDstId(0x000001U); + + uint8_t raw[P25_TSBK_LENGTH_BYTES]; + osp.encode(raw, true, true); + + REQUIRE(raw[2U] == 0x12U); // 1, 2 + REQUIRE(raw[3U] == 0xF0U); // ESC, A + REQUIRE(raw[4U] == 0xABU); // *, # + + IOSP_TELE_INT_ANS decoded; + REQUIRE(decoded.decode(raw, true) == true); + REQUIRE(decoded.getDigits() == "12A*#"); + } + + SECTION("IOSP_TELE_INT_ANS_Response_Decode") { + uint8_t raw[P25_TSBK_LENGTH_BYTES]; + ::memset(raw, 0x00U, P25_TSBK_LENGTH_BYTES); + + raw[0U] = 0x80U | TSBKO::IOSP_TELE_INT_ANS; // Last Block + LCO + raw[1U] = MFG_STANDARD; + raw[2U] = 0x00U; // Service Options + raw[3U] = ResponseCode::ANS_PROCEED; // Answer Response + raw[7U] = 0x00U; // Source Address + raw[8U] = 0x12U; + raw[9U] = 0x34U; + edac::CRC::addCCITT162(raw, P25_TSBK_LENGTH_BYTES); + + std::unique_ptr tsbk = TSBKFactory::createTSBK(raw, true); + REQUIRE(tsbk != nullptr); + + IOSP_TELE_INT_ANS* decoded = dynamic_cast(tsbk.get()); + REQUIRE(decoded != nullptr); + REQUIRE(decoded->getResponse() == ResponseCode::ANS_PROCEED); + REQUIRE(decoded->getSrcId() == 0x001234U); + } +}