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

it compiles

Browse Source
pull/1/head
Tom Early 3 years ago
parent 6e7ba8c5a0
commit 72e64ec801
82 changed files with 552 additions and 750 deletions
Show Stats Download Patch File Download Diff File

4
config/urfd.interlink
Unescape View File

@ -5,12 +5,10 @@
# each entry specifies a remote XLX or XRF to peer with # each entry specifies a remote XLX or XRF to peer with
# format: # format:
# <URF callsign> <ip> <list of modules shared> # <URF callsign> <ip> <list of modules shared>
# <XRF callsign> <ip> <local module><remote module>
# example: # example:
# URF270 158.64.26.132 ACD # URF270 158.64.26.132 ACD
# XRF270 158.64.26.132 BB
# #
# note: the remote XLX must list this XLX in its interlink file # note: the remote URFD must list this in its interlink file
# for the link to be established # for the link to be established
# #
############################################################################# #############################################################################

2
reflector/BMClient.cpp
Unescape View File

@ -43,5 +43,5 @@ CBmClient::CBmClient(const CBmClient &client)
bool CBmClient::IsAlive(void) const bool CBmClient::IsAlive(void) const
{ {
return (m_LastKeepaliveTime.time() < XLX_KEEPALIVE_TIMEOUT); return (m_LastKeepaliveTime.time() < BM_KEEPALIVE_TIMEOUT);
} }

1
reflector/BMClient.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CBmClient : public CClient class CBmClient : public CClient

2
reflector/BMPeer.cpp
Unescape View File

@ -50,7 +50,7 @@ CBmPeer::CBmPeer(const CCallsign &callsign, const CIp &ip, const char *modules,
bool CBmPeer::IsAlive(void) const bool CBmPeer::IsAlive(void) const
{ {
return (m_LastKeepaliveTime.time() < XLX_KEEPALIVE_TIMEOUT); return (m_LastKeepaliveTime.time() < BM_KEEPALIVE_TIMEOUT);
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////

45
reflector/BMProtocol.cpp
Unescape View File

@ -18,12 +18,9 @@
#include <string.h> #include <string.h>
#include "BMPeer.h" #include "BMPeer.h"
#include "BMProtocol.h" #include "BMProtocol.h"
#include "Reflector.h" #include "Global.h"
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -104,7 +101,7 @@ void CBMProtocol::Task(void)
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::bm, Modules) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::bm, Modules) )
{ {
// already connected ? // already connected ?
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
if ( peers->FindPeer(Callsign, Ip, EProtocol::bm) == nullptr ) if ( peers->FindPeer(Callsign, Ip, EProtocol::bm) == nullptr )
{ {
// create the new peer // create the new peer
@ -115,7 +112,7 @@ void CBMProtocol::Task(void)
// this also add all new clients to reflector client list // this also add all new clients to reflector client list
peers->AddPeer(peer); peers->AddPeer(peer);
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
} }
else if ( IsValidDisconnectPacket(Buffer, &Callsign) ) else if ( IsValidDisconnectPacket(Buffer, &Callsign) )
@ -123,7 +120,7 @@ void CBMProtocol::Task(void)
std::cout << "XLX disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "XLX disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find peer // find peer
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::bm); std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::bm);
if ( peer != nullptr ) if ( peer != nullptr )
{ {
@ -132,7 +129,7 @@ void CBMProtocol::Task(void)
// and delete them // and delete them
peers->RemovePeer(peer); peers->RemovePeer(peer);
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
else if ( IsValidNackPacket(Buffer, &Callsign) ) else if ( IsValidNackPacket(Buffer, &Callsign) )
{ {
@ -143,14 +140,14 @@ void CBMProtocol::Task(void)
//std::cout << "XLX keepalive packet from " << Callsign << " at " << Ip << std::endl; //std::cout << "XLX keepalive packet from " << Callsign << " at " << Ip << std::endl;
// find peer // find peer
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::bm); std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::bm);
if ( peer != nullptr ) if ( peer != nullptr )
{ {
// keep it alive // keep it alive
peer->Alive(); peer->Alive();
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
else else
{ {
@ -167,7 +164,7 @@ void CBMProtocol::Task(void)
HandleQueue(); HandleQueue();
// keep alive // keep alive
if ( m_LastKeepaliveTime.time() > XLX_KEEPALIVE_PERIOD ) if ( m_LastKeepaliveTime.time() > BM_KEEPALIVE_PERIOD )
{ {
// handle keep alives // handle keep alives
HandleKeepalives(); HandleKeepalives();
@ -177,7 +174,7 @@ void CBMProtocol::Task(void)
} }
// peer connections // peer connections
if ( m_LastPeersLinkTime.time() > XLX_RECONNECT_PERIOD ) if ( m_LastPeersLinkTime.time() > BM_RECONNECT_PERIOD )
{ {
// handle remote peers connections // handle remote peers connections
HandlePeerLinks(); HandlePeerLinks();
@ -210,7 +207,7 @@ void CBMProtocol::HandleQueue(void)
} }
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::bm, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::bm, it)) != nullptr )
@ -237,7 +234,7 @@ void CBMProtocol::HandleQueue(void)
} }
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -255,7 +252,7 @@ void CBMProtocol::HandleKeepalives(void)
EncodeKeepAlivePacket(&keepalive); EncodeKeepAlivePacket(&keepalive);
// iterate on peers // iterate on peers
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
auto pit = peers->begin(); auto pit = peers->begin();
std::shared_ptr<CPeer>peer = nullptr; std::shared_ptr<CPeer>peer = nullptr;
while ( (peer = peers->FindNextPeer(EProtocol::bm, pit)) != nullptr ) while ( (peer = peers->FindNextPeer(EProtocol::bm, pit)) != nullptr )
@ -282,7 +279,7 @@ void CBMProtocol::HandleKeepalives(void)
peers->RemovePeer(peer); peers->RemovePeer(peer);
} }
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -294,7 +291,7 @@ void CBMProtocol::HandlePeerLinks(void)
// get the list of peers // get the list of peers
CPeerCallsignList *list = g_Gate.GetPeerList(); CPeerCallsignList *list = g_Gate.GetPeerList();
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
// check if all our connected peers are still listed by gatekeeper // check if all our connected peers are still listed by gatekeeper
// if not, disconnect // if not, disconnect
@ -324,13 +321,13 @@ void CBMProtocol::HandlePeerLinks(void)
it->ResolveIp(); it->ResolveIp();
// send connect packet to re-initiate peer link // send connect packet to re-initiate peer link
EncodeConnectPacket(&buffer, it->GetModules()); EncodeConnectPacket(&buffer, it->GetModules());
Send(buffer, it->GetIp(), XLX_PORT); Send(buffer, it->GetIp(), m_Port);
std::cout << "Sending connect packet to BM peer " << cs << " @ " << it->GetIp() << " for modules " << it->GetModules() << std::endl; std::cout << "Sending connect packet to BM peer " << cs << " @ " << it->GetIp() << " for modules " << it->GetModules() << std::endl;
} }
} }
// done // done
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
g_Gate.ReleasePeerList(); g_Gate.ReleasePeerList();
} }
@ -360,11 +357,11 @@ void CBMProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, c
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// no stream open yet, open a new one // no stream open yet, open a new one
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::bm, Header->GetRpt2Module()); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::bm, Header->GetRpt2Module());
if ( client ) if ( client )
{ {
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
@ -373,10 +370,10 @@ void CBMProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, c
peer = client->GetCallsign(); peer = client->GetCallsign();
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2, peer); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2, peer);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }

1
reflector/BMProtocol.h
Unescape View File

@ -18,6 +18,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Defines.h"
#include "Version.h" #include "Version.h"
#include "Timer.h" #include "Timer.h"
#include "SEProtocol.h" #include "SEProtocol.h"

1
reflector/Buffer.cpp
Unescape View File

@ -16,6 +16,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <iostream>
#include <string.h> #include <string.h>
#include "Buffer.h" #include "Buffer.h"

6
reflector/CNotificationQueue.h
Unescape View File

@ -23,12 +23,6 @@
#include "Notification.h" #include "Notification.h"
////////////////////////////////////////////////////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////////////
// class
class CNotificationQueue class CNotificationQueue
{ {
public: public:

7
reflector/Callsign.cpp
Unescape View File

@ -19,10 +19,7 @@
#include <string.h> #include <string.h>
#include <cctype> #include <cctype>
#include "DMRIdDirFile.h" #include "Global.h"
#include "DMRIdDirHttp.h"
#include "NXDNIdDirFile.h"
#include "NXDNIdDirHttp.h"
#include "Callsign.h" #include "Callsign.h"
// if a client is using special characters '.', '-' or '/', he's out of luck! // if a client is using special characters '.', '-' or '/', he's out of luck!
@ -277,7 +274,7 @@ void CCallsign::SetNXDNid(uint16_t nxdnid, bool UpdateCallsign)
m_uiNXDNid = nxdnid; m_uiNXDNid = nxdnid;
if ( UpdateCallsign ) if ( UpdateCallsign )
{ {
g_LDid.Lock(); g_LNid.Lock();
{ {
const CCallsign *callsign = g_LNid.FindCallsign(nxdnid); const CCallsign *callsign = g_LNid.FindCallsign(nxdnid);
if ( callsign != nullptr ) if ( callsign != nullptr )

11
reflector/CallsignList.cpp
Unescape View File

@ -16,6 +16,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <fstream>
#include <string.h> #include <string.h>
#include <fcntl.h> #include <fcntl.h>
#include <sys/stat.h> #include <sys/stat.h>
@ -34,7 +35,7 @@ CCallsignList::CCallsignList()
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// file io // file io
bool CCallsignList::LoadFromFile(const char *filename) bool CCallsignList::LoadFromFile(const std::string &filename)
{ {
bool ok = false; bool ok = false;
char sz[256]; char sz[256];
@ -77,7 +78,7 @@ bool CCallsignList::LoadFromFile(const char *filename)
file.close(); file.close();
// keep file path // keep file path
m_Filename = filename; m_Filename.assign(filename);
// update time // update time
GetLastModTime(&m_LastModTime); GetLastModTime(&m_LastModTime);
@ -99,7 +100,7 @@ bool CCallsignList::ReloadFromFile(void)
{ {
bool ok = false; bool ok = false;
if ( m_Filename != nullptr ) if (! m_Filename.empty())
{ {
ok = LoadFromFile(m_Filename); ok = LoadFromFile(m_Filename);
} }
@ -210,10 +211,10 @@ bool CCallsignList::GetLastModTime(time_t *time)
{ {
bool ok = false; bool ok = false;
if ( m_Filename != nullptr ) if (! m_Filename.empty())
{ {
struct stat fileStat; struct stat fileStat;
if( ::stat(m_Filename, &fileStat) != -1 ) if( ::stat(m_Filename.c_str(), &fileStat) != -1 )
{ {
*time = fileStat.st_mtime; *time = fileStat.st_mtime;
ok = true; ok = true;

10
reflector/CallsignList.h
Unescape View File

@ -18,6 +18,9 @@
#pragma once #pragma once
#include <list>
#include <mutex>
#include "CallsignListItem.h" #include "CallsignListItem.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -29,15 +32,12 @@ public:
// constructor // constructor
CCallsignList(); CCallsignList();
// destructor
virtual ~CCallsignList() {}
// locks // locks
void Lock(void) { m_Mutex.lock(); } void Lock(void) { m_Mutex.lock(); }
void Unlock(void) { m_Mutex.unlock(); } void Unlock(void) { m_Mutex.unlock(); }
// file io // file io
virtual bool LoadFromFile(const char *); virtual bool LoadFromFile(const std::string &str);
bool ReloadFromFile(void); bool ReloadFromFile(void);
bool NeedReload(void); bool NeedReload(void);
@ -61,7 +61,7 @@ protected:
// data // data
std::mutex m_Mutex; std::mutex m_Mutex;
const char * m_Filename; std::string m_Filename;
time_t m_LastModTime; time_t m_LastModTime;
std::list<CCallsignListItem> m_Callsigns; std::list<CCallsignListItem> m_Callsigns;
}; };

12
reflector/CallsignListItem.cpp
Unescape View File

@ -18,6 +18,8 @@
#include <string.h> #include <string.h>
#include "Global.h"
#include "CallsignListItem.h" #include "CallsignListItem.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -31,6 +33,7 @@ CCallsignListItem::CCallsignListItem()
CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const CIp &ip, const char *modules) CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const CIp &ip, const char *modules)
{ {
const std::string mods(g_Conf.GetString(g_Conf.j.modules.modules));
m_Callsign = callsign; m_Callsign = callsign;
memset(m_szUrl, 0, sizeof(m_szUrl)); memset(m_szUrl, 0, sizeof(m_szUrl));
m_Ip = ip; m_Ip = ip;
@ -39,14 +42,14 @@ CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const CIp &ip, c
memset(m_Modules, 0, sizeof(m_Modules)); memset(m_Modules, 0, sizeof(m_Modules));
if ( modules[0] == '*' ) if ( modules[0] == '*' )
{ {
memcpy(m_Modules, ACTIVE_MODULES, sizeof(ACTIVE_MODULES)); memcpy(m_Modules, mods.c_str(), mods.size());
} }
else else
{ {
int n = MIN(::strlen(modules), sizeof(m_Modules)-1); int n = MIN(::strlen(modules), sizeof(m_Modules)-1);
for (int i=0, j=0; i<n; i++) for (int i=0, j=0; i<n; i++)
{ {
if (strchr(ACTIVE_MODULES, modules[i])) if (std::string::npos != mods.find(modules[i]))
{ {
m_Modules[j++] = modules[i]; m_Modules[j++] = modules[i];
} }
@ -57,6 +60,7 @@ CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const CIp &ip, c
CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const char *url, const char *modules) CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const char *url, const char *modules)
{ {
const std::string mods(g_Conf.GetString(g_Conf.j.modules.modules));
m_Callsign = callsign; m_Callsign = callsign;
::strncpy(m_szUrl, url, URL_MAXLEN); ::strncpy(m_szUrl, url, URL_MAXLEN);
m_Ip = CIp(m_szUrl); m_Ip = CIp(m_szUrl);
@ -65,14 +69,14 @@ CCallsignListItem::CCallsignListItem(const CCallsign &callsign, const char *url,
memset(m_Modules, 0, sizeof(m_Modules)); memset(m_Modules, 0, sizeof(m_Modules));
if ( modules[0] == '*' ) if ( modules[0] == '*' )
{ {
memcpy(m_Modules, ACTIVE_MODULES, sizeof(ACTIVE_MODULES)); memcpy(m_Modules, mods.c_str(), mods.size());
} }
else else
{ {
int n = MIN(::strlen(modules), sizeof(m_Modules)-1); int n = MIN(::strlen(modules), sizeof(m_Modules)-1);
for (int i=0, j=0; i<n; i++) for (int i=0, j=0; i<n; i++)
{ {
if (strchr(ACTIVE_MODULES, modules[i])) if (std::string::npos != mods.find(modules[i]))
{ {
m_Modules[j++] = modules[i]; m_Modules[j++] = modules[i];
} }

1
reflector/Client.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "IP.h" #include "IP.h"
#include "Callsign.h" #include "Callsign.h"

8
reflector/Clients.cpp
Unescape View File

@ -17,14 +17,12 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Reflector.h" #include "Global.h"
#include "Clients.h" #include "Clients.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
CClients::CClients() CClients::CClients()
{ {
} }
@ -66,7 +64,7 @@ void CClients::AddClient(std::shared_ptr<CClient> client)
} }
std::cout << std::endl; std::cout << std::endl;
// notify // notify
g_Refl..OnClientsChanged(); g_Refl.OnClientsChanged();
} }
void CClients::RemoveClient(std::shared_ptr<CClient> client) void CClients::RemoveClient(std::shared_ptr<CClient> client)
@ -90,7 +88,7 @@ void CClients::RemoveClient(std::shared_ptr<CClient> client)
std::cout << std::endl; std::cout << std::endl;
m_Clients.erase(it); m_Clients.erase(it);
// notify // notify
g_Refl..OnClientsChanged(); g_Refl.OnClientsChanged();
break; break;
} }
} }

10
reflector/Configure.cpp
Unescape View File

@ -441,7 +441,7 @@ bool CConfigure::ReadData(const std::string &path)
data[j.usrp.defaultcallsign] = cs; data[j.usrp.defaultcallsign] = cs;
} }
else if (0 == key.compare(JCLIENTSPATH)) else if (0 == key.compare(JCLIENTSPATH))
data[j.usrp.clientfilepath] == value; data[j.usrp.clientfilepath] = value;
else else
badParam(key); badParam(key);
break; break;
@ -915,14 +915,14 @@ bool CConfigure::IsString(const std::string &key) const
#ifdef INICHECK #ifdef INICHECK
int main(int argc, char *argv[]) int main(int argc, char *argv[])
{ {
if (argc == 2) if (argc == 2 || argc == 3)
{ {
CConfigure d; CConfigure d;
auto rval = d.ReadData(argv[1]); auto rval = d.ReadData(argv[argc-1]);
d.Dump(true); d.Dump((2==argc) ? false : true);
return rval ? EXIT_FAILURE : EXIT_SUCCESS; return rval ? EXIT_FAILURE : EXIT_SUCCESS;
} }
std::cerr << "Usage: " << argv[0] << " FILENAME" << std::endl; std::cerr << "Usage: " << argv[0] << " <x> FILENAME\nWhere <x> is anything.\nThis option only shows values whose key begins with an uppercase letter." << std::endl;
return EXIT_SUCCESS; return EXIT_SUCCESS;
} }
#endif #endif

1
reflector/DCSClient.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CDcsClient : public CClient class CDcsClient : public CClient

39
reflector/DCSProtocol.cpp
Unescape View File

@ -16,12 +16,11 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <string.h> #include <string.h>
#include "Global.h"
#include "DCSClient.h" #include "DCSClient.h"
#include "DCSProtocol.h" #include "DCSProtocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -80,18 +79,18 @@ void CDcsProtocol::Task(void)
std::cout << "DCS connect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl; std::cout << "DCS connect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl;
// callsign authorized? // callsign authorized?
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::dcs) && g_Refl..IsValidModule(ToLinkModule) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::dcs) && g_Refl.IsValidModule(ToLinkModule) )
{ {
// valid module ? // valid module ?
if ( g_Refl..IsValidModule(ToLinkModule) ) if ( g_Refl.IsValidModule(ToLinkModule) )
{ {
// acknowledge the request // acknowledge the request
EncodeConnectAckPacket(Callsign, ToLinkModule, &Buffer); EncodeConnectAckPacket(Callsign, ToLinkModule, &Buffer);
Send(Buffer, Ip); Send(Buffer, Ip);
// create the client and append // create the client and append
g_Refl..GetClients()->AddClient(std::make_shared<CDcsClient>(Callsign, Ip, ToLinkModule)); g_Refl.GetClients()->AddClient(std::make_shared<CDcsClient>(Callsign, Ip, ToLinkModule));
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -115,7 +114,7 @@ void CDcsProtocol::Task(void)
std::cout << "DCS disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "DCS disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dcs); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dcs);
if ( client != nullptr ) if ( client != nullptr )
{ {
@ -125,21 +124,21 @@ void CDcsProtocol::Task(void)
EncodeConnectNackPacket(Callsign, ' ', &Buffer); EncodeConnectNackPacket(Callsign, ' ', &Buffer);
Send(Buffer, Ip); Send(Buffer, Ip);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidKeepAlivePacket(Buffer, &Callsign) ) else if ( IsValidKeepAlivePacket(Buffer, &Callsign) )
{ {
//std::cout << "DCS keepalive packet from " << Callsign << " at " << Ip << std::endl; //std::cout << "DCS keepalive packet from " << Callsign << " at " << Ip << std::endl;
// find all clients with that callsign & ip and keep them alive // find all clients with that callsign & ip and keep them alive
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dcs, it)) != nullptr ) while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dcs, it)) != nullptr )
{ {
client->Alive(); client->Alive();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsIgnorePacket(Buffer) ) else if ( IsIgnorePacket(Buffer) )
{ {
@ -193,24 +192,24 @@ void CDcsProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::dcs); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::dcs);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
rpt1 = client->GetCallsign(); rpt1 = client->GetCallsign();
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -253,7 +252,7 @@ void CDcsProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dcs, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dcs, it)) != nullptr )
@ -266,7 +265,7 @@ void CDcsProtocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
} }
@ -285,7 +284,7 @@ void CDcsProtocol::HandleKeepalives(void)
EncodeKeepAlivePacket(&keepalive1); EncodeKeepAlivePacket(&keepalive1);
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dcs, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dcs, it)) != nullptr )
@ -318,7 +317,7 @@ void CDcsProtocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////

1
reflector/DCSProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"

2
reflector/DExtraClient.cpp
Unescape View File

@ -16,10 +16,8 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "DExtraClient.h" #include "DExtraClient.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructors // constructors

8
reflector/DExtraClient.h
Unescape View File

@ -18,15 +18,9 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
////////////////////////////////////////////////////////////////////////////////////////
// define
////////////////////////////////////////////////////////////////////////////////////////
// class
class CDextraClient : public CClient class CDextraClient : public CClient
{ {
public: public:

67
reflector/DExtraPeer.cpp
Unescape View File

@ -1,67 +0,0 @@
// Created by Antony Chazapis (SV9OAN) on 25/2/2018.
// Copyright © 2016 Jean-Luc Deltombe (LX3JL). All rights reserved.
// urfd -- The universal reflector
// Copyright © 2021 Thomas A. Early N7TAE
//
// 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 3 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, see <https://www.gnu.org/licenses/>.
#include <string.h>
#include "Reflector.h"
#include "DExtraPeer.h"
#include "DExtraClient.h"
////////////////////////////////////////////////////////////////////////////////////////
// constructor
CDextraPeer::CDextraPeer()
{
}
CDextraPeer::CDextraPeer(const CCallsign &callsign, const CIp &ip, const char *modules, const CVersion &version)
: CPeer(callsign, ip, modules, version)
{
std::cout << "Adding DExtra peer" << std::endl;
// and construct the DExtra clients
for ( unsigned i = 0; i < ::strlen(modules); i++ )
{
// create and append to list
m_Clients.push_back(std::make_shared<CDextraClient>(callsign, ip, modules[i], EProtoRev::ambe));
}
}
////////////////////////////////////////////////////////////////////////////////////////
// status
bool CDextraPeer::IsAlive(void) const
{
for ( auto it=cbegin(); it!=cend(); it++ )
{
if (! (*it)->IsAlive())
return false;
}
return true;
}
////////////////////////////////////////////////////////////////////////////////////////
// revision helper
int CDextraPeer::GetProtocolRevision(const CVersion &version)
{
return version.GetMajor();
}

42
reflector/DExtraPeer.h
Unescape View File

@ -1,42 +0,0 @@
// Created by Antony Chazapis (SV9OAN) on 25/2/2018.
// Copyright © 2016 Jean-Luc Deltombe (LX3JL). All rights reserved.
// urfd -- The universal reflector
// Copyright © 2021 Thomas A. Early N7TAE
//
// 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 3 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, see <https://www.gnu.org/licenses/>.
#pragma once
#include "Peer.h"
#include "DExtraClient.h"
class CDextraPeer : public CPeer
{
public:
// constructors
CDextraPeer();
CDextraPeer(const CCallsign &, const CIp &, const char *, const CVersion &);
CDextraPeer(const CDextraPeer &) = delete;
// status
bool IsAlive(void) const;
// identity
EProtocol GetProtocol(void) const { return EProtocol::dextra; }
const char *GetProtocolName(void) const { return "DExtra"; }
// revision helper
static int GetProtocolRevision(const CVersion &);
};

137
reflector/DExtraProtocol.cpp
Unescape View File

@ -18,12 +18,11 @@
#include <string.h> #include <string.h>
#include "DExtraPeer.h"
#include "Global.h"
#include "DExtraClient.h" #include "DExtraClient.h"
#include "DExtraProtocol.h" #include "DExtraProtocol.h"
#include "Reflector.h" #
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -36,7 +35,6 @@ bool CDextraProtocol::Initialize(const char *type, const EProtocol ptype, const
// update time // update time
m_LastKeepaliveTime.start(); m_LastKeepaliveTime.start();
m_LastPeersLinkTime.start();
// done // done
return true; return true;
@ -101,38 +99,15 @@ void CDextraProtocol::Task(void)
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::dextra) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::dextra) )
{ {
// valid module ? // valid module ?
if ( g_Refl..IsValidModule(ToLinkModule) ) if ( g_Refl.IsValidModule(ToLinkModule) )
{
// is this an ack for a link request?
CPeerCallsignList *list = g_Gate.GetPeerList();
CCallsignListItem *item = list->FindListItem(Callsign);
if ( item != nullptr && Callsign.GetCSModule() == item->GetModules()[1] && ToLinkModule == item->GetModules()[0] )
{
std::cout << "DExtra ack packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl;
// already connected ?
CPeers *peers = g_Refl..GetPeers();
if ( peers->FindPeer(Callsign, Ip, EProtocol::dextra) == nullptr )
{
// create the new peer
// this also create one client per module
// append the peer to reflector peer list
// this also add all new clients to reflector client list
peers->AddPeer(std::make_shared<CDextraPeer>(Callsign, Ip, std::string(1, ToLinkModule).c_str(), CVersion(2, 0, 0)));
}
g_Refl..ReleasePeers();
}
else
{ {
// acknowledge the request // acknowledge the request
EncodeConnectAckPacket(&Buffer, ProtRev); EncodeConnectAckPacket(&Buffer, ProtRev);
Send(Buffer, Ip); Send(Buffer, Ip);
// create the client and append // create the client and append
g_Refl..GetClients()->AddClient(std::make_shared<CDextraClient>(Callsign, Ip, ToLinkModule, ProtRev)); g_Refl.GetClients()->AddClient(std::make_shared<CDextraClient>(Callsign, Ip, ToLinkModule, ProtRev));
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
}
g_Gate.ReleasePeerList();
} }
else else
{ {
@ -155,7 +130,7 @@ void CDextraProtocol::Task(void)
std::cout << "DExtra disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "DExtra disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find client & remove it // find client & remove it
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dextra); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dextra);
if ( client != nullptr ) if ( client != nullptr )
{ {
@ -172,21 +147,21 @@ void CDextraProtocol::Task(void)
// and remove it // and remove it
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidKeepAlivePacket(Buffer, &Callsign) ) else if ( IsValidKeepAlivePacket(Buffer, &Callsign) )
{ {
//std::cout << "DExtra keepalive packet from " << Callsign << " at " << Ip << std::endl; //std::cout << "DExtra keepalive packet from " << Callsign << " at " << Ip << std::endl;
// find all clients with that callsign & ip and keep them alive // find all clients with that callsign & ip and keep them alive
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dextra, it)) != nullptr ) while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dextra, it)) != nullptr )
{ {
client->Alive(); client->Alive();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -211,16 +186,6 @@ void CDextraProtocol::Task(void)
// update time // update time
m_LastKeepaliveTime.start(); m_LastKeepaliveTime.start();
} }
// peer connections
if ( m_LastPeersLinkTime.time() > DEXTRA_RECONNECT_PERIOD )
{
// handle remote peers connections
HandlePeerLinks();
// update time
m_LastPeersLinkTime.start();
}
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -239,7 +204,7 @@ void CDextraProtocol::HandleQueue(void)
if ( EncodeDvPacket(*packet, buffer) ) if ( EncodeDvPacket(*packet, buffer) )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dextra, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dextra, it)) != nullptr )
@ -255,7 +220,7 @@ void CDextraProtocol::HandleQueue(void)
} }
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -273,7 +238,7 @@ void CDextraProtocol::HandleKeepalives(void)
EncodeKeepAlivePacket(&keepalive); EncodeKeepAlivePacket(&keepalive);
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dextra, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dextra, it)) != nullptr )
@ -290,7 +255,7 @@ void CDextraProtocol::HandleKeepalives(void)
// otherwise check if still with us // otherwise check if still with us
else if ( !client->IsAlive() ) else if ( !client->IsAlive() )
{ {
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
std::shared_ptr<CPeer>peer = peers->FindPeer(client->GetCallsign(), client->GetIp(), EProtocol::dextra); std::shared_ptr<CPeer>peer = peers->FindPeer(client->GetCallsign(), client->GetIp(), EProtocol::dextra);
if ( peer != nullptr && peer->GetReflectorModules()[0] == client->GetReflectorModule() ) if ( peer != nullptr && peer->GetReflectorModules()[0] == client->GetReflectorModule() )
{ {
@ -307,14 +272,14 @@ void CDextraProtocol::HandleKeepalives(void)
std::cout << "DExtra client " << client->GetCallsign() << " keepalive timeout" << std::endl; std::cout << "DExtra client " << client->GetCallsign() << " keepalive timeout" << std::endl;
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// iterate on peers // iterate on peers
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
auto pit = peers->begin(); auto pit = peers->begin();
std::shared_ptr<CPeer>peer = nullptr; std::shared_ptr<CPeer>peer = nullptr;
while ( (peer = peers->FindNextPeer(EProtocol::dextra, pit)) != nullptr ) while ( (peer = peers->FindNextPeer(EProtocol::dextra, pit)) != nullptr )
@ -327,71 +292,19 @@ void CDextraProtocol::HandleKeepalives(void)
// no, disconnect all clients // no, disconnect all clients
CBuffer disconnect; CBuffer disconnect;
EncodeDisconnectPacket(&disconnect, peer->GetReflectorModules()[0]); EncodeDisconnectPacket(&disconnect, peer->GetReflectorModules()[0]);
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
for ( auto cit=peer->cbegin(); cit!=peer->cend(); cit++ ) for ( auto cit=peer->cbegin(); cit!=peer->cend(); cit++ )
{ {
Send(disconnect, (*cit)->GetIp()); Send(disconnect, (*cit)->GetIp());
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// remove it // remove it
std::cout << "DExtra peer " << peer->GetCallsign() << " keepalive timeout" << std::endl; std::cout << "DExtra peer " << peer->GetCallsign() << " keepalive timeout" << std::endl;
peers->RemovePeer(peer); peers->RemovePeer(peer);
} }
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
}
////////////////////////////////////////////////////////////////////////////////////////
// Peers helpers
void CDextraProtocol::HandlePeerLinks(void)
{
CBuffer buffer;
// get the list of peers
CPeerCallsignList *list = g_Gate.GetPeerList();
CPeers *peers = g_Refl..GetPeers();
// check if all our connected peers are still listed by gatekeeper
// if not, disconnect
auto pit = peers->begin();
std::shared_ptr<CPeer>peer = nullptr;
while ( (peer = peers->FindNextPeer(EProtocol::dextra, pit)) != nullptr )
{
if ( list->FindListItem(peer->GetCallsign()) == nullptr )
{
// send disconnect packet
EncodeDisconnectPacket(&buffer, peer->GetReflectorModules()[0]);
Send(buffer, peer->GetIp());
std::cout << "Sending disconnect packet to XRF peer " << peer->GetCallsign() << " at " << peer->GetIp() << std::endl;
// remove client
peers->RemovePeer(peer);
}
}
// check if all ours peers listed by gatekeeper are connected
// if not, connect or reconnect
for ( auto it=list->begin(); it!=list->end(); it++ )
{
if ( !it->GetCallsign().HasSameCallsignWithWildcard(CCallsign("XRF*")) )
continue;
if ( strlen(it->GetModules()) != 2 )
continue;
if ( peers->FindPeer(it->GetCallsign(), EProtocol::dextra) == nullptr )
{
// resolve again peer's IP in case it's a dynamic IP
it->ResolveIp();
// send connect packet to re-initiate peer link
EncodeConnectPacket(&buffer, it->GetModules());
Send(buffer, it->GetIp(), DEXTRA_PORT);
std::cout << "Sending connect packet to XRF peer " << it->GetCallsign() << " @ " << it->GetIp() << " for module " << it->GetModules()[1] << " (module " << it->GetModules()[0] << ")" << std::endl;
}
}
// done
g_Refl..ReleasePeers();
g_Gate.ReleasePeerList();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -415,7 +328,7 @@ void CDextraProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Heade
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::dextra); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::dextra);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
@ -430,18 +343,18 @@ void CDextraProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Heade
rpt2.SetCSModule(m); rpt2.SetCSModule(m);
} }
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }

4
reflector/DExtraProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "SEProtocol.h" #include "SEProtocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -61,7 +62,6 @@ protected:
void HandleQueue(void); void HandleQueue(void);
// keepalive helpers // keepalive helpers
void HandlePeerLinks(void);
void HandleKeepalives(void); void HandleKeepalives(void);
// stream helpers // stream helpers
@ -84,8 +84,6 @@ protected:
bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer &) const; bool EncodeDvHeaderPacket(const CDvHeaderPacket &, CBuffer &) const;
bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer &) const; bool EncodeDvFramePacket(const CDvFramePacket &, CBuffer &) const;
protected:
// time // time
CTimer m_LastKeepaliveTime; CTimer m_LastKeepaliveTime;
CTimer m_LastPeersLinkTime;
}; };

1
reflector/DMRMMDVMClient.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CDmrmmdvmClient : public CClient class CDmrmmdvmClient : public CClient

50
reflector/DMRMMDVMProtocol.cpp
Unescape View File

@ -18,16 +18,15 @@
#include <string.h> #include <string.h>
#include "Global.h"
#include "DMRMMDVMClient.h" #include "DMRMMDVMClient.h"
#include "DMRMMDVMProtocol.h" #include "DMRMMDVMProtocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
#include "BPTC19696.h" #include "BPTC19696.h"
#include "RS129.h" #include "RS129.h"
#include "Golay2087.h" #include "Golay2087.h"
#include "QR1676.h" #include "QR1676.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// define // define
@ -49,6 +48,7 @@ static uint8_t g_DmrSyncMSData[] = { 0x0D,0x5D,0x7F,0x77,0xFD,0x75,0x70 };
bool CDmrmmdvmProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CDmrmmdvmProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
m_DefaultId = g_Conf.GetUnsigned(g_Conf.j.mmdvm.defaultid);
// base class // base class
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6)) if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
return false; return false;
@ -93,7 +93,7 @@ void CDmrmmdvmProtocol::Task(void)
if ( Receive4(Buffer, Ip, 20) ) if ( Receive4(Buffer, Ip, 20) )
#endif #endif
{ {
//Buffer.DebugDump(g_Refl..m_DebugFile); //Buffer.DebugDump(g_Refl.m_DebugFile);
// crack the packet // crack the packet
if ( IsValidDvFramePacket(Buffer, Frames) ) if ( IsValidDvFramePacket(Buffer, Frames) )
{ {
@ -146,7 +146,7 @@ void CDmrmmdvmProtocol::Task(void)
Send(Buffer, Ip); Send(Buffer, Ip);
// add client if needed // add client if needed
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::dmrmmdvm); std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::dmrmmdvm);
// client already connected ? // client already connected ?
if ( client == nullptr ) if ( client == nullptr )
@ -161,7 +161,7 @@ void CDmrmmdvmProtocol::Task(void)
client->Alive(); client->Alive();
} }
// and done // and done
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -176,13 +176,13 @@ void CDmrmmdvmProtocol::Task(void)
std::cout << "DMRmmdvm disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "DMRmmdvm disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find client & remove it // find client & remove it
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dmrmmdvm); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dmrmmdvm);
if ( client != nullptr ) if ( client != nullptr )
{ {
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidConfigPacket(Buffer, &Callsign, Ip) ) else if ( IsValidConfigPacket(Buffer, &Callsign, Ip) )
{ {
@ -197,7 +197,7 @@ void CDmrmmdvmProtocol::Task(void)
//std::cout << "DMRmmdvm keepalive packet from " << Callsign << " at " << Ip << std::endl; //std::cout << "DMRmmdvm keepalive packet from " << Callsign << " at " << Ip << std::endl;
// find all clients with that callsign & ip and keep them alive // find all clients with that callsign & ip and keep them alive
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dmrmmdvm, it)) != nullptr ) while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::dmrmmdvm, it)) != nullptr )
@ -209,7 +209,7 @@ void CDmrmmdvmProtocol::Task(void)
// and mark as alive // and mark as alive
client->Alive(); client->Alive();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidRssiPacket(Buffer, &Callsign, &iRssi) ) else if ( IsValidRssiPacket(Buffer, &Callsign, &iRssi) )
{ {
@ -273,7 +273,7 @@ void CDmrmmdvmProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Hea
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// no stream open yet, open a new one // no stream open yet, open a new one
// firstfind this client // firstfind this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::dmrmmdvm); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::dmrmmdvm);
if ( client ) if ( client )
{ {
// process cmd if any // process cmd if any
@ -282,7 +282,7 @@ void CDmrmmdvmProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Hea
// not linked yet // not linked yet
if ( cmd == CMD_LINK ) if ( cmd == CMD_LINK )
{ {
if ( g_Refl..IsValidModule(rpt2.GetCSModule()) ) if ( g_Refl.IsValidModule(rpt2.GetCSModule()) )
{ {
std::cout << "DMRmmdvm client " << client->GetCallsign() << " linking on module " << rpt2.GetCSModule() << std::endl; std::cout << "DMRmmdvm client " << client->GetCallsign() << " linking on module " << rpt2.GetCSModule() << std::endl;
// link // link
@ -313,10 +313,10 @@ void CDmrmmdvmProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Hea
} }
// and now, re-check module is valid && that it's not a private call // and now, re-check module is valid && that it's not a private call
if ( g_Refl..IsValidModule(rpt2.GetCSModule()) && (CallType == DMR_GROUP_CALL) ) if ( g_Refl.IsValidModule(rpt2.GetCSModule()) && (CallType == DMR_GROUP_CALL) )
{ {
// yes, try to open the stream // yes, try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
@ -330,13 +330,13 @@ void CDmrmmdvmProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Hea
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
if ( lastheard ) if ( lastheard )
{ {
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
} }
@ -403,7 +403,7 @@ void CDmrmmdvmProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dmrmmdvm, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dmrmmdvm, it)) != nullptr )
@ -416,7 +416,7 @@ void CDmrmmdvmProtocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -432,7 +432,7 @@ void CDmrmmdvmProtocol::HandleKeepalives(void)
// and disconnect them if not // and disconnect them if not
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dmrmmdvm, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dmrmmdvm, it)) != nullptr )
@ -456,7 +456,7 @@ void CDmrmmdvmProtocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -696,7 +696,7 @@ bool CDmrmmdvmProtocol::IsValidDvFramePacket(const CBuffer &Buffer, std::array<s
// debug // debug
//CBuffer dump; //CBuffer dump;
//dump.Set(dmrsync, 6); //dump.Set(dmrsync, 6);
//dump.DebugDump(g_Refl..m_DebugFile); //dump.DebugDump(g_Refl.m_DebugFile);
// and create 3 dv frames // and create 3 dv frames
// frame1 // frame1
@ -878,7 +878,7 @@ void CDmrmmdvmProtocol::EncodeMMDVMPacket(const CDvHeaderPacket &Header, const C
uiSrcId = DvFrame2.GetMyCallsign().GetDmrid(); uiSrcId = DvFrame2.GetMyCallsign().GetDmrid();
} }
if(uiSrcId == 0){ if(uiSrcId == 0){
uiSrcId = DMRMMDVM_DEFAULTID; uiSrcId = m_DefaultId;
} }
AppendDmrIdToBuffer(Buffer, uiSrcId); AppendDmrIdToBuffer(Buffer, uiSrcId);
@ -924,7 +924,7 @@ void CDmrmmdvmProtocol::EncodeMMDVMPacket(const CDvHeaderPacket &Header, const C
// debug // debug
//CBuffer dump; //CBuffer dump;
//dump.Set(&(Buffer->data()[33]), 7); //dump.Set(&(Buffer->data()[33]), 7);
//dump.DebugDump(g_Refl..m_DebugFile); //dump.DebugDump(g_Refl.m_DebugFile);
// BER // BER
Buffer->Append((uint8_t)0); Buffer->Append((uint8_t)0);
@ -982,7 +982,7 @@ char CDmrmmdvmProtocol::DmrDstIdToModule(uint32_t tg) const
if (tg > 4000 && tg < 4027) if (tg > 4000 && tg < 4027)
{ {
const char mod = 'A' + (tg - 4001U); const char mod = 'A' + (tg - 4001U);
if (strchr(ACTIVE_MODULES, mod)) if (g_Refl.IsValidModule(mod))
{ {
return mod; return mod;
} }

4
reflector/DMRMMDVMProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -117,4 +118,7 @@ protected:
// for authentication // for authentication
uint32_t m_uiAuthSeed; uint32_t m_uiAuthSeed;
// config data
unsigned m_DefaultId;
}; };

1
reflector/DMRPlusClient.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CDmrplusClient : public CClient class CDmrplusClient : public CClient

41
reflector/DMRPlusProtocol.cpp
Unescape View File

@ -18,11 +18,10 @@
#include <string.h> #include <string.h>
#include "Global.h"
#include "DMRPlusClient.h" #include "DMRPlusClient.h"
#include "DMRPlusProtocol.h" #include "DMRPlusProtocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
#include "DMRIdDir.h"
#include "BPTC19696.h" #include "BPTC19696.h"
#include "RS129.h" #include "RS129.h"
#include "Golay2087.h" #include "Golay2087.h"
@ -111,7 +110,7 @@ void CDmrplusProtocol::Task(void)
Send(Buffer, Ip); Send(Buffer, Ip);
// add client if needed // add client if needed
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::dmrplus); std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::dmrplus);
// client already connected ? // client already connected ?
if ( client == nullptr ) if ( client == nullptr )
@ -126,7 +125,7 @@ void CDmrplusProtocol::Task(void)
client->Alive(); client->Alive();
} }
// and done // and done
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -141,13 +140,13 @@ void CDmrplusProtocol::Task(void)
std::cout << "DMRplus disconnect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl; std::cout << "DMRplus disconnect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl;
// find client & remove it // find client & remove it
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dmrplus); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dmrplus);
if ( client != nullptr ) if ( client != nullptr )
{ {
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -196,21 +195,21 @@ void CDmrplusProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Head
// no stream open yet, open a new one // no stream open yet, open a new one
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::dmrplus); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::dmrplus);
if ( client ) if ( client )
{ {
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -268,7 +267,7 @@ void CDmrplusProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr )
@ -280,10 +279,10 @@ void CDmrplusProtocol::HandleQueue(void)
Send(buffer, client->GetIp()); Send(buffer, client->GetIp());
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// debug // debug
//buffer.DebugDump(g_Refl..m_DebugFile); //buffer.DebugDump(g_Refl.m_DebugFile);
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -294,7 +293,7 @@ void CDmrplusProtocol::SendBufferToClients(const CBuffer &buffer, uint8_t module
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr )
@ -306,10 +305,10 @@ void CDmrplusProtocol::SendBufferToClients(const CBuffer &buffer, uint8_t module
Send(buffer, client->GetIp()); Send(buffer, client->GetIp());
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// debug // debug
//buffer.DebugDump(g_Refl..m_DebugFile); //buffer.DebugDump(g_Refl.m_DebugFile);
} }
} }
@ -324,7 +323,7 @@ void CDmrplusProtocol::HandleKeepalives(void)
// and disconnect them if not // and disconnect them if not
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dmrplus, it)) != nullptr )
@ -349,7 +348,7 @@ void CDmrplusProtocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -642,7 +641,7 @@ char CDmrplusProtocol::DmrDstIdToModule(uint32_t tg) const
// is it a 4xxx ? // is it a 4xxx ?
if (tg > 4000 && tg < 4027) { if (tg > 4000 && tg < 4027) {
char mod = 'A' + (tg - 4001U); char mod = 'A' + (tg - 4001U);
if (strchr(ACTIVE_MODULES, mod)) if (g_Refl.IsValidModule(mod))
{ {
return mod; return mod;
} }

1
reflector/DMRPlusProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"

1
reflector/DPlusClient.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CDplusClient : public CClient class CDplusClient : public CClient

37
reflector/DPlusProtocol.cpp
Unescape View File

@ -18,11 +18,10 @@
#include <string.h> #include <string.h>
#include "Global.h"
#include "DPlusClient.h" #include "DPlusClient.h"
#include "DPlusProtocol.h" #include "DPlusProtocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -97,8 +96,8 @@ void CDplusProtocol::Task(void)
Send(Buffer, Ip); Send(Buffer, Ip);
// create the client and append // create the client and append
g_Refl..GetClients()->AddClient(std::make_shared<CDplusClient>(Callsign, Ip)); g_Refl.GetClients()->AddClient(std::make_shared<CDplusClient>(Callsign, Ip));
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -113,7 +112,7 @@ void CDplusProtocol::Task(void)
std::cout << "DPlus disconnect packet from " << Ip << std::endl; std::cout << "DPlus disconnect packet from " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dplus); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::dplus);
if ( client != nullptr ) if ( client != nullptr )
{ {
@ -123,21 +122,21 @@ void CDplusProtocol::Task(void)
EncodeDisconnectPacket(&Buffer); EncodeDisconnectPacket(&Buffer);
Send(Buffer, Ip); Send(Buffer, Ip);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidKeepAlivePacket(Buffer) ) else if ( IsValidKeepAlivePacket(Buffer) )
{ {
//std::cout << "DPlus keepalive packet from " << Ip << std::endl; //std::cout << "DPlus keepalive packet from " << Ip << std::endl;
// find all clients with that callsign & ip and keep them alive // find all clients with that callsign & ip and keep them alive
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(Ip, EProtocol::dplus, it)) != nullptr ) while ( (client = clients->FindNextClient(Ip, EProtocol::dplus, it)) != nullptr )
{ {
client->Alive(); client->Alive();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -185,10 +184,10 @@ void CDplusProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// first, check module is valid // first, check module is valid
if ( g_Refl..IsValidModule(rpt2.GetCSModule()) ) if ( g_Refl.IsValidModule(rpt2.GetCSModule()) )
{ {
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::dplus); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::dplus);
if ( client ) if ( client )
{ {
// now we know if it's a dextra dongle or a genuine dplus node // now we know if it's a dextra dongle or a genuine dplus node
@ -204,18 +203,18 @@ void CDplusProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header
// get client callsign // get client callsign
rpt1 = client->GetCallsign(); rpt1 = client->GetCallsign();
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
else else
{ {
@ -253,7 +252,7 @@ void CDplusProtocol::HandleQueue(void)
// and push it to all our clients who are not streaming in // and push it to all our clients who are not streaming in
// note that for dplus protocol, all stream of all modules are push to all clients // note that for dplus protocol, all stream of all modules are push to all clients
// it's client who decide which stream he's interrrested in // it's client who decide which stream he's interrrested in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dplus, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dplus, it)) != nullptr )
@ -290,7 +289,7 @@ void CDplusProtocol::HandleQueue(void)
} }
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -343,7 +342,7 @@ void CDplusProtocol::HandleKeepalives(void)
EncodeKeepAlivePacket(&keepalive); EncodeKeepAlivePacket(&keepalive);
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::dplus, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::dplus, it)) != nullptr )
@ -371,7 +370,7 @@ void CDplusProtocol::HandleKeepalives(void)
clients->RemoveClient(client); clients->RemoveClient(client);
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////

1
reflector/DPlusProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "SEProtocol.h" #include "SEProtocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"

2
reflector/DVFramePacket.cpp
Unescape View File

@ -16,7 +16,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <iostream>
#include <string.h> #include <string.h>
#include "DVFramePacket.h" #include "DVFramePacket.h"

6
reflector/DVHeaderPacket.cpp
Unescape View File

@ -18,10 +18,10 @@
#include <string.h> #include <string.h>
#include <cstdio> #include <iostream>
#include "DMRIdDir.h"
#include "DVHeaderPacket.h"
#include "Defines.h"
#include "DVHeaderPacket.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor

31
reflector/Defines.h
Unescape View File

@ -46,25 +46,31 @@
#define DSTAR_IPV4 true #define DSTAR_IPV4 true
#define DMR_IPV4 true #define DMR_IPV4 true
#define YSF_IPV4 true #define YSF_IPV4 true
#define BM_IPV4 true #define XLX_IPV4 true
#define M17_IPV4 true #define M17_IPV4 true
#define P25_IPV4 true
#define NXDN_IPV4 true
#define USRP_IPV4 true
#define URF_IPV4 true #define URF_IPV4 true
#define DSTAR_IPV6 true
#define DSTAR_IPV6 true // QnetGateway can use IPv6
#define DMR_IPV6 false #define DMR_IPV6 false
#define YSF_IPV6 false #define YSF_IPV6 false
#define BM_IPV6 false #define XLX_IPV6 false
#define M17_IPV6 true #define M17_IPV6 true
#define P25_IPV6 false
#define NXDN_IPV6 false
#define USRP_IPV6 false
#define URF_IPV6 true #define URF_IPV6 true
// protocols --------------------------------------------------- // protocols ---------------------------------------------------
enum class EProtocol { any, none, dextra, dplus, dcs, bm, urf, dmrplus, dmrmmdvm, ysf, m17 }; enum class EProtocol { any, none, dextra, dplus, dcs, g3, bm, urf, dmrplus, dmrmmdvm, nxdn, p25, usrp, ysf, m17 };
// DExtra // DExtra
#define DEXTRA_KEEPALIVE_PERIOD 3 // in seconds #define DEXTRA_KEEPALIVE_PERIOD 3 // in seconds
#define DEXTRA_KEEPALIVE_TIMEOUT (DEXTRA_KEEPALIVE_PERIOD*10) // in seconds #define DEXTRA_KEEPALIVE_TIMEOUT (DEXTRA_KEEPALIVE_PERIOD*10) // in seconds
#define DEXTRA_RECONNECT_PERIOD 5 // in seconds
// DPlus // DPlus
#define DPLUS_KEEPALIVE_PERIOD 1 // in seconds #define DPLUS_KEEPALIVE_PERIOD 1 // in seconds
@ -77,7 +83,7 @@ enum class EProtocol { any, none, dextra, dplus, dcs, bm, urf, dmrplus, dmrmmdvm
// XLX, used for BM // XLX, used for BM
#define BM_KEEPALIVE_PERIOD 1 // in seconds #define BM_KEEPALIVE_PERIOD 1 // in seconds
#define BM_KEEPALIVE_TIMEOUT (XLX_KEEPALIVE_PERIOD*30) // in seconds #define BM_KEEPALIVE_TIMEOUT (BM_KEEPALIVE_PERIOD*30) // in seconds
#define BM_RECONNECT_PERIOD 5 // in seconds #define BM_RECONNECT_PERIOD 5 // in seconds
// URF // URF
@ -89,6 +95,7 @@ enum class EProtocol { any, none, dextra, dplus, dcs, bm, urf, dmrplus, dmrmmdvm
#define DMRPLUS_KEEPALIVE_PERIOD 1 // in seconds #define DMRPLUS_KEEPALIVE_PERIOD 1 // in seconds
#define DMRPLUS_KEEPALIVE_TIMEOUT (DMRPLUS_KEEPALIVE_PERIOD*10) // in seconds #define DMRPLUS_KEEPALIVE_TIMEOUT (DMRPLUS_KEEPALIVE_PERIOD*10) // in seconds
#define DMRPLUS_REFLECTOR_SLOT DMR_SLOT2 #define DMRPLUS_REFLECTOR_SLOT DMR_SLOT2
#define DMRPLUS_REFLECTOR_COLOUR 1
// DMRMmdvm // DMRMmdvm
#define DMRMMDVM_KEEPALIVE_PERIOD 10 // in seconds #define DMRMMDVM_KEEPALIVE_PERIOD 10 // in seconds
@ -104,6 +111,18 @@ enum class EProtocol { any, none, dextra, dplus, dcs, bm, urf, dmrplus, dmrmmdvm
#define M17_KEEPALIVE_PERIOD 3 #define M17_KEEPALIVE_PERIOD 3
#define M17_KEEPALIVE_TIMEOUT (M17_KEEPALIVE_PERIOD*10) #define M17_KEEPALIVE_TIMEOUT (M17_KEEPALIVE_PERIOD*10)
// P25
#define P25_KEEPALIVE_PERIOD 3 // in seconds
#define P25_KEEPALIVE_TIMEOUT (P25_KEEPALIVE_PERIOD*10) // in seconds
// NXDN
#define NXDN_KEEPALIVE_PERIOD 3 // in seconds
#define NXDN_KEEPALIVE_TIMEOUT (NXDN_KEEPALIVE_PERIOD*10) // in seconds
// USRP
#define USRP_KEEPALIVE_PERIOD 1 // in seconds
#define USRP_KEEPALIVE_TIMEOUT (USRP_KEEPALIVE_PERIOD*10) // in seconds
// G3 Terminal // G3 Terminal
#define G3_PRESENCE_PORT 12346 // UDP port #define G3_PRESENCE_PORT 12346 // UDP port
#define G3_CONFIG_PORT 12345 // UDP port #define G3_CONFIG_PORT 12345 // UDP port

1
reflector/G3Client.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CG3Client : public CClient class CG3Client : public CClient

64
reflector/G3Protocol.cpp
Unescape View File

@ -16,16 +16,14 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
#include <string.h> #include <string.h>
#include <sys/stat.h> #include <sys/stat.h>
#include "Global.h"
#include "G3Client.h" #include "G3Client.h"
#include "G3Protocol.h" #include "G3Protocol.h"
#include "Reflector.h"
#include "GateKeeper.h"
#include <netinet/ip.h>
#include <netinet/ip_icmp.h>
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -34,10 +32,14 @@
bool CG3Protocol::Initialize(const char */*type*/, const EProtocol /*type*/, const uint16_t /*port*/, const bool /*has_ipv4*/, const bool /*has_ipv6*/) bool CG3Protocol::Initialize(const char */*type*/, const EProtocol /*type*/, const uint16_t /*port*/, const bool /*has_ipv4*/, const bool /*has_ipv6*/)
// everything is hard coded until ICOM gets their act together and start supporting IPv6 // everything is hard coded until ICOM gets their act together and start supporting IPv6
{ {
//config data
m_TerminalPath.assign(g_Conf.GetString(g_Conf.j.files.terminal));
const std::string ipv4address(g_Conf.GetString(g_Conf.j.ip.ipv4bind));
ReadOptions(); ReadOptions();
// init reflector apparent callsign // init reflector apparent callsign
m_ReflectorCallsign = g_Refl..GetCallsign(); m_ReflectorCallsign = g_Refl.GetCallsign();
// reset stop flag // reset stop flag
keep_running = true; keep_running = true;
@ -46,7 +48,7 @@ bool CG3Protocol::Initialize(const char */*type*/, const EProtocol /*type*/, con
//m_ReflectorCallsign.PatchCallsign(0, "XLX", 3); //m_ReflectorCallsign.PatchCallsign(0, "XLX", 3);
// create our sockets // create our sockets
CIp ip(AF_INET, G3_DV_PORT, LISTEN_IPV4); CIp ip(AF_INET, G3_DV_PORT, ipv4address.c_str());
if ( ip.IsSet() ) if ( ip.IsSet() )
{ {
if (! m_Socket4.Open(ip)) if (! m_Socket4.Open(ip))
@ -177,7 +179,7 @@ void CG3Protocol::PresenceTask(void)
Buffer.Append(m_GwAddress); Buffer.Append(m_GwAddress);
} }
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>extant = nullptr; std::shared_ptr<CClient>extant = nullptr;
while ( (extant = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (extant = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -219,7 +221,7 @@ void CG3Protocol::PresenceTask(void)
clients->AddClient(std::make_shared<CG3Client>(Terminal, Ip)); clients->AddClient(std::make_shared<CG3Client>(Terminal, Ip));
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
m_PresenceSocket.Send(Buffer, ReqIp); m_PresenceSocket.Send(Buffer, ReqIp);
} }
@ -260,7 +262,7 @@ void CG3Protocol::ConfigTask(void)
if (isRepeaterCall) if (isRepeaterCall)
{ {
if ((Call.HasSameCallsign(GetReflectorCallsign())) && (g_Refl..IsValidModule(Call.GetCSModule()))) if ((Call.HasSameCallsign(GetReflectorCallsign())) && (g_Refl.IsValidModule(Call.GetCSModule())))
{ {
Buffer.data()[3] = 0x00; // ok Buffer.data()[3] = 0x00; // ok
} }
@ -343,7 +345,7 @@ void CG3Protocol::IcmpTask(void)
{ {
if (iIcmpType == ICMP_DEST_UNREACH) if (iIcmpType == ICMP_DEST_UNREACH)
{ {
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -354,7 +356,7 @@ void CG3Protocol::IcmpTask(void)
clients->RemoveClient(client); clients->RemoveClient(client);
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
} }
@ -378,7 +380,7 @@ void CG3Protocol::Task(void)
{ {
CIp ClIp; CIp ClIp;
CIp *BaseIp = nullptr; CIp *BaseIp = nullptr;
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -394,7 +396,7 @@ void CG3Protocol::Task(void)
break; break;
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
if (BaseIp != nullptr) if (BaseIp != nullptr)
{ {
@ -454,7 +456,7 @@ void CG3Protocol::HandleQueue(void)
if ( EncodeDvPacket(*packet, buffer) ) if ( EncodeDvPacket(*packet, buffer) )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -470,7 +472,7 @@ void CG3Protocol::HandleQueue(void)
} }
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -487,7 +489,7 @@ void CG3Protocol::HandleKeepalives(void)
CBuffer keepalive((uint8_t *)"PING", 4); CBuffer keepalive((uint8_t *)"PING", 4);
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -502,7 +504,7 @@ void CG3Protocol::HandleKeepalives(void)
Send(keepalive, client->GetIp()); Send(keepalive, client->GetIp());
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -527,7 +529,7 @@ void CG3Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, c
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -554,7 +556,7 @@ void CG3Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, c
} }
else else
{ {
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
return; return;
} }
} }
@ -563,19 +565,19 @@ void CG3Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header, c
rpt1 = client->GetCallsign(); rpt1 = client->GetCallsign();
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
@ -672,14 +674,14 @@ void CG3Protocol::NeedReload(void)
{ {
struct stat fileStat; struct stat fileStat;
if (::stat(TERMINALOPTIONS_PATH, &fileStat) != -1) if (::stat(m_TerminalPath.c_str(), &fileStat) != -1)
{ {
if (m_LastModTime != fileStat.st_mtime) if (m_LastModTime != fileStat.st_mtime)
{ {
ReadOptions(); ReadOptions();
// we have new options - iterate on clients for potential removal // we have new options - iterate on clients for potential removal
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::g3, it)) != nullptr )
@ -690,7 +692,7 @@ void CG3Protocol::NeedReload(void)
clients->RemoveClient(client); clients->RemoveClient(client);
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
} }
@ -701,7 +703,7 @@ void CG3Protocol::ReadOptions(void)
int opts = 0; int opts = 0;
std::ifstream file(TERMINALOPTIONS_PATH); std::ifstream file(m_TerminalPath.c_str());
if (file.is_open()) if (file.is_open())
{ {
m_GwAddress = 0u; m_GwAddress = 0u;
@ -742,12 +744,12 @@ void CG3Protocol::ReadOptions(void)
} }
} }
} }
std::cout << "G3 handler loaded " << opts << " options from file " << TERMINALOPTIONS_PATH << std::endl; std::cout << "G3 handler loaded " << opts << " options from file " << m_TerminalPath << std::endl;
file.close(); file.close();
struct stat fileStat; struct stat fileStat;
if (::stat(TERMINALOPTIONS_PATH, &fileStat) != -1) if (::stat(m_TerminalPath.c_str(), &fileStat) != -1)
{ {
m_LastModTime = fileStat.st_mtime; m_LastModTime = fileStat.st_mtime;
} }

3
reflector/G3Protocol.h
Unescape View File

@ -19,6 +19,8 @@
#pragma once #pragma once
#include <string> #include <string>
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "SEProtocol.h" #include "SEProtocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -117,4 +119,5 @@ protected:
uint32_t m_GwAddress; uint32_t m_GwAddress;
std::string m_Modules; std::string m_Modules;
time_t m_LastModTime; time_t m_LastModTime;
std::string m_TerminalPath;
}; };

8
reflector/GateKeeper.cpp
Unescape View File

@ -18,7 +18,7 @@
#include "Timer.h" #include "Timer.h"
#include "GateKeeper.h" #include "Global.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -49,9 +49,9 @@ bool CGateKeeper::Init(void)
{ {
// load lists from files // load lists from files
m_NodeWhiteList.LoadFromFile(WHITELIST_PATH); m_NodeWhiteList.LoadFromFile(g_Conf.GetString(g_Conf.j.files.white));
m_NodeBlackList.LoadFromFile(BLACKLIST_PATH); m_NodeBlackList.LoadFromFile(g_Conf.GetString(g_Conf.j.files.black));
m_PeerList.LoadFromFile(INTERLINKLIST_PATH); m_PeerList.LoadFromFile(g_Conf.GetString(g_Conf.j.files.interlink));
// reset run flag // reset run flag
keep_running = true; keep_running = true;

18
reflector/LookupDmr.cpp
Unescape View File

@ -21,11 +21,7 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <netdb.h> #include <netdb.h>
#include "Reflector.h" #include "Global.h"
#include "LookupDmr.h"
extern CReflector g_ref;
extern CConfigure g_cfg;
void CLookupDmr::ClearContents() void CLookupDmr::ClearContents()
{ {
@ -35,11 +31,11 @@ void CLookupDmr::ClearContents()
void CLookupDmr::LoadParameters() void CLookupDmr::LoadParameters()
{ {
g_cfg.GetRefreshType(g_cfg.j.dmriddb.mode, m_Type); m_Type = g_Conf.GetRefreshType(g_Conf.j.dmriddb.mode);
g_cfg.GetUnsigned(g_cfg.j.dmriddb.refreshmin, m_Refresh); m_Refresh = g_Conf.GetUnsigned(g_Conf.j.dmriddb.refreshmin);
g_cfg.GetString(g_cfg.j.dmriddb.filepath, m_Path); m_Path.assign(g_Conf.GetString(g_Conf.j.dmriddb.filepath));
g_cfg.GetString(g_cfg.j.dmriddb.hostname, m_Host); m_Host.assign(g_Conf.GetString(g_Conf.j.dmriddb.hostname));
g_cfg.GetString(g_cfg.j.dmriddb.suffix, m_Suffix); m_Suffix.assign(g_Conf.GetString(g_Conf.j.dmriddb.suffix));
} }
uint32_t CLookupDmr::FindDmrid(const CCallsign &callsign) uint32_t CLookupDmr::FindDmrid(const CCallsign &callsign)
@ -204,7 +200,7 @@ bool CLookupDmr::HttpGet(const char *hostname, const char *filename, int port, C
{ {
// send the GET request // send the GET request
char request[DMRID_HTTPGET_SIZEMAX]; char request[DMRID_HTTPGET_SIZEMAX];
::sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, g_ref.GetCallsign().GetCS().c_str()); ::sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, g_Conf.GetString(g_Conf.j.names.cs).c_str());
::write(sock_id, request, strlen(request)); ::write(sock_id, request, strlen(request));
// config receive timeouts // config receive timeouts

18
reflector/LookupNxdn.cpp
Unescape View File

@ -21,11 +21,7 @@
#include <sys/socket.h> #include <sys/socket.h>
#include <netdb.h> #include <netdb.h>
#include "Reflector.h" #include "Global.h"
#include "LookupNxdn.h"
extern CReflector g_ref;
extern CConfigure g_cfg;
void CLookupNxdn::ClearContents() void CLookupNxdn::ClearContents()
{ {
@ -35,11 +31,11 @@ void CLookupNxdn::ClearContents()
void CLookupNxdn::LoadParameters() void CLookupNxdn::LoadParameters()
{ {
g_cfg.GetRefreshType(g_cfg.j.nxdniddb.mode, m_Type); m_Type = g_Conf.GetRefreshType(g_Conf.j.nxdniddb.mode);
g_cfg.GetUnsigned(g_cfg.j.nxdniddb.refreshmin, m_Refresh); m_Refresh = g_Conf.GetUnsigned(g_Conf.j.nxdniddb.refreshmin);
g_cfg.GetString(g_cfg.j.nxdniddb.filepath, m_Path); m_Path.assign(g_Conf.GetString(g_Conf.j.nxdniddb.filepath));
g_cfg.GetString(g_cfg.j.dmriddb.hostname, m_Host); m_Host.assign(g_Conf.GetString(g_Conf.j.nxdniddb.hostname));
g_cfg.GetString(g_cfg.j.nxdniddb.suffix, m_Suffix); m_Suffix.assign(g_Conf.GetString(g_Conf.j.nxdniddb.suffix));
} }
const CCallsign *CLookupNxdn::FindCallsign(uint16_t nxdnid) const CCallsign *CLookupNxdn::FindCallsign(uint16_t nxdnid)
@ -206,7 +202,7 @@ bool CLookupNxdn::HttpGet(const char *hostname, const char *filename, int port,
{ {
// send the GET request // send the GET request
char request[NXDNID_HTTPGET_SIZEMAX]; char request[NXDNID_HTTPGET_SIZEMAX];
::sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, (const char *)g_ref.GetCallsign()); ::sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, g_Conf.GetString(g_Conf.j.names.cs).c_str());
::write(sock_id, request, strlen(request)); ::write(sock_id, request, strlen(request));
// config receive timeouts // config receive timeouts

22
reflector/LookupYsf.cpp
Unescape View File

@ -22,11 +22,7 @@
#include <mysql/mysql.h> #include <mysql/mysql.h>
#include <netdb.h> #include <netdb.h>
#include "Reflector.h" #include "Global.h"
#include "LookupYsf.h"
extern CReflector g_ref;
extern CConfigure g_cfg;
void CLookupYsf::ClearContents() void CLookupYsf::ClearContents()
{ {
@ -35,13 +31,13 @@ void CLookupYsf::ClearContents()
void CLookupYsf::LoadParameters() void CLookupYsf::LoadParameters()
{ {
g_cfg.GetRefreshType(g_cfg.j.ysftxrxdb.mode, m_Type); m_Type = g_Conf.GetRefreshType(g_Conf.j.ysftxrxdb.mode);
g_cfg.GetUnsigned(g_cfg.j.ysftxrxdb.refreshmin, m_Refresh); m_Refresh = g_Conf.GetUnsigned(g_Conf.j.ysftxrxdb.refreshmin);
g_cfg.GetString(g_cfg.j.ysftxrxdb.filepath, m_Path); m_Path.assign(g_Conf.GetString(g_Conf.j.ysftxrxdb.filepath));
g_cfg.GetString(g_cfg.j.ysftxrxdb.hostname, m_Host); m_Host.assign(g_Conf.GetString(g_Conf.j.ysftxrxdb.hostname));
g_cfg.GetString(g_cfg.j.ysftxrxdb.suffix, m_Suffix); m_Suffix.assign(g_Conf.GetString(g_Conf.j.ysftxrxdb.suffix));
g_cfg.GetUnsigned(g_cfg.j.ysf.defaulttxfreq, m_DefaultTx); m_DefaultTx = g_Conf.GetUnsigned(g_Conf.j.ysf.defaulttxfreq);
g_cfg.GetUnsigned(g_cfg.j.ysf.defaultrxfreq, m_DefaultRx); m_DefaultRx = g_Conf.GetUnsigned(g_Conf.j.ysf.defaultrxfreq);
} }
bool CLookupYsf::LoadContentFile(CBuffer &buffer) bool CLookupYsf::LoadContentFile(CBuffer &buffer)
@ -182,7 +178,7 @@ bool CLookupYsf::HttpGet(const char *hostname, const char *filename, int port, C
{ {
// send the GET request // send the GET request
char request[YSFNODE_HTTPGET_SIZEMAX]; char request[YSFNODE_HTTPGET_SIZEMAX];
sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, g_ref.GetCallsign().GetCS().c_str()); sprintf(request, "GET /%s HTTP/1.0\r\nFrom: %s\r\nUser-Agent: urfd\r\n\r\n", filename, g_Conf.GetString(g_Conf.j.names.cs).c_str());
write(sock_id, request, strlen(request)); write(sock_id, request, strlen(request));
// config receive timeouts // config receive timeouts

2
reflector/LookupYsf.h
Unescape View File

@ -40,4 +40,6 @@ private:
CsNodeMap m_map; CsNodeMap m_map;
bool HttpGet(const char *, const char *, int, CBuffer &); bool HttpGet(const char *, const char *, int, CBuffer &);
unsigned m_DefaultTx, m_DefaultRx;
}; };

8
reflector/M17Client.h
Unescape View File

@ -16,15 +16,9 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Defines.h"
#include "Client.h" #include "Client.h"
////////////////////////////////////////////////////////////////////////////////////////
// define
////////////////////////////////////////////////////////////////////////////////////////
// class
class CM17Client : public CClient class CM17Client : public CClient
{ {
public: public:

39
reflector/M17Protocol.cpp
Unescape View File

@ -21,8 +21,7 @@
#include "M17Client.h" #include "M17Client.h"
#include "M17Protocol.h" #include "M17Protocol.h"
#include "M17Packet.h" #include "M17Packet.h"
#include "Reflector.h" #include "Global.h"
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -93,17 +92,17 @@ void CM17Protocol::Task(void)
std::cout << "M17 connect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl; std::cout << "M17 connect packet for module " << ToLinkModule << " from " << Callsign << " at " << Ip << std::endl;
// callsign authorized? // callsign authorized?
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::m17) && g_Refl..IsValidModule(ToLinkModule) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::m17) && g_Refl.IsValidModule(ToLinkModule) )
{ {
// valid module ? // valid module ?
if ( g_Refl..IsValidModule(ToLinkModule) ) if ( g_Refl.IsValidModule(ToLinkModule) )
{ {
// acknowledge the request // acknowledge the request
Send("ACKN", Ip); Send("ACKN", Ip);
// create the client and append // create the client and append
g_Refl..GetClients()->AddClient(std::make_shared<CM17Client>(Callsign, Ip, ToLinkModule)); g_Refl.GetClients()->AddClient(std::make_shared<CM17Client>(Callsign, Ip, ToLinkModule));
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -125,7 +124,7 @@ void CM17Protocol::Task(void)
std::cout << "M17 disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "M17 disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::m17); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::m17);
if ( client != nullptr ) if ( client != nullptr )
{ {
@ -134,19 +133,19 @@ void CM17Protocol::Task(void)
// and acknowledge the disconnect // and acknowledge the disconnect
Send("DISC", Ip); Send("DISC", Ip);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidKeepAlivePacket(Buffer, Callsign) ) else if ( IsValidKeepAlivePacket(Buffer, Callsign) )
{ {
// find all clients with that callsign & ip and keep them alive // find all clients with that callsign & ip and keep them alive
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::m17, it)) != nullptr ) while ( (client = clients->FindNextClient(Callsign, Ip, EProtocol::m17, it)) != nullptr )
{ {
client->Alive(); client->Alive();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -196,24 +195,24 @@ void CM17Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::m17); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::m17);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
rpt1 = client->GetCallsign(); rpt1 = client->GetCallsign();
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -249,7 +248,7 @@ void CM17Protocol::HandleQueue(void)
EncodeM17Packet(frame, m_StreamsCache[module].m_dvHeader, (CDvFramePacket *)packet.get(), m_StreamsCache[module].m_iSeqCounter); EncodeM17Packet(frame, m_StreamsCache[module].m_dvHeader, (CDvFramePacket *)packet.get(), m_StreamsCache[module].m_iSeqCounter);
// push it to all our clients linked to the module and who are not streaming in // push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::m17, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::m17, it)) != nullptr )
@ -266,7 +265,7 @@ void CM17Protocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
m_StreamsCache[module].m_iSeqCounter++; m_StreamsCache[module].m_iSeqCounter++;
} }
@ -286,7 +285,7 @@ void CM17Protocol::HandleKeepalives(void)
EncodeKeepAlivePacket(keepalive); EncodeKeepAlivePacket(keepalive);
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::m17, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::m17, it)) != nullptr )
@ -312,7 +311,7 @@ void CM17Protocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -389,7 +388,7 @@ void CM17Protocol::EncodeKeepAlivePacket(CBuffer &Buffer)
{ {
Buffer.resize(10); Buffer.resize(10);
memcpy(Buffer.data(), "PING", 4); memcpy(Buffer.data(), "PING", 4);
g_Refl..GetCallsign().CodeOut(Buffer.data() + 4); g_Refl.GetCallsign().CodeOut(Buffer.data() + 4);
} }
void CM17Protocol::EncodeM17Packet(SM17Frame &frame, const CDvHeaderPacket &Header, const CDvFramePacket *DvFrame, uint32_t iSeq) const void CM17Protocol::EncodeM17Packet(SM17Frame &frame, const CDvHeaderPacket &Header, const CDvFramePacket *DvFrame, uint32_t iSeq) const

1
reflector/M17Protocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"

48
reflector/Makefile
Unescape View File

@ -18,55 +18,37 @@
# if you change these locations, make sure the sgs.service file is updated! # if you change these locations, make sure the sgs.service file is updated!
# you will also break hard coded paths in the dashboard file, index.php. # you will also break hard coded paths in the dashboard file, index.php.
include configure.mk EXE = urfd
# if you make changed in these two variable, you'll need to change things INICHECK = inicheck
# in the main.h file as well as the systemd service file.
BINDIR = /usr/local/bin
CFGDIR = /usr/local/etc
CC = g++ include configure.mk
ifeq ($(debug), true) ifeq ($(debug), true)
CFLAGS = -ggdb3 -W -Werror -Wno-psabi -c -std=c++11 -MMD -MD -c CFLAGS = -ggdb3 -W -Werror -c -std=c++11 -MMD -MD
else else
CFLAGS = -c -W -Werror -Wno-psabi -std=c++11 -MMD -MD -c CFLAGS = -W -Werror -std=c++11 -MMD -MD
endif endif
LDFLAGS=-pthread LDFLAGS=-pthread -lcurl
URFSRCS = 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 GateKeeper.cpp IP.cpp Notification.cpp Packet.cpp PacketStream.cpp PeerCallsignList.cpp Peer.cpp Peers.cpp Protocol.cpp Protocols.cpp Reflector.cpp SEProtocol.cpp UDPSocket.cpp User.cpp Users.cpp Version.cpp Main.cpp BMClient.cpp BMPeer.cpp BMProtocol.cpp BPTC19696.cpp CRC.cpp DMRIdDir.cpp DMRIdDirFile.cpp DMRIdDirHttp.cpp NXDNIdDir.cpp NXDNIdDirFile.cpp NXDNIdDirHttp.cpp DMRMMDVMClient.cpp DMRMMDVMProtocol.cpp DMRPlusClient.cpp DMRPlusProtocol.cpp Golay2087.cpp Golay24128.cpp Hamming.cpp M17Client.cpp M17CRC.cpp M17Packet.cpp M17Client.cpp M17Protocol.cpp NXDNClient.cpp NXDNProtocol.cpp P25Client.cpp P25Protocol.cpp QR1676.cpp RS129.cpp Semaphore.cpp USRPClient.cpp USRPProtocol.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 = $(URFSRCS)
ifeq ($(use_g3), true)
SRCS += $(G3SRCS)
endif
ifeq ($(ysf_db), true)
LDFLAGS += `mysql_config --libs`
endif
ifdef tc_ip
SRCS += CodecStream.cpp UnixDgramSocket.cpp
endif
SRCS = $(wildcard *.cpp)
OBJS = $(SRCS:.cpp=.o) OBJS = $(SRCS:.cpp=.o)
DEPS = $(SRCS:.cpp=.d) DEPS = $(SRCS:.cpp=.d)
EXE=urfd all : $(EXE) $(INICHECK)
all : $(EXE)
$(EXE) : $(OBJS) $(EXE) : $(OBJS)
$(CC) $^ -o $@ $(LDFLAGS) $(CXX) $^ -o $@ $(LDFLAGS)
$(INICHECK) : Configure.cpp Configure.h
$(CXX) -DINICHECK $(CFLAGS) $< -o $(INICHECK) -lcurl
%.o : %.cpp %.o : %.cpp
g++ $(CFLAGS) $< -o $@ $(CXX) $(CFLAGS) -c $< -o $@
clean : clean :
$(RM) *.o *.d urfd $(RM) *.o *.d $(EXE) $(INICHECK)
-include $(DEPS) -include $(DEPS)
@ -74,9 +56,7 @@ install :
ln -f -s $(shell pwd)/$(EXE).blacklist $(CFGDIR)/$(EXE).blacklist ln -f -s $(shell pwd)/$(EXE).blacklist $(CFGDIR)/$(EXE).blacklist
ln -f -s $(shell pwd)/$(EXE).whitelist $(CFGDIR)/$(EXE).whitelist ln -f -s $(shell pwd)/$(EXE).whitelist $(CFGDIR)/$(EXE).whitelist
ln -f -s $(shell pwd)/$(EXE).interlink $(CFGDIR)/$(EXE).interlink ln -f -s $(shell pwd)/$(EXE).interlink $(CFGDIR)/$(EXE).interlink
ifeq ($(use_g3), true)
ln -f -s $(shell pwd)/$(EXE).terminal $(CFGDIR)/$(EXE).terminal ln -f -s $(shell pwd)/$(EXE).terminal $(CFGDIR)/$(EXE).terminal
endif
cp -f ../systemd/$(EXE).service /etc/systemd/system/ cp -f ../systemd/$(EXE).service /etc/systemd/system/
cp -f $(EXE) $(BINDIR) cp -f $(EXE) $(BINDIR)
systemctl enable $(EXE).service systemctl enable $(EXE).service

2
reflector/NXDNClient.h
Unescape View File

@ -19,7 +19,9 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CNXDNClient : public CClient class CNXDNClient : public CClient
{ {
public: public:

44
reflector/NXDNProtocol.cpp
Unescape View File

@ -22,9 +22,8 @@
#include "NXDNClient.h" #include "NXDNClient.h"
#include "NXDNProtocol.h" #include "NXDNProtocol.h"
#include "YSFDefines.h" #include "YSFDefines.h"
#include "Reflector.h"
#include "GateKeeper.h"
#include "Golay24128.h" #include "Golay24128.h"
#include "Global.h"
const uint8_t NXDN_LICH_RFCT_RDCH = 2U; const uint8_t NXDN_LICH_RFCT_RDCH = 2U;
const uint8_t NXDN_LICH_USC_SACCH_NS = 0U; const uint8_t NXDN_LICH_USC_SACCH_NS = 0U;
@ -53,6 +52,10 @@ CNXDNProtocol::CNXDNProtocol()
bool CNXDNProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CNXDNProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
// config value
m_ReflectorId = g_Conf.GetUnsigned(g_Conf.j.nxdn.reflectorid);
m_AutolinkModule = g_Conf.GetAutolinkModule(g_Conf.j.nxdn.autolinkmod);
// base class // base class
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6)) if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
return false; return false;
@ -119,7 +122,7 @@ void CNXDNProtocol::Task(void)
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::nxdn) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::nxdn) )
{ {
// add client if needed // add client if needed
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::nxdn); std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::nxdn);
// client already connected ? // client already connected ?
if ( client == nullptr ) if ( client == nullptr )
@ -130,9 +133,8 @@ void CNXDNProtocol::Task(void)
auto newclient = std::make_shared<CNXDNClient>(Callsign, Ip); auto newclient = std::make_shared<CNXDNClient>(Callsign, Ip);
// aautolink, if enabled // aautolink, if enabled
#if NXDN_AUTOLINK_ENABLE if (m_AutolinkModule)
newclient->SetReflectorModule(NXDN_AUTOLINK_MODULE); newclient->SetReflectorModule(m_AutolinkModule);
#endif
// and append // and append
clients->AddClient(newclient); clients->AddClient(newclient);
@ -145,7 +147,7 @@ void CNXDNProtocol::Task(void)
// acknowledge the request -- NXDNReflector simply echoes the packet // acknowledge the request -- NXDNReflector simply echoes the packet
Send(Buffer, Ip); Send(Buffer, Ip);
// and done // and done
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
else if ( IsValidDisconnectPacket(Buffer) ) else if ( IsValidDisconnectPacket(Buffer) )
@ -153,14 +155,14 @@ void CNXDNProtocol::Task(void)
std::cout << "NXDN disconnect packet from " << Ip << std::endl; std::cout << "NXDN disconnect packet from " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::nxdn); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::nxdn);
if ( client != nullptr ) if ( client != nullptr )
{ {
// remove it // remove it
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -210,7 +212,7 @@ void CNXDNProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::nxdn); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::nxdn);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
@ -221,20 +223,20 @@ void CNXDNProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
rpt2.SetCSModule(m); rpt2.SetCSModule(m);
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
if ( g_Refl..IsValidModule(rpt2.GetCSModule()) ) if ( g_Refl.IsValidModule(rpt2.GetCSModule()) )
{ {
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
} }
@ -292,7 +294,7 @@ void CNXDNProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::nxdn, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::nxdn, it)) != nullptr )
@ -305,7 +307,7 @@ void CNXDNProtocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -321,7 +323,7 @@ void CNXDNProtocol::HandleKeepalives(void)
// and disconnect them if not // and disconnect them if not
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::nxdn, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::nxdn, it)) != nullptr )
@ -341,7 +343,7 @@ void CNXDNProtocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -479,7 +481,7 @@ bool CNXDNProtocol::EncodeNXDNHeaderPacket(const CDvHeaderPacket &Header, CBuffe
{ {
Buffer.resize(43); Buffer.resize(43);
uint16_t NXDNId = Header.GetMyCallsign().GetNXDNid(); uint16_t NXDNId = Header.GetMyCallsign().GetNXDNid();
uint16_t RptrId = NXDN_REFID; uint16_t RptrId = m_ReflectorId;
memcpy(Buffer.data(), "NXDND", 5); memcpy(Buffer.data(), "NXDND", 5);
Buffer.data()[5U] = (NXDNId >> 8) & 0xFFU; Buffer.data()[5U] = (NXDNId >> 8) & 0xFFU;
@ -535,7 +537,7 @@ bool CNXDNProtocol::EncodeNXDNPacket(const CDvHeaderPacket &Header, uint32_t seq
uint8_t ambe[28]; uint8_t ambe[28];
Buffer.resize(43); Buffer.resize(43);
uint16_t NXDNId = Header.GetMyCallsign().GetNXDNid(); uint16_t NXDNId = Header.GetMyCallsign().GetNXDNid();
uint16_t RptrId = NXDN_REFID; uint16_t RptrId = m_ReflectorId;
memcpy(Buffer.data(), "NXDND", 5); memcpy(Buffer.data(), "NXDND", 5);
Buffer.data()[5U] = (NXDNId >> 8) & 0xFFU; Buffer.data()[5U] = (NXDNId >> 8) & 0xFFU;

4
reflector/NXDNProtocol.h
Unescape View File

@ -19,6 +19,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -121,4 +122,7 @@ protected:
uint8_t m_lich; uint8_t m_lich;
uint8_t m_sacch[5]; uint8_t m_sacch[5];
uint8_t m_layer3[22]; uint8_t m_layer3[22];
uint16_t m_ReflectorId;
char m_AutolinkModule;
}; };

6
reflector/NotificationQueue.h
Unescape View File

@ -32,12 +32,6 @@
class CNotificationQueue class CNotificationQueue
{ {
public: public:
// constructor
CNotificationQueue() {}
// destructor
~CNotificationQueue() {}
// lock // lock
void Lock() { m_Mutex.lock(); } void Lock() { m_Mutex.lock(); }
void Unlock() { m_Mutex.unlock(); } void Unlock() { m_Mutex.unlock(); }

3
reflector/P25Client.h
Unescape View File

@ -18,8 +18,9 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CP25Client : public CClient class CP25Client : public CClient
{ {
public: public:

48
reflector/P25Protocol.cpp
Unescape View File

@ -22,8 +22,7 @@
#include "P25Client.h" #include "P25Client.h"
#include "P25Protocol.h" #include "P25Protocol.h"
#include "Reflector.h" #include "Global.h"
#include "GateKeeper.h"
const uint8_t REC62[] = {0x62U, 0x02U, 0x02U, 0x0CU, 0x0BU, 0x12U, 0x64U, 0x00U, 0x00U, 0x80U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,0x00U, 0x00U, 0x00U, 0x00U, 0x00U}; const uint8_t REC62[] = {0x62U, 0x02U, 0x02U, 0x0CU, 0x0BU, 0x12U, 0x64U, 0x00U, 0x00U, 0x80U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,0x00U, 0x00U, 0x00U, 0x00U, 0x00U};
const uint8_t REC63[] = {0x63U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x02U}; const uint8_t REC63[] = {0x63U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x02U};
@ -50,6 +49,11 @@ const uint8_t REC80[] = {0x80U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U, 0x00U,
bool CP25Protocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CP25Protocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
// config data
m_ReflectorId = g_Conf.GetUnsigned(g_Conf.j.p25.reflectorid);
m_DefaultId = g_Conf.GetUnsigned(g_Conf.j.mmdvm.defaultid);
m_AutolinkModule = g_Conf.GetAutolinkModule(g_Conf.j.p25.autolinkmod);
m_uiStreamId = 0; m_uiStreamId = 0;
// base class // base class
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6)) if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
@ -107,7 +111,7 @@ void CP25Protocol::Task(void)
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::p25) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::p25) )
{ {
// add client if needed // add client if needed
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::p25); std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::p25);
// client already connected ? // client already connected ?
if ( client == nullptr ) if ( client == nullptr )
@ -118,9 +122,8 @@ void CP25Protocol::Task(void)
auto newclient = std::make_shared<CP25Client>(Callsign, Ip); auto newclient = std::make_shared<CP25Client>(Callsign, Ip);
// aautolink, if enabled // aautolink, if enabled
#if P25_AUTOLINK_ENABLE if (m_AutolinkModule)
newclient->SetReflectorModule(P25_AUTOLINK_MODULE); newclient->SetReflectorModule(m_AutolinkModule);
#endif
// and append // and append
clients->AddClient(newclient); clients->AddClient(newclient);
@ -133,7 +136,7 @@ void CP25Protocol::Task(void)
// acknowledge the request -- P25Reflector simply echoes the packet // acknowledge the request -- P25Reflector simply echoes the packet
Send(Buffer, Ip); Send(Buffer, Ip);
// and done // and done
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
else if ( IsValidDisconnectPacket(Buffer, &Callsign) ) else if ( IsValidDisconnectPacket(Buffer, &Callsign) )
@ -141,14 +144,14 @@ void CP25Protocol::Task(void)
std::cout << "P25 disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "P25 disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::p25); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::p25);
if ( client != nullptr ) if ( client != nullptr )
{ {
// remove it // remove it
clients->RemoveClient(client); clients->RemoveClient(client);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -197,7 +200,7 @@ void CP25Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::p25); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::p25);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
@ -206,18 +209,18 @@ void CP25Protocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
Header->SetRpt2Module(m); Header->SetRpt2Module(m);
rpt2.SetCSModule(m); rpt2.SetCSModule(m);
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -256,7 +259,7 @@ void CP25Protocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::p25, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::p25, it)) != nullptr )
@ -269,7 +272,7 @@ void CP25Protocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
} }
@ -387,10 +390,9 @@ bool CP25Protocol::IsValidDvHeaderPacket(const CIp &Ip, const CBuffer &Buffer, s
void CP25Protocol::EncodeP25Packet(const CDvHeaderPacket &Header, const CDvFramePacket &DvFrame, uint32_t iSeq, CBuffer &Buffer, bool islast) const void CP25Protocol::EncodeP25Packet(const CDvHeaderPacket &Header, const CDvFramePacket &DvFrame, uint32_t iSeq, CBuffer &Buffer, bool islast) const
{ {
uint32_t uiSrcId = Header.GetMyCallsign().GetDmrid(); uint32_t uiSrcId = Header.GetMyCallsign().GetDmrid();
uint32_t uiRptrId = P25_REFID;
if(uiSrcId == 0){ if(uiSrcId == 0){
uiSrcId = DMRMMDVM_DEFAULTID; uiSrcId = m_DefaultId;
} }
if(islast) if(islast)
@ -420,9 +422,9 @@ void CP25Protocol::EncodeP25Packet(const CDvHeaderPacket &Header, const CDvFrame
Buffer.resize(17); Buffer.resize(17);
::memcpy(Buffer.data(), REC65, 17U); ::memcpy(Buffer.data(), REC65, 17U);
::memcpy(Buffer.data() + 5U, DvFrame.GetCodecData(ECodecType::p25), 11U); ::memcpy(Buffer.data() + 5U, DvFrame.GetCodecData(ECodecType::p25), 11U);
Buffer.data()[1U] = (uiRptrId >> 16) & 0xFFU; Buffer.data()[1U] = (m_ReflectorId >> 16) & 0xFFU;
Buffer.data()[2U] = (uiRptrId >> 8) & 0xFFU; Buffer.data()[2U] = (m_ReflectorId >> 8) & 0xFFU;
Buffer.data()[3U] = (uiRptrId >> 0) & 0xFFU; Buffer.data()[3U] = (m_ReflectorId >> 0) & 0xFFU;
break; break;
case 0x04U: case 0x04U:
Buffer.resize(17); Buffer.resize(17);
@ -506,7 +508,7 @@ void CP25Protocol::EncodeP25Packet(const CDvHeaderPacket &Header, const CDvFrame
void CP25Protocol::HandleKeepalives(void) void CP25Protocol::HandleKeepalives(void)
{ {
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::p25, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::p25, it)) != nullptr )
@ -526,5 +528,5 @@ void CP25Protocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }

6
reflector/P25Protocol.h
Unescape View File

@ -19,6 +19,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -72,4 +73,9 @@ protected:
// for queue header caches // for queue header caches
std::unordered_map<char, CP25StreamCacheItem> m_StreamsCache; std::unordered_map<char, CP25StreamCacheItem> m_StreamsCache;
uint32_t m_uiStreamId; uint32_t m_uiStreamId;
// config data
uint32_t m_ReflectorId;
uint32_t m_DefaultId;
char m_AutolinkModule;
}; };

2
reflector/Packet.cpp
Unescape View File

@ -16,7 +16,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <iostream>
#include "Packet.h" #include "Packet.h"
// default constructor // default constructor

2
reflector/PacketQueue.h
Unescape View File

@ -18,6 +18,8 @@
#pragma once #pragma once
#include <mutex>
#include <queue>
#include "Packet.h" #include "Packet.h"
class CClient; class CClient;

5
reflector/PacketStream.cpp
Unescape View File

@ -60,7 +60,8 @@ bool CPacketStream::OpenPacketStream(const CDvHeaderPacket &DvHeader, std::share
m_LastPacketTime.start(); m_LastPacketTime.start();
return true; return true;
} }
if (m_CodecStream)
m_CodecStream->ResetStats(m_uiStreamId, m_DvHeader.GetCodecIn());
return false; return false;
} }
@ -71,7 +72,7 @@ void CPacketStream::ClosePacketStream(void)
m_uiStreamId = 0; m_uiStreamId = 0;
m_OwnerClient.reset(); m_OwnerClient.reset();
if (m_CodecStream) if (m_CodecStream)
m_CodecStream.reset(); m_CodecStream->ReportStats();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////

3
reflector/PeerCallsignList.cpp
Unescape View File

@ -16,11 +16,12 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <fstream>
#include <string.h> #include <string.h>
#include "PeerCallsignList.h" #include "PeerCallsignList.h"
bool CPeerCallsignList::LoadFromFile(const char *filename) bool CPeerCallsignList::LoadFromFile(const std::string &filename)
{ {
bool ok = false; bool ok = false;
char sz[256]; char sz[256];

2
reflector/PeerCallsignList.h
Unescape View File

@ -34,5 +34,5 @@ public:
virtual ~CPeerCallsignList() {} virtual ~CPeerCallsignList() {}
// file io // file io
bool LoadFromFile(const char *); bool LoadFromFile(const std::string &filename);
}; };

16
reflector/Peers.cpp
Unescape View File

@ -16,11 +16,9 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Global.h"
#include "Reflector.h"
#include "Peers.h" #include "Peers.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
@ -60,15 +58,15 @@ void CPeers::AddPeer(std::shared_ptr<CPeer> peer)
std::cout << "New peer " << peer->GetCallsign() << " at " << peer->GetIp() << " added with protocol " << peer->GetProtocolName() << std::endl; std::cout << "New peer " << peer->GetCallsign() << " at " << peer->GetIp() << " added with protocol " << peer->GetProtocolName() << std::endl;
// and append all peer's client to reflector client list // and append all peer's client to reflector client list
// it is double lock safe to lock Clients list after Peers list // it is double lock safe to lock Clients list after Peers list
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
for ( auto cit=peer->cbegin(); cit!=peer->cend(); cit++ ) for ( auto cit=peer->cbegin(); cit!=peer->cend(); cit++ )
{ {
clients->AddClient(*cit); clients->AddClient(*cit);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// notify // notify
g_Refl..OnPeersChanged(); g_Refl.OnPeersChanged();
} }
void CPeers::RemovePeer(std::shared_ptr<CPeer> peer) void CPeers::RemovePeer(std::shared_ptr<CPeer> peer)
@ -81,7 +79,7 @@ void CPeers::RemovePeer(std::shared_ptr<CPeer> peer)
{ {
// remove all clients from reflector client list // remove all clients from reflector client list
// it is double lock safe to lock Clients list after Peers list // it is double lock safe to lock Clients list after Peers list
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
for ( auto cit=peer->begin(); cit!=peer->end(); cit++ ) for ( auto cit=peer->begin(); cit!=peer->end(); cit++ )
{ {
// this also delete the client object // this also delete the client object
@ -89,13 +87,13 @@ void CPeers::RemovePeer(std::shared_ptr<CPeer> peer)
} }
// so clear it then // so clear it then
(*pit)->ClearClients(); (*pit)->ClearClients();
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// remove it // remove it
std::cout << "Peer " << (*pit)->GetCallsign() << " at " << (*pit)->GetIp() << " removed" << std::endl; std::cout << "Peer " << (*pit)->GetCallsign() << " at " << (*pit)->GetIp() << " removed" << std::endl;
pit = m_Peers.erase(pit); pit = m_Peers.erase(pit);
// notify // notify
g_Refl..OnPeersChanged(); g_Refl.OnPeersChanged();
} }
else else
{ {

26
reflector/Protocol.cpp
Unescape View File

@ -16,11 +16,10 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Defines.h"
#include "Global.h"
#include "Protocol.h" #include "Protocol.h"
#include "Clients.h" #include "Clients.h"
#include "Reflector.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
@ -51,8 +50,9 @@ CProtocol::~CProtocol()
bool CProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
m_Port = port;
// init reflector apparent callsign // init reflector apparent callsign
m_ReflectorCallsign = g_Refl..GetCallsign(); m_ReflectorCallsign = g_Refl.GetCallsign();
// reset stop flag // reset stop flag
keep_running = true; keep_running = true;
@ -62,10 +62,10 @@ bool CProtocol::Initialize(const char *type, const EProtocol ptype, const uint16
m_ReflectorCallsign.PatchCallsign(0, type, 3); m_ReflectorCallsign.PatchCallsign(0, type, 3);
// create our sockets // create our sockets
#ifdef LISTEN_IPV4
if (has_ipv4) if (has_ipv4)
{ {
CIp ip4(AF_INET, port, LISTEN_IPV4); const std::string ipv4binding(g_Conf.GetString(g_Conf.j.ip.ipv4bind));
CIp ip4(AF_INET, port, ipv4binding.c_str());
if ( ip4.IsSet() ) if ( ip4.IsSet() )
{ {
if (! m_Socket4.Open(ip4)) if (! m_Socket4.Open(ip4))
@ -73,12 +73,13 @@ bool CProtocol::Initialize(const char *type, const EProtocol ptype, const uint16
} }
std::cout << "Listening on " << ip4 << std::endl; std::cout << "Listening on " << ip4 << std::endl;
} }
#endif
#ifdef LISTEN_IPV6 if (g_Conf.IsString(g_Conf.j.ip.ipv6bind))
{
if (has_ipv6) if (has_ipv6)
{ {
CIp ip6(AF_INET6, port, LISTEN_IPV6); const std::string ipv6binding(g_Conf.j.ip.ipv6bind);
CIp ip6(AF_INET6, port, ipv6binding.c_str());
if ( ip6.IsSet() ) if ( ip6.IsSet() )
{ {
if (! m_Socket6.Open(ip6)) if (! m_Socket6.Open(ip6))
@ -89,9 +90,10 @@ bool CProtocol::Initialize(const char *type, const EProtocol ptype, const uint16
std::cout << "Listening on " << ip6 << std::endl; std::cout << "Listening on " << ip6 << std::endl;
} }
} }
#endif }
try { try
{
m_Future = std::async(std::launch::async, &CProtocol::Thread, this); m_Future = std::async(std::launch::async, &CProtocol::Thread, this);
} }
catch (const std::exception &e) catch (const std::exception &e)
@ -179,7 +181,7 @@ void CProtocol::CheckStreamsTimeout(void)
{ {
// yes, close it // yes, close it
it->second->Unlock(); it->second->Unlock();
g_Refl..CloseStream(it->second); g_Refl.CloseStream(it->second);
// and remove it from the m_Streams map // and remove it from the m_Streams map
it = m_Streams.erase(it); it = m_Streams.erase(it);
} }

6
reflector/Protocol.h
Unescape View File

@ -132,10 +132,8 @@ protected:
// identity // identity
CCallsign m_ReflectorCallsign; CCallsign m_ReflectorCallsign;
// data
uint8_t m_Port;
// debug // debug
CTimer m_DebugTimer; CTimer m_DebugTimer;
#ifdef DEBUG
void Dump(const char *title, const uint8_t *pointer, int length);
#endif
}; };

29
reflector/Protocols.cpp
Unescape View File

@ -29,10 +29,9 @@
#include "P25Protocol.h" #include "P25Protocol.h"
#include "NXDNProtocol.h" #include "NXDNProtocol.h"
#include "USRPProtocol.h" #include "USRPProtocol.h"
#ifndef NO_G3
#include "G3Protocol.h" #include "G3Protocol.h"
#endif
#include "Protocols.h" #include "Protocols.h"
#include "Global.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// destructor // destructor
@ -50,58 +49,56 @@ bool CProtocols::Init(void)
m_Mutex.lock(); m_Mutex.lock();
{ {
m_Protocols.emplace_back(std::unique_ptr<CDextraProtocol>(new CDextraProtocol)); m_Protocols.emplace_back(std::unique_ptr<CDextraProtocol>(new CDextraProtocol));
if (! m_Protocols.back()->Initialize("XRF", EProtocol::dextra, DEXTRA_PORT, DSTAR_IPV4, DSTAR_IPV6)) if (! m_Protocols.back()->Initialize("XRF", EProtocol::dextra, uint16_t(g_Conf.GetUnsigned(g_Conf.j.dextra.port)), DSTAR_IPV4, DSTAR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CDplusProtocol>(new CDplusProtocol)); m_Protocols.emplace_back(std::unique_ptr<CDplusProtocol>(new CDplusProtocol));
if (! m_Protocols.back()->Initialize("REF", EProtocol::dplus, DPLUS_PORT, DSTAR_IPV4, DSTAR_IPV6)) if (! m_Protocols.back()->Initialize("REF", EProtocol::dplus, uint16_t(g_Conf.GetUnsigned(g_Conf.j.dplus.port)), DSTAR_IPV4, DSTAR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CDcsProtocol>(new CDcsProtocol)); m_Protocols.emplace_back(std::unique_ptr<CDcsProtocol>(new CDcsProtocol));
if (! m_Protocols.back()->Initialize("DCS", EProtocol::dcs, DCS_PORT, DSTAR_IPV4, DSTAR_IPV6)) if (! m_Protocols.back()->Initialize("DCS", EProtocol::dcs, uint16_t(g_Conf.GetUnsigned(g_Conf.j.dcs.port)), DSTAR_IPV4, DSTAR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CDmrmmdvmProtocol>(new CDmrmmdvmProtocol)); m_Protocols.emplace_back(std::unique_ptr<CDmrmmdvmProtocol>(new CDmrmmdvmProtocol));
if (! m_Protocols.back()->Initialize(nullptr, EProtocol::dmrmmdvm, DMRMMDVM_PORT, DMR_IPV4, DMR_IPV6)) if (! m_Protocols.back()->Initialize(nullptr, EProtocol::dmrmmdvm, uint16_t(g_Conf.GetUnsigned(g_Conf.j.mmdvm.port)), DMR_IPV4, DMR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CBMProtocol>(new CBMProtocol)); m_Protocols.emplace_back(std::unique_ptr<CBMProtocol>(new CBMProtocol));
if (! m_Protocols.back()->Initialize("XLX", EProtocol::bm, XLX_PORT, DMR_IPV4, DMR_IPV6)) if (! m_Protocols.back()->Initialize("XLX", EProtocol::bm, uint16_t(g_Conf.GetUnsigned(g_Conf.j.bm.port)), DMR_IPV4, DMR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CDmrplusProtocol>(new CDmrplusProtocol)); m_Protocols.emplace_back(std::unique_ptr<CDmrplusProtocol>(new CDmrplusProtocol));
if (! m_Protocols.back()->Initialize(nullptr, EProtocol::dmrplus, DMRPLUS_PORT, DMR_IPV4, DMR_IPV6)) if (! m_Protocols.back()->Initialize(nullptr, EProtocol::dmrplus, uint16_t(g_Conf.GetUnsigned(g_Conf.j.dmrplus.port)), DMR_IPV4, DMR_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CYsfProtocol>(new CYsfProtocol)); m_Protocols.emplace_back(std::unique_ptr<CYsfProtocol>(new CYsfProtocol));
if (! m_Protocols.back()->Initialize("YSF", EProtocol::ysf, YSF_PORT, YSF_IPV4, YSF_IPV6)) if (! m_Protocols.back()->Initialize("YSF", EProtocol::ysf, uint16_t(g_Conf.GetUnsigned(g_Conf.j.ysf.port)), YSF_IPV4, YSF_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CM17Protocol>(new CM17Protocol)); m_Protocols.emplace_back(std::unique_ptr<CM17Protocol>(new CM17Protocol));
if (! m_Protocols.back()->Initialize("URF", EProtocol::m17, M17_PORT, M17_IPV4, M17_IPV6)) if (! m_Protocols.back()->Initialize("URF", EProtocol::m17, uint16_t(g_Conf.GetUnsigned(g_Conf.j.m17.port)), M17_IPV4, M17_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CP25Protocol>(new CP25Protocol)); m_Protocols.emplace_back(std::unique_ptr<CP25Protocol>(new CP25Protocol));
if (! m_Protocols.back()->Initialize("P25", EProtocol::p25, P25_PORT, P25_IPV4, P25_IPV6)) if (! m_Protocols.back()->Initialize("P25", EProtocol::p25, uint16_t(g_Conf.GetUnsigned(g_Conf.j.p25.port)), P25_IPV4, P25_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CNXDNProtocol>(new CNXDNProtocol)); m_Protocols.emplace_back(std::unique_ptr<CNXDNProtocol>(new CNXDNProtocol));
if (! m_Protocols.back()->Initialize("NXDN", EProtocol::nxdn, NXDN_PORT, NXDN_IPV4, NXDN_IPV6)) if (! m_Protocols.back()->Initialize("NXDN", EProtocol::nxdn, uint16_t(g_Conf.GetUnsigned(g_Conf.j.nxdn.port)), NXDN_IPV4, NXDN_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CUSRPProtocol>(new CUSRPProtocol)); m_Protocols.emplace_back(std::unique_ptr<CUSRPProtocol>(new CUSRPProtocol));
if (! m_Protocols.back()->Initialize("USRP", EProtocol::usrp, USRP_PORT, USRP_IPV4, USRP_IPV6)) if (! m_Protocols.back()->Initialize("USRP", EProtocol::usrp, uint16_t(g_Conf.GetUnsigned(g_Conf.j.usrp.port)), USRP_IPV4, USRP_IPV6))
return false; return false;
m_Protocols.emplace_back(std::unique_ptr<CURFProtocol>(new CURFProtocol)); m_Protocols.emplace_back(std::unique_ptr<CURFProtocol>(new CURFProtocol));
if (! m_Protocols.back()->Initialize("URF", EProtocol::urf, URF_PORT, URF_IPV4, URF_IPV6)) if (! m_Protocols.back()->Initialize("URF", EProtocol::urf, uint16_t(g_Conf.GetUnsigned(g_Conf.j.urf.port)), URF_IPV4, URF_IPV6))
return false; return false;
#ifndef NO_G3
m_Protocols.emplace_back(std::unique_ptr<CG3Protocol>(new CG3Protocol)); m_Protocols.emplace_back(std::unique_ptr<CG3Protocol>(new CG3Protocol));
if (! m_Protocols.back()->Initialize("XLX", EProtocol::g3, G3_DV_PORT, DMR_IPV4, DMR_IPV6)) if (! m_Protocols.back()->Initialize("XLX", EProtocol::g3, G3_DV_PORT, DMR_IPV4, DMR_IPV6))
return false; return false;
#endif
} }
m_Mutex.unlock(); m_Mutex.unlock();

5
reflector/Semaphore.h
Unescape View File

@ -18,7 +18,8 @@
#pragma once #pragma once
#include <mutex>
#include <condition_variable>
class CSemaphore class CSemaphore
{ {
@ -39,6 +40,6 @@ protected:
// data // data
std::mutex m_Mutex; std::mutex m_Mutex;
std::condition_variable m_Condition; std::condition_variable m_Condition;
size_t m_Count; std::size_t m_Count;
}; };

1
reflector/URFClient.h
Unescape View File

@ -18,6 +18,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CURFClient : public CClient class CURFClient : public CClient

64
reflector/URFProtocol.cpp
Unescape View File

@ -22,7 +22,7 @@
#include "URFProtocol.h" #include "URFProtocol.h"
#include "Reflector.h" #include "Reflector.h"
#include "GateKeeper.h" #include "GateKeeper.h"
#include "Global.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// operation // operation
@ -73,14 +73,14 @@ void CURFProtocol::Task(void)
else if ( IsValidKeepAlivePacket(Buffer, &Callsign) ) else if ( IsValidKeepAlivePacket(Buffer, &Callsign) )
{ {
// find peer // find peer
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::urf); std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::urf);
if ( peer != nullptr ) if ( peer != nullptr )
{ {
// keep it alive // keep it alive
peer->Alive(); peer->Alive();
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
else if ( IsValidDvHeaderPacket(Buffer, Header) ) else if ( IsValidDvHeaderPacket(Buffer, Header) )
{ {
@ -126,7 +126,7 @@ void CURFProtocol::Task(void)
if ( g_Gate.MayLink(Callsign, Ip, EProtocol::urf, Modules) ) if ( g_Gate.MayLink(Callsign, Ip, EProtocol::urf, Modules) )
{ {
// already connected ? // already connected ?
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
if ( peers->FindPeer(Callsign, Ip, EProtocol::urf) == nullptr ) if ( peers->FindPeer(Callsign, Ip, EProtocol::urf) == nullptr )
{ {
// create the new peer // create the new peer
@ -137,7 +137,7 @@ void CURFProtocol::Task(void)
// this also add all new clients to reflector client list // this also add all new clients to reflector client list
peers->AddPeer(peer); peers->AddPeer(peer);
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
} }
else if ( IsValidDisconnectPacket(Buffer, &Callsign) ) else if ( IsValidDisconnectPacket(Buffer, &Callsign) )
@ -145,7 +145,7 @@ void CURFProtocol::Task(void)
std::cout << "URF disconnect packet from " << Callsign << " at " << Ip << std::endl; std::cout << "URF disconnect packet from " << Callsign << " at " << Ip << std::endl;
// find peer // find peer
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::urf); std::shared_ptr<CPeer>peer = peers->FindPeer(Ip, EProtocol::urf);
if ( peer != nullptr ) if ( peer != nullptr )
{ {
@ -154,7 +154,7 @@ void CURFProtocol::Task(void)
// and delete them // and delete them
peers->RemovePeer(peer); peers->RemovePeer(peer);
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
else if ( IsValidNackPacket(Buffer, &Callsign) ) else if ( IsValidNackPacket(Buffer, &Callsign) )
{ {
@ -216,7 +216,7 @@ void CURFProtocol::HandleQueue(void)
if ( EncodeDvPacket(*packet, buffer) ) if ( EncodeDvPacket(*packet, buffer) )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::urf, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::urf, it)) != nullptr )
@ -232,7 +232,7 @@ void CURFProtocol::HandleQueue(void)
} }
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
} }
@ -251,7 +251,7 @@ void CURFProtocol::HandleKeepalives(void)
EncodeKeepAlivePacket(&keepalive); EncodeKeepAlivePacket(&keepalive);
// iterate on peers // iterate on peers
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
auto pit = peers->begin(); auto pit = peers->begin();
std::shared_ptr<CPeer>peer = nullptr; std::shared_ptr<CPeer>peer = nullptr;
while ( (peer = peers->FindNextPeer(EProtocol::urf, pit)) != nullptr ) while ( (peer = peers->FindNextPeer(EProtocol::urf, pit)) != nullptr )
@ -278,7 +278,7 @@ void CURFProtocol::HandleKeepalives(void)
peers->RemovePeer(peer); peers->RemovePeer(peer);
} }
} }
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -290,7 +290,7 @@ void CURFProtocol::HandlePeerLinks(void)
// get the list of peers // get the list of peers
CPeerCallsignList *list = g_Gate.GetPeerList(); CPeerCallsignList *list = g_Gate.GetPeerList();
CPeers *peers = g_Refl..GetPeers(); CPeers *peers = g_Refl.GetPeers();
// check if all our connected peers are still listed by gatekeeper // check if all our connected peers are still listed by gatekeeper
// if not, disconnect // if not, disconnect
@ -324,13 +324,13 @@ void CURFProtocol::HandlePeerLinks(void)
it->ResolveIp(); it->ResolveIp();
// send connect packet to re-initiate peer link // send connect packet to re-initiate peer link
EncodeConnectPacket(&buffer, it->GetModules()); EncodeConnectPacket(&buffer, it->GetModules());
Send(buffer, it->GetIp(), URF_PORT); Send(buffer, it->GetIp(), m_Port);
std::cout << "Sending connect packet to URF peer " << cs << " @ " << it->GetIp() << " for modules " << it->GetModules() << std::endl; std::cout << "Sending connect packet to URF peer " << cs << " @ " << it->GetIp() << " for modules " << it->GetModules() << std::endl;
} }
} }
// done // done
g_Refl..ReleasePeers(); g_Refl.ReleasePeers();
g_Gate.ReleasePeerList(); g_Gate.ReleasePeerList();
} }
@ -363,11 +363,11 @@ void CURFProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// no stream open yet, open a new one // no stream open yet, open a new one
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::urf, Header->GetRpt2Module()); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::urf, Header->GetRpt2Module());
if ( client ) if ( client )
{ {
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
@ -376,10 +376,10 @@ void CURFProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
peer = client->GetCallsign(); peer = client->GetCallsign();
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2, peer); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2, peer);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -420,7 +420,7 @@ bool CURFProtocol::IsValidConnectPacket(const CBuffer &Buffer, CCallsign *callsi
memcpy(modules, Buffer.data()+10, 27); memcpy(modules, Buffer.data()+10, 27);
for ( unsigned i = 0; i < strlen(modules); i++ ) for ( unsigned i = 0; i < strlen(modules); i++ )
{ {
valid &= (nullptr != strchr(ACTIVE_MODULES, modules[i])); valid = valid && (g_Refl.IsValidModule (modules[i]));
} }
} }
return valid; return valid;
@ -450,7 +450,7 @@ bool CURFProtocol::IsValidAckPacket(const CBuffer &Buffer, CCallsign *callsign,
memcpy(modules, Buffer.data()+10, 27); memcpy(modules, Buffer.data()+10, 27);
for ( unsigned i = 0; i < strlen(modules); i++ ) for ( unsigned i = 0; i < strlen(modules); i++ )
{ {
valid &= (nullptr != strchr(ACTIVE_MODULES, modules[i])); valid = valid && (g_Refl.IsValidModule(modules[i]));
} }
} }
return valid; return valid;
@ -521,7 +521,7 @@ void CURFProtocol::EncodeKeepAlivePacket(CBuffer *Buffer)
{ {
Buffer->Set("PING"); Buffer->Set("PING");
Buffer->resize(10); Buffer->resize(10);
g_Refl..GetCallsign().CodeOut(Buffer->data()+4); g_Refl.GetCallsign().CodeOut(Buffer->data()+4);
} }
void CURFProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules) void CURFProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules)
@ -530,12 +530,12 @@ void CURFProtocol::EncodeConnectPacket(CBuffer *Buffer, const char *Modules)
Buffer->Set("CONN"); Buffer->Set("CONN");
// our callsign // our callsign
Buffer->resize(37); Buffer->resize(37);
g_Refl..GetCallsign().CodeOut(Buffer->data()+4); g_Refl.GetCallsign().CodeOut(Buffer->data()+4);
// our version // our version
Buffer->ReplaceAt(10, (uint8_t *)Modules, strlen(Modules)); Buffer->ReplaceAt(10, (uint8_t *)Modules, strlen(Modules));
Buffer->Append((uint8_t)VERSION_MAJOR); Buffer->Append((uint8_t)g_Vers.GetMajor());
Buffer->Append((uint8_t)VERSION_MINOR); Buffer->Append((uint8_t)g_Vers.GetMinor());
Buffer->Append((uint8_t)VERSION_REVISION); Buffer->Append((uint8_t)g_Vers.GetRevision());
} }
void CURFProtocol::EncodeDisconnectPacket(CBuffer *Buffer) void CURFProtocol::EncodeDisconnectPacket(CBuffer *Buffer)
@ -543,7 +543,7 @@ void CURFProtocol::EncodeDisconnectPacket(CBuffer *Buffer)
Buffer->Set("DISC"); Buffer->Set("DISC");
// our callsign // our callsign
Buffer->resize(10); Buffer->resize(10);
g_Refl..GetCallsign().CodeOut(Buffer->data()+4); g_Refl.GetCallsign().CodeOut(Buffer->data()+4);
} }
void CURFProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules) void CURFProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules)
@ -551,18 +551,18 @@ void CURFProtocol::EncodeConnectAckPacket(CBuffer *Buffer, const char *Modules)
Buffer->Set("ACKN"); Buffer->Set("ACKN");
// our callsign // our callsign
Buffer->resize(37); Buffer->resize(37);
g_Refl..GetCallsign().CodeOut(Buffer->data()+4); g_Refl.GetCallsign().CodeOut(Buffer->data()+4);
// the shared modules // the shared modules
Buffer->ReplaceAt(10, (uint8_t *)Modules, strlen(Modules)); Buffer->ReplaceAt(10, (uint8_t *)Modules, strlen(Modules));
// our version // our version
Buffer->Append((uint8_t)VERSION_MAJOR); Buffer->Append((uint8_t)g_Vers.GetMajor());
Buffer->Append((uint8_t)VERSION_MINOR); Buffer->Append((uint8_t)g_Vers.GetMinor());
Buffer->Append((uint8_t)VERSION_REVISION); Buffer->Append((uint8_t)g_Vers.GetRevision());
} }
void CURFProtocol::EncodeConnectNackPacket(CBuffer *Buffer) void CURFProtocol::EncodeConnectNackPacket(CBuffer *Buffer)
{ {
Buffer->Set("NACK"); Buffer->Set("NACK");
Buffer->resize(10); Buffer->resize(10);
g_Refl..GetCallsign().CodeOut(Buffer->data()+4); g_Refl.GetCallsign().CodeOut(Buffer->data()+4);
} }

1
reflector/URFProtocol.h
Unescape View File

@ -18,6 +18,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include "Defines.h"
#include "Version.h" #include "Version.h"
#include "Timer.h" #include "Timer.h"
#include "SEProtocol.h" #include "SEProtocol.h"

2
reflector/USRPClient.h
Unescape View File

@ -19,7 +19,9 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CUSRPClient : public CClient class CUSRPClient : public CClient
{ {
public: public:

42
reflector/USRPProtocol.cpp
Unescape View File

@ -22,8 +22,7 @@
#include "USRPClient.h" #include "USRPClient.h"
#include "USRPProtocol.h" #include "USRPProtocol.h"
#include "Reflector.h" #include "Global.h"
#include "GateKeeper.h"
const uint8_t USRP_TYPE_VOICE = 0; const uint8_t USRP_TYPE_VOICE = 0;
const uint8_t USRP_TYPE_TEXT = 2; const uint8_t USRP_TYPE_TEXT = 2;
@ -38,10 +37,13 @@ const uint8_t TLV_TAG_SET_INFO = 8;
bool CUSRPProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CUSRPProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
// config data
m_DefaultCallsign.assign(g_Conf.GetString(g_Conf.j.usrp.defaultcallsign));
m_AutolinkModule = g_Conf.GetAutolinkModule(g_Conf.j.usrp.autolinkmod);
CBuffer buffer; CBuffer buffer;
m_uiStreamId = 0; m_uiStreamId = 0;
CCallsign cs(USRP_DEFAULT_CALLSIGN); CCallsign cs(m_DefaultCallsign.c_str());
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::ifstream file; std::ifstream file;
std::streampos size; std::streampos size;
@ -49,7 +51,7 @@ bool CUSRPProtocol::Initialize(const char *type, const EProtocol ptype, const ui
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6)) if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
return false; return false;
file.open(USRPCLIENTS_PATH, std::ios::in | std::ios::binary | std::ios::ate); file.open(g_Conf.GetString(g_Conf.j.usrp.clientfilepath), std::ios::in | std::ios::binary | std::ios::ate);
if ( file.is_open() ) if ( file.is_open() )
{ {
// read file // read file
@ -83,9 +85,9 @@ bool CUSRPProtocol::Initialize(const char *type, const EProtocol ptype, const ui
uint32_t ui = atoi(port); uint32_t ui = atoi(port);
CIp Ip(AF_INET, ui, ip); CIp Ip(AF_INET, ui, ip);
auto newclient = std::make_shared<CUSRPClient>(cs, Ip); auto newclient = std::make_shared<CUSRPClient>(cs, Ip);
#if USRP_AUTOLINK_ENABLE if (m_AutolinkModule)
newclient->SetReflectorModule(USRP_AUTOLINK_MODULE); newclient->SetReflectorModule(m_AutolinkModule);
#endif
clients->AddClient(newclient); clients->AddClient(newclient);
} }
} }
@ -93,7 +95,7 @@ bool CUSRPProtocol::Initialize(const char *type, const EProtocol ptype, const ui
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update time // update time
m_LastKeepaliveTime.start(); m_LastKeepaliveTime.start();
@ -192,7 +194,7 @@ void CUSRPProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::usrp); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::usrp);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
@ -201,18 +203,18 @@ void CUSRPProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
Header->SetRpt2Module(m); Header->SetRpt2Module(m);
rpt2.SetCSModule(m); rpt2.SetCSModule(m);
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
@ -249,7 +251,7 @@ void CUSRPProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::usrp, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::usrp, it)) != nullptr )
@ -261,7 +263,7 @@ void CUSRPProtocol::HandleQueue(void)
Send(buffer, client->GetIp()); Send(buffer, client->GetIp());
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -279,8 +281,8 @@ bool CUSRPProtocol::IsValidDvPacket(const CIp &Ip, const CBuffer &Buffer, std::u
if ( !stream ) if ( !stream )
{ {
m_uiStreamId = static_cast<uint32_t>(::rand()); m_uiStreamId = static_cast<uint32_t>(::rand());
CCallsign csMY = CCallsign(USRP_DEFAULT_CALLSIGN); CCallsign csMY = CCallsign(m_DefaultCallsign.c_str());
CCallsign rpt1 = CCallsign(USRP_DEFAULT_CALLSIGN); CCallsign rpt1 = CCallsign(m_DefaultCallsign.c_str());
CCallsign rpt2 = m_ReflectorCallsign; CCallsign rpt2 = m_ReflectorCallsign;
rpt1.SetCSModule(USRP_MODULE_ID); rpt1.SetCSModule(USRP_MODULE_ID);
rpt2.SetCSModule(' '); rpt2.SetCSModule(' ');
@ -375,7 +377,7 @@ void CUSRPProtocol::EncodeUSRPPacket(const CDvHeaderPacket &Header, const CDvFra
void CUSRPProtocol::HandleKeepalives(void) void CUSRPProtocol::HandleKeepalives(void)
{ {
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::usrp, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::usrp, it)) != nullptr )
@ -395,5 +397,5 @@ void CUSRPProtocol::HandleKeepalives(void)
//} //}
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }

5
reflector/USRPProtocol.h
Unescape View File

@ -19,6 +19,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -72,4 +73,8 @@ protected:
// for queue header caches // for queue header caches
std::unordered_map<char, CUSRPStreamCacheItem> m_StreamsCache; std::unordered_map<char, CUSRPStreamCacheItem> m_StreamsCache;
uint32_t m_uiStreamId; uint32_t m_uiStreamId;
// config data
std::string m_DefaultCallsign;
char m_AutolinkModule;
}; };

2
reflector/User.cpp
Unescape View File

@ -16,7 +16,7 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <ctime>
#include <string.h> #include <string.h>
#include "User.h" #include "User.h"

7
reflector/Users.cpp
Unescape View File

@ -18,7 +18,7 @@
#include "Users.h" #include "Users.h"
#include "Reflector.h" #include "Global.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
@ -28,6 +28,7 @@ CUsers::CUsers() {}
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// users management // users management
#define LASTHEARD_USERS_MAX_SIZE 20
void CUsers::AddUser(const CUser &user) void CUsers::AddUser(const CUser &user)
{ {
// add // add
@ -40,7 +41,7 @@ void CUsers::AddUser(const CUser &user)
} }
// notify // notify
g_Refl..OnUsersChanged(); g_Refl.OnUsersChanged();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -48,7 +49,7 @@ void CUsers::AddUser(const CUser &user)
void CUsers::Hearing(const CCallsign &my, const CCallsign &rpt1, const CCallsign &rpt2) void CUsers::Hearing(const CCallsign &my, const CCallsign &rpt1, const CCallsign &rpt2)
{ {
Hearing(my, rpt1, rpt2, g_Refl..GetCallsign()); Hearing(my, rpt1, rpt2, g_Refl.GetCallsign());
} }
void CUsers::Hearing(const CCallsign &my, const CCallsign &rpt1, const CCallsign &rpt2, const CCallsign &xlx) void CUsers::Hearing(const CCallsign &my, const CCallsign &rpt1, const CCallsign &rpt2, const CCallsign &xlx)

31
reflector/WiresXCmdHandler.cpp
Unescape View File

@ -22,11 +22,9 @@
#include "YSFFich.h" #include "YSFFich.h"
#include "YSFPayload.h" #include "YSFPayload.h"
#include "YSFClient.h" #include "YSFClient.h"
#include "YSFNodeDirFile.h"
#include "YSFNodeDirHttp.h"
#include "YSFUtils.h" #include "YSFUtils.h"
#include "Reflector.h"
#include "WiresXCmdHandler.h" #include "WiresXCmdHandler.h"
#include "Global.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
@ -61,8 +59,8 @@ CWiresxCmdHandler::~CWiresxCmdHandler()
bool CWiresxCmdHandler::Init(void) bool CWiresxCmdHandler::Init(void)
{ {
// fill our wiresx info // fill our wiresx info
m_ReflectorWiresxInfo.SetCallsign(g_Refl..GetCallsign()); m_ReflectorWiresxInfo.SetCallsign(g_Refl.GetCallsign());
m_ReflectorWiresxInfo.SetNode(g_Refl..GetCallsign()); m_ReflectorWiresxInfo.SetNode(g_Refl.GetCallsign());
m_ReflectorWiresxInfo.SetName("Reflector"); m_ReflectorWiresxInfo.SetName("Reflector");
// reset stop flag // reset stop flag
@ -141,7 +139,6 @@ void CWiresxCmdHandler::Task(void)
// handle it // handle it
if ( bCmd ) if ( bCmd )
{ {
const char *modules = ACTIVE_MODULES;
// fill our info object // fill our info object
Info = m_ReflectorWiresxInfo; Info = m_ReflectorWiresxInfo;
g_LYtr.FindFrequencies(Cmd.GetCallsign(), &uiNodeTxFreq, &uiNodeRxFreq); g_LYtr.FindFrequencies(Cmd.GetCallsign(), &uiNodeTxFreq, &uiNodeRxFreq);
@ -149,13 +146,13 @@ void CWiresxCmdHandler::Task(void)
// find our client and the module it's currentlink linked to // find our client and the module it's currentlink linked to
cModule = ' '; cModule = ' ';
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf); std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf);
if ( client ) if ( client )
{ {
cModule = client->GetReflectorModule(); cModule = client->GetReflectorModule();
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// and crack the cmd // and crack the cmd
switch ( Cmd.GetCmd() ) switch ( Cmd.GetCmd() )
@ -173,19 +170,19 @@ void CWiresxCmdHandler::Task(void)
break; break;
case WIRESX_CMD_CONN_REQ: case WIRESX_CMD_CONN_REQ:
cModule = 'A' + (char)(Cmd.GetArg() - 1); cModule = 'A' + (char)(Cmd.GetArg() - 1);
if (::strchr(modules, cModule)) if (g_Refl.IsValidModule(cModule))
{ {
std::cout << "Wires-X CONN_REQ command to link on module " << cModule << " from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl; std::cout << "Wires-X CONN_REQ command to link on module " << cModule << " from " << Cmd.GetCallsign() << " at " << Cmd.GetIp() << std::endl;
// acknowledge // acknowledge
ReplyToWiresxConnReqPacket(Cmd.GetIp(), Info, cModule); ReplyToWiresxConnReqPacket(Cmd.GetIp(), Info, cModule);
// change client's module // change client's module
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf); std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf);
if ( client ) if ( client )
{ {
client->SetReflectorModule(cModule); client->SetReflectorModule(cModule);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else else
{ {
@ -198,13 +195,13 @@ void CWiresxCmdHandler::Task(void)
ReplyToWiresxDiscReqPacket(Cmd.GetIp(), Info); ReplyToWiresxDiscReqPacket(Cmd.GetIp(), Info);
// change client's module // change client's module
{ {
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf); std::shared_ptr<CClient>client = clients->FindClient(Cmd.GetCallsign(), Cmd.GetIp(), EProtocol::ysf);
if ( client != nullptr ) if ( client != nullptr )
{ {
client->SetReflectorModule(' '); client->SetReflectorModule(' ');
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
break; break;
case WIRESX_CMD_UNKNOWN: case WIRESX_CMD_UNKNOWN:
@ -337,8 +334,8 @@ bool CWiresxCmdHandler::ReplyToWiresxAllReqPacket(const CIp &Ip, const CWiresxIn
memcpy(data + 12U, WiresxInfo.GetNode(), 10U); memcpy(data + 12U, WiresxInfo.GetNode(), 10U);
// number of entries // number of entries
const char *modules = ACTIVE_MODULES; const std::string modules(g_Conf.GetString(g_Conf.j.modules.modules));
uint NB_OF_MODULES = ::strlen(modules); uint NB_OF_MODULES = modules.size();
uint total = NB_OF_MODULES; uint total = NB_OF_MODULES;
uint n = NB_OF_MODULES - Start; uint n = NB_OF_MODULES - Start;
if (n > 20U) if (n > 20U)
@ -741,8 +738,8 @@ bool CWiresxCmdHandler::DebugTestDecodePacket(const CBuffer &Buffer)
std::cout << "Trailer" << std::endl; std::cout << "Trailer" << std::endl;
std::cout << "length of payload : " << len << std::endl; std::cout << "length of payload : " << len << std::endl;
dump.Set(command, len); dump.Set(command, len);
dump.DebugDump(g_Refl..m_DebugFile); dump.DebugDump(g_Refl.m_DebugFile);
dump.DebugDumpAscii(g_Refl..m_DebugFile); dump.DebugDumpAscii(g_Refl.m_DebugFile);
break; break;
case YSF_FI_COMMUNICATIONS: case YSF_FI_COMMUNICATIONS:
if ( Fich.getDT() == YSF_DT_DATA_FR_MODE ) if ( Fich.getDT() == YSF_DT_DATA_FR_MODE )

2
reflector/WiresXInfo.cpp
Unescape View File

@ -18,10 +18,10 @@
#include <string.h> #include <string.h>
#include "Defines.h"
#include "Callsign.h" #include "Callsign.h"
#include "WiresXInfo.h" #include "WiresXInfo.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor

2
reflector/YSFClient.h
Unescape View File

@ -18,7 +18,9 @@
#pragma once #pragma once
#include "Defines.h"
#include "Client.h" #include "Client.h"
class CYsfClient : public CClient class CYsfClient : public CClient
{ {
public: public:

2
reflector/YSFNode.h
Unescape View File

@ -18,7 +18,7 @@
#pragma once #pragma once
#include <cstdint>
class CYsfNode class CYsfNode
{ {

51
reflector/YSFProtocol.cpp
Unescape View File

@ -21,12 +21,9 @@
#include "CRC.h" #include "CRC.h"
#include "YSFPayload.h" #include "YSFPayload.h"
#include "YSFClient.h" #include "YSFClient.h"
#include "YSFNodeDirFile.h"
#include "YSFNodeDirHttp.h"
#include "YSFUtils.h" #include "YSFUtils.h"
#include "YSFProtocol.h" #include "YSFProtocol.h"
#include "Reflector.h" #include "Global.h"
#include "GateKeeper.h"
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// constructor // constructor
@ -40,6 +37,9 @@ CYsfProtocol::CYsfProtocol()
bool CYsfProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6) bool CYsfProtocol::Initialize(const char *type, const EProtocol ptype, const uint16_t port, const bool has_ipv4, const bool has_ipv6)
{ {
// config data
m_AutolinkModule = g_Conf.GetAutolinkModule(g_Conf.j.ysf.autolinkmod);
// base class // base class
if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6)) if (! CProtocol::Initialize(type, ptype, port, has_ipv4, has_ipv6))
return false; return false;
@ -145,7 +145,7 @@ void CYsfProtocol::Task(void)
Send(Buffer, Ip); Send(Buffer, Ip);
// add client if needed // add client if needed
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::ysf); std::shared_ptr<CClient>client = clients->FindClient(Callsign, Ip, EProtocol::ysf);
// client already connected ? // client already connected ?
if ( client == nullptr ) if ( client == nullptr )
@ -156,9 +156,8 @@ void CYsfProtocol::Task(void)
auto newclient = std::make_shared<CYsfClient>(Callsign, Ip); auto newclient = std::make_shared<CYsfClient>(Callsign, Ip);
// aautolink, if enabled // aautolink, if enabled
#if YSF_AUTOLINK_ENABLE if (m_AutolinkModule)
newclient->SetReflectorModule(YSF_AUTOLINK_MODULE); newclient->SetReflectorModule(m_AutolinkModule);
#endif
// and append // and append
clients->AddClient(newclient); clients->AddClient(newclient);
@ -168,7 +167,7 @@ void CYsfProtocol::Task(void)
client->Alive(); client->Alive();
} }
// and done // and done
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
else if ( IsValidDisconnectPacket(Buffer) ) else if ( IsValidDisconnectPacket(Buffer) )
@ -176,7 +175,7 @@ void CYsfProtocol::Task(void)
std::cout << "YSF disconnect packet from " << Ip << std::endl; std::cout << "YSF disconnect packet from " << Ip << std::endl;
// find client // find client
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::ysf); std::shared_ptr<CClient>client = clients->FindClient(Ip, EProtocol::ysf);
if ( client != nullptr ) if ( client != nullptr )
{ {
@ -186,7 +185,7 @@ void CYsfProtocol::Task(void)
//EncodeDisconnectPacket(&Buffer); //EncodeDisconnectPacket(&Buffer);
//Send(Buffer, Ip); //Send(Buffer, Ip);
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
else if ( IsValidwirexPacket(Buffer, &Fich, &Callsign, &iWiresxCmd, &iWiresxArg) ) else if ( IsValidwirexPacket(Buffer, &Fich, &Callsign, &iWiresxCmd, &iWiresxArg) )
{ {
@ -263,7 +262,7 @@ void CYsfProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
CCallsign rpt2(Header->GetRpt2Callsign()); CCallsign rpt2(Header->GetRpt2Callsign());
// find this client // find this client
std::shared_ptr<CClient>client = g_Refl..GetClients()->FindClient(Ip, EProtocol::ysf); std::shared_ptr<CClient>client = g_Refl.GetClients()->FindClient(Ip, EProtocol::ysf);
if ( client ) if ( client )
{ {
// get client callsign // get client callsign
@ -274,20 +273,20 @@ void CYsfProtocol::OnDvHeaderPacketIn(std::unique_ptr<CDvHeaderPacket> &Header,
rpt2.SetCSModule(m); rpt2.SetCSModule(m);
// and try to open the stream // and try to open the stream
if ( (stream = g_Refl..OpenStream(Header, client)) != nullptr ) if ( (stream = g_Refl.OpenStream(Header, client)) != nullptr )
{ {
// keep the handle // keep the handle
m_Streams[stream->GetStreamId()] = stream; m_Streams[stream->GetStreamId()] = stream;
} }
} }
// release // release
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
// update last heard // update last heard
if ( g_Refl..IsValidModule(rpt2.GetCSModule()) ) if ( g_Refl.IsValidModule(rpt2.GetCSModule()) )
{ {
g_Refl..GetUsers()->Hearing(my, rpt1, rpt2); g_Refl.GetUsers()->Hearing(my, rpt1, rpt2);
g_Refl..ReleaseUsers(); g_Refl.ReleaseUsers();
} }
} }
} }
@ -346,7 +345,7 @@ void CYsfProtocol::HandleQueue(void)
if ( buffer.size() > 0 ) if ( buffer.size() > 0 )
{ {
// and push it to all our clients linked to the module and who are not streaming in // and push it to all our clients linked to the module and who are not streaming in
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::ysf, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::ysf, it)) != nullptr )
@ -359,7 +358,7 @@ void CYsfProtocol::HandleQueue(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
} }
m_Queue.Unlock(); m_Queue.Unlock();
@ -375,7 +374,7 @@ void CYsfProtocol::HandleKeepalives(void)
// and disconnect them if not // and disconnect them if not
// iterate on clients // iterate on clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
auto it = clients->begin(); auto it = clients->begin();
std::shared_ptr<CClient>client = nullptr; std::shared_ptr<CClient>client = nullptr;
while ( (client = clients->FindNextClient(EProtocol::ysf, it)) != nullptr ) while ( (client = clients->FindNextClient(EProtocol::ysf, it)) != nullptr )
@ -395,7 +394,7 @@ void CYsfProtocol::HandleKeepalives(void)
} }
} }
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
} }
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
@ -998,7 +997,7 @@ bool CYsfProtocol::EncodeServerStatusPacket(CBuffer *Buffer) const
const std::string cs = YSF_REFLECTOR_NAME; const std::string cs = YSF_REFLECTOR_NAME;
memcpy(callsign, cs.c_str(), cs.size() > 16 ? 16 : cs.size()); memcpy(callsign, cs.c_str(), cs.size() > 16 ? 16 : cs.size());
#else #else
g_Refl..GetCallsign().GetCallsign(callsign); g_Refl.GetCallsign().GetCallsign(callsign);
#endif #endif
char sz[16]; char sz[16];
::sprintf(sz, "%05u", CalcHash(callsign, 16) % 100000U); ::sprintf(sz, "%05u", CalcHash(callsign, 16) % 100000U);
@ -1010,9 +1009,9 @@ bool CYsfProtocol::EncodeServerStatusPacket(CBuffer *Buffer) const
memcpy(description, desc.c_str(), desc.size() > 14 ? 14 : desc.size()); memcpy(description, desc.c_str(), desc.size() > 14 ? 14 : desc.size());
Buffer->Append(description, 14); Buffer->Append(description, 14);
// connected clients // connected clients
CClients *clients = g_Refl..GetClients(); CClients *clients = g_Refl.GetClients();
int count = MIN(999, clients->GetSize()); int count = MIN(999, clients->GetSize());
g_Refl..ReleaseClients(); g_Refl.ReleaseClients();
::sprintf(sz, "%03u", count); ::sprintf(sz, "%03u", count);
Buffer->Append((uint8_t *)sz, 3); Buffer->Append((uint8_t *)sz, 3);
@ -1090,8 +1089,8 @@ bool CYsfProtocol::DebugTestDecodePacket(const CBuffer &Buffer)
std::cout << "Trailer" << std::endl; std::cout << "Trailer" << std::endl;
std::cout << "length of payload : " << len << std::endl; std::cout << "length of payload : " << len << std::endl;
dump.Set(command, len); dump.Set(command, len);
dump.DebugDump(g_Refl..m_DebugFile); dump.DebugDump(g_Refl.m_DebugFile);
dump.DebugDumpAscii(g_Refl..m_DebugFile); dump.DebugDumpAscii(g_Refl.m_DebugFile);
break; break;
case YSF_FI_COMMUNICATIONS: case YSF_FI_COMMUNICATIONS:
if ( Fich.getDT() == YSF_DT_DATA_FR_MODE ) if ( Fich.getDT() == YSF_DT_DATA_FR_MODE )

4
reflector/YSFProtocol.h
Unescape View File

@ -18,6 +18,7 @@
#pragma once #pragma once
#include "Defines.h"
#include "Timer.h" #include "Timer.h"
#include "Protocol.h" #include "Protocol.h"
#include "DVHeaderPacket.h" #include "DVHeaderPacket.h"
@ -129,4 +130,7 @@ protected:
CWiresxCmdHandler m_WiresxCmdHandler; CWiresxCmdHandler m_WiresxCmdHandler;
unsigned char m_seqNo; unsigned char m_seqNo;
uint32_t m_uiStreamId; uint32_t m_uiStreamId;
// config data
char m_AutolinkModule;
}; };

9
reflector/YSFUtils.cpp
Unescape View File

@ -19,20 +19,11 @@
// You should have received a copy of the GNU General Public License // You should have received a copy of the GNU General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>. // along with this program. If not, see <https://www.gnu.org/licenses/>.
#include <string.h> #include <string.h>
#include "YSFDefines.h" #include "YSFDefines.h"
#include "YSFUtils.h" #include "YSFUtils.h"
#include "Golay24128.h" #include "Golay24128.h"
////////////////////////////////////////////////////////////////////////////////////////
// constants & defines
////////////////////////////////////////////////////////////////////////////////////////
//
void CYsfUtils::DecodeVD2Vchs(uint8_t *data, uint8_t **ambe) void CYsfUtils::DecodeVD2Vchs(uint8_t *data, uint8_t **ambe)
{ {
int frame = 0; int frame = 0;

2
reflector/YSFUtils.h
Unescape View File

@ -21,6 +21,8 @@
#pragma once #pragma once
#include <cstdint>
//////////////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////////////
// class // class

2
reflector/example.ini
Unescape View File

@ -58,7 +58,7 @@ Port = 17000
[MMDVM] [MMDVM]
Port = 62030 Port = 62030
DefaultId = 0 DefaultId = 0 # if the DMR id is zero, this will be used (also used for P25)
[NXDN] [NXDN]
Port = 41400 Port = 41400

Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.