if ( BUILD_MOD_RADIUS )
find_package ( Boost REQUIRED )
- add_library ( mod_radius MODULE other/radius/radius.cpp )
+ add_library ( mod_radius MODULE other/radius/radius.cpp
+ other/radius/server.cpp)
target_link_libraries ( mod_radius PRIVATE scriptexecuter logger common )
set_target_properties ( mod_radius PROPERTIES PREFIX "" )
add_dependencies ( mod_radius async-radius )
- target_link_libraries ( mod_radius PRIVATE radproto Boost::boost )
+ find_package ( OpenSSL 1.0.0 REQUIRED )
+ target_link_libraries ( mod_radius PRIVATE radproto Boost::boost OpenSSL::Crypto)
if ( CLANG_TIDY_EXE )
set_target_properties ( mod_radius PROPERTIES CXX_CLANG_TIDY "${DO_CLANG_TIDY}" )
#include "radius.h"
+#include "server.h"
+#include "radproto/error.h"
+
+#include "stg/common.h"
+
+#include <boost/asio.hpp>
+#include <string>
+#include <iostream>
+#include <cstdint> //uint8_t, uint32_t
using STG::RADIUS;
}
RADIUS::RADIUS()
+ : m_logger(PluginLogger::get("radius")),
+ m_running(false)
+{
+}
+
+int RADIUS::Start()
+{
+ m_thread = std::jthread([this](auto token){ Run(std::move(token)); });
+ return 0;
+}
+
+int RADIUS::Stop()
+{
+ if (!m_thread.joinable())
+ return 0;
+
+ m_thread.request_stop();
+
+ m_thread.join();
+ return 0;
+}
+
+void RADIUS::SetRunning(bool val)
+{
+ const std::lock_guard lock(m_mutex);
+ m_running = val;
+}
+
+bool RADIUS::IsRunning()
{
+ const std::lock_guard lock(m_mutex);
+ return m_running;
}
+int RADIUS::Run(std::stop_token token)
+{
+ SetRunning(true);
+
+ try
+ {
+ boost::asio::io_service ioService;
+ Server server(ioService, "secret", 1812, "/usr/share/freeradius/dictionary");
+ ioService.run();
+ }
+ catch (const std::exception& e)
+ {
+ m_errorStr = "Exception in RADIUS::Run(): " + std::string(e.what());
+ m_logger("Exception in RADIUS:: Run(): %s", e.what());
+ printfd(__FILE__, "Exception in RADIUS:: Run(). Message: '%s'\n", e.what());
+ }
+
+ SetRunning(false);
+ return 0;
+}
#pragma once
#include "stg/auth.h"
+#include "stg/logger.h"
+
#include <string>
+#include <mutex>
+#include <jthread.hpp>
namespace STG
{
public:
RADIUS();
- int Start() override { return 0; }
- int Stop() override { return 0; }
+ int Start() override;
+ int Stop() override;
int Reload(const ModuleSettings & /*ms*/) override { return 0; }
- bool IsRunning() override { return isRunning; }
+ bool IsRunning() override;
+ void SetRunning(bool val);
int ParseSettings() override { return 0; }
- const std::string & GetStrError() const override { return errorStr; }
+ const std::string & GetStrError() const override { return m_errorStr; }
std::string GetVersion() const override;
uint16_t GetStartPosition() const override { return 0; }
uint16_t GetStopPosition() const override { return 0; }
int SendMessage(const Message & msg, uint32_t ip) const override { return 0; }
private:
- mutable std::string errorStr;
- bool isRunning;
+ std::mutex m_mutex;
+ mutable std::string m_errorStr;
+ std::jthread m_thread;
+ bool m_running;
+ PluginLogger m_logger;
+ int Run(std::stop_token token);
};
}
--- /dev/null
+#include "server.h"
+#include "radproto/packet_codes.h"
+#include <functional>
+#include <iostream>
+
+using STG::Server;
+using boost::system::error_code;
+
+Server::Server(boost::asio::io_service& io_service, const std::string& secret, uint16_t port, const std::string& filePath)
+ : m_radius(io_service, secret, port),
+ m_dictionaries(filePath)
+{
+ startReceive();
+}
+
+void Server::startReceive()
+{
+ m_radius.asyncReceive([this](const auto& error, const auto& packet, const boost::asio::ip::udp::endpoint& source){ handleReceive(error, packet, source); });
+}
+
+RadProto::Packet Server::makeResponse(const RadProto::Packet& request)
+{
+ std::vector<RadProto::Attribute*> attributes;
+ attributes.push_back(new RadProto::String(m_dictionaries.attributeCode("User-Name"), "test"));
+ attributes.push_back(new RadProto::Integer(m_dictionaries.attributeCode("NAS-Port"), 20));
+ std::array<uint8_t, 4> address {127, 104, 22, 17};
+ attributes.push_back(new RadProto::IpAddress(m_dictionaries.attributeCode("NAS-IP-Address"), address));
+ std::vector<uint8_t> bytes {'1', '2', '3', 'a', 'b', 'c'};
+ attributes.push_back(new RadProto::Bytes(m_dictionaries.attributeCode("Callback-Number"), bytes));
+ std::vector<uint8_t> chapPassword {'1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'g' };
+ attributes.push_back(new RadProto::ChapPassword(m_dictionaries.attributeCode("CHAP-Password"), 1, chapPassword));
+
+ std::vector<RadProto::VendorSpecific> vendorSpecific;
+ std::vector<uint8_t> vendorValue {0, 0, 0, 3};
+ vendorSpecific.push_back(RadProto::VendorSpecific(m_dictionaries.vendorCode("Dlink"), m_dictionaries.vendorAttributeCode("Dlink", "Dlink-User-Level"), vendorValue));
+
+ if (request.type() == RadProto::ACCESS_REQUEST)
+ return RadProto::Packet(RadProto::ACCESS_ACCEPT, request.id(), request.auth(), attributes, vendorSpecific);
+
+ return RadProto::Packet(RadProto::ACCESS_REJECT, request.id(), request.auth(), attributes, vendorSpecific);
+}
+
+void Server::handleSend(const error_code& ec)
+{
+ if (ec)
+ std::cout << "Error asyncSend: " << ec.message() << "\n";
+
+ startReceive();
+}
+
+void Server::handleReceive(const error_code& error, const std::optional<RadProto::Packet>& packet, const boost::asio::ip::udp::endpoint& source)
+{
+ if (error)
+ {
+ std::cout << "Error asyncReceive: " << error.message() << "\n";
+ return;
+ }
+
+ if (packet == std::nullopt)
+ {
+ std::cout << "Error asyncReceive: the request packet is missing\n";
+ return;
+ }
+ else
+ {
+ m_radius.asyncSend(makeResponse(*packet), source, [this](const auto& ec){ handleSend(ec); });
+ }
+}
--- /dev/null
+#pragma once
+
+#include "radproto/socket.h"
+#include "radproto/packet.h"
+#include "radproto/dictionaries.h"
+#include <boost/asio.hpp>
+#include <optional>
+#include <cstdint> //uint8_t, uint32_t
+
+namespace STG
+{
+ class Server
+ {
+ public:
+ Server(boost::asio::io_service& io_service, const std::string& secret, uint16_t port, const std::string& filePath);
+
+ private:
+ RadProto::Packet makeResponse(const RadProto::Packet& request);
+ void handleReceive(const boost::system::error_code& error, const std::optional<RadProto::Packet>& packet, const boost::asio::ip::udp::endpoint& source);
+ void handleSend(const boost::system::error_code& ec);
+ void startReceive();
+
+ RadProto::Socket m_radius;
+ RadProto::Dictionaries m_dictionaries;
+ };
+}
git.stg.codes / stg.git / commitdiff