client_exchange.h

Go to the documentation of this file.

// Copyright (C) 2023-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_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 boost::enable_shared_from_this<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;

    Exchange(const asiolink::IOServicePtr io_service,
             const MessagePtr& request,
             unsigned maxretries,
             const Servers& servers,
             Handler handler);

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

    virtual ~Exchange();

    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();

    virtual void shutdown();
 
protected:
    std::string identifier_;

    asiolink::IOServicePtr io_service_;

    bool sync_;

    bool started_;

    bool terminated_;

    int rc_;

    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_;

    MessagePtr request_;

    MessagePtr sent_;

    MessagePtr received_;

    std::vector<uint8_t> buffer_;

    size_t size_;

    unsigned retries_;

    unsigned maxretries_;

    Servers servers_;

    std::list<size_t> postponed_;

    Handler handler_;

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

    void createIdentifier();

    void buildRequest();

    void open();

    virtual void shutdownInternal();

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

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

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

    void setTimer();

    void cancelTimer();

    static void timeoutHandler(ExchangePtr ex);

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