client_server.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_SERVER_H
#define RADIUS_CLIENT_SERVER_H
 
#include <client_attribute.h>
#include <client_message.h>
#include <asiolink/asio_wrapper.h>
#include <asiolink/crypto_tls.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 {

static constexpr uint16_t PW_AUTH_PORT = 1812;

static constexpr uint16_t PW_ACCT_PORT = 1813;

static constexpr uint16_t PW_TLS_PORT = 2083;

enum RadiusProtocol {
    PW_PROTO_UDP,
    PW_PROTO_TCP,
    PW_PROTO_TLS
};

std::string protocolToText(const int proto);

class Server : public data::CfgToElement {
public:
    static asiolink::IOAddress getAddress(const std::string& name);

    static asiolink::IOAddress getSrcAddress(const asiolink::IOAddress& dest);

    Server(const asiolink::IOAddress& peer_addr, const uint16_t peer_port,
           const asiolink::IOAddress& local_addr,
           const asiolink::TlsContextPtr& tls_context,
           const std::string& secret, const unsigned timeout,
           const unsigned deadtime = 0)
        : peer_addr_(peer_addr), peer_port_(peer_port),
          local_addr_(local_addr), tls_context_(tls_context), secret_(secret),
          timeout_(timeout), deadtime_(deadtime),
          deadtime_end_(std::chrono::steady_clock::now()),
          mutex_(new std::mutex) {
 
        // Extra checks.
        setLocalAddress(local_addr);
        setSecret(secret);
        setTimeout(timeout);
    }

    virtual ~Server();

    asiolink::IOAddress getPeerAddress() const {
        return (peer_addr_);
    }

    uint16_t getPeerPort() const {
        return (peer_port_);
    }

    void setPeerPort(const uint16_t peer_port) {
        peer_port_ = peer_port;
    }

    asiolink::IOAddress getLocalAddress() const {
        return (local_addr_);
    }

    asiolink::TlsContextPtr getTlsContext() const {
        return (tls_context_);
    }

    std::string getSecret() const {
        return (secret_);
    }

    void setSecret(const std::string& secret);

    void setLocalAddress(const asiolink::IOAddress& local_addr);

    unsigned getTimeout() const {
        return (timeout_);
    }

    void setTimeout(const unsigned timeout);

    unsigned getDeadtime() const {
        return (deadtime_);
    }

    void setDeadtime(const unsigned deadtime) {
        if (deadtime == 0) {
            deadtime_end_ = std::chrono::steady_clock::now();
        }
        deadtime_ = deadtime;
 
    }

    std::chrono::steady_clock::time_point getDeadtimeEnd() const;

    void setDeadtimeEnd(const std::chrono::steady_clock::time_point& deadtime_end);

    data::ElementPtr toElement() const override;
 
protected:
    const asiolink::IOAddress peer_addr_;

    uint16_t peer_port_;

    asiolink::IOAddress local_addr_;

    asiolink::TlsContextPtr tls_context_;

    std::string secret_;

    unsigned timeout_;

    unsigned deadtime_;

    std::chrono::steady_clock::time_point deadtime_end_;

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

typedef boost::shared_ptr<Server> ServerPtr;

typedef std::vector<ServerPtr> Servers;
 
} // end of namespace isc::radius
} // end of namespace isc
 
#endif