radius_accounting.h

Go to the documentation of this file.

// Copyright (C) 2020-2025 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_ACCOUNTING_H
#define RADIUS_ACCOUNTING_H
 
#include <util/csv_file.h>
#include <dhcpsrv/lease.h>
#include <radius_service.h>
#include <radius_request.h>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/member.hpp>
#include <boost/multi_index/ordered_index.hpp>
#include <boost/date_time/gregorian/gregorian_types.hpp>
#include <boost/date_time/posix_time/posix_time_types.hpp>
#include <mutex>
 
namespace isc {
namespace radius {

typedef enum {
    EVENT_CREATE,  //< A new lease was created (leaseX_select hooks).
    EVENT_RENEW,   //< A lease was renewed (leaseX_renew hooks).
    EVENT_REBIND,  //< A lease was rebound (lease6_rebind hook).
    EVENT_EXPIRE,  //< A lease was expired (leaseX_expire hooks).
    EVENT_RELEASE, //< A lease was released (leaseX_release hooks).
    EVENT_DECLINE, //< A lease was declined (leaseX_decline hooks).
    EVENT_ADD,     //< A command added a lease (command_processed hook).
    EVENT_UPDATE,  //< A command updated a lease (command_processed hook).
    EVENT_DEL      //< A command deleted a lease (command_processed hook).
} Event;

std::string eventToText(Event event);

class LeaseTS {
public:

    LeaseTS(const asiolink::IOAddress& addr,
            const boost::posix_time::ptime& timestamp)
        : addr_(addr), timestamp_(timestamp) {
    }

    const asiolink::IOAddress addr_;

    const boost::posix_time::ptime timestamp_;
};

struct TMAddressIndexTag { };

struct TMTimestampIndexTag { };

typedef boost::multi_index_container<

    LeaseTS,
 
    // Start specification of indexes here.
    boost::multi_index::indexed_by<
 
        // First index is used to search by an address.
        boost::multi_index::ordered_unique<
            boost::multi_index::tag<TMAddressIndexTag>,
            boost::multi_index::member<LeaseTS,
                                       const asiolink::IOAddress,
                                       &LeaseTS::addr_>
        >,
 
        // Second index is used to search by timestamp.
        boost::multi_index::ordered_non_unique<
            boost::multi_index::tag<TMTimestampIndexTag>,
            boost::multi_index::member<LeaseTS,
                                       const boost::posix_time::ptime,
                                       &LeaseTS::timestamp_>
        >
    >
> TMContainer;

typedef TMContainer::index<TMAddressIndexTag>::type TMContainerAddressIndex;

typedef TMContainer::index<TMTimestampIndexTag>::type TMContainerTimestampIndex;

class RadiusAcctEnv {
public:

    RadiusAcctEnv(std::string session_id, Event event, uint32_t subnet_id,
                  AttributesPtr send_attrs);

    std::string session_id_;

    Event event_;

    uint32_t subnet_id_;

    AttributesPtr send_attrs_;

    bool finished_;
};

class RadiusAcctHandler {
public:

    RadiusAcctHandler(RadiusAcctEnv env, const CallbackAcct& callback);

    virtual ~RadiusAcctHandler();

    void start();

    static size_t getCounter();

    RadiusAcctEnv env_;
 
protected:

    RadiusAsyncAcctPtr acct_;
 
private:

    static size_t counter_;

    static std::mutex mutex_;
};

typedef boost::shared_ptr<RadiusAcctHandler> RadiusAcctHandlerPtr;

typedef boost::shared_ptr<util::CSVFile> CSVFilePtr;

class RadiusAccounting : public RadiusService {
public:

    RadiusAccounting();

    virtual ~RadiusAccounting() = default;

    void init(const std::string& filename);

    RadiusAcctHandlerPtr buildAcct(const dhcp::Lease4Ptr& lease, Event event);

    RadiusAcctHandlerPtr buildAcct(const dhcp::Lease6Ptr& lease, Event event);

    RadiusAcctHandlerPtr buildAcct4(const data::ConstElementPtr& arguments,
                                    Event event);

    RadiusAcctHandlerPtr buildAcct6(const data::ConstElementPtr& arguments,
                                    Event event);

    static void runAsync(RadiusAcctHandlerPtr handler);

    static void terminate(RadiusAcctEnv env, int result);

    boost::posix_time::ptime
    getCreateTimestamp(const asiolink::IOAddress& addr, bool generate);

    void eraseCreateTimestamp(const asiolink::IOAddress& addr);

    bool loadFromFile();

    void storeToFile();
 
protected:

    std::string filename_;

    TMContainer container_;

    const boost::posix_time::ptime epoch_;

    CSVFilePtr file_;

    size_t record_count_;

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