KB8PMY
/
urfd
mirror of https://github.com/nostar/urfd.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

renamed ULX to URF

Browse Source
unstable
Tom Early 4 years ago
parent af66a282fd
commit 55deafb30c
10 changed files with 58 additions and 58 deletions
Show Stats Download Patch File Download Diff File

2
.gitignore vendored
Unescape View File

@ -11,4 +11,4 @@ configure.h
configure.sql
reflector.cfg
wiresx/configure.php
src/ulxd
urfd

2
reflector/BMClient.h
Unescape View File

@ -19,7 +19,7 @@
#pragma once
#include "Client.h"
#include "ULXClient.h"
#include "URFClient.h"
class CBmClient : public CClient
{

4
reflector/Makefile
Unescape View File

@ -37,7 +37,7 @@ endif
LDFLAGS=-pthread
XRFSRCS = Buffer.cpp Callsign.cpp CallsignList.cpp CallsignListItem.cpp Client.cpp Clients.cpp DCSClient.cpp DCSProtocol.cpp DExtraClient.cpp DExtraPeer.cpp DExtraProtocol.cpp DPlusClient.cpp DPlusProtocol.cpp DVFramePacket.cpp DVHeaderPacket.cpp DVLastFramePacket.cpp GateKeeper.cpp IP.cpp Notification.cpp Packet.cpp PacketStream.cpp PeerCallsignList.cpp Peer.cpp Peers.cpp Protocol.cpp Protocols.cpp Reflector.cpp UDPSocket.cpp User.cpp Users.cpp Version.cpp Main.cpp
XLXSRCS = BMClient.cpp BMPeer.cpp BPTC19696.cpp CRC.cpp DMRIdDir.cpp DMRIdDirFile.cpp DMRIdDirHttp.cpp DMRMMDVMClient.cpp DMRMMDVMProtocol.cpp DMRPlusClient.cpp DMRPlusProtocol.cpp Golay2087.cpp Golay24128.cpp Hamming.cpp QR1676.cpp RS129.cpp Semaphore.cpp Utils.cpp WiresXCmd.cpp WiresXCmdHandler.cpp WiresXInfo.cpp ULXClient.cpp ULXProtocol.cpp ULXPeer.cpp YSFClient.cpp YSFConvolution.cpp YSFFich.cpp YSFNode.cpp YSFNodeDir.cpp YSFNodeDirFile.cpp YSFNodeDirHttp.cpp YSFPayload.cpp YSFProtocol.cpp YSFUtils.cpp
XLXSRCS = BMClient.cpp BMPeer.cpp BPTC19696.cpp CRC.cpp DMRIdDir.cpp DMRIdDirFile.cpp DMRIdDirHttp.cpp DMRMMDVMClient.cpp DMRMMDVMProtocol.cpp DMRPlusClient.cpp DMRPlusProtocol.cpp Golay2087.cpp Golay24128.cpp Hamming.cpp QR1676.cpp RS129.cpp Semaphore.cpp Utils.cpp WiresXCmd.cpp WiresXCmdHandler.cpp WiresXInfo.cpp URFClient.cpp URFProtocol.cpp URFPeer.cpp YSFClient.cpp YSFConvolution.cpp YSFFich.cpp YSFNode.cpp YSFNodeDir.cpp YSFNodeDirFile.cpp YSFNodeDirHttp.cpp YSFPayload.cpp YSFProtocol.cpp YSFUtils.cpp
G3SRCS = G3Client.cpp G3Protocol.cpp RawSocket.cpp UDPMsgSocket.cpp
SRCS = $(XRFSRCS)
@ -58,7 +58,7 @@ endif
OBJS = $(SRCS:.cpp=.o)
DEPS = $(SRCS:.cpp=.d)
EXE=ulxd
EXE=urfd
all : $(EXE)

4
reflector/Protocols.cpp
Unescape View File

@ -20,7 +20,7 @@
#include "DExtraProtocol.h"
#include "DPlusProtocol.h"
#include "DCSProtocol.h"
#include "ULXProtocol.h"
#include "URFProtocol.h"
#include "DMRPlusProtocol.h"
#include "DMRMMDVMProtocol.h"
#include "YSFProtocol.h"
@ -68,7 +68,7 @@ bool CProtocols::Init(void)
if (! m_Protocols.back()->Initialize("YSF", EProtocol::ysf, YSF_PORT, YSF_IPV4, YSF_IPV6))
return false;
m_Protocols.emplace_back(std::unique_ptr<CUlxProtocol>(new CUlxProtocol));
m_Protocols.emplace_back(std::unique_ptr<CURFProtocol>(new CURFProtocol));
if (! m_Protocols.back()->Initialize("XLX", EProtocol::ulx, XLX_PORT, DMR_IPV4, DMR_IPV6))
return false;

12
reflector/ULXClient.cpp → reflector/URFClient.cpp
Unescape View File

@ -18,24 +18,24 @@
#include <string.h>
#include "Main.h"
#include "ULXClient.h"
#include "URFClient.h"
////////////////////////////////////////////////////////////////////////////////////////
// constructors
CUlxClient::CUlxClient()
CURFClient::CURFClient()
{
m_ProtRev = XLX_PROTOCOL_REVISION_0;
}
CUlxClient::CUlxClient(const CCallsign &callsign, const CIp &ip, char reflectorModule, int protRev)
CURFClient::CURFClient(const CCallsign &callsign, const CIp &ip, char reflectorModule, int protRev)
: CClient(callsign, ip, reflectorModule)
{
m_ProtRev = protRev;
}
CUlxClient::CUlxClient(const CUlxClient &client)
CURFClient::CURFClient(const CURFClient &client)
: CClient(client)
{
m_ProtRev = client.m_ProtRev;
@ -44,7 +44,7 @@ CUlxClient::CUlxClient(const CUlxClient &client)
////////////////////////////////////////////////////////////////////////////////////////
// identity
int CUlxClient::GetCodec(void) const
int CURFClient::GetCodec(void) const
{
int codec;
@ -65,7 +65,7 @@ int CUlxClient::GetCodec(void) const
////////////////////////////////////////////////////////////////////////////////////////
// status
bool CUlxClient::IsAlive(void) const
bool CURFClient::IsAlive(void) const
{
return (m_LastKeepaliveTime.time() < XLX_KEEPALIVE_TIMEOUT);
}

10
reflector/ULXClient.h → reflector/URFClient.h
Unescape View File

@ -24,16 +24,16 @@
#define XLX_PROTOCOL_REVISION_1 1 // AMBE only, revised connect mechanism
#define XLX_PROTOCOL_REVISION_2 2 // Transcoded AMBE+AMBE2 interlink
class CUlxClient : public CClient
class CURFClient : public CClient
{
public:
// constructors
CUlxClient();
CUlxClient(const CCallsign &, const CIp &, char = ' ', int = XLX_PROTOCOL_REVISION_0);
CUlxClient(const CUlxClient &);
CURFClient();
CURFClient(const CCallsign &, const CIp &, char = ' ', int = XLX_PROTOCOL_REVISION_0);
CURFClient(const CURFClient &);
// destructor
virtual ~CUlxClient() {};
virtual ~CURFClient() {};
// identity
EProtocol GetProtocol(void) const { return EProtocol::ulx; }

14
reflector/ULXPeer.cpp → reflector/URFPeer.cpp
Unescape View File

@ -19,19 +19,19 @@
#include "Main.h"
#include <string.h>
#include "Reflector.h"
#include "ULXPeer.h"
#include "ULXClient.h"
#include "URFPeer.h"
#include "URFClient.h"
////////////////////////////////////////////////////////////////////////////////////////
// constructor
CUlxPeer::CUlxPeer()
CURFPeer::CURFPeer()
{
}
CUlxPeer::CUlxPeer(const CCallsign &callsign, const CIp &ip, const char *modules, const CVersion &version)
CURFPeer::CURFPeer(const CCallsign &callsign, const CIp &ip, const char *modules, const CVersion &version)
: CPeer(callsign, ip, modules, version)
{
// get protocol revision
@ -42,14 +42,14 @@ CUlxPeer::CUlxPeer(const CCallsign &callsign, const CIp &ip, const char *modules
for ( unsigned i = 0; i < ::strlen(modules); i++ )
{
// create and append to vector
m_Clients.push_back(std::make_shared<CUlxClient>(callsign, ip, modules[i], protrev));
m_Clients.push_back(std::make_shared<CURFClient>(callsign, ip, modules[i], protrev));
}
}
////////////////////////////////////////////////////////////////////////////////////////
// status
bool CUlxPeer::IsAlive(void) const
bool CURFPeer::IsAlive(void) const
{
return (m_LastKeepaliveTime.time() < XLX_KEEPALIVE_TIMEOUT);
}
@ -57,7 +57,7 @@ bool CUlxPeer::IsAlive(void) const
////////////////////////////////////////////////////////////////////////////////////////
// revision helper
int CUlxPeer::GetProtocolRevision(const CVersion &version)
int CURFPeer::GetProtocolRevision(const CVersion &version)
{
int protrev = XLX_PROTOCOL_REVISION_0;

10
reflector/ULXPeer.h → reflector/URFPeer.h
Unescape View File

@ -19,15 +19,15 @@
#pragma once
#include "Peer.h"
#include "ULXClient.h"
#include "URFClient.h"
class CUlxPeer : public CPeer
class CURFPeer : public CPeer
{
public:
// constructors
CUlxPeer();
CUlxPeer(const CCallsign &, const CIp &, const char *, const CVersion &);
CUlxPeer(const CUlxPeer &) = delete;
CURFPeer();
CURFPeer(const CCallsign &, const CIp &, const char *, const CVersion &);
CURFPeer(const CURFPeer &) = delete;
// status
bool IsAlive(void) const;

56
reflector/ULXProtocol.cpp → reflector/URFProtocol.cpp
Unescape View File

@ -18,9 +18,9 @@
#include "Main.h"
#include <string.h>
#include "ULXPeer.h"
#include "URFPeer.h"
#include "BMPeer.h"
#include "ULXProtocol.h"
#include "URFProtocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
@ -28,7 +28,7 @@
////////////////////////////////////////////////////////////////////////////////////////
// operation
bool CUlxProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
bool CURFProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
return false;
@ -44,7 +44,7 @@ bool CUlxProtocol::Initialize(const char *type, const EProtocol ptype, const uin
////////////////////////////////////////////////////////////////////////////////////////
// task
void CUlxProtocol::Task(void)
void CURFProtocol::Task(void)
{
CBuffer Buffer;
CIp Ip;
@ -218,7 +218,7 @@ void CUlxProtocol::Task(void)
////////////////////////////////////////////////////////////////////////////////////////
// queue helper
void CUlxProtocol::HandleQueue(void)
void CURFProtocol::HandleQueue(void)
{
m_Queue.Lock();
while ( !m_Queue.empty() )
@ -285,7 +285,7 @@ void CUlxProtocol::HandleQueue(void)
////////////////////////////////////////////////////////////////////////////////////////
// keepalive helpers
void CUlxProtocol::HandleKeepalives(void)
void CURFProtocol::HandleKeepalives(void)
{
// DExtra protocol sends and monitors keepalives packets
// event if the client is currently streaming
@ -327,7 +327,7 @@ void CUlxProtocol::HandleKeepalives(void)
////////////////////////////////////////////////////////////////////////////////////////
// Peers helpers
void CUlxProtocol::HandlePeerLinks(void)
void CURFProtocol::HandlePeerLinks(void)
{
CBuffer buffer;
@ -378,7 +378,7 @@ void CUlxProtocol::HandlePeerLinks(void)
////////////////////////////////////////////////////////////////////////////////////////
// streams helpers
void CUlxProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, const CIp &Ip)
void CURFProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, const CIp &Ip)
{
CCallsign peer;
@ -423,7 +423,7 @@ void CUlxProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
}
}
void CUlxProtocol::OnDvFramePacketIn(std::unique_ptr<CDvFramePacket> &DvFrame, const CIp *Ip)
void CURFProtocol::OnDvFramePacketIn(std::unique_ptr<CDvFramePacket> &DvFrame, const CIp *Ip)
{
// tag packet as remote peer origin
DvFrame->SetRemotePeerOrigin();
@ -432,7 +432,7 @@ void CUlxProtocol::OnDvFramePacketIn(std::unique_ptr<CDvFramePacket> &DvFrame, c
CDextraProtocol::OnDvFramePacketIn(DvFrame, Ip);
}
void CUlxProtocol::OnDvLastFramePacketIn(std::unique_ptr<CDvLastFramePacket> &DvFrame, const CIp *Ip)
void CURFProtocol::OnDvLastFramePacketIn(std::unique_ptr<CDvLastFramePacket> &DvFrame, const CIp *Ip)
{
// tag packet as remote peer origin
DvFrame->SetRemotePeerOrigin();
@ -445,7 +445,7 @@ void CUlxProtocol::OnDvLastFramePacketIn(std::unique_ptr<CDvLastFramePacket> &Dv
////////////////////////////////////////////////////////////////////////////////////////
// packet decoding helpers
bool CUlxProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *callsign)
bool CURFProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *callsign)
{
bool valid = false;
if (Buffer.size() == 9)
@ -457,7 +457,7 @@ bool CUlxProtocol::IsValidKeepAlivePacket(const CBuffer &Buffer, CCallsign *call
}
bool CUlxProtocol::IsValidConnectPacket(const CBuffer &Buffer, CCallsign *callsign, char *modules, CVersion *version)
bool CURFProtocol::IsValidConnectPacket(const CBuffer &Buffer, CCallsign *callsign, char *modules, CVersion *version)
{
bool valid = false;
if ((Buffer.size() == 39) && (Buffer.data()[0] == 'L') && (Buffer.data()[38] == 0))
@ -474,7 +474,7 @@ bool CUlxProtocol::IsValidConnectPacket(const CBuffer &Buffer, CCallsign *callsi
return valid;
}
bool CUlxProtocol::IsValidDisconnectPacket(const CBuffer &Buffer, CCallsign *callsign)
bool CURFProtocol::IsValidDisconnectPacket(const CBuffer &Buffer, CCallsign *callsign)
{
bool valid = false;
if ((Buffer.size() == 10) && (Buffer.data()[0] == 'U') && (Buffer.data()[9] == 0))
@ -485,7 +485,7 @@ bool CUlxProtocol::IsValidDisconnectPacket(const CBuffer &Buffer, CCallsign *cal
return valid;
}
bool CUlxProtocol::IsValidAckPacket(const CBuffer &Buffer, CCallsign *callsign, char *modules, CVersion *version)
bool CURFProtocol::IsValidAckPacket(const CBuffer &Buffer, CCallsign *callsign, char *modules, CVersion *version)
{
bool valid = false;
if ((Buffer.size() == 39) && (Buffer.data()[0] == 'A') && (Buffer.data()[38] == 0))
@ -502,7 +502,7 @@ bool CUlxProtocol::IsValidAckPacket(const CBuffer &Buffer, CCallsign *callsign,
return valid;
}
bool CUlxProtocol::IsValidNackPacket(const CBuffer &Buffer, CCallsign *callsign)
bool CURFProtocol::IsValidNackPacket(const CBuffer &Buffer, CCallsign *callsign)
{
bool valid = false;
if ((Buffer.size() == 10) && (Buffer.data()[0] == 'N') && (Buffer.data()[9] == 0))
@ -513,7 +513,7 @@ bool CUlxProtocol::IsValidNackPacket(const CBuffer &Buffer, CCallsign *callsign)
return valid;
}
bool CUlxProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr<CDvFramePacket> &dvframe)
bool CURFProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr<CDvFramePacket> &dvframe)
{
// base class first (protocol revision 1 and lower)
if (CDextraProtocol::IsValidDvFramePacket(Buffer, dvframe))
@ -538,7 +538,7 @@ bool CUlxProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::unique_ptr<C
return false;
}
bool CUlxProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr<CDvLastFramePacket> &dvframe)
bool CURFProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_ptr<CDvLastFramePacket> &dvframe)
{
// base class first (protocol revision 1 and lower)
if (CDextraProtocol::IsValidDvLastFramePacket(Buffer, dvframe))
@ -566,12 +566,12 @@ bool CUlxProtocol::IsValidDvLastFramePacket(const CBuffer &Buffer, std::unique_p
////////////////////////////////////////////////////////////////////////////////////////
// packet encoding helpers
void CUlxProtocol::EncodeKeepAlivePacket(CBuffer *Buffer)
void CURFProtocol::EncodeKeepAlivePacket(CBuffer *Buffer)
{
Buffer->Set(GetReflectorCallsign());
}
void CUlxProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules)
void CURFProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules)
{
uint8_t tag[] = { 'L' };
@ -589,7 +589,7 @@ void CUlxProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules)
Buffer->resize(39);
}
void CUlxProtocol::EncodeDisconnectPacket(CBuffer *Buffer)
void CURFProtocol::EncodeDisconnectPacket(CBuffer *Buffer)
{
uint8_t tag[] = { 'U' };
@ -601,7 +601,7 @@ void CUlxProtocol::EncodeDisconnectPacket(CBuffer *Buffer)
Buffer->Append((uint8_t)0);
}
void CUlxProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules)
void CURFProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules)
{
uint8_t tag[] = { 'A' };
@ -619,7 +619,7 @@ void CUlxProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules)
Buffer->resize(39);
}
void CUlxProtocol::EncodeConnectNackPacket(CBuffer *Buffer)
void CURFProtocol::EncodeConnectNackPacket(CBuffer *Buffer)
{
uint8_t tag[] = { 'N' };
@ -631,7 +631,7 @@ void CUlxProtocol::EncodeConnectNackPacket(CBuffer *Buffer)
Buffer->Append((uint8_t)0);
}
bool CUlxProtocol::EncodeDvFramePacket(const CDvFramePacket &Packet, CBuffer *Buffer) const
bool CURFProtocol::EncodeDvFramePacket(const CDvFramePacket &Packet, CBuffer *Buffer) const
{
uint8_t tag[] = { 'D','S','V','T',0x20,0x00,0x00,0x00,0x20,0x00,0x01,0x02 };
@ -650,7 +650,7 @@ bool CUlxProtocol::EncodeDvFramePacket(const CDvFramePacket &Packet, CBuffer *Bu
}
bool CUlxProtocol::EncodeDvLastFramePacket(const CDvLastFramePacket &Packet, CBuffer *Buffer) const
bool CURFProtocol::EncodeDvLastFramePacket(const CDvLastFramePacket &Packet, CBuffer *Buffer) const
{
uint8_t tag[] = { 'D','S','V','T',0x20,0x00,0x00,0x00,0x20,0x00,0x01,0x02 };
uint8_t dstarambe[] = { 0x55,0xC8,0x7A,0x00,0x00,0x00,0x00,0x00,0x00 };
@ -674,7 +674,7 @@ bool CUlxProtocol::EncodeDvLastFramePacket(const CDvLastFramePacket &Packet, CBu
////////////////////////////////////////////////////////////////////////////////////////
// protocol revision helper
int CUlxProtocol::GetConnectingPeerProtocolRevision(const CCallsign &Callsign, const CVersion &Version)
int CURFProtocol::GetConnectingPeerProtocolRevision(const CCallsign &Callsign, const CVersion &Version)
{
int protrev;
@ -686,14 +686,14 @@ int CUlxProtocol::GetConnectingPeerProtocolRevision(const CCallsign &Callsign, c
// otherwise, assume native xlx
else
{
protrev = CUlxPeer::GetProtocolRevision(Version);
protrev = CURFPeer::GetProtocolRevision(Version);
}
// done
return protrev;
}
std::shared_ptr<CPeer> CUlxProtocol::CreateNewPeer(const CCallsign &Callsign, const CIp &Ip, char *Modules, const CVersion &Version)
std::shared_ptr<CPeer> CURFProtocol::CreateNewPeer(const CCallsign &Callsign, const CIp &Ip, char *Modules, const CVersion &Version)
{
// BM ?
if ( Callsign.HasSameCallsignWithWildcard(CCallsign("BM*")) )
@ -702,6 +702,6 @@ std::shared_ptr<CPeer> CUlxProtocol::CreateNewPeer(const CCallsign &Callsign, co
}
else
{
return std::make_shared<CUlxPeer>(Callsign, Ip, Modules, Version);
return std::make_shared<CURFPeer>(Callsign, Ip, Modules, Version);
}
}

2
reflector/ULXProtocol.h → reflector/URFProtocol.h
Unescape View File

@ -30,7 +30,7 @@ class CPeer;
////////////////////////////////////////////////////////////////////////////////////////
// class
class CUlxProtocol : public CDextraProtocol
class CURFProtocol : public CDextraProtocol
{
public:
// initialization
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.