Initial commit.

2026-04-06 23:04:09 +00:00 · 2018-05-09 19:23:17 +01:00 · 2018-05-09 19:23:17 +01:00 · 12d55cef37
commit 12d55cef37
430 changed files with 72067 additions and 0 deletions
--- a/Common/IcomRepeaterProtocolHandler.cpp
+++ b/Common/IcomRepeaterProtocolHandler.cpp
@ -0,0 +1,650 @@
+/*
+ *   Copyright (C) 2010-2014 by Jonathan Naylor G4KLX
+ *
+ *   This program is free software; you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation; either version 2 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program; if not, write to the Free Software
+ *   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ */
+
+#include "IcomRepeaterProtocolHandler.h"
+
+#include <wx/datetime.h>
+
+#include "CCITTChecksum.h"
+#include "DStarDefines.h"
+#include "Utils.h"
+
+// Allow space for a big DD packet
+const unsigned int BUFFER_LENGTH = 2500U;
+
+const unsigned int QUEUE_LENGTH  = 50U;
+
+const unsigned int LOOP_DELAY    = 5UL;
+const unsigned int LOOP_TICKS    = 200U;
+
+CIcomRepeaterProtocolHandler::CIcomRepeaterProtocolHandler(const wxString& address, unsigned int port, const wxString& icomAddress, unsigned int icomPort) :
+wxThread(wxTHREAD_JOINABLE),
+m_socket(address, port),
+m_icomAddress(),
+m_icomPort(icomPort),
+m_over1(false),
+m_seqNo(0U),
+m_tries(0U),
+m_ackQueue(NULL),
+m_killed(false),
+m_type(RT_NONE),
+m_buffer(NULL),
+m_rptrQueue(QUEUE_LENGTH),
+m_gwyQueue(QUEUE_LENGTH),
+m_retryTimer(LOOP_TICKS, 0U, 200U)		// 200ms
+{
+	wxASSERT(!icomAddress.IsEmpty());
+	wxASSERT(!address.IsEmpty());
+	wxASSERT(icomPort > 0U);
+	wxASSERT(port > 0U);
+
+	m_icomAddress.s_addr = ::inet_addr(icomAddress.mb_str());
+
+	m_buffer = new unsigned char[BUFFER_LENGTH];
+
+	wxDateTime now = wxDateTime::UNow();
+	::srand(now.GetMillisecond());
+}
+
+CIcomRepeaterProtocolHandler::~CIcomRepeaterProtocolHandler()
+{
+	while (!m_gwyQueue.isEmpty()) {
+		CDataQueue* dq = m_gwyQueue.getData();
+		free(dq);
+	}
+
+	while (!m_rptrQueue.isEmpty()) {
+		CDataQueue* dq = m_rptrQueue.getData();
+		free(dq);
+	}
+
+	delete[] m_buffer;
+}
+
+void CIcomRepeaterProtocolHandler::setCount(unsigned int count)
+{
+	m_over1 = count > 1U;
+}
+
+bool CIcomRepeaterProtocolHandler::open()
+{
+	bool ret = m_socket.open();
+	if (!ret)
+		return false;
+
+	unsigned char buffer[10U];
+
+	buffer[0U] = 'I';
+	buffer[1U] = 'N';
+	buffer[2U] = 'I';
+	buffer[3U] = 'T';
+	buffer[4U] = 0x00;
+	buffer[5U] = 0x00;
+	buffer[6U] = 0x73;
+	buffer[7U] = 0x00;
+	buffer[8U] = 0x00;
+	buffer[9U] = 0x00;
+
+	ret = m_socket.write(buffer, 10U, m_icomAddress, m_icomPort);
+	if (!ret) {
+		m_socket.close();
+		return false;
+	}
+
+	// Wait for a reply from the RP2C
+	for (unsigned int i = 0U; i < 10U; i++) {
+		in_addr address;
+		unsigned int port;
+		int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port);
+
+		if (length == 10 && m_buffer[0U] == 'I' && m_buffer[1U] == 'N' && m_buffer[2U] == 'I' && m_buffer[3U] == 'T' && m_buffer[6U] == 0x72 && m_buffer[7U] == 0x00) {
+			m_seqNo = m_buffer[4U] * 256U + m_buffer[5U] + 1U;
+			wxLogMessage(wxT("Initial sequence number from the RP2C is %u"), m_seqNo);
+
+			// Start the thread
+			Create();
+			Run();
+
+			return true;
+		}
+
+		::wxSleep(1);
+	}
+
+	m_socket.close();
+
+	wxLogError(wxT("No reply from the RP2C for 10 seconds, aborting"));
+
+	return false;
+}
+
+void* CIcomRepeaterProtocolHandler::Entry()
+{
+	wxLogMessage(wxT("Starting the Icom Controller thread"));
+
+	try {
+		while (!m_killed) {
+			sendGwyPackets();
+
+			Sleep(LOOP_DELAY);
+
+			readIcomPackets();
+
+			m_retryTimer.clock();
+		}
+	}
+	catch (std::exception& e) {
+		wxString message(e.what(), wxConvLocal);
+		wxLogError(wxT("Exception raised in the Icom Controller thread - \"%s\""), message.c_str());
+	}
+	catch (...) {
+		wxLogError(wxT("Unknown exception raised in the Icom Controller thread"));
+	}
+
+	wxLogMessage(wxT("Stopping the Icom Controller thread"));
+
+	m_socket.close();
+
+	return NULL;
+}
+
+bool CIcomRepeaterProtocolHandler::writeHeader(CHeaderData& header)
+{
+	CDataQueue* dq = new CDataQueue(new CHeaderData(header));
+
+	m_gwyQueue.addData(dq);
+
+	return true;
+}
+
+bool CIcomRepeaterProtocolHandler::writeAMBE(CAMBEData& data)
+{
+	CDataQueue* dq = new CDataQueue(new CAMBEData(data));
+
+	m_gwyQueue.addData(dq);
+
+	return true;
+}
+
+bool CIcomRepeaterProtocolHandler::writeDD(CDDData& data)
+{
+	CDataQueue* dq = new CDataQueue(new CDDData(data));
+
+	m_gwyQueue.addData(dq);
+
+	return true;
+}
+
+bool CIcomRepeaterProtocolHandler::writeText(CTextData&)
+{
+	return true;
+}
+
+bool CIcomRepeaterProtocolHandler::writeStatus(CStatusData&)
+{
+	return true;
+}
+
+void CIcomRepeaterProtocolHandler::readIcomPackets()
+{
+	for (;;) {
+		// No more data?
+		in_addr address;
+		unsigned int port;
+		int length = m_socket.read(m_buffer, BUFFER_LENGTH, address, port);
+		if (length <= 0)
+			return;
+
+		if (address.s_addr != m_icomAddress.s_addr || port != m_icomPort) {
+			wxLogError(wxT("Incoming Icom data from an unknown source"));
+			continue;
+		}
+
+		// Invalid packet type?
+		if (m_buffer[0] != 'D' || m_buffer[1] != 'S' || m_buffer[2] != 'T' || m_buffer[3] != 'R') {
+			CUtils::dump(wxT("Missing DSTR from the RP2C"), m_buffer, length);
+			continue;
+		}
+
+		// An ack
+		if (length == 10 && m_buffer[6] == 0x72) {
+			wxUint16 seqNo = m_buffer[4] * 256U + m_buffer[5];
+
+			if (seqNo == m_seqNo)
+				m_seqNo++;
+			else
+				m_seqNo = seqNo;
+
+			// Free the ack queue
+			free(m_ackQueue);
+			m_ackQueue = NULL;
+
+			m_retryTimer.stop();
+			m_tries = 0U;
+
+			continue;
+		}
+
+		// Send an ack for all packet types except an ack
+		wxUint16 seqNo = m_buffer[4] * 256U + m_buffer[5];
+		sendAck(seqNo);
+
+		// Heard data
+		if (m_buffer[6] == 0x73 && m_buffer[7] == 0x21) {
+			CHeardData* heard = new CHeardData;
+			bool ret = heard->setIcomRepeaterData(m_buffer, length, m_icomAddress, m_icomPort);
+			if (!ret) {
+				wxLogError(wxT("Invalid heard data from the RP2C"));
+				delete heard;
+				continue;
+			}
+
+			m_rptrQueue.addData(new CDataQueue(heard));
+			continue;
+		}
+
+		// Poll data
+		if (m_buffer[6] == 0x73 && m_buffer[7] == 0x00) {
+			m_rptrQueue.addData(new CDataQueue);
+			continue;
+		}
+
+		// DD Data
+		if (m_buffer[6] == 0x73 && m_buffer[7] == 0x11) {
+			CDDData* data = new CDDData;
+			bool ret = data->setIcomRepeaterData(m_buffer, length, m_icomAddress, m_icomPort);
+			if (!ret) {
+				wxLogError(wxT("Invalid DD data from the RP2C"));
+				delete data;
+				continue;
+			}
+
+			m_rptrQueue.addData(new CDataQueue(data));
+			continue;
+		}
+
+		// DV data
+		if (m_buffer[6] == 0x73 && m_buffer[7] == 0x12 && m_buffer[10] == 0x20) {
+			if ((m_buffer[16] & 0x80) == 0x80) {
+				CHeaderData* header = new CHeaderData;
+				bool ret = header->setIcomRepeaterData(m_buffer, length, true, m_icomAddress, m_icomPort);
+				if (!ret) {
+					wxLogError(wxT("Invalid header data or checksum from the RP2C"));
+					delete header;
+					continue;
+				}
+
+				if (m_over1)
+					sendMultiReply(*header);
+				else
+					sendSingleReply(*header);
+
+				m_rptrQueue.addData(new CDataQueue(header));
+				continue;
+			} else {
+				CAMBEData* data = new CAMBEData;
+				bool ret = data->setIcomRepeaterData(m_buffer, length, m_icomAddress, m_icomPort);
+				if (!ret) {
+					wxLogError(wxT("Invalid AMBE data from the RP2C"));
+					delete data;
+					continue;
+				}
+
+				m_rptrQueue.addData(new CDataQueue(data));
+				continue;
+			}
+		}
+
+		// An unknown type
+		CUtils::dump(wxT("Unknown packet type from the RP2C"), m_buffer, length);
+	}
+}
+
+void CIcomRepeaterProtocolHandler::sendGwyPackets()
+{
+	// Anything to send
+	if (m_gwyQueue.isEmpty() && m_ackQueue == NULL)
+		return;
+
+	if (m_tries > 0U && !m_retryTimer.hasExpired())
+		return;
+
+	if (m_ackQueue == NULL) {
+		m_ackQueue = m_gwyQueue.getData();
+		if (m_ackQueue == NULL) {
+			wxLogError(wxT("getData of a non-empty gateway queue is NULL"));
+			return;
+		}
+	}
+
+	unsigned int length = 0U;
+
+	switch (m_ackQueue->getType()) {
+		case RT_HEADER: {
+				CHeaderData* header = m_ackQueue->getHeader();
+				header->setRptSeq(m_seqNo);
+				length = header->getIcomRepeaterData(m_buffer, 60U, true);
+			}
+			break;
+
+		case RT_AMBE: {
+				CAMBEData* data = m_ackQueue->getAMBE();
+				data->setRptSeq(m_seqNo);
+				length = data->getIcomRepeaterData(m_buffer, 60U);
+			}
+			break;
+
+		case RT_DD: {
+				CDDData* data = m_ackQueue->getDD();
+				data->setRptSeq(m_seqNo);
+				length = data->getIcomRepeaterData(m_buffer, BUFFER_LENGTH);
+			}
+			break;
+
+		default:
+			wxLogError(wxT("Invalid type in the gateway queue"));
+			break;
+	}
+
+	if (length > 0U) {
+		m_socket.write(m_buffer, length, m_icomAddress, m_icomPort);
+
+		m_tries++;
+		m_retryTimer.start();
+
+		if (m_tries > 0U && (m_tries % 100U) == 0U)
+			wxLogMessage(wxT("No reply from the RP2C after %u retries"), m_tries);
+	}
+}
+
+REPEATER_TYPE CIcomRepeaterProtocolHandler::read()
+{
+	if (m_rptrQueue.isEmpty()) {
+		m_type = RT_NONE;
+	} else {
+		CDataQueue* dq = m_rptrQueue.peek();
+		if (dq == NULL) {
+			wxLogError(wxT("Peek of a non-empty repeater queue is NULL"));
+			m_type = RT_NONE;
+		} else {
+			m_type = dq->getType();
+		}
+	}
+
+	return m_type;
+}
+
+CPollData* CIcomRepeaterProtocolHandler::readPoll()
+{
+	if (m_type != RT_POLL)
+		return NULL;
+
+	CDataQueue* dq = m_rptrQueue.getData();
+	if (dq == NULL) {
+		wxLogError(wxT("Missing DataQueue in readPoll"));
+		return NULL;
+	}
+
+	if (dq->getType() != RT_POLL) {
+		wxLogError(wxT("Wrong DataQueue type in readPoll"));
+		delete dq;
+		return NULL;
+	}
+
+	delete dq;
+
+	CPollData* data = new CPollData;
+	data->setData1(wxT("icom_rp2c"));
+
+	return data;
+}
+
+CHeaderData* CIcomRepeaterProtocolHandler::readHeader()
+{
+	if (m_type != RT_HEADER)
+		return NULL;
+
+	CDataQueue* dq = m_rptrQueue.getData();
+	if (dq == NULL) {
+		wxLogError(wxT("Missing DataQueue in readHeader"));
+		return NULL;
+	}
+
+	if (dq->getType() != RT_HEADER) {
+		wxLogError(wxT("Wrong DataQueue type in readHeader"));
+		delete dq;
+		return NULL;
+	}
+
+	CHeaderData* header = dq->getHeader();
+
+	delete dq;
+
+	return header;
+}
+
+CAMBEData* CIcomRepeaterProtocolHandler::readAMBE()
+{
+	if (m_type != RT_AMBE)
+		return NULL;
+
+	CDataQueue* dq = m_rptrQueue.getData();
+	if (dq == NULL) {
+		wxLogError(wxT("Missing DataQueue in readData"));
+		return NULL;
+	}
+
+	if (dq->getType() != RT_AMBE) {
+		wxLogError(wxT("Wrong DataQueue type in readData"));
+		delete dq;
+		return NULL;
+	}
+
+	CAMBEData* data = dq->getAMBE();
+
+	delete dq;
+
+	return data;
+}
+
+CHeardData* CIcomRepeaterProtocolHandler::readHeard()
+{
+	if (m_type != RT_HEARD)
+		return NULL;
+
+	CDataQueue* dq = m_rptrQueue.getData();
+	if (dq == NULL) {
+		wxLogError(wxT("Missing DataQueue in readHeard"));
+		return NULL;
+	}
+
+	if (dq->getType() != RT_HEARD) {
+		wxLogError(wxT("Wrong DataQueue type in readHeard"));
+		delete dq;
+		return NULL;
+	}
+
+	CHeardData* heard = dq->getHeard();
+
+	delete dq;
+
+	return heard;
+}
+
+CDDData* CIcomRepeaterProtocolHandler::readDD()
+{
+	if (m_type != RT_DD)
+		return NULL;
+
+	CDataQueue* dq = m_rptrQueue.getData();
+	if (dq == NULL) {
+		wxLogError(wxT("Missing DataQueue in readData"));
+		return NULL;
+	}
+
+	if (dq->getType() != RT_DD) {
+		wxLogError(wxT("Wrong DataQueue type in readData"));
+		delete dq;
+		return NULL;
+	}
+
+	CDDData* data = dq->getDD();
+
+	delete dq;
+
+	return data;
+}
+
+CHeaderData* CIcomRepeaterProtocolHandler::readBusyHeader()
+{
+	return NULL;
+}
+
+CAMBEData* CIcomRepeaterProtocolHandler::readBusyAMBE()
+{
+	return NULL;
+}
+
+void CIcomRepeaterProtocolHandler::close()
+{
+	m_killed = true;
+
+	Wait();
+}
+
+bool CIcomRepeaterProtocolHandler::sendAck(wxUint16 seqNo)
+{
+	unsigned char buffer[10U];
+
+	buffer[0U] = 'D';
+	buffer[1U] = 'S';
+	buffer[2U] = 'T';
+	buffer[3U] = 'R';
+
+	buffer[4U] = seqNo / 256U;
+	buffer[5U] = seqNo % 256U;
+
+	buffer[6U] = 0x72U;
+	buffer[7U] = 0x00U;
+
+	buffer[8U] = 0x00U;
+	buffer[9U] = 0x00U;
+
+	return m_socket.write(buffer, 10U, m_icomAddress, m_icomPort);
+}
+
+void CIcomRepeaterProtocolHandler::sendSingleReply(const CHeaderData& header)
+{
+	unsigned int id = ::rand() % 0xFFFF;
+
+	CHeaderData replyHdr;
+	replyHdr.setId(id);
+	replyHdr.setBand1(0xFFU);
+	replyHdr.setBand2(0xFFU);
+	replyHdr.setBand3(0xFFU);
+	replyHdr.setFlag1(0x01U);
+	replyHdr.setMyCall1(header.getRptCall2());
+	replyHdr.setMyCall2(wxT("    "));
+	replyHdr.setYourCall(header.getMyCall1());
+	replyHdr.setRptCall1(header.getRptCall2());
+	replyHdr.setRptCall2(header.getRptCall1());
+
+	writeHeader(replyHdr);
+
+	unsigned char buffer[DV_FRAME_MAX_LENGTH_BYTES];
+	::memcpy(buffer + 0U, NULL_AMBE_DATA_BYTES, VOICE_FRAME_LENGTH_BYTES);
+	::memcpy(buffer + VOICE_FRAME_LENGTH_BYTES, END_PATTERN_BYTES, END_PATTERN_LENGTH_BYTES);
+
+	CAMBEData replyData;
+	replyData.setId(id);
+	replyData.setBand1(0xFFU);
+	replyData.setBand2(0xFFU);
+	replyData.setBand3(0xFFU);
+	replyData.setSeq(0x40U);		// Seq = 0 and end-of-data
+	replyData.setData(buffer, DV_FRAME_MAX_LENGTH_BYTES);
+
+	writeAMBE(replyData);
+}
+
+void CIcomRepeaterProtocolHandler::sendMultiReply(const CHeaderData& header)
+{
+	unsigned int id = ::rand() % 0xFFFF;
+
+	CHeaderData replyHdr;
+	replyHdr.setId(id);
+	replyHdr.setBand1(0xFFU);
+	replyHdr.setBand2(0xFFU);
+	replyHdr.setBand3(0xFFU);
+	replyHdr.setFlag1(0x41U);
+	replyHdr.setMyCall1(header.getRptCall2());
+	replyHdr.setMyCall2(wxT("    "));
+	replyHdr.setYourCall(header.getMyCall1());
+	replyHdr.setRptCall1(header.getRptCall2());
+	replyHdr.setRptCall2(header.getRptCall1());
+
+	writeHeader(replyHdr);
+
+	CAMBEData replyData;
+	unsigned char buffer[DV_FRAME_LENGTH_BYTES];
+
+	replyData.setId(id);
+	replyData.setBand1(0xFFU);
+	replyData.setBand2(0xFFU);
+	replyData.setBand3(0xFFU);
+
+	::memcpy(buffer + 0U, NULL_AMBE_DATA_BYTES, VOICE_FRAME_LENGTH_BYTES);
+	::memcpy(buffer + VOICE_FRAME_LENGTH_BYTES, END_PATTERN_BYTES + 0U, 3U);
+
+	replyData.setSeq(0x00U);		// Seq = 0
+	replyData.setData(buffer, DV_FRAME_LENGTH_BYTES);
+
+	writeAMBE(replyData);
+
+	::memset(buffer + 0U, 0x00, DV_FRAME_LENGTH_BYTES);
+	::memcpy(buffer + 0U, END_PATTERN_BYTES + 3U, 3U);
+
+	replyData.setSeq(0x41U);		// Seq = 1 and end-of-data
+	replyData.setData(buffer, DV_FRAME_LENGTH_BYTES);
+
+	writeAMBE(replyData);
+}
+
+void CIcomRepeaterProtocolHandler::free(CDataQueue* dataQueue)
+{
+	if (dataQueue == NULL)
+		return;
+
+	switch (dataQueue->getType()) {
+		case RT_HEADER:
+			delete dataQueue->getHeader();
+			break;
+		case RT_HEARD:
+			delete dataQueue->getHeard();
+			break;
+		case RT_AMBE:
+			delete dataQueue->getAMBE();
+			break;
+		case RT_DD:
+			delete dataQueue->getDD();
+			break;
+		default:
+			break;
+	}
+
+	delete dataQueue;
+}