radius.h

Go to the documentation of this file.

// Copyright (C) 2020-2026 Internet Systems Consortium, Inc. ("ISC")
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.
 
#ifndef RADIUS_H
#define RADIUS_H
 
#include <cfg_attribute.h>
#include <client_exchange.h>
#include <radius_backend.h>
#include <exceptions/exceptions.h>
#include <cc/data.h>
#include <asiolink/asio_wrapper.h>
#include <asiolink/io_service.h>
#include <asiolink/io_service_thread_pool.h>
#include <dhcpsrv/cache_host_data_source.h>
#include <dhcpsrv/host.h>
#include <tcp/tcp_client.h>
 
#include <boost/noncopyable.hpp>
#include <boost/shared_ptr.hpp>
 
#include <atomic>
#include <list>
#include <map>
#include <mutex>
#include <thread>
#include <unordered_set>
#include <vector>
 
namespace isc {
namespace radius {

class UdpClient {
public:
    UdpClient(const asiolink::IOServicePtr& io_service,
              unsigned thread_pool_size = 0);

    ~UdpClient();

    void start();

    void stop();

    void checkPermissions();

    void pause();

    void resume();

    const asiolink::IOServicePtr getThreadIOService() const;

    unsigned getThreadPoolSize() const;

    void registerExchange(ExchangePtr exchange);

    void unregisterExchange(ExchangePtr exchange);
 
private:
    isc::asiolink::IOServicePtr io_service_;

    unsigned thread_pool_size_;

    isc::asiolink::IOServicePtr thread_io_service_;

    asiolink::IoServiceThreadPoolPtr thread_pool_;

    std::list<ExchangePtr> exchange_list_;

    std::mutex mutex_;
};

typedef boost::shared_ptr<UdpClient> UdpClientPtr;

static const uint32_t SUBNET_ID_DEFAULT = 0;

class RadiusTls;

class RadiusAccess;

class RadiusAccounting;

class RadiusImpl;
typedef boost::shared_ptr<RadiusImpl> RadiusImplPtr;

class RadiusImpl : public data::CfgToElement, public boost::noncopyable {
public:

    static RadiusImpl& instance();

    ~RadiusImpl();

    void reset();

    void init(data::ElementPtr& config);

    void checkEarlyGlobalResvLookup();

    void checkSharedNetworks();

    bool checkHostBackends();

    void startServices();

    bool serveAccess() const;

    bool serveAccounting() const;

    const Servers& getAccessServers() const;

    const Servers& getAccountingServers() const;

    void setAccessIdleTimer();

    void setAccountingIdleTimer();

    isc::asiolink::IOServicePtr getIOContext() {
        return (io_context_);
    }

    void setIOContext(isc::asiolink::IOServicePtr io_service) {
        io_context_ = io_service;
    }

    isc::asiolink::IOServicePtr getIOService() {
        return (io_service_);
    }

    void setIOService(isc::asiolink::IOServicePtr io_service) {
        io_service_ = io_service;
    }

    data::ElementPtr toElement() const override;

    void registerExchange(ExchangePtr exchange);

    void unregisterExchange(ExchangePtr exchange);

    std::string dictionary_;

    RadiusProtocol proto_;

    UdpClientPtr udp_client_;

    isc::tcp::TcpClientPtr tcp_client_;

    std::map<uint32_t, uint32_t> remap_;

    boost::shared_ptr<RadiusTls> tls_;

    boost::shared_ptr<RadiusAccess> auth_;

    boost::shared_ptr<RadiusAccounting> acct_;

    dhcp::CacheHostDataSourcePtr cache_;

    RadiusBackendPtr backend_;

    std::string bindaddr_;

    bool canonical_mac_address_;

    bool clientid_pop0_;

    bool clientid_printable_;

    unsigned deadtime_;

    bool extract_duid_;

    bool reselect_subnet_pool_;

    bool reselect_subnet_address_;

    unsigned retries_;

    std::string session_history_filename_;

    unsigned thread_pool_size_;

    unsigned timeout_;

    dhcp::Host::IdentifierType id_type4_;

    dhcp::Host::IdentifierType id_type6_;

    bool use_message_authenticator_;

    static std::atomic<bool> shutdown_;
 
protected:
    RadiusImpl();

    static const RadiusImplPtr& instancePtr();

    void cleanup();
 
private:

    isc::asiolink::IOServicePtr io_context_;

    isc::asiolink::IOServicePtr io_service_;
};

class InHook {
public:
    InHook();

    ~InHook();

    static bool check();
 
private:
    static std::unordered_set<std::thread::id> set_;

    static std::mutex mutex_;
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif