radius_access.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_ACCESS_H
#define RADIUS_ACCESS_H
 
#include <dhcp/pkt4.h>
#include <dhcp/pkt6.h>
#include <hooks/hooks.h>
#include <radius/radius_request.h>
#include <radius/radius_service.h>
 
#include <map>
#include <mutex>
 
namespace isc {
namespace radius {

template <class PktPtrType>
class RadiusAuthPendingRequest {
public:

    RadiusAuthPendingRequest(PktPtrType query) : query_(query) { }

    PktPtrType query_;
};

template <class PktPtrType>
using RadiusAuthPendingRequestPtr =
    boost::shared_ptr<RadiusAuthPendingRequest<PktPtrType>>;

template <class PktPtrType>
class RadiusAuthPendingRequests {
public:

    size_t size() const {
        return (map_.size());
    }

    void clear() {
        map_.clear();
    }

    RadiusAuthPendingRequestPtr<PktPtrType>
        get(const std::vector<uint8_t>& id) const {
        auto const& it = map_.find(id);
        if (it != map_.end()) {
            return (it->second);
        } else {
            return (RadiusAuthPendingRequestPtr<PktPtrType>());
        }
    }

    void set(const std::vector<uint8_t>& id, PktPtrType query) {
        map_[id] = RadiusAuthPendingRequestPtr<PktPtrType>(
                        new RadiusAuthPendingRequest<PktPtrType>(query));
    }

    void remove(const std::vector<uint8_t>& id) {
        static_cast<void>(map_.erase(id));
    }
 
private:
    std::map<std::vector<uint8_t>, RadiusAuthPendingRequestPtr<PktPtrType>> map_;
 
public:
    std::mutex mutex_;
};

class RadiusAuthEnv {
public:

    RadiusAuthEnv(uint32_t subnet_id,
                  const std::vector<uint8_t>& id,
                  AttributesPtr send_attrs);

    uint32_t subnet_id_;

    const std::vector<uint8_t> id_;

    AttributesPtr send_attrs_;
};

class RadiusAuthHandler {
public:

    RadiusAuthHandler(RadiusAuthEnv env, const CallbackAuth& callback);

    virtual ~RadiusAuthHandler() = default;

    void start();

    RadiusAuthEnv env_;
 
protected:

    RadiusAsyncAuthPtr auth_;
};

typedef boost::shared_ptr<RadiusAuthHandler> RadiusAuthHandlerPtr;

class RadiusAccess : public RadiusService {
public:

    RadiusAccess();

    virtual ~RadiusAccess() = default;

    bool getIdentifier(dhcp::Pkt4& query, std::vector<uint8_t>& id,
                       std::string& text);

    bool getIdentifier(dhcp::Pkt6& query, std::vector<uint8_t>& id,
                       std::string& text);

    RadiusAuthHandlerPtr buildAuth(dhcp::Pkt4& query, uint32_t subnet_id,
                                   const std::vector<uint8_t>& id,
                                   const std::string& text);

    RadiusAuthHandlerPtr buildAuth(dhcp::Pkt6& query, uint32_t subnet_id,
                                   const std::vector<uint8_t>& id,
                                   const std::string& text);

    static bool reselectSubnet(const dhcp::Pkt4Ptr& query, uint32_t& subnet_id,
                               bool& both_global, const std::string& cclass);

    static bool reselectSubnet(const dhcp::Pkt6Ptr& query, uint32_t& subnet_id,
                               bool& both_global, const std::string& cclass);

    static bool reselectSubnet(const isc::dhcp::Pkt4Ptr& query,
                               uint32_t& subnet_id,
                               bool& both_global,
                               const asiolink::IOAddress& address);

    static bool reselectSubnet(const isc::dhcp::Pkt6Ptr& query,
                               uint32_t& subnet_id,
                               bool& both_global,
                               const asiolink::IOAddress& address);

    static void terminate4(RadiusAuthEnv env, int result,
                           AttributesPtr recv_attrs);

    static void terminate6(RadiusAuthEnv env, int result,
                           AttributesPtr recv_attrs);

    static void terminate4Internal(RadiusAuthEnv& env, int result,
                                   AttributesPtr recv_attrs,
                                   dhcp::Pkt4Ptr& query, bool& drop);

    static void terminate6Internal(RadiusAuthEnv& env, int result,
                                   AttributesPtr recv_attrs,
                                   dhcp::Pkt6Ptr& query, bool& drop);

    RadiusAuthPendingRequests<dhcp::Pkt4Ptr> requests4_;

    RadiusAuthPendingRequests<dhcp::Pkt6Ptr> requests6_;

    void setIdleTimer();

    static void IdleTimerCallback();
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif