radius_request.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_REQUEST_H
#define RADIUS_REQUEST_H
 
#include <client_exchange.h>
#include <radius.h>
#include <dhcp/iface_mgr.h>
#include <dhcpsrv/subnet_id.h>
#include <dhcpsrv/timer_mgr.h>
 
#include <functional>
#include <sstream>
 
namespace isc {
namespace radius {

typedef std::function<void(int, AttributesPtr)> CallbackAuth;

typedef std::function<void(int)> CallbackAcct;

uint32_t getNASPort(uint32_t subnet_id);

class RadiusRequest {
public:

    RadiusRequest(const MsgCode code,
                  uint32_t subnet_id,
                  const AttributesPtr& send_attrs,
                  bool sync,
                  const Exchange::Handler& handler);

    virtual ~RadiusRequest() = default;

    virtual void start() {
        exchange_->start();
    }

    int getRC() const {
        return (exchange_->getRC());
    }

    AttributesPtr getReqAttrs() const {
        MessagePtr request = exchange_->getRequest();
        if (request) {
            return (request->getAttributes());
        }
        return (AttributesPtr());
    }

    AttributesPtr getRespAttrs() const {
        MessagePtr response = exchange_->getResponse();
        if (response) {
            return (response->getAttributes());
        }
        return (AttributesPtr());
    }

    ExchangePtr getExchange() {
        return (exchange_);
    }
 
protected:
    uint32_t nas_port_;

    ExchangePtr exchange_;
};

class RadiusAuth : public RadiusRequest {
public:

    RadiusAuth(uint32_t subnet_id,
               const AttributesPtr& send_attrs,
               bool sync,
               const Exchange::Handler& handler)
        : RadiusRequest(PW_ACCESS_REQUEST, subnet_id, send_attrs, sync,
                        handler) {
    }

    virtual ~RadiusAuth() = default;
};

class RadiusSyncAuth : public RadiusAuth {
public:

    RadiusSyncAuth(uint32_t subnet_id,
                   const AttributesPtr& send_attrs,
                   const CallbackAuth& callback)
        : RadiusAuth(subnet_id, send_attrs, true, Exchange::Handler()),
          callback_(callback) {
    }

    virtual ~RadiusSyncAuth() = default;

    virtual void start() override;
 
protected:
    CallbackAuth callback_;
};

typedef boost::shared_ptr<RadiusSyncAuth> RadiusSyncAuthPtr;

class RadiusAsyncAuth : public RadiusAuth {
public:

    RadiusAsyncAuth(uint32_t subnet_id,
                    const AttributesPtr& send_attrs,
                    const CallbackAuth& callback);

    virtual ~RadiusAsyncAuth() = default;

    virtual void start() override;

    static void invokeCallback(const CallbackAuth& callback,
                               const ExchangePtr exchange);
};

typedef boost::shared_ptr<RadiusAsyncAuth> RadiusAsyncAuthPtr;

class RadiusAcct : public RadiusRequest {
public:

    RadiusAcct(uint32_t subnet_id,
               const AttributesPtr& send_attrs,
               bool sync,
               const Exchange::Handler& handler)
        : RadiusRequest(PW_ACCOUNTING_REQUEST, subnet_id, send_attrs, sync,
                        handler) {
    }

    virtual ~RadiusAcct() = default;
};

class RadiusSyncAcct : public RadiusAcct {
public:

    RadiusSyncAcct(uint32_t subnet_id,
                   const AttributesPtr& send_attrs,
                   const CallbackAcct& callback)
        : RadiusAcct(subnet_id, send_attrs, true, Exchange::Handler()), callback_(callback) {
    }

    virtual ~RadiusSyncAcct() = default;

    virtual void start() override;
 
protected:
    CallbackAcct callback_;
};

typedef boost::shared_ptr<RadiusSyncAcct> RadiusSyncAcctPtr;

class RadiusAsyncAcct : public RadiusAcct {
public:

    RadiusAsyncAcct(uint32_t subnet_id,
                    const AttributesPtr& send_attrs,
                    const CallbackAcct& callback);

    virtual ~RadiusAsyncAcct() = default;

    virtual void start() override;

    static void invokeCallback(const CallbackAcct& callback,
                               const ExchangePtr exchange);
};

typedef boost::shared_ptr<RadiusAsyncAcct> RadiusAsyncAcctPtr;
 
} // end of namespace radius
} // end of namespace isc
#endif // RADIUS_REQUEST_H