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

better dht-values def

Browse Source
pull/3/head
Tom Early 3 years ago
parent e5138a6f72
commit 411728e375
4 changed files with 169 additions and 102 deletions
Show Stats Download Patch File Download Diff File

24
reflector/Reflector.cpp
Unescape View File

@ -555,7 +555,7 @@ void CReflector::PutDHTPeers()
ReleasePeers(); ReleasePeers();
auto nv = std::make_shared<dht::Value>(p); auto nv = std::make_shared<dht::Value>(p);
nv->user_type.assign("urfd-peers-1"); nv->user_type.assign(URFD_PEERS_1);
nv->id = toUType(EUrfdValueID::Peers); nv->id = toUType(EUrfdValueID::Peers);
node.putSigned( node.putSigned(
@ -584,7 +584,7 @@ void CReflector::PutDHTClients()
ReleaseClients(); ReleaseClients();
auto nv = std::make_shared<dht::Value>(c); auto nv = std::make_shared<dht::Value>(c);
nv->user_type.assign("urfd-clients-1"); nv->user_type.assign(URFD_CLIENTS_1);
nv->id = toUType(EUrfdValueID::Clients); nv->id = toUType(EUrfdValueID::Clients);
node.putSigned( node.putSigned(
@ -613,7 +613,7 @@ void CReflector::PutDHTUsers()
ReleaseUsers(); ReleaseUsers();
auto nv = std::make_shared<dht::Value>(u); auto nv = std::make_shared<dht::Value>(u);
nv->user_type.assign("urfd-users-1"); nv->user_type.assign(URFD_USERS_1);
nv->id = toUType(EUrfdValueID::Users); nv->id = toUType(EUrfdValueID::Users);
node.putSigned( node.putSigned(
@ -633,11 +633,11 @@ void CReflector::PutDHTConfig()
const std::string cs(g_Configure.GetString(g_Keys.names.callsign)); const std::string cs(g_Configure.GetString(g_Keys.names.callsign));
SUrfdConfig1 cfg; SUrfdConfig1 cfg;
time(&cfg.timestamp); time(&cfg.timestamp);
cfg.cs.assign(cs); cfg.callsign.assign(cs);
cfg.ipv4.assign(g_Configure.GetString(g_Keys.ip.ipv4address)); cfg.ipv4addr.assign(g_Configure.GetString(g_Keys.ip.ipv4address));
cfg.ipv6.assign(g_Configure.GetString(g_Keys.ip.ipv6address)); cfg.ipv6addr.assign(g_Configure.GetString(g_Keys.ip.ipv6address));
cfg.mods.assign(g_Configure.GetString(g_Keys.modules.modules)); cfg.modules.assign(g_Configure.GetString(g_Keys.modules.modules));
cfg.tcmods.assign(g_Configure.GetString(g_Keys.modules.tcmodules)); cfg.transcodedmods.assign(g_Configure.GetString(g_Keys.modules.tcmodules));
cfg.url.assign(g_Configure.GetString(g_Keys.names.url)); cfg.url.assign(g_Configure.GetString(g_Keys.names.url));
cfg.email.assign(g_Configure.GetString(g_Keys.names.email)); cfg.email.assign(g_Configure.GetString(g_Keys.names.email));
cfg.country.assign(g_Configure.GetString(g_Keys.names.country)); cfg.country.assign(g_Configure.GetString(g_Keys.names.country));
@ -663,11 +663,11 @@ void CReflector::PutDHTConfig()
cfg.port[toUType(EUrfdPorts::urf)] = (uint16_t)g_Configure.GetUnsigned(g_Keys.urf.port); cfg.port[toUType(EUrfdPorts::urf)] = (uint16_t)g_Configure.GetUnsigned(g_Keys.urf.port);
cfg.port[toUType(EUrfdPorts::ysf)] = (uint16_t)g_Configure.GetUnsigned(g_Keys.ysf.port); cfg.port[toUType(EUrfdPorts::ysf)] = (uint16_t)g_Configure.GetUnsigned(g_Keys.ysf.port);
cfg.g3enabled = g_Configure.GetBoolean(g_Keys.g3.enable); cfg.g3enabled = g_Configure.GetBoolean(g_Keys.g3.enable);
for (const auto m : cfg.mods) for (const auto m : cfg.modules)
cfg.description[m] = g_Configure.GetString(g_Keys.modules.descriptor[m-'A']); cfg.description[m] = g_Configure.GetString(g_Keys.modules.descriptor[m-'A']);
auto nv = std::make_shared<dht::Value>(cfg); auto nv = std::make_shared<dht::Value>(cfg);
nv->user_type.assign("urfd-config-1"); nv->user_type.assign(URFD_CONFIG_1);
nv->id = toUType(EUrfdValueID::Config); nv->id = toUType(EUrfdValueID::Config);
node.putSigned( node.putSigned(
@ -696,7 +696,7 @@ void CReflector::GetDHTConfig(const std::string &cs)
node.get( node.get(
dht::InfoHash::get(cs), dht::InfoHash::get(cs),
[](const std::shared_ptr<dht::Value> &v) { [](const std::shared_ptr<dht::Value> &v) {
if (0 == v->user_type.compare("urfd-config-1")) if (0 == v->user_type.compare(URFD_CONFIG_1))
{ {
auto rdat = dht::Value::unpack<SUrfdConfig1>(*v); auto rdat = dht::Value::unpack<SUrfdConfig1>(*v);
if (rdat.timestamp > cfg.timestamp) if (rdat.timestamp > cfg.timestamp)
@ -717,7 +717,7 @@ void CReflector::GetDHTConfig(const std::string &cs)
if (cfg.timestamp) if (cfg.timestamp)
{ {
// if the get() call was successful and there is a nonzero timestamp, then do the update // if the get() call was successful and there is a nonzero timestamp, then do the update
g_GateKeeper.GetInterlinkMap()->Update(cfg.cs, cfg.mods, cfg.ipv4, cfg.ipv6, cfg.port[toUType(EUrfdPorts::urf)], cfg.tcmods); g_GateKeeper.GetInterlinkMap()->Update(cfg.callsign, cfg.modules, cfg.ipv4addr, cfg.ipv6addr, cfg.port[toUType(EUrfdPorts::urf)], cfg.transcodedmods);
g_GateKeeper.ReleaseInterlinkMap(); g_GateKeeper.ReleaseInterlinkMap();
} }
else else

2
reflector/Reflector.h
Unescape View File

@ -27,7 +27,7 @@
#include "PacketStream.h" #include "PacketStream.h"
#ifndef NO_DHT #ifndef NO_DHT
#include "urfd-dht-values.h" #include "dht-values.h"
#endif #endif

156
reflector/dht-values.h
Unescape View File

@ -0,0 +1,156 @@
// Copyright © 2022 Thomas A. Early, N7TAE
//
// ----------------------------------------------------------------------------
// This 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 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
// with this software. If not, see <http://www.gnu.org/licenses/>.
// ----------------------------------------------------------------------------
#pragma once
#include <opendht.h>
//#define USE_MREFD_VALUES
#define USE_URFD_VALUES
/* HELPERS */
template<typename E> constexpr auto toUType(E enumerator) noexcept
{
return static_cast<std::underlying_type_t<E>>(enumerator);
} // Item #10 in "Effective Modern C++", by Scott Meyers, O'REILLY
// every value type needs a const user_type and a timestamp
struct SDhtValueBase
{
SDhtValueBase(const std::string &s) : user_type(s) {}
std::string user_type;
std::time_t timestamp;
};
#ifdef USE_MREFD_VALUES
// user_type for mrefd values
#define MREFD_USERS_1 "mrefd-users-1"
#define MREFD_PEERS_1 "mrefd-peers-1"
#define MREFD_CONFIG_1 "mrefd-config-1"
#define MREFD_CLIENTS_1 "mrefd-clients-1"
// dht::Value ids of the different parts of the document
// can be assigned any unsigned value except 0
enum class EMrefdValueID : uint64_t { Config=1, Peers=2, Clients=3, Users=4 };
using MrefdPeerTuple = std::tuple<std::string, std::string, std::time_t>;
enum class EMrefdPeerFields { Callsign, Modules, ConnectTime };
struct SMrefdPeers1 : public SDhtValueBase
{
SMrefdPeers1() : SDhtValueBase(MREFD_PEERS_1) {}
unsigned int sequence;
std::list<MrefdPeerTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
using MrefdClientTuple = std::tuple<std::string, std::string, char, std::time_t, std::time_t>;
enum class EMrefdClientFields { Callsign, Ip, Module, ConnectTime, LastHeardTime };
struct SMrefdClients1 : public SDhtValueBase
{
SMrefdClients1() : SDhtValueBase(MREFD_CLIENTS_1) {}
unsigned int sequence;
std::list<MrefdClientTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
using MrefdUserTuple = std::tuple<std::string, std::string, std::string, std::time_t>;
enum class EMrefdUserFields { Source, Destination, Reflector, LastHeardTime };
struct SMrefdUsers1 : public SDhtValueBase
{
SMrefdUsers1() : SDhtValueBase(MREFD_USERS_1) {}
unsigned int sequence;
std::list<MrefdUserTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
struct SMrefdConfig1 : public SDhtValueBase
{
SMrefdConfig1() : SDhtValueBase(MREFD_CONFIG_1) {}
std::string callsign, ipv4addr, ipv6addr, modules, encryptedmods, url, email, sponsor, country, version;
uint16_t port;
MSGPACK_DEFINE(timestamp, callsign, ipv4addr, ipv6addr, modules, encryptedmods, url, email, sponsor, country, version, port)
};
#endif
#ifdef USE_URFD_VALUES
#define URFD_PEERS_1 "urfd-peers-1"
#define URFD_USERS_1 "urfd-users-1"
#define URFD_CONFIG_1 "urfd-config-1"
#define URFD_CLIENTS_1 "urfd-clients-1"
enum class EUrfdValueID : uint64_t { Config=1, Peers=2, Clients=3, Users=4 };
using UrfdPeerTuple = std::tuple<std::string, std::string, std::time_t>;
enum class EUrfdPeerFields { Callsign, Modules, ConnectTime };
struct SUrfdPeers1 : public SDhtValueBase
{
SUrfdPeers1() : SDhtValueBase(URFD_PEERS_1) {}
unsigned int sequence;
std::list<UrfdPeerTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
using UrfdClientTuple = std::tuple<std::string, std::string, char, std::time_t, std::time_t>;
enum class EUrfdClientFields { Callsign, Ip, Module, ConnectTime, LastHeardTime };
struct SUrfdClients1 : public SDhtValueBase
{
SUrfdClients1() : SDhtValueBase(URFD_CLIENTS_1) {}
unsigned int sequence;
std::list<UrfdClientTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
using UrfdUserTuple = std::tuple<std::string, std::string, char, std::string, std::time_t>;
enum class EUrfdUserFields { Callsign, ViaNode, OnModule, ViaPeer, LastHeardTime };
struct SUrfdUsers1 : public SDhtValueBase
{
SUrfdUsers1() : SDhtValueBase(URFD_USERS_1) {}
unsigned int sequence;
std::list<UrfdUserTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
// 'SIZE' has to be last value for these scoped enums
enum class EUrfdPorts : unsigned { dcs, dextra, dmrplus, dplus, m17, mmdvm, nxdn, p25, urf, ysf, SIZE };
enum class EUrfdAlMod : unsigned { nxdn, p25, ysf, SIZE };
enum class EUrfdTxRx : unsigned { rx, tx, SIZE };
enum class EUrfdRefId : unsigned { nxdn, p25, SIZE };
struct SUrfdConfig1 : public SDhtValueBase
{
SUrfdConfig1() : SDhtValueBase(URFD_CONFIG_1) {}
std::string callsign, ipv4addr, ipv6addr, modules, transcodedmods, url, email, sponsor, country, version;
std::array<uint16_t, toUType(EUrfdPorts::SIZE)> port;
std::array<char, toUType(EUrfdAlMod::SIZE)> almod;
std::array<unsigned long, toUType(EUrfdTxRx::SIZE)> ysffreq;
std::array<unsigned, toUType(EUrfdRefId::SIZE)> refid;
std::unordered_map<char, std::string> description;
bool g3enabled;
MSGPACK_DEFINE(timestamp, callsign, ipv4addr, ipv6addr, modules, transcodedmods, url, email, sponsor, country, version, almod, ysffreq, refid, g3enabled, port, description)
};
#endif

89
reflector/urfd-dht-values.h
Unescape View File

@ -1,89 +0,0 @@
// Copyright © 2023 Thomas A. Early, N7TAE
//
// ----------------------------------------------------------------------------
// This file is part of urfd.
//
// M17Refd 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.
//
// M17Refd 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
// with this software. If not, see <http://www.gnu.org/licenses/>.
// ----------------------------------------------------------------------------
#pragma once
#include <opendht.h>
/* HELPERS */
#ifndef TO_U_TYPE_DEF
#define TO_U_TYPE_DEF
template<typename E> constexpr auto toUType(E enumerator) noexcept
{
return static_cast<std::underlying_type_t<E>>(enumerator);
} // Item #10 in "Effective Modern C++", by Scott Meyers, O'REILLY
#endif
enum class EUrfdValueID : uint64_t { Config=1, Peers=2, Clients=3, Users=4 };
/* PEERS */
using UrfdPeerTuple = std::tuple<std::string, std::string, std::time_t>;
enum class EUrfdPeerFields { Callsign, Modules, ConnectTime };
struct SUrfdPeers1
{
std::time_t timestamp;
unsigned int sequence;
std::list<UrfdPeerTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
/* CLIENTS */
using UrfdClientTuple = std::tuple<std::string, std::string, char, std::time_t, std::time_t>;
enum class EUrfdClientFields { Callsign, Ip, Module, ConnectTime, LastHeardTime };
struct SUrfdClients1
{
std::time_t timestamp;
unsigned int sequence;
std::list<UrfdClientTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
/* USERS */
using UrfdUserTuple = std::tuple<std::string, std::string, char, std::string, std::time_t>;
enum class EUrfdUserFields { Callsign, ViaNode, OnModule, ViaPeer, LastHeardTime };
struct SUrfdUsers1
{
std::time_t timestamp;
unsigned int sequence;
std::list<UrfdUserTuple> list;
MSGPACK_DEFINE(timestamp, sequence, list)
};
/* CONFIGURATION */
// 'SIZE' has to be last for these scoped enums
enum class EUrfdPorts : unsigned { dcs, dextra, dmrplus, dplus, m17, mmdvm, nxdn, p25, urf, ysf, SIZE };
enum class EUrfdAlMod : unsigned { nxdn, p25, ysf, SIZE };
enum class EUrfdTxRx : unsigned { rx, tx, SIZE };
enum class EUrfdRefId : unsigned { nxdn, p25, SIZE };
struct SUrfdConfig1
{
std::time_t timestamp;
std::string cs, ipv4, ipv6, mods, tcmods, url, email, sponsor, country, version;
std::array<uint16_t, toUType(EUrfdPorts::SIZE)> port;
std::array<char, toUType(EUrfdAlMod::SIZE)> almod;
std::array<unsigned long, toUType(EUrfdTxRx::SIZE)> ysffreq;
std::array<unsigned, toUType(EUrfdRefId::SIZE)> refid;
std::unordered_map<char, std::string> description;
bool g3enabled;
MSGPACK_DEFINE(timestamp, cs, ipv4, ipv6, mods, tcmods, url, email, sponsor, country, version, almod, ysffreq, refid, g3enabled, port, description)
};
Write Preview
Loading…
Cancel
Save

Powered by TurnKey Linux.