g4klx/ircDDBGateway
1
0
Fork 0
mirror of https://github.com/g4klx/ircDDBGateway.git synced 2026-04-06 06:43:52 +00:00
Code Issues Projects Releases Packages Wiki Activity

First stage of CCS removal.

Browse source
This commit is contained in:
Jonathan Naylor 2018-09-19 15:05:20 +01:00
parent 094f0d286d
commit 9669d865b5
35 changed files with 39 additions and 2286 deletions
Download patch file Download diff file Expand all files Collapse all files

235
Common/CCSProtocolHandler.cpp
View file

@ -1,235 +0,0 @@
/*
* Copyright (C) 2013 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 "CCSProtocolHandler.h"
#include "DStarDefines.h"
#include "Utils.h"
// #define DUMP_TX
const unsigned int BUFFER_LENGTH = 2000U;
CCCSProtocolHandler::CCCSProtocolHandler(unsigned int port, const wxString& addr) :
m_socket(addr, port),
m_type(CT_NONE),
m_buffer(NULL),
m_length(0U),
m_yourAddress(),
m_yourPort(0U),
m_myPort(port)
{
m_buffer = new unsigned char[BUFFER_LENGTH];
}
CCCSProtocolHandler::~CCCSProtocolHandler()
{
delete[] m_buffer;
}
bool CCCSProtocolHandler::open()
{
return m_socket.open();
}
unsigned int CCCSProtocolHandler::getPort() const
{
return m_myPort;
}
bool CCCSProtocolHandler::writeData(const CAMBEData& data)
{
unsigned char buffer[100U];
unsigned int length = data.getCCSData(buffer, 100U);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Data"), buffer, length);
#endif
return m_socket.write(buffer, length, data.getYourAddress(), data.getYourPort());
}
bool CCCSProtocolHandler::writePoll(const CPollData& poll)
{
unsigned char buffer[30U];
unsigned int length = poll.getCCSData(buffer, 30U);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Poll"), buffer, length);
#endif
return m_socket.write(buffer, length, poll.getYourAddress(), poll.getYourPort());
}
bool CCCSProtocolHandler::writeHeard(const CHeardData& heard)
{
unsigned char buffer[100U];
unsigned int length = heard.getCCSData(buffer, 100U);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Heard"), buffer, length);
#endif
return m_socket.write(buffer, length, heard.getAddress(), heard.getPort());
}
bool CCCSProtocolHandler::writeConnect(const CConnectData& connect)
{
unsigned char buffer[40U];
unsigned int length = connect.getCCSData(buffer, 40U);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Connect"), buffer, length);
#endif
return m_socket.write(buffer, length, connect.getYourAddress(), connect.getYourPort());
}
bool CCCSProtocolHandler::writeMisc(const CCCSData& data)
{
unsigned char buffer[140U];
unsigned int length = data.getCCSData(buffer, 140U);
#if defined(DUMP_TX)
CUtils::dump(wxT("Sending Misc"), buffer, length);
#endif
return m_socket.write(buffer, length, data.getYourAddress(), data.getYourPort());
}
CCS_TYPE CCCSProtocolHandler::read()
{
bool res = true;
// Loop until we have no more data from the socket or we have data for the higher layers
while (res)
res = readPackets();
return m_type;
}
bool CCCSProtocolHandler::readPackets()
{
m_type = CT_NONE;
// No more data?
int length = m_socket.read(m_buffer, BUFFER_LENGTH, m_yourAddress, m_yourPort);
if (length <= 0)
return false;
m_length = length;
if (m_buffer[0] == '0' && m_buffer[1] == '0' && m_buffer[2] == '0' && m_buffer[3] == '1') {
m_type = CT_DATA;
return false;
} else if (m_buffer[0] == 'L' && m_buffer[1] == 'L' && m_buffer[2] == 'L') {
return true;
} else {
switch (m_length) {
case 14U:
m_type = CT_CONNECT;
return false;
case 25U:
m_type = CT_POLL;
return false;
case 100U:
case 20U:
case 17U:
m_type = CT_MISC;
return false;
case 39U:
return true;
default:
break;
}
}
// An unknown type
CUtils::dump(wxT("Unknown packet type from CCS"), m_buffer, m_length);
return true;
}
CAMBEData* CCCSProtocolHandler::readData()
{
if (m_type != CT_DATA)
return NULL;
CAMBEData* data = new CAMBEData;
bool res = data->setCCSData(m_buffer, m_length, m_yourAddress, m_yourPort, m_myPort);
if (!res) {
delete data;
return NULL;
}
return data;
}
CConnectData* CCCSProtocolHandler::readConnect()
{
if (m_type != CT_CONNECT)
return NULL;
CConnectData* connect = new CConnectData;
bool res = connect->setCCSData(m_buffer, m_length, m_yourAddress, m_yourPort, m_myPort);
if (!res) {
delete connect;
return NULL;
}
return connect;
}
CPollData* CCCSProtocolHandler::readPoll()
{
if (m_type != CT_POLL)
return NULL;
CPollData* poll = new CPollData;
bool res = poll->setCCSData(m_buffer, m_length, m_yourAddress, m_yourPort, m_myPort);
if (!res) {
delete poll;
return NULL;
}
return poll;
}
CCCSData* CCCSProtocolHandler::readMisc()
{
if (m_type != CT_MISC)
return NULL;
CCCSData* data = new CCCSData;
bool res = data->setCCSData(m_buffer, m_length, m_yourAddress, m_yourPort, m_myPort);
if (!res) {
delete data;
return NULL;
}
return data;
}
void CCCSProtocolHandler::close()
{
m_socket.close();
}