You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
452 lines
11 KiB
452 lines
11 KiB
/*
|
|
* Copyright (C) 2011,2013 by Jonathan Naylor G4KLX
|
|
* copyright (c) 2021 by Geoffrey Merck F4FXL / KC3FRA
|
|
*
|
|
* 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 <cstring>
|
|
#include <cassert>
|
|
|
|
#include "RemoteProtocolHandler.h"
|
|
#include "DStarDefines.h"
|
|
#include "SHA256.h"
|
|
#include "Utils.h"
|
|
#include "StringUtils.h"
|
|
#include "Log.h"
|
|
|
|
const unsigned int BUFFER_LENGTH = 2000U;
|
|
|
|
CRemoteProtocolHandler::CRemoteProtocolHandler(unsigned int port, const std::string& address) :
|
|
m_socket(address, port),
|
|
m_address(),
|
|
m_port(0U),
|
|
m_loggedIn(false),
|
|
m_type(RPHT_NONE),
|
|
m_inBuffer(NULL),
|
|
m_inLength(0U),
|
|
m_outBuffer(NULL)
|
|
{
|
|
assert(port > 0U);
|
|
|
|
m_inBuffer = new unsigned char[BUFFER_LENGTH];
|
|
m_outBuffer = new unsigned char[BUFFER_LENGTH];
|
|
}
|
|
|
|
CRemoteProtocolHandler::~CRemoteProtocolHandler()
|
|
{
|
|
delete[] m_outBuffer;
|
|
delete[] m_inBuffer;
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::open()
|
|
{
|
|
return m_socket.open();
|
|
}
|
|
|
|
RPH_TYPE CRemoteProtocolHandler::readType()
|
|
{
|
|
m_type = RPHT_NONE;
|
|
|
|
in_addr address;
|
|
unsigned int port;
|
|
|
|
int length = m_socket.read(m_inBuffer, BUFFER_LENGTH, address, port);
|
|
if (length <= 0)
|
|
return m_type;
|
|
|
|
// CUtils::dump("Incoming", m_inBuffer, length);
|
|
|
|
if (::memcmp(m_inBuffer, "LIN", 3U) == 0) {
|
|
m_loggedIn = false;
|
|
m_address = address;
|
|
m_port = port;
|
|
m_type = RPHT_LOGIN;
|
|
return m_type;
|
|
}
|
|
|
|
if (address.s_addr == inet_addr("127.0.0.1")) {
|
|
if (::memcmp(m_inBuffer, "LKS", 3U) == 0) {
|
|
m_inLength = length;
|
|
m_type = RPHT_LINKSCR;
|
|
return m_type;
|
|
}
|
|
}
|
|
|
|
if (m_loggedIn) {
|
|
if (address.s_addr != m_address.s_addr || port != m_port) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
}
|
|
|
|
m_inLength = length;
|
|
|
|
if (::memcmp(m_inBuffer, "SHA", 3U) == 0) {
|
|
if (m_loggedIn) {
|
|
sendNAK("Someone is already logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_HASH;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "GCS", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_CALLSIGNS;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "GRP", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_REPEATER;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "GSN", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_STARNET;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "LNK", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_LINK;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "UNL", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_UNLINK;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "LGO", 3U) == 0) {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_LOGOFF;
|
|
return m_type;
|
|
} else if (::memcmp(m_inBuffer, "LOG", 3U) == 0) {
|
|
if (!m_loggedIn)
|
|
return m_type;
|
|
m_type = RPHT_LOGOUT;
|
|
return m_type;
|
|
} else {
|
|
if (!m_loggedIn) {
|
|
sendNAK("You are not logged in");
|
|
return m_type;
|
|
}
|
|
m_type = RPHT_UNKNOWN;
|
|
return m_type;
|
|
}
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::readHash(const std::string& password, uint32_t random)
|
|
{
|
|
if (m_type != RPHT_HASH)
|
|
return false;
|
|
|
|
unsigned char* hash = m_inBuffer + 3U;
|
|
|
|
unsigned int len = password.length() + sizeof(uint32_t);
|
|
unsigned char* in = new unsigned char[len];
|
|
unsigned char* out = new unsigned char[32U];
|
|
|
|
::memcpy(in, &random, sizeof(uint32_t));
|
|
for (unsigned int i = 0U; i < password.length(); i++)
|
|
in[i + sizeof(unsigned int)] = password[i];
|
|
|
|
CSHA256 sha256;
|
|
sha256.buffer(in, len, out);
|
|
|
|
bool res = ::memcmp(out, hash, 32U) == 0;
|
|
|
|
delete[] in;
|
|
delete[] out;
|
|
|
|
return res;
|
|
}
|
|
|
|
std::string CRemoteProtocolHandler::readRepeater()
|
|
{
|
|
if (m_type != RPHT_REPEATER)
|
|
return "";
|
|
|
|
std::string callsign((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
|
|
return callsign;
|
|
}
|
|
|
|
#ifdef USE_STARNET
|
|
std::string CRemoteProtocolHandler::readStarNetGroup()
|
|
{
|
|
if (m_type != RPHT_STARNET)
|
|
return "";
|
|
|
|
std::string callsign((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
|
|
return callsign;
|
|
}
|
|
#endif
|
|
|
|
bool CRemoteProtocolHandler::readLogoff(std::string& callsign, std::string& user)
|
|
{
|
|
if (m_type != RPHT_LOGOFF)
|
|
return false;
|
|
|
|
callsign = std::string((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
user = std::string((char*)(m_inBuffer + 3U + LONG_CALLSIGN_LENGTH), LONG_CALLSIGN_LENGTH);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
bool CRemoteProtocolHandler::readLink(std::string& callsign, RECONNECT& reconnect, std::string& reflector)
|
|
{
|
|
if (m_type != RPHT_LINK)
|
|
return false;
|
|
|
|
callsign = std::string((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
|
|
int32_t temp;
|
|
::memcpy(&temp, m_inBuffer + 3U + LONG_CALLSIGN_LENGTH, sizeof(int32_t));
|
|
reconnect = RECONNECT(CUtils::swap_endian_be(temp));
|
|
|
|
reflector = std::string((char*)(m_inBuffer + 3U + LONG_CALLSIGN_LENGTH + sizeof(int32_t)),LONG_CALLSIGN_LENGTH);
|
|
|
|
if (reflector == (" "))
|
|
reflector.clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::readUnlink(std::string& callsign, PROTOCOL& protocol, std::string& reflector)
|
|
{
|
|
if (m_type != RPHT_UNLINK)
|
|
return false;
|
|
|
|
callsign = std::string((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
|
|
int32_t temp;
|
|
::memcpy(&temp, m_inBuffer + 3U + LONG_CALLSIGN_LENGTH, sizeof(int32_t));
|
|
protocol = PROTOCOL(CUtils::swap_endian_be(temp));
|
|
|
|
reflector = std::string((char*)(m_inBuffer + 3U + LONG_CALLSIGN_LENGTH + sizeof(int32_t)),LONG_CALLSIGN_LENGTH);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::readLinkScr(std::string& callsign, RECONNECT& reconnect, std::string& reflector)
|
|
{
|
|
if (m_type != RPHT_LINKSCR)
|
|
return false;
|
|
|
|
callsign = std::string((char*)(m_inBuffer + 3U), LONG_CALLSIGN_LENGTH);
|
|
|
|
reflector = std::string((char*)(m_inBuffer + 3U + LONG_CALLSIGN_LENGTH), LONG_CALLSIGN_LENGTH);
|
|
|
|
std::string rec = std::string((char*)(m_inBuffer + 3U + 2U * LONG_CALLSIGN_LENGTH),1U);
|
|
|
|
unsigned long val = std::stoul(rec);
|
|
|
|
reconnect = RECONNECT(val);
|
|
|
|
if (reflector == " ")
|
|
reflector.clear();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::sendCallsigns(const std::vector<std::string> & repeaters, const std::vector<std::string>& starNets)
|
|
{
|
|
unsigned char* p = m_outBuffer;
|
|
|
|
::memcpy(p, "CAL", 3U);
|
|
p += 3U;
|
|
|
|
for (unsigned int n = 0U; n < repeaters.size(); n++) {
|
|
*p++ = 'R';
|
|
|
|
::memset(p, ' ' , LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < repeaters[n].length(); i++)
|
|
p[i] = repeaters[n][i];
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
}
|
|
|
|
for (unsigned int n = 0U; n < starNets.size(); n++) {
|
|
*p++ = 'S';
|
|
|
|
::memset(p, ' ' , LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < starNets[n].length(); i++)
|
|
p[i] = starNets[n][i];
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
}
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, p - m_outBuffer);
|
|
|
|
return m_socket.write(m_outBuffer, p - m_outBuffer, m_address, m_port);
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::sendRepeater(const CRemoteRepeaterData& data)
|
|
{
|
|
unsigned char* p = m_outBuffer;
|
|
|
|
::memcpy(p, "RPT", 3U);
|
|
p += 3U;
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < data.getCallsign().length(); i++)
|
|
p[i] = data.getCallsign()[i];
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
int32_t reconnect = CUtils::swap_endian_be(data.getReconnect());
|
|
::memcpy(p, &reconnect, sizeof(int32_t));
|
|
p += sizeof(int32_t);
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < data.getReflector().length(); i++)
|
|
p[i] = data.getReflector()[i];
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
for (unsigned int n = 0U; n < data.getLinkCount(); n++) {
|
|
CRemoteLinkData* link = data.getLink(n);
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < link->getCallsign().length(); i++)
|
|
p[i] = link->getCallsign()[i];
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
int32_t protocol = CUtils::swap_endian_be(link->getProtocol());
|
|
::memcpy(p, &protocol, sizeof(int32_t));
|
|
p += sizeof(int32_t);
|
|
|
|
int32_t linked = CUtils::swap_endian_be(link->isLinked());
|
|
::memcpy(p, &linked, sizeof(int32_t));
|
|
p += sizeof(int32_t);
|
|
|
|
int32_t direction = CUtils::swap_endian_be(link->getDirection());
|
|
::memcpy(p, &direction, sizeof(int32_t));
|
|
p += sizeof(int32_t);
|
|
|
|
int32_t dongle = CUtils::swap_endian_be(link->isDongle());
|
|
::memcpy(p, &dongle, sizeof(int32_t));
|
|
p += sizeof(int32_t);
|
|
}
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, p - m_outBuffer);
|
|
|
|
return m_socket.write(m_outBuffer, p - m_outBuffer, m_address, m_port);
|
|
}
|
|
|
|
#if USE_STARNET
|
|
bool CRemoteProtocolHandler::sendStarNetGroup(const CRemoteStarNetGroup& data)
|
|
{
|
|
unsigned char* p = m_outBuffer;
|
|
|
|
::memcpy(p, "SNT", 3U);
|
|
p += 3U;
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < data.getCallsign().length(); i++)
|
|
p[i] = data.getCallsign().at(i);
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < data.getLogoff().length(); i++)
|
|
p[i] = data.getLogoff().at(i);
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
uint32_t timer = wxUINT32_SWAP_ON_BE(data.getTimer());
|
|
::memcpy(p, &timer, sizeof(uint32_t));
|
|
p += sizeof(uint32_t);
|
|
|
|
uint32_t timeout = wxUINT32_SWAP_ON_BE(data.getTimeout());
|
|
::memcpy(p, &timeout, sizeof(uint32_t));
|
|
p += sizeof(uint32_t);
|
|
|
|
for (unsigned int n = 0U; n < data.getUserCount(); n++) {
|
|
CRemoteStarNetUser& user = data.getUser(n);
|
|
|
|
::memset(p, ' ', LONG_CALLSIGN_LENGTH);
|
|
for (unsigned int i = 0U; i < user.getCallsign().length(); i++)
|
|
p[i] = user.getCallsign().at(i);
|
|
p += LONG_CALLSIGN_LENGTH;
|
|
|
|
timer = wxUINT32_SWAP_ON_BE(user.getTimer());
|
|
::memcpy(p, &timer, sizeof(uint32_t));
|
|
p += sizeof(uint32_t);
|
|
|
|
timeout = wxUINT32_SWAP_ON_BE(user.getTimeout());
|
|
::memcpy(p, &timeout, sizeof(uint32_t));
|
|
p += sizeof(uint32_t);
|
|
}
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, p - m_outBuffer);
|
|
|
|
return m_socket.write(m_outBuffer, p - m_outBuffer, m_address, m_port);
|
|
}
|
|
#endif
|
|
|
|
void CRemoteProtocolHandler::setLoggedIn(bool set)
|
|
{
|
|
m_loggedIn = set;
|
|
}
|
|
|
|
void CRemoteProtocolHandler::close()
|
|
{
|
|
m_socket.close();
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::sendACK()
|
|
{
|
|
::memcpy(m_outBuffer + 0U, "ACK", 3U);
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, 3U);
|
|
|
|
return m_socket.write(m_outBuffer, 3U, m_address, m_port);
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::sendNAK(const std::string& text)
|
|
{
|
|
::memcpy(m_outBuffer + 0U, "NAK", 3U);
|
|
|
|
::memset(m_outBuffer + 3U, 0x00U, text.length() + 1U);
|
|
|
|
for (unsigned int i = 0U; i < text.length(); i++)
|
|
m_outBuffer[i + 3U] = text[i];
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, 3U + text.length() + 1U);
|
|
|
|
return m_socket.write(m_outBuffer, 3U + text.length() + 1U, m_address, m_port);
|
|
}
|
|
|
|
bool CRemoteProtocolHandler::sendRandom(uint32_t random)
|
|
{
|
|
::memcpy(m_outBuffer + 0U, "RND", 3U);
|
|
|
|
CLog::logTrace("Send Random %X", random);
|
|
uint32_t temp = CUtils::swap_endian_be(random);
|
|
::memcpy(m_outBuffer + 3U, &temp, sizeof(uint32_t));
|
|
|
|
// CUtils::dump("Outgoing", m_outBuffer, 3U + sizeof(uint32_t));
|
|
|
|
return m_socket.write(m_outBuffer, 3U + sizeof(uint32_t), m_address, m_port);
|
|
}
|