add support to send raw CSBK or TSBKs from the network;

src/dmr/Control.cpp

@@ -692,6 +692,8 @@ void Control::processNetwork()
 
     data::Data data;
 
+    uint8_t frameMessageType = buffer[14U];
+
     // process network message header
     uint8_t seqNo = buffer[4U];
 
@@ -723,6 +725,25 @@ void Control::processNetwork()
         return;
     }
 
+    // is this a control frame? (i.e. does the network frame contain raw TSBK data)
+    if (frameMessageType == network::NET_DATATYPE_CONTROL) {
+        UInt8Array data = std::unique_ptr<uint8_t[]>(new uint8_t[length]);
+        ::memset(data.get(), 0x00U, length);
+        ::memcpy(data.get(), buffer.get() + 20U, length);
+
+        // forward onto the specific slot for final processing and delivery
+        switch (slotNo) {
+            case 1U:
+                m_slot1->control()->writeRF_CSBK_Raw(data.get());
+                break;
+            case 2U:
+                m_slot2->control()->writeRF_CSBK_Raw(data.get());
+                break;
+        }
+
+        return;
+    }
+
     data.setSeqNo(seqNo);
     data.setSlotNo(slotNo);
     data.setSrcId(srcId);

src/dmr/packet/ControlSignaling.cpp

@@ -652,6 +652,22 @@ void ControlSignaling::writeRF_Call_Alrt(uint32_t srcId, uint32_t dstId)
     writeRF_CSBK(csbk.get());
 }
 
+/// <summary>
+/// Helper to write a raw CSBK packet on the RF interface.
+/// </summary>
+/// <param name="data"></param>
+void ControlSignaling::writeRF_CSBK_Raw(uint8_t* data)
+{
+    std::unique_ptr<CSBK_RAW> csbk = new_unique(CSBK_RAW);
+    csbk->setCSBK(data);
+
+    if (m_verbose) {
+        LogMessage(LOG_RF, "DMR Slot %u, raw DT_CSBK, %s", m_slot->m_slotNo, csbk->toString().c_str());
+    }
+
+    writeRF_CSBK(csbk.get());
+}
+
 // ---------------------------------------------------------------------------
 //  Private Class Members
 // ---------------------------------------------------------------------------

src/dmr/packet/ControlSignaling.h

@@ -71,6 +71,8 @@ namespace dmr
             void writeRF_Ext_Func(uint32_t func, uint32_t arg, uint32_t dstId);
             /// <summary>Helper to write a call alert packet on the RF interface.</summary>
             void writeRF_Call_Alrt(uint32_t srcId, uint32_t dstId);
+            /// <summary>Helper to write a raw CSBK packet on the RF interface.</summary>
+            void writeRF_CSBK_Raw(uint8_t* data);
 
         private:
             friend class dmr::Slot;

src/network/BaseNetwork.cpp

@@ -651,6 +651,8 @@ UInt8Array BaseNetwork::createDMR_Message(uint32_t& length, const uint32_t strea
     if (slotNo == 2U && !m_slot2)
         return nullptr;
 
+    buffer[14U] = NET_DATATYPE_DATA;                                                // Frame Message Data Type
+
     buffer[15U] = slotNo == 1U ? 0x00U : 0x80U;                                     // Slot Number
 
     uint8_t flco = data.getFLCO();
@@ -706,6 +708,8 @@ void BaseNetwork::createP25_MessageHdr(uint8_t* data, uint8_t duid, const p25::l
     uint32_t dstId = control.getDstId();                                            // Target Address
     __SET_UINT16(dstId, data, 8U);
 
+    data[14U] = NET_DATATYPE_DATA;                                                  // Frame Message Data Type
+
     data[15U] = control.getMFId();                                                  // MFId
 
     data[20U] = lsd.getLSD1();                                                      // LSD 1
@@ -717,7 +721,6 @@ void BaseNetwork::createP25_MessageHdr(uint8_t* data, uint8_t duid, const p25::l
 
     // is this the first frame of a call?
     if (frameType == p25::P25_FT_HDU_VALID) {
-        data[180U] = 0x01U;                                                         // First LDU1 Marker
         data[181U] = control.getAlgId();                                            // Algorithm ID
 
         uint32_t kid = control.getKId();
@@ -988,6 +991,8 @@ UInt8Array BaseNetwork::createP25_PDUMessage(uint32_t& length, const p25::data::
 
     __SET_UINT16(len, buffer, 8U);                                                  // PDU Length [bytes]
 
+    buffer[14U] = NET_DATATYPE_DATA;                                                // Frame Message Data Type
+
     buffer[15U] = header.getMFId();                                                 // MFId
 
     buffer[20U] = header.getBlocksToFollow();                                       // Blocks To Follow
@@ -1036,6 +1041,8 @@ UInt8Array BaseNetwork::createNXDN_Message(uint32_t& length, const nxdn::lc::RTC
     uint32_t dstId = lc.getDstId();                                             // Target Address
     __SET_UINT16(dstId, buffer, 8U);
 
+    buffer[14U] = NET_DATATYPE_DATA;                                            // Frame Message Data Type
+
     buffer[15U] |= lc.getGroup() ? 0x00U : 0x40U;                               // Group
 
     // pack raw NXDN message bytes

src/network/BaseNetwork.h

@@ -118,6 +118,9 @@ namespace network
     const uint8_t   NET_TRANSFER_SUBFUNC_ACTIVITY = 0x01U;                      // Activity Log Transfer
     const uint8_t   NET_TRANSFER_SUBFUNC_DIAG = 0x02U;                          // Diagnostic Log Transfer
 
+    const uint8_t   NET_DATATYPE_DATA = 0x00U;                                  // 
+    const uint8_t   NET_DATATYPE_CONTROL = 0x01U;                               // 
+
     // ---------------------------------------------------------------------------
     //  Network Peer Connection Status
     // ---------------------------------------------------------------------------

src/nxdn/Control.cpp

@@ -891,6 +891,13 @@ void Control::processNetwork()
         return;
     }
 
+    uint8_t frameMessageType = buffer[14U];
+
+    if (frameMessageType == network::NET_DATATYPE_CONTROL) {
+        LogError(LOG_NXDN, "invalid network data type, ignored");
+        return;
+    }
+
     // process network message header
     uint8_t messageType = buffer[4U];
 

src/p25/Control.cpp

@@ -32,6 +32,7 @@
 #include "p25/P25Defines.h"
 #include "p25/Control.h"
 #include "p25/acl/AccessControl.h"
+#include "p25/lc/tsbk/TSBKFactory.h"
 #include "p25/P25Utils.h"
 #include "p25/Sync.h"
 #include "edac/CRC.h"
@@ -1047,6 +1048,8 @@ void Control::processNetwork()
         return;
     }
 
+    uint8_t frameMessageType = buffer[14U];
+
     // process network message header
     uint8_t duid = buffer[22U];
     uint8_t MFId = buffer[15U];
@@ -1099,6 +1102,24 @@ void Control::processNetwork()
         return;
     }
 
+    // is this a control frame? (i.e. does the network frame contain raw TSBK data)
+    if (frameMessageType == network::NET_DATATYPE_CONTROL) {
+        if (m_control && m_trunk != nullptr) {
+            std::unique_ptr<lc::tsbk::OSP_TSBK_RAW> osp = new_unique(lc::tsbk::OSP_TSBK_RAW);
+            osp->setTSBK(data.get());
+
+            if (m_verbose) {
+                LogMessage(LOG_NET, "P25, raw TSBK, %s", osp->toString().c_str());
+            }
+
+            m_trunk->writeRF_TSDU_SBF_Imm(osp.get(), true);
+        }
+        else {
+            LogError(LOG_P25, "refusing to transmit control data, ignored, control = %u", m_control);
+            return;
+        }
+    }
+
     // handle LDU, TDU or TSDU frame
     uint8_t lco = buffer[4U];