Begin handling Icom format network frames. Work in progress.

MMDVMHost.cpp

@@ -1173,7 +1173,7 @@ bool CMMDVMHost::createNXDNNetwork()
 	LogInfo("    Gateway Port: %u", gatewayPort);
 	LogInfo("    Mode Hang: %us", m_nxdnNetModeHang);
 
-	m_nxdnNetwork = new CNXDNNetwork(myAddress, myPort, gatewayAddress, gatewayPort, m_callsign, debug);
+	m_nxdnNetwork = new CNXDNNetwork(myAddress, myPort, gatewayAddress, gatewayPort, debug);
 
 	bool ret = m_nxdnNetwork->open();
 	if (!ret) {

NXDNControl.cpp

@@ -60,12 +60,9 @@ m_netFrames(0U),
 m_netLost(0U),
 m_rfErrs(0U),
 m_rfBits(1U),
-m_netErrs(0U),
-m_netBits(1U),
 m_rfLastLICH(),
 m_rfLayer3(),
 m_rfMask(0x00U),
-m_netN(0U),
 m_rssiMapper(rssiMapper),
 m_rssi(0U),
 m_maxRSSI(0U),
@@ -232,7 +229,8 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
 
 		scrambler(data + 2U);
 
-		writeNetwork(data, false);
+		// XXX This is wrong
+		writeNetwork(data, true);
 
 #if defined(DUMP_NXDN)
 		writeFile(data + 2U);
@@ -404,7 +402,8 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
 
 			scrambler(start + 2U);
 
-			writeNetwork(start, false);
+			// XXX This is wrong
+			writeNetwork(start, true);
 
 #if defined(DUMP_NXDN)
 			writeFile(start + 2U);
@@ -491,6 +490,7 @@ bool CNXDNControl::processVoice(unsigned char usc, unsigned char option, unsigne
 
 		scrambler(data + 2U);
 
+		// XXX This is wrong
 		writeNetwork(data, false);
 
 #if defined(DUMP_NXDN)
@@ -586,6 +586,7 @@ bool CNXDNControl::processData(unsigned char option, unsigned char *data)
 
 	scrambler(data + 2U);
 
+	// XXX This is wrong
 	writeNetwork(data, true);
 
 	if (m_duplex)
@@ -657,80 +658,123 @@ void CNXDNControl::writeEndNet()
 
 void CNXDNControl::writeNetwork()
 {
-	unsigned short srcId = 0U;
+	unsigned char netData[40U];
-	unsigned short dstId = 0U;
+	bool exists = m_network->read(netData);
-	unsigned char count = 0U;
+	if (!exists)
-	bool grp = false;
-	bool dat = false;
-	bool end = false;
-	unsigned char data[200U];
-	unsigned int length = m_network->read(data + 2U, srcId, grp, dstId, dat, count, end);
-	if (length == 0U)
 		return;
 
 	if (m_rfState != RS_RF_LISTENING && m_netState == RS_NET_IDLE)
 		return;
 
-	if (end && m_netState == RS_NET_IDLE)
-		return;
-
 	m_networkWatchdog.start();
 
-	scrambler(data + 2U);
+	unsigned char data[NXDN_FRAME_LENGTH_BYTES + 2U];
 
-	if (dat) {
+	CSync::addNXDNSync(data + 2U);
-		CNXDNUDCH udch;
-		bool valid = udch.decode(data + 2U);
-		if (valid) {
-			if (m_netState == RS_NET_IDLE) {
-				unsigned char buffer[23U];
-				udch.getData(buffer);
 
-				CNXDNLayer3 layer3;
+	CNXDNLICH lich;
-				layer3.decode(buffer, 184U);
+	lich.setData(netData[0U]);
+	unsigned char usc    = lich.getFCT();
+	unsigned char option = lich.getOption();
+	lich.setDirection(m_remoteGateway ? NXDN_LICH_DIRECTION_INBOUND : NXDN_LICH_DIRECTION_OUTBOUND);
+	lich.encode(data + 2U);
 
-				unsigned char type = layer3.getMessageType();
+	if (usc == NXDN_LICH_USC_UDCH) {
-				if (type == NXDN_MESSAGE_TYPE_DCALL_HDR) {
+		CNXDNLayer3 layer3;
-					unsigned short srcId = layer3.getSourceUnitId();
+		layer3.setData(netData + 2U, 23U);
-					unsigned short dstId = layer3.getDestinationGroupId();
+		unsigned char type = layer3.getMessageType();
-					bool grp = layer3.getIsGroup();
 
-					unsigned char frames = layer3.getDataBlocks();
+		if (m_netState == RS_NET_IDLE) {
+			if (type == NXDN_MESSAGE_TYPE_DCALL_HDR) {
+				unsigned short srcId = layer3.getSourceUnitId();
+				unsigned short dstId = layer3.getDestinationGroupId();
+				bool grp = layer3.getIsGroup();
 
-					std::string source = m_lookup->find(srcId);
+				unsigned char frames = layer3.getDataBlocks();
 
-					m_display->writeNXDN(source.c_str(), grp, dstId, "N");
+				std::string source = m_lookup->find(srcId);
+				m_display->writeNXDN(source.c_str(), grp, dstId, "N");
+				LogMessage("NXDN, received network data header from %s to %s%u, %u blocks", source.c_str(), grp ? "TG " : "", dstId, frames);
 
-					LogMessage("NXDN, received network data header from %s to %s%u, %u blocks", source.c_str(), grp ? "TG " : "", dstId, frames);
+				m_netState = RS_NET_DATA;
-
+			} else {
-					m_netState = RS_NET_DATA;
+				return;
-				}
-			}
-
-			if (m_netState == RS_NET_DATA) {
-				data[0U] = end ? TAG_EOT : TAG_DATA;
-				data[1U] = 0x00U;
-
-				CSync::addNXDNSync(data + 2U);
-
-				CNXDNLICH lich;
-				lich.decode(data + 2U);
-				lich.encode(data + 2U);
-
-				udch.setRAN(m_ran);
-				udch.encode(data + 2U);
-
-				scrambler(data + 2U);
-
-				writeQueueNet(data);
-
-				if (end) {
-					LogMessage("NXDN, ended network data transmission");
-					writeEndNet();
-				}
 			}
 		}
-	} else {
+
+		if (m_netState == RS_NET_DATA) {
+			data[0U] = type == NXDN_MESSAGE_TYPE_TX_REL ? TAG_EOT : TAG_DATA;
+			data[1U] = 0x00U;
+
+			CNXDNUDCH udch;
+			udch.setRAN(m_ran);
+			udch.setData(netData + 2U);
+			udch.encode(data + 2U);
+
+			scrambler(data + 2U);
+
+			writeQueueNet(data);
+
+			if (type == NXDN_MESSAGE_TYPE_TX_REL) {
+				LogMessage("NXDN, ended network data transmission");
+				writeEndNet();
+			}
+		}
+	} else if (usc == NXDN_LICH_USC_SACCH_NS) {
+		CNXDNLayer3 layer3;
+		layer3.setData(netData + 5U, 10U);
+
+		unsigned char type = layer3.getMessageType();
+		if (type == NXDN_MESSAGE_TYPE_TX_REL && m_netState == RS_RF_LISTENING)
+			return;
+		if (type == NXDN_MESSAGE_TYPE_VCALL && m_netState != RS_RF_LISTENING)
+			return;
+
+		CNXDNSACCH sacch;
+		sacch.setRAN(m_ran);
+		sacch.setStructure(NXDN_SR_SINGLE);
+		sacch.setData(SACCH_IDLE);
+		sacch.encode(data + 2U);
+
+		unsigned char message[22U];
+		m_rfLayer3.getData(message);
+
+		CNXDNFACCH1 facch;
+		facch.setData(message);
+		facch.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
+		facch.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
+
+		data[0U] = type == NXDN_MESSAGE_TYPE_TX_REL ? TAG_EOT : TAG_DATA;
+		data[1U] = 0x00U;
+
+		scrambler(data + 2U);
+
+		writeQueueNet(data);
+
+		if (type == NXDN_MESSAGE_TYPE_TX_REL) {
+			m_netFrames++;
+			LogMessage("NXDN, received network end of transmission, %.1f seconds, %u%% packet loss", float(m_netFrames) / 12.5F, (m_netLost * 100U) / m_netFrames);
+			writeEndNet();
+		} else if (type == NXDN_MESSAGE_TYPE_VCALL) {
+			unsigned short srcId = layer3.getSourceUnitId();
+			unsigned short dstId = layer3.getDestinationGroupId();
+			bool grp             = layer3.getIsGroup();
+
+			std::string source = m_lookup->find(srcId);
+			LogMessage("NXDN, received network transmission from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId);
+			m_display->writeNXDN(source.c_str(), grp, dstId, "N");
+
+			m_netTimeoutTimer.start();
+			m_packetTimer.start();
+			m_elapsed.start();
+			m_netState  = RS_NET_AUDIO;
+			m_netFrames = 1U;
+			m_netLost   = 0U;
+		} else {
+			m_netFrames++;
+			CUtils::dump(2U, "NXDN, interesting non superblock network frame", netData, 33U);
+		}
+	} else if (m_netState == RS_NET_IDLE) {
 		if (m_netState == RS_NET_IDLE) {
 			std::string source = m_lookup->find(srcId);
 			LogMessage("NXDN, received network transmission from %s to %s%u", source.c_str(), grp ? "TG " : "", dstId);
@@ -742,39 +786,25 @@ void CNXDNControl::writeNetwork()
 			m_netState  = RS_NET_AUDIO;
 			m_netFrames = 0U;
 			m_netLost   = 0U;
-			m_netErrs   = 0U;
-			m_netBits   = 1U;
-			m_netN      = 0U;
 		}
-
+	} else {
 		m_netFrames++;
 
-		data[0U] = end ? TAG_EOT : TAG_DATA;
+		data[0U] = TAG_DATA;
 		data[1U] = 0x00U;
 
-		CSync::addNXDNSync(data + 2U);
-
-		CNXDNLICH lich;
-		lich.decode(data + 2U);
-		lich.encode(data + 2U);
-		unsigned char option = lich.getOption();
-
 		CNXDNSACCH sacch;
-		bool valid = sacch.decode(data + 2U);
+		sacch.setData(netData + 1U);
-		if (valid) {
+		sacch.setRAN(m_ran);
-			sacch.setRAN(m_ran);
+		sacch.encode(data + 2U);
-			sacch.encode(data + 2U);
-		}
 
+		// XXX this is wrong
 		if (option == NXDN_LICH_STEAL_NONE) {
 			CAMBEFEC ambe;
-			unsigned int errors = 0U;
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
-			m_netErrs += errors;
-			m_netBits += 188U;
 		} else if (option == NXDN_LICH_STEAL_FACCH1_1) {
 			CNXDNFACCH1 facch1;
 			bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
@@ -782,18 +812,12 @@ void CNXDNControl::writeNetwork()
 				facch1.encode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS);
 
 			CAMBEFEC ambe;
-			unsigned int errors = 0U;
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 18U);
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 27U);
-			m_netErrs += errors;
-			m_netBits += 94U;
 		} else if (option == NXDN_LICH_STEAL_FACCH1_2) {
 			CAMBEFEC ambe;
-			unsigned int errors = 0U;
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES);
+			ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
-			errors += ambe.regenerateYSFDN(data + 2U + NXDN_FSW_LICH_SACCH_LENGTH_BYTES + 9U);
-			m_netErrs += errors;
-			m_netBits += 94U;
 
 			CNXDNFACCH1 facch1;
 			bool valid = facch1.decode(data + 2U, NXDN_FSW_LENGTH_BITS + NXDN_LICH_LENGTH_BITS + NXDN_SACCH_LENGTH_BITS + NXDN_FACCH1_LENGTH_BITS);
@@ -814,11 +838,6 @@ void CNXDNControl::writeNetwork()
 		scrambler(data + 2U);
 
 		writeQueueNet(data);
-
-		if (end) {
-			LogMessage("NXDN, received network end of transmission, %.1f seconds, %u%% packet loss, BER: %.1f%%", float(m_netFrames) / 12.5F, (m_netLost * 100U) / m_netFrames, float(m_netErrs * 100U) / float(m_netBits));
-			writeEndNet();
-		}
 	}
 }
 
@@ -834,7 +853,7 @@ void CNXDNControl::clock(unsigned int ms)
 		m_networkWatchdog.clock(ms);
 
 		if (m_networkWatchdog.hasExpired()) {
-			LogMessage("NXDN, network watchdog has expired, %.1f seconds, %u%% packet loss, BER: %.1f%%", float(m_netFrames) / 12.5F, (m_netLost * 100U) / m_netFrames, float(m_netErrs * 100U) / float(m_netBits));
+			LogMessage("NXDN, network watchdog has expired, %.1f seconds, %u%% packet loss", float(m_netFrames) / 12.5F, (m_netLost * 100U) / m_netFrames);
 			writeEndNet();
 		}
 	}
@@ -883,7 +902,7 @@ void CNXDNControl::writeQueueNet(const unsigned char *data)
 	m_queue.addData(data, len);
 }
 
-void CNXDNControl::writeNetwork(const unsigned char *data, bool dat)
+void CNXDNControl::writeNetwork(const unsigned char *data, bool single)
 {
 	assert(data != NULL);
 
@@ -893,13 +912,7 @@ void CNXDNControl::writeNetwork(const unsigned char *data, bool dat)
 	if (m_rfTimeoutTimer.isRunning() && m_rfTimeoutTimer.hasExpired())
 		return;
 
-	unsigned short srcId = m_rfLayer3.getSourceUnitId();
+	m_network->write(data, single);
-	unsigned short dstId = m_rfLayer3.getDestinationGroupId();
-	bool grp             = m_rfLayer3.getIsGroup();
-
-	bool end = data[0U] == TAG_EOT;
-
-	m_network->write(data + 2U, srcId, grp, dstId, dat, m_rfFrames, end);
 }
 
 void CNXDNControl::scrambler(unsigned char* data) const

NXDNControl.h

@@ -67,12 +67,9 @@ private:
 	unsigned int               m_netLost;
 	unsigned int               m_rfErrs;
 	unsigned int               m_rfBits;
-	unsigned int               m_netErrs;
-	unsigned int               m_netBits;
 	CNXDNLICH                  m_rfLastLICH;
 	CNXDNLayer3                m_rfLayer3;
 	unsigned char              m_rfMask;
-	unsigned char              m_netN;
 	CRSSIInterpolator*         m_rssiMapper;
 	unsigned char              m_rssi;
 	unsigned char              m_maxRSSI;
@@ -86,7 +83,7 @@ private:
 
 	void writeQueueRF(const unsigned char* data);
 	void writeQueueNet(const unsigned char* data);
-	void writeNetwork(const unsigned char* data, bool dat);
+	void writeNetwork(const unsigned char* data, bool single);
 	void writeNetwork();
 
 	void scrambler(unsigned char* data) const;

NXDNLICH.cpp

@@ -107,6 +107,11 @@ unsigned char CNXDNLICH::getDirection() const
 	return (m_lich[0U] >> 1) & 0x01U;
 }
 
+unsigned char CNXDNLICH::getData() const
+{
+	return m_lich[0U];
+}
+
 void CNXDNLICH::setRFCT(unsigned char rfct)
 {
 	m_lich[0U] &= 0x3FU;
@@ -131,6 +136,11 @@ void CNXDNLICH::setDirection(unsigned char direction)
 	m_lich[0U] |= (direction << 1) & 0x02U;
 }
 
+void CNXDNLICH::setData(unsigned char lich)
+{
+	m_lich[0U] = lich;
+}
+
 CNXDNLICH& CNXDNLICH::operator=(const CNXDNLICH& lich)
 {
 	if (&lich != this)

NXDNLICH.h

@@ -33,11 +33,13 @@ public:
 	unsigned char getFCT() const;
 	unsigned char getOption() const;
 	unsigned char getDirection() const;
+	unsigned char getData() const;
 	
 	void setRFCT(unsigned char rfct);
 	void setFCT(unsigned char usc);
 	void setOption(unsigned char option);
 	void setDirection(unsigned char direction);
+	void setData(unsigned char lich);
 
 	CNXDNLICH& operator=(const CNXDNLICH& lich);
 

NXDNLayer3.cpp

@@ -97,6 +97,12 @@ void CNXDNLayer3::getData(unsigned char* data) const
 	::memcpy(data, m_data, 22U);
 }
 
+void CNXDNLayer3::setData(const unsigned char* data, unsigned int length)
+{
+	::memset(m_data, 0x00U, 22U);
+	::memcpy(m_data, data, length);
+}
+
 void CNXDNLayer3::reset()
 {
 	::memset(m_data, 0x00U, 22U);

NXDNLayer3.h

@@ -35,6 +35,7 @@ public:
 	bool           getIsGroup() const;
 	unsigned char  getDataBlocks() const;
 
+	void           setData(const unsigned char* data, unsigned int length);
 	void           getData(unsigned char* data) const;
 
 	void           reset();

NXDNNetwork.cpp

@@ -28,18 +28,14 @@
 
 const unsigned int BUFFER_LENGTH = 200U;
 
-CNXDNNetwork::CNXDNNetwork(const std::string& myAddress, unsigned int myPort, const std::string& gatewayAddress, unsigned int gatewayPort, const std::string& callsign, bool debug) :
+CNXDNNetwork::CNXDNNetwork(const std::string& myAddress, unsigned int myPort, const std::string& gatewayAddress, unsigned int gatewayPort, bool debug) :
 m_socket(myAddress, myPort),
 m_address(),
 m_port(gatewayPort),
-m_callsign(callsign),
 m_debug(debug),
 m_enabled(false),
-m_buffer(1000U, "NXDN Network"),
+m_buffer(1000U, "NXDN Network")
-m_pollTimer(1000U, 5U)
 {
-	m_callsign.resize(10U, ' ');
-
 	m_address = CUDPSocket::lookup(gatewayAddress);
 }
 
@@ -54,70 +50,39 @@ bool CNXDNNetwork::open()
 	if (m_address.s_addr == INADDR_NONE)
 		return false;
 
-	m_pollTimer.start();
-
 	return m_socket.open();
 }
 
-bool CNXDNNetwork::write(const unsigned char* data, unsigned short src, bool grp, unsigned short dst, bool dat, unsigned char cnt, bool end)
+bool CNXDNNetwork::write(const unsigned char* data, bool single)
 {
 	assert(data != NULL);
 
-	unsigned char buffer[100U];
+	unsigned char buffer[110U];
+	::memset(buffer, 0x00U, 110U);
 
-	buffer[0U] = 'N';
+	buffer[0U] = 'I';
-	buffer[1U] = 'X';
+	buffer[1U] = 'C';
-	buffer[2U] = 'D';
+	buffer[2U] = 'O';
-	buffer[3U] = 'N';
+	buffer[3U] = 'M';
-	buffer[4U] = 'D';
+	buffer[4U] = 0x01U;
+	buffer[5U] = 0x01U;
+	buffer[6U] = 0x08U;
+	buffer[7U] = 0xE0U;
 
-	buffer[5U] = (src >> 8) & 0xFFU;
+	buffer[37U] = 0x23U;
-	buffer[6U] = (src >> 0) & 0xFFU;
+	buffer[38U] = single ? 0x1CU : 0x10U;
+	buffer[39U] = 0x21U;
 
-	buffer[7U]  = grp ? 0x01U : 0x00U;
+	::memcpy(buffer + 40U, data, 33U);
-	buffer[7U] |= dat ? 0x02U : 0x00U;
-	buffer[7U] |= end ? 0x04U : 0x00U;
-
-	buffer[8U] = (dst >> 8) & 0xFFU;
-	buffer[9U] = (dst >> 0) & 0xFFU;
-
-	buffer[10U] = cnt;
-
-	::memcpy(buffer + 11U, data, NXDN_FRAME_LENGTH_BYTES);
 
 	if (m_debug)
-		CUtils::dump(1U, "NXDN Network Data Sent", buffer, 59U);
+		CUtils::dump(1U, "NXDN Network Data Sent", buffer, 102U);
 
-	return m_socket.write(buffer, 59U, m_address, m_port);
+	return m_socket.write(buffer, 102U, m_address, m_port);
-}
-
-bool CNXDNNetwork::writePoll()
-{
-	unsigned char buffer[20U];
-
-	buffer[0U] = 'N';
-	buffer[1U] = 'X';
-	buffer[2U] = 'D';
-	buffer[3U] = 'N';
-	buffer[4U] = 'P';
-
-	for (unsigned int i = 0U; i < 10U; i++)
-		buffer[5U + i] = m_callsign.at(i);
-
-	if (m_debug)
-		CUtils::dump(1U, "NXDN Network Poll Sent", buffer, 15U);
-
-	return m_socket.write(buffer, 15U, m_address, m_port);
 }
 
 void CNXDNNetwork::clock(unsigned int ms)
 {
-	m_pollTimer.clock(ms);
-	if (m_pollTimer.hasExpired()) {
-		writePoll();
-		m_pollTimer.start();
-	}
-
 	unsigned char buffer[BUFFER_LENGTH];
 
 	in_addr address;
@@ -132,12 +97,11 @@ void CNXDNNetwork::clock(unsigned int ms)
 		return;
 	}
 
-	// Ignore incoming polls
+	// Invalid packet type?
-	if (::memcmp(buffer, "NXDNP", 5U) == 0)
+	if (::memcmp(buffer, "ICOM", 4U) != 0)
 		return;
 
-	// Invalid packet type?
+	if (length != 102)
-	if (::memcmp(buffer, "NXDND", 5U) != 0)
 		return;
 
 	if (!m_enabled)
@@ -146,30 +110,19 @@ void CNXDNNetwork::clock(unsigned int ms)
 	if (m_debug)
 		CUtils::dump(1U, "NXDN Network Data Received", buffer, length);
 
-	m_buffer.addData(buffer, 59U);
+	m_buffer.addData(buffer + 40U, 33U);
 }
 
-unsigned int CNXDNNetwork::read(unsigned char* data, unsigned short& src, bool& grp, unsigned short& dst, bool& dat, unsigned char& cnt, bool& end)
+bool CNXDNNetwork::read(unsigned char* data)
 {
 	assert(data != NULL);
 
 	if (m_buffer.isEmpty())
-		return 0U;
+		return false;
 
-	unsigned char buffer[100U];
+	m_buffer.getData(data, 33U);
-	m_buffer.getData(buffer, 59U);
 
-	src = (buffer[5U] << 8) + buffer[6U];
+	return true;
-	grp = (buffer[7U] & 0x01U) == 0x01U;
-	dat = (buffer[7U] & 0x02U) == 0x02U;
-	end = (buffer[7U] & 0x04U) == 0x04U;
-	dst = (buffer[8U] << 8) + buffer[9U];
-
-	cnt = buffer[10U];
-
-	::memcpy(data, buffer + 11U, NXDN_FRAME_LENGTH_BYTES);
-
-	return NXDN_FRAME_LENGTH_BYTES;
 }
 
 void CNXDNNetwork::reset()

NXDNNetwork.h

@@ -29,16 +29,16 @@
 
 class CNXDNNetwork {
 public:
-	CNXDNNetwork(const std::string& myAddress, unsigned int myPort, const std::string& gatewayAddress, unsigned int gatewayPort, const std::string& callsign, bool debug);
+	CNXDNNetwork(const std::string& myAddress, unsigned int myPort, const std::string& gatewayAddress, unsigned int gatewayPort, bool debug);
 	~CNXDNNetwork();
 
 	bool open();
 
 	void enable(bool enabled);
 
-	bool write(const unsigned char* data, unsigned short src, bool grp, unsigned short dst, bool dat, unsigned char cnt, bool end);
+	bool write(const unsigned char* data, bool single);
 
-	unsigned int read(unsigned char* data, unsigned short& src, bool& grp, unsigned short& dst, bool& dat, unsigned char& cnt, bool& end);
+	bool read(unsigned char* data);
 
 	void reset();
 
@@ -50,13 +50,9 @@ private:
 	CUDPSocket     m_socket;
 	in_addr        m_address;
 	unsigned int   m_port;
-	std::string    m_callsign;
 	bool           m_debug;
 	bool           m_enabled;
 	CRingBuffer<unsigned char> m_buffer;
-	CTimer         m_pollTimer;
-
-	bool writePoll();
 };
 
 #endif