void CDPlusHandler::writeHeaderInt(IReflectorCallback* handler, CHeaderData& header, DIRECTION direction)
{
wxASSERT(handler != NULL);
if (m_linkState != DPLUS_LINKED)
return;
if (direction != m_direction)
return;
// Already is use?
if (m_dPlusId != 0x00U)
return;
switch (m_direction) {
case DIR_OUTGOING:
if (m_destination == handler) {
header.setRepeaters(m_callsign, m_reflector);
header.setDestination(m_yourAddress, m_yourPort);
m_handler->writeHeader(header);
m_rptrId = header.getId();
}
break;
case DIR_INCOMING:
header.setDestination(m_yourAddress, m_yourPort);
m_handler->writeHeader(header);
break;
}
}
void CCCSHandler::writeHeader(CHeaderData& header)
{
m_myCall1 = header.getMyCall1();
m_myCall2 = header.getMyCall2();
m_seqNo = 0U;
}
void CDExtraHandler::process(CHeaderData& header)
{
for (unsigned int i = 0U; i < m_maxReflectors; i++) {
CDExtraHandler* reflector = m_reflectors[i];
if (reflector != NULL) {
if (reflector->m_address.s_addr == header.getAddress().s_addr &&
reflector->m_port == header.getPort())
reflector->processInt(header);
}
}
}
bool CHBRepeaterProtocolHandler::writeHeader(CHeaderData& header)
{
unsigned char buffer[50U];
unsigned int length = header.getHBRepeaterData(buffer, 50U, true);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Header"), buffer, length);
return true;
#else
return m_socket.write(buffer, length, header.getYourAddress(), header.getYourPort());
#endif
}
bool CAPRSTransmit::sendHeader(const CHeaderData& header)
{
unsigned char buffer[60U];
unsigned int length = header.getG2Data(buffer, 60U, true);
for (unsigned int i = 0U; i < 2U; i++) {
bool res = m_socket.write(buffer, length, header.getYourAddress(), header.getYourPort());
if (!res)
return false;
}
return true;
}
bool CDVAPController::writeHeader(const CHeaderData& header)
{
m_streamId++;
unsigned char buffer[50U];
::memcpy(buffer, DVAP_HEADER, DVAP_HEADER_LEN);
wxUint16 sid = wxUINT16_SWAP_ON_BE(m_streamId);
::memcpy(buffer + 2U, &sid, sizeof(wxUint16));
buffer[4U] = 0x80U;
buffer[5U] = 0U;
::memset(buffer + 6U, ' ', RADIO_HEADER_LENGTH_BYTES);
buffer[6U] = header.getFlag1();
buffer[7U] = header.getFlag2();
buffer[8U] = header.getFlag3();
wxString rpt2 = header.getRptCall2();
for (unsigned int i = 0U; i < rpt2.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 9U] = rpt2.GetChar(i);
wxString rpt1 = header.getRptCall1();
for (unsigned int i = 0U; i < rpt1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 17U] = rpt1.GetChar(i);
wxString your = header.getYourCall();
for (unsigned int i = 0U; i < your.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 25U] = your.GetChar(i);
wxString my1 = header.getMyCall1();
for (unsigned int i = 0U; i < my1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 33U] = my1.GetChar(i);
wxString my2 = header.getMyCall2();
for (unsigned int i = 0U; i < my2.Len() && i < SHORT_CALLSIGN_LENGTH; i++)
buffer[i + 41U] = my2.GetChar(i);
CCCITTChecksumReverse cksum;
cksum.update(buffer + 6U, RADIO_HEADER_LENGTH_BYTES - 2U);
cksum.result(buffer + 45U);
m_framePos = 0U;
m_seq = 0U;
wxMutexLocker locker(m_mutex);
unsigned int space = m_txData.freeSpace();
if (space < 48U)
return false;
unsigned char len = DVAP_HEADER_LEN;
m_txData.addData(&len, 1U);
m_txData.addData(buffer, DVAP_HEADER_LEN);
return true;
}
void CDummyRepeaterFrame::onHeader(wxEvent& event)
{
CDummyRepeaterHeaderEvent& hdrEvent = dynamic_cast<CDummyRepeaterHeaderEvent&>(event);
CHeaderData* header = hdrEvent.getHeaderData();
if (header != NULL) {
wxDateTime dateTime = header->getTime();
wxString hrdDateTime = dateTime.FormatISODate() + wxT(" ") + dateTime.FormatISOTime();
m_heard->InsertItem(0L, hrdDateTime);
wxString urCall = header->getYourCall();
m_hrdYour->SetLabel(urCall);
m_heard->SetItem(0L, 1, urCall);
wxString myCall = header->getMyCall1();
wxString myCall2 = header->getMyCall2();
if (!myCall2.IsSameAs(wxT(" "))) {
myCall.Append(wxT("/"));
myCall.Append(myCall2);
}
m_hrdMy->SetLabel(myCall);
m_heard->SetItem(0L, 2, myCall);
wxString rpt1Call = header->getRptCall1();
m_hrdRpt1->SetLabel(rpt1Call);
m_heard->SetItem(0L, 3, rpt1Call);
wxString rpt2Call = header->getRptCall2();
m_hrdRpt2->SetLabel(rpt2Call);
m_heard->SetItem(0L, 4, rpt2Call);
wxString flags;
flags.Printf(wxT("%02X %02X %02X"), header->getFlag1(), header->getFlag2(), header->getFlag3());
m_hrdFlags->SetLabel(flags);
m_hrdMessage->SetLabel(wxEmptyString);
delete header;
} else {
m_hrdYour->SetLabel(wxEmptyString);
m_hrdMy->SetLabel(wxEmptyString);
m_hrdRpt1->SetLabel(wxEmptyString);
m_hrdRpt2->SetLabel(wxEmptyString);
m_hrdFlags->SetLabel(wxEmptyString);
m_hrdMessage->SetLabel(wxEmptyString);
}
}
void CGMSKModemWinUSB::writeHeader(const CHeaderData& header)
{
unsigned char myCall1[LONG_CALLSIGN_LENGTH];
unsigned char myCall2[SHORT_CALLSIGN_LENGTH];
unsigned char yourCall[LONG_CALLSIGN_LENGTH];
unsigned char rptCall1[LONG_CALLSIGN_LENGTH];
unsigned char rptCall2[LONG_CALLSIGN_LENGTH];
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
myCall1[i] = header.getMyCall1().GetChar(i);
for (unsigned int i = 0U; i < SHORT_CALLSIGN_LENGTH; i++)
myCall2[i] = header.getMyCall2().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
yourCall[i] = header.getYourCall().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
rptCall1[i] = header.getRptCall1().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
rptCall2[i] = header.getRptCall2().GetChar(i);
io(SET_MyCALL2, 0x40U, 0U, myCall2, SHORT_CALLSIGN_LENGTH);
io(SET_MyCALL, 0x40U, 0U, myCall1, LONG_CALLSIGN_LENGTH);
io(SET_YourCALL, 0x40U, 0U, yourCall, LONG_CALLSIGN_LENGTH);
io(SET_RPT1CALL, 0x40U, 0U, rptCall1, LONG_CALLSIGN_LENGTH);
io(SET_RPT2CALL, 0x40U, 0U, rptCall2, LONG_CALLSIGN_LENGTH);
unsigned char flags[3U];
flags[0U] = header.getFlag1();
flags[1U] = header.getFlag2();
flags[2U] = header.getFlag3();
io(SET_FLAGS, 0x40U, 0U, flags, 3U);
setPTT(true);
}
bool CDVRPTRV3Controller::writeHeader(const CHeaderData& header)
{
bool ret = m_txData.hasSpace(106U);
if (!ret) {
wxLogWarning(wxT("No space to write the header"));
return false;
}
unsigned char buffer[105U];
::memset(buffer, 0x00U, 105U);
buffer[0U] = 'H';
buffer[1U] = 'E';
buffer[2U] = 'A';
buffer[3U] = 'D';
buffer[4U] = 'X';
buffer[5U] = '0';
buffer[6U] = '0';
buffer[7U] = '0';
buffer[8U] = '2';
::memset(buffer + 9U, ' ', RADIO_HEADER_LENGTH_BYTES);
buffer[9U] = header.getFlag1();
buffer[10U] = header.getFlag2();
buffer[11U] = header.getFlag3();
wxString rpt2 = header.getRptCall2();
for (unsigned int i = 0U; i < rpt2.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 12U] = rpt2.GetChar(i);
wxString rpt1 = header.getRptCall1();
for (unsigned int i = 0U; i < rpt1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 20U] = rpt1.GetChar(i);
wxString your = header.getYourCall();
for (unsigned int i = 0U; i < your.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 28U] = your.GetChar(i);
wxString my1 = header.getMyCall1();
for (unsigned int i = 0U; i < my1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 36U] = my1.GetChar(i);
wxString my2 = header.getMyCall2();
for (unsigned int i = 0U; i < my2.Len() && i < SHORT_CALLSIGN_LENGTH; i++)
buffer[i + 44U] = my2.GetChar(i);
wxMutexLocker locker(m_mutex);
unsigned char len = 105U;
m_txData.addData(&len, 1U);
m_txData.addData(buffer, 105U);
m_tx = true;
return true;
}
void CStarNetHandler::sendToRepeaters(CHeaderData& header) const
{
for (CStarNetRepeatersHashMap::const_iterator it = m_repeaters.begin(); it != m_repeaters.end(); ++it) {
CStarNetRepeater* repeater = it->second;
if (repeater != NULL) {
header.setYourCall(repeater->m_destination);
header.setDestination(repeater->m_address, G2_DV_PORT);
header.setRepeaters(repeater->m_gateway, repeater->m_repeater);
if (repeater->m_local != NULL)
repeater->m_local->process(header, AS_G2);
else
m_g2Handler->writeHeader(header);
}
}
}
bool CRepeaterProtocolHandler::writeHeader(const CHeaderData& header)
{
unsigned char buffer[50U];
buffer[0] = 'D';
buffer[1] = 'S';
buffer[2] = 'R';
buffer[3] = 'P';
buffer[4] = 0x20U;
// Create a random id for this transmission
m_outId = (::rand() % 65535U) + 1U;
buffer[5] = m_outId / 256U; // Unique session id
buffer[6] = m_outId % 256U;
buffer[7] = 0U;
buffer[8] = header.getFlag1();
buffer[9] = header.getFlag2();
buffer[10] = header.getFlag3();
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
buffer[11 + i] = header.getRptCall1().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
buffer[19 + i] = header.getRptCall2().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
buffer[27 + i] = header.getYourCall().GetChar(i);
for (unsigned int i = 0U; i < LONG_CALLSIGN_LENGTH; i++)
buffer[35 + i] = header.getMyCall1().GetChar(i);
for (unsigned int i = 0U; i < SHORT_CALLSIGN_LENGTH; i++)
buffer[43 + i] = header.getMyCall2().GetChar(i);
// Get the checksum for the header
CCCITTChecksumReverse csum;
csum.update(buffer + 8U, 4U * LONG_CALLSIGN_LENGTH + SHORT_CALLSIGN_LENGTH + 3U);
csum.result(buffer + 47U);
m_outSeq = 0U;
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Header"), buffer, 49U);
return true;
#else
for (unsigned int i = 0U; i < 2U; i++) {
bool ret = m_socket.write(buffer, 49U);
if (!ret)
return false;
}
return true;
#endif
}
bool CGMSKRepeaterTXRXThread::receiveRadioHeader()
{
bool error;
CHeaderData* header = m_modem->readHeader(error);
if (header == NULL)
return error;
wxLogMessage(wxT("Header decoded - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3());
bool res = processRadioHeader(header);
if (res) {
// A valid header and is a DV packet
m_radioSeqNo = 20U;
m_ambeFrames = 0U;
m_ambeSilence = 0U;
m_ambeBits = 1U;
m_ambeErrors = 0U;
m_ambeLength = 0U;
m_lastAMBEBits = 0U;
m_lastAMBEErrors = 0U;
} else {
// This is a DD packet or some other problem
// wxLogMessage(wxT("Invalid header"));
}
return false;
}
CHeaderData* CDPlusProtocolHandler::readHeader()
{
if (m_type != DP_HEADER)
return NULL;
CHeaderData* header = new CHeaderData;
// DPlus checksums are unreliable
bool res = header->setDPlusData(m_buffer, m_length, false, m_yourAddress, m_yourPort, m_myPort);
if (!res) {
delete header;
return NULL;
}
return header;
}
CHeaderData* CHBRepeaterProtocolHandler::readBusyHeader()
{
if (m_type != RT_BUSY_HEADER)
return NULL;
CHeaderData* header = new CHeaderData;
bool res = header->setHBRepeaterData(m_buffer, m_length, true, m_address, m_port);
if (!res) {
wxLogError(wxT("Invalid checksum from the repeater"));
delete header;
return NULL;
}
return header;
}
CHeaderData* CSoundCardRepeaterTXRXThread::processSlowData(bool sync)
{
bool bits[DV_FRAME_LENGTH_BITS];
m_bitBuffer.getData(bits, DV_FRAME_LENGTH_BITS);
if (sync) {
m_slowDataDecoder.sync();
return NULL;
}
unsigned char bytes[DATA_FRAME_LENGTH_BYTES];
// Convert the bits to bytes
unsigned int n = 0U;
for (unsigned int i = 0U; i < DATA_FRAME_LENGTH_BYTES; i++, n += 8U)
bytes[i] = CUtils::bitsToByteRev(bits + VOICE_FRAME_LENGTH_BITS + n);
m_slowDataDecoder.addData(bytes);
CHeaderData* header = m_slowDataDecoder.getHeaderData();
if (header == NULL)
return NULL;
wxLogMessage(wxT("Radio header from slow data - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X BER: 0%%"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3());
m_headerBER = 0U;
return header;
}
void CDVToolReaderFrame::onHeader(wxEvent& event)
{
CHeaderEvent& hdrEvent = dynamic_cast<CHeaderEvent&>(event);
CHeaderData* header = hdrEvent.getHeaderData();
if (header != NULL) {
wxDateTime dateTime = header->getTime();
wxString hrdDateTime = dateTime.FormatISODate() + wxT(" ") + dateTime.FormatISOTime();
wxString urCall = header->getYourCall();
m_your->SetLabel(urCall);
wxString myCall = header->getMyCall1();
wxString myCall2 = header->getMyCall2();
if (!myCall2.IsSameAs(wxT(" "))) {
myCall.Append(wxT("/"));
myCall.Append(myCall2);
}
m_my->SetLabel(myCall);
wxString rpt1Call = header->getRptCall1();
m_rpt1->SetLabel(rpt1Call);
wxString rpt2Call = header->getRptCall2();
m_rpt2->SetLabel(rpt2Call);
wxString flags;
flags.Printf(wxT("%02X %02X %02X"), header->getFlag1(), header->getFlag2(), header->getFlag3());
m_flags->SetLabel(flags);
m_message->SetLabel(wxEmptyString);
delete header;
} else {
m_fileName->SetLabel(wxEmptyString);
m_your->SetLabel(wxEmptyString);
m_my->SetLabel(wxEmptyString);
m_rpt1->SetLabel(wxEmptyString);
m_rpt2->SetLabel(wxEmptyString);
m_flags->SetLabel(wxEmptyString);
m_message->SetLabel(wxEmptyString);
}
}
bool CDPlusProtocolHandler::writeHeader(const CHeaderData& header)
{
unsigned char buffer[60U];
unsigned int length = header.getDPlusData(buffer, 60U, true);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Header"), buffer, length);
#endif
for (unsigned int i = 0U; i < 5U; i++) {
bool res = m_socket.write(buffer, length, header.getYourAddress(), header.getYourPort());
if (!res)
return false;
}
return true;
}
bool CMMDVMController::writeHeader(const CHeaderData& header)
{
bool ret = m_txData.hasSpace(46U);
if (!ret) {
wxLogWarning(wxT("No space to write the header"));
return false;
}
unsigned char buffer[50U];
buffer[0U] = MMDVM_FRAME_START;
buffer[1U] = RADIO_HEADER_LENGTH_BYTES + 3U;
buffer[2U] = MMDVM_DSTAR_HEADER;
::memset(buffer + 3U, ' ', RADIO_HEADER_LENGTH_BYTES);
buffer[3U] = header.getFlag1();
buffer[4U] = header.getFlag2();
buffer[5U] = header.getFlag3();
wxString rpt2 = header.getRptCall2();
for (unsigned int i = 0U; i < rpt2.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 6U] = rpt2.GetChar(i);
wxString rpt1 = header.getRptCall1();
for (unsigned int i = 0U; i < rpt1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 14U] = rpt1.GetChar(i);
wxString your = header.getYourCall();
for (unsigned int i = 0U; i < your.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 22U] = your.GetChar(i);
wxString my1 = header.getMyCall1();
for (unsigned int i = 0U; i < my1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 30U] = my1.GetChar(i);
wxString my2 = header.getMyCall2();
for (unsigned int i = 0U; i < my2.Len() && i < SHORT_CALLSIGN_LENGTH; i++)
buffer[i + 38U] = my2.GetChar(i);
CCCITTChecksumReverse cksum1;
cksum1.update(buffer + 3U, RADIO_HEADER_LENGTH_BYTES - 2U);
cksum1.result(buffer + 42U);
wxMutexLocker locker(m_mutex);
unsigned char type = DSMTT_HEADER;
m_txData.addData(&type, 1U);
unsigned char len = RADIO_HEADER_LENGTH_BYTES + 3U;
m_txData.addData(&len, 1U);
m_txData.addData(buffer, RADIO_HEADER_LENGTH_BYTES + 3U);
return true;
}
void CVersionUnit::clock(unsigned int ms)
{
m_timer.clock(ms);
if (m_status == VS_WAIT && m_timer.hasExpired()) {
m_timer.stop();
// RPT1 and RPT2 will be filled in later
CHeaderData header;
header.setMyCall1(m_callsign);
header.setMyCall2(wxT("VERS"));
header.setYourCall(wxT("CQCQCQ "));
header.setId(m_id);
m_handler->process(header, DIR_INCOMING, AS_VERSION);
m_out = 0U;
m_status = VS_TRANSMIT;
m_time.Start();
return;
}
if (m_status == VS_TRANSMIT) {
unsigned int needed = m_time.Time() / DSTAR_FRAME_TIME_MS;
while (m_out < needed) {
CAMBEData* data = m_data[m_out];
data->setId(m_id);
m_out++;
m_handler->process(*data, DIR_INCOMING, AS_VERSION);
if (m_out == NUM_FRAMES) {
m_out = 0U;
m_status = VS_IDLE;
return;
}
}
return;
}
}
bool CTimeServerThread::sendHeader(const CHeaderData &header)
{
unsigned char buffer[60U];
unsigned int length = header.getG2Data(buffer, 60U, true);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Header"), buffer, length);
return true;
#else
for (unsigned int i = 0U; i < 5U; i++) {
bool res = m_socket.write(buffer, length, header.getAddress(), header.getPort());
if (!res)
return false;
}
return true;
#endif
}
void CDVToolReaderThread::processHeader(const unsigned char* buffer)
{
// Tell the GUI about the header, we assume that it's valid
CHeaderData* header = new CHeaderData(buffer, RADIO_HEADER_LENGTH_BYTES, false);
wxLogMessage(wxT("Header decoded - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3());
::wxGetApp().showHeader(header);
}
TRISTATE CDVAPNodeTRXThread::checkHeader(CHeaderData& header)
{
// If not in RPT1 validation mode, then a simplex header is converted to a proper repeater header
if (!m_rpt1Validation) {
if (!header.isRepeaterMode()) {
// Convert to a properly addressed repeater packet
header.setRepeaterMode(true);
header.setRptCall1(m_rptCallsign);
header.setRptCall2(m_gwyCallsign);
}
}
// The repeater bit must be set
if (!header.isRepeaterMode()) {
wxLogMessage(wxT("Received a non-repeater packet, ignoring"));
return STATE_FALSE;
}
wxString my = header.getMyCall1();
// Make sure MyCall is not empty, a silly value, or the repeater or gateway callsigns
if (my.IsSameAs(m_rptCallsign) ||
my.IsSameAs(m_gwyCallsign) ||
my.Left(6U).IsSameAs(wxT("NOCALL")) ||
my.Left(6U).IsSameAs(wxT("N0CALL")) ||
my.Left(6U).IsSameAs(wxT("MYCALL"))) {
wxLogMessage(wxT("Invalid MYCALL value of %s, ignoring"), my.c_str());
return STATE_UNKNOWN;
}
// Check the MyCall value against the regular expression
bool ok = m_regEx.Matches(my);
if (!ok) {
wxLogMessage(wxT("Invalid MYCALL value of %s, ignoring"), my.c_str());
return STATE_UNKNOWN;
}
// Is it for us?
if (!header.getRptCall1().IsSameAs(m_rptCallsign)) {
wxLogMessage(wxT("Invalid RPT1 value %s, ignoring"), header.getRptCall1().c_str());
return STATE_FALSE;
}
// If using callsign restriction, validate the my callsign
if (m_restriction) {
if (!my.Left(LONG_CALLSIGN_LENGTH - 1U).IsSameAs(m_rptCallsign.Left(LONG_CALLSIGN_LENGTH - 1U))) {
wxLogMessage(wxT("Unauthorised user %s tried to access the repeater"), my.c_str());
return STATE_UNKNOWN;
}
}
return STATE_TRUE;
}
void CDPlusHandler::process(CHeaderData& header)
{
in_addr yourAddress = header.getYourAddress();
unsigned int yourPort = header.getYourPort();
unsigned int myPort = header.getMyPort();
for (unsigned int i = 0U; i < m_maxReflectors; i++) {
CDPlusHandler* reflector = m_reflectors[i];
if (reflector != NULL) {
if (reflector->m_yourAddress.s_addr == yourAddress.s_addr &&
reflector->m_yourPort == yourPort &&
reflector->m_myPort == myPort) {
reflector->processInt(header);
return;
}
}
}
}
void CHeaderLogger::write(const wxChar* type, const CHeaderData& header)
{
wxASSERT(type != NULL);
time_t timeNow = ::time(NULL);
struct tm* tm = ::gmtime(&timeNow);
char* t = ::inet_ntoa(header.getYourAddress());
wxString address(t, wxConvLocal);
wxString text;
text.Printf(wxT("%04d-%02d-%02d %02d:%02d:%02d: %s header - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X (%s:%u)\n"),
tm->tm_year + 1900, tm->tm_mon + 1, tm->tm_mday, tm->tm_hour, tm->tm_min, tm->tm_sec, type,
header.getMyCall1().c_str(), header.getMyCall2().c_str(), header.getYourCall().c_str(),
header.getRptCall1().c_str(), header.getRptCall2().c_str(), header.getFlag1(), header.getFlag2(),
header.getFlag3(), address.c_str(), header.getYourPort());
m_file.Write(text);
m_file.Flush();
}
CHeaderData* CRepeaterProtocolHandler::readHeader()
{
if (m_type != NETWORK_HEADER)
return NULL;
// If the checksum is 0xFFFF then we accept the header without testing the checksum
if (m_buffer[47U] == 0xFFU && m_buffer[48U] == 0xFFU)
return new CHeaderData(m_buffer + 8U, RADIO_HEADER_LENGTH_BYTES, false);
// Header checksum testing is enabled
CHeaderData* header = new CHeaderData(m_buffer + 8U, RADIO_HEADER_LENGTH_BYTES, true);
if (!header->isValid()) {
CUtils::dump(wxT("Header checksum failure from the Gateway"), m_buffer + 8U, RADIO_HEADER_LENGTH_BYTES);
delete header;
return NULL;
}
return header;
}
void CXReflectorDPlusHandler::writeHeaderInt(CHeaderData& header)
{
if (!m_linked)
return;
// If there's an incoming data stream, don't send
if (m_dPlusId != 0x00U)
return;
wxString rpt2 = m_dplusCallsign;
wxChar band = header.getRptCall1().GetChar(LONG_CALLSIGN_LENGTH - 1U);
rpt2.SetChar(LONG_CALLSIGN_LENGTH - 1U, band);
wxString rpt1 = m_dplusCallsign;
band = header.getRptCall2().GetChar(LONG_CALLSIGN_LENGTH - 1U);
rpt1.SetChar(LONG_CALLSIGN_LENGTH - 1U, band);
header.setRepeaters(rpt1, rpt2);
header.setDestination(m_address, m_port);
m_handler->writeHeader(header);
}
void CDPlusHandler::process(CHeaderData& header)
{
in_addr address = header.getAddress();
for (unsigned int i = 0U; i < m_maxReflectors; i++) {
CDPlusHandler* reflector = m_reflectors[i];
if (reflector != NULL) {
if (reflector->m_address.s_addr == address.s_addr)
reflector->processInt(header);
}
}
}
void CDExtraHandler::writeHeaderInt(const wxString& callsign, CHeaderData& header, DIRECTION direction)
{
if (m_linkState != DEXTRA_LINKED)
return;
// Is it link in the right direction
if (m_direction != direction)
return;
// Reject on invalid callsign if not a dongle link
if (!m_repeater.IsEmpty()) {
// Do the callsigns match?
if (!callsign.IsSameAs(m_repeater))
return;
}
// Already in use?
if (m_dExtraId != 0x00)
return;
header.setDestination(m_address, m_port);
m_handler->writeHeader(header);
m_rptrId = header.getId();
}
bool CGMSKController::writeHeader(const CHeaderData& header)
{
unsigned char buffer[50U];
::memset(buffer, ' ', RADIO_HEADER_LENGTH_BYTES - 2U);
buffer[0U] = header.getFlag1();
buffer[1U] = header.getFlag2();
buffer[2U] = header.getFlag3();
wxString rpt2 = header.getRptCall2();
for (unsigned int i = 0U; i < rpt2.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 3U] = rpt2.GetChar(i);
wxString rpt1 = header.getRptCall1();
for (unsigned int i = 0U; i < rpt1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 11U] = rpt1.GetChar(i);
wxString your = header.getYourCall();
for (unsigned int i = 0U; i < your.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 19U] = your.GetChar(i);
wxString my1 = header.getMyCall1();
for (unsigned int i = 0U; i < my1.Len() && i < LONG_CALLSIGN_LENGTH; i++)
buffer[i + 27U] = my1.GetChar(i);
wxString my2 = header.getMyCall2();
for (unsigned int i = 0U; i < my2.Len() && i < SHORT_CALLSIGN_LENGTH; i++)
buffer[i + 35U] = my2.GetChar(i);
wxMutexLocker locker(m_mutex);
bool ret = m_txData.hasSpace(RADIO_HEADER_LENGTH_BYTES);
if (!ret)
return false;
unsigned char data[2U];
data[0U] = DSMTT_HEADER;
data[1U] = RADIO_HEADER_LENGTH_BYTES - 2U;
m_txData.addData(data, 2U);
m_txData.addData(buffer, RADIO_HEADER_LENGTH_BYTES - 2U);
return true;
}
void CDVRPTRRepeaterRXThread::receiveHeader(unsigned char* data, unsigned int length)
{
CHeaderData* header = new CHeaderData(data, length, false);
wxLogMessage(wxT("Radio header decoded - My: %s/%s Your: %s Rpt1: %s Rpt2: %s Flags: %02X %02X %02X"), header->getMyCall1().c_str(), header->getMyCall2().c_str(), header->getYourCall().c_str(), header->getRptCall1().c_str(), header->getRptCall2().c_str(), header->getFlag1(), header->getFlag2(), header->getFlag3());
bool res = processRadioHeader(header);
if (res) {
// A valid header and is a DV packet
m_radioSeqNo = 20U;
setRadioState(DSRXS_PROCESS_DATA);
} else {
// This is a DD packet or some other problem
// wxLogMessage(wxT("Invalid header"));
}
}
