rbac_role.h

Go to the documentation of this file.

// Copyright (C) 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 RBAC_ROLE_H
#define RBAC_ROLE_H
 
#include <exceptions/exceptions.h>
#include <http/request.h>
 
namespace isc {
namespace rbac {

class Role;

typedef boost::shared_ptr<Role> RolePtr;

class Role {
public:

    Role(const std::string& name) : name_(name) {
        if (name.empty()) {
            isc_throw(Unexpected, "empty role name");
        }
    }

    virtual ~Role() = default;

    std::string getName() const {
        return (name_);
    }

    virtual std::string assign(const http::HttpRequestPtr& request) = 0;

    virtual void setup(bool load) = 0;

    static bool requireTls(const http::HttpRequestPtr& request) {
        return (request && request->getTls());
    }

    static RolePtr parse(data::ConstElementPtr cfg);
 
protected:
    std::string name_;
};

class RemoteRole : public Role {
public:

    RemoteRole() : Role("remote") {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (request->getRemote());
        } else {
            return ("");
        }
    }

    virtual void setup(bool) final {
    }
};

class SubjectRole : public Role {
public:

    SubjectRole() : Role("subject") {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (request->getSubject());
        } else {
            return ("");
        }
    }

    virtual void setup(bool load) final {
        http::HttpRequest::recordSubject_ = load;
    }
};

class IssuerRole : public Role {
public:

    IssuerRole() : Role("issuer") {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (request->getIssuer());
        } else {
            return ("");
        }
    }

    virtual void setup(bool load) final {
        http::HttpRequest::recordIssuer_ = load;
    }
};

class BasicAuthRole : public Role {
public:

    BasicAuthRole() : Role("basic-auth") {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (request->getBasicAuth());
        } else {
            return ("");
        }
    }

    virtual void setup(bool load) final {
        http::HttpRequest::recordBasicAuth_ = load;
    }
};

class CustomRole : public Role {
public:

    CustomRole() : Role("custom") {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (request->getCustom());
        } else {
            return ("");
        }
    }

    virtual void setup(bool) final {
    }
};

class StaticRole : public Role {
public:

    StaticRole(const std::string& role) : Role("static"), role_(role) {
    }

    virtual std::string assign(const http::HttpRequestPtr& request) final {
        if (request) {
            return (role_);
        } else {
            return ("");
        }
    }

    virtual void setup(bool) final {
    }

    std::string getRole() const {
        return (role_);
    }
 
private:
    std::string role_;
};
 
} // end of namespace rbac
} // end of namespace isc
#endif