client_exchange.h

Go to the documentation of this file.

// Copyright (C) 2023-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_CLIENT_EXCHANGE_H
#define RADIUS_CLIENT_EXCHANGE_H
 
#include <client_attribute.h>
#include <client_message.h>
#include <client_server.h>
#include <asiolink/asio_wrapper.h>
#include <asiolink/interval_timer.h>
#include <asiolink/io_address.h>
#include <asiolink/io_service.h>
#include <asiolink/udp_socket.h>
#include <cc/cfg_to_element.h>
#include <cc/data.h>
#include <exceptions/exceptions.h>
#include <boost/enable_shared_from_this.hpp>
#include <boost/scoped_ptr.hpp>
#include <boost/shared_ptr.hpp>
#include <chrono>
#include <functional>
#include <list>
#include <mutex>
#include <string>
#include <vector>
 
namespace isc {
namespace radius {

enum ExchangeRC {
    BADRESP_RC = -2,        // Got a bad response.
    ERROR_RC = -1,          // General error.
    OK_RC = 0,              // OK: no error.
    TIMEOUT_RC = 1,         // Timeout occurred.
    REJECT_RC = 2,          // Got an Access-Reject response.
    READBLOCK_RC = 3        // Get AGAIN or EWOULDBLOCK.
};

std::string exchangeRCtoText(const int rc);

class Exchange;

typedef boost::shared_ptr<Exchange> ExchangePtr;

class Exchange {
public:
    static constexpr size_t BUF_LEN = 8192;

    typedef std::function<void(const boost::system::error_code ec,
                               const size_t size)> SocketCallback;

    typedef asiolink::UDPSocket<const SocketCallback> RadiusSocket;

    typedef std::function<void(const ExchangePtr ex)> Handler;

    static ExchangePtr create(const asiolink::IOServicePtr io_service,
                              const MessagePtr& request,
                              unsigned maxretries,
                              const Servers& servers,
                              Handler handler,
                              RadiusProtocol protocol = PW_PROTO_UDP);

    static ExchangePtr create(const MessagePtr& request,
                              unsigned maxretries,
                              const Servers& servers);

    virtual ~Exchange() = default;

    const std::string& getId() const {
        return (identifier_);
    }

    int getRC() const {
        return (rc_);
    }

    MessagePtr getRequest() const {
        return (request_);
    }

    MessagePtr getResponse() const {
        return (received_);
    }

    void logReplyMessages() const;

    virtual void start() = 0;

    virtual void shutdown() = 0;

    void processResponse();
 
protected:
    Exchange(const MessagePtr& request,
             unsigned maxretries,
             const Servers& servers,
             Handler handler);

    Exchange(const MessagePtr& request,
             unsigned maxretries,
             const Servers& servers);

    std::string identifier_;

    bool sync_;

    int rc_;

    MessagePtr request_;

    MessagePtr sent_;

    MessagePtr received_;

    unsigned maxretries_;

    Servers servers_;

    Handler handler_;

    void createIdentifier();

    void buildRequest(const ServerPtr& server,
                      std::chrono::steady_clock::time_point start_time);
};

class UdpExchange;

typedef boost::shared_ptr<UdpExchange> UdpExchangePtr;

class UdpExchange : public Exchange,
                    public boost::enable_shared_from_this<UdpExchange> {
public:
    UdpExchange(const asiolink::IOServicePtr io_service,
                const MessagePtr& request,
                unsigned maxretries,
                const Servers& servers,
                Handler handler);

    UdpExchange(const MessagePtr& request,
                unsigned maxretries,
                const Servers& servers);

    virtual ~UdpExchange();

    virtual void start();

    virtual void shutdown();
 
protected:
    asiolink::IOServicePtr io_service_;

    bool started_;

    bool terminated_;

    std::chrono::steady_clock::time_point start_time_;

    boost::scoped_ptr<RadiusSocket> socket_;

    boost::scoped_ptr<asiolink::UDPEndpoint> ep_;

    asiolink::IntervalTimerPtr timer_;

    ServerPtr server_;

    size_t idx_;

    std::vector<uint8_t> buffer_;

    size_t size_;

    unsigned retries_;

    std::list<size_t> postponed_;

    boost::scoped_ptr<std::mutex> mutex_;

    void buildRequest();

    void open();

    virtual void shutdownInternal();

    static void openNext(UdpExchangePtr ex) {
        ex->open();
    }

    static void sentHandler(UdpExchangePtr ex,
                            const boost::system::error_code ec,
                            const size_t size);

    static void receivedHandler(UdpExchangePtr ex,
                                const boost::system::error_code ec,
                                const size_t size);

    void setTimer();

    void cancelTimer();

    static void timeoutHandler(UdpExchangePtr ex);

    void terminate();
};

class TcpExchange;

typedef boost::shared_ptr<TcpExchange> TcpExchangePtr;

class TcpExchange : public Exchange,
                    public boost::enable_shared_from_this<TcpExchange> {
public:
    TcpExchange(const MessagePtr& request,
                unsigned maxretries,
                const Servers& servers,
                Handler handler);


    virtual ~TcpExchange() = default;

    virtual void start();

    virtual void shutdown();
 
protected:
    std::chrono::steady_clock::time_point start_time_;

    ServerPtr server_;

    isc::tcp::WireDataPtr response_;

    void buildRequest();

    static void RequestHandler(TcpExchangePtr ex,
                               const boost::system::error_code& ec,
                               const isc::tcp::WireDataPtr& response,
                               const std::string& error_msg);

    static int CompleteCheck(const isc::tcp::WireDataPtr& response,
                             std::string& error_msg);
};
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif