redfish-core/include/node.hpp

/*
// Copyright (c) 2018 Intel Corporation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
*/
#pragma once

#include "async_resp.hpp"
#include "http_request.hpp"
#include "http_response.hpp"
#include "privileges.hpp"
#include "redfish_v1.hpp"

#include <error_messages.hpp>
#include <rf_async_resp.hpp>

#include <vector>

namespace redfish
{

/**
 * @brief  Abstract class used for implementing Redfish nodes.
 *
 */
class Node
{
  private:
    bool redfishPreChecks(const crow::Request& req,
                          const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
    {
        std::string_view odataHeader = req.getHeaderValue("OData-Version");
        if (odataHeader.empty())
        {
            // Clients aren't required to provide odata version
            return true;
        }
        if (odataHeader != "4.0")
        {
            redfish::messages::preconditionFailed(asyncResp->res);
            return false;
        }

        asyncResp->res.addHeader("OData-Version", "4.0");
        return true;
    }

  public:
    template <typename... Params>
    Node(App& app, std::string&& entityUrl,
         [[maybe_unused]] Params... paramsIn) :
        app(app)
    {
        crow::DynamicRule& get = app.routeDynamic(entityUrl.c_str());
        getRule = &get;
        get.methods(boost::beast::http::verb::get)(
            [this](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   Params... params) {
                if (!redfishPreChecks(req, asyncResp))
                {
                    return;
                }
                std::vector<std::string> paramVec = {params...};
                doGet(asyncResp, req, paramVec);
            });

        crow::DynamicRule& patch = app.routeDynamic(entityUrl.c_str());
        patchRule = &patch;
        patch.methods(boost::beast::http::verb::patch)(
            [this](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   Params... params) {
                if (!redfishPreChecks(req, asyncResp))
                {
                    return;
                }
                std::vector<std::string> paramVec = {params...};
                doPatch(asyncResp, req, paramVec);
            });

        crow::DynamicRule& post = app.routeDynamic(entityUrl.c_str());
        postRule = &post;
        post.methods(boost::beast::http::verb::post)(
            [this](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   Params... params) {
                if (!redfishPreChecks(req, asyncResp))
                {
                    return;
                }
                std::vector<std::string> paramVec = {params...};
                doPost(asyncResp, req, paramVec);
            });

        crow::DynamicRule& put = app.routeDynamic(entityUrl.c_str());
        putRule = &put;
        put.methods(boost::beast::http::verb::put)(
            [this](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   Params... params) {
                if (!redfishPreChecks(req, asyncResp))
                {
                    return;
                }
                std::vector<std::string> paramVec = {params...};
                doPut(asyncResp, req, paramVec);
            });

        crow::DynamicRule& deleteR = app.routeDynamic(entityUrl.c_str());
        deleteRule = &deleteR;
        deleteR.methods(boost::beast::http::verb::delete_)(
            [this](const crow::Request& req,
                   const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                   Params... params) {
                if (!redfishPreChecks(req, asyncResp))
                {
                    return;
                }
                std::vector<std::string> paramVec = {params...};
                doDelete(asyncResp, req, paramVec);
            });
    }

    void initPrivileges()
    {
        auto it = entityPrivileges.find(boost::beast::http::verb::get);
        if (it != entityPrivileges.end())
        {
            if (getRule != nullptr)
            {
                getRule->privileges(it->second);
            }
        }
        it = entityPrivileges.find(boost::beast::http::verb::post);
        if (it != entityPrivileges.end())
        {
            if (postRule != nullptr)
            {
                postRule->privileges(it->second);
            }
        }
        it = entityPrivileges.find(boost::beast::http::verb::patch);
        if (it != entityPrivileges.end())
        {
            if (patchRule != nullptr)
            {
                patchRule->privileges(it->second);
            }
        }
        it = entityPrivileges.find(boost::beast::http::verb::put);
        if (it != entityPrivileges.end())
        {
            if (putRule != nullptr)
            {
                putRule->privileges(it->second);
            }
        }
        it = entityPrivileges.find(boost::beast::http::verb::delete_);
        if (it != entityPrivileges.end())
        {
            if (deleteRule != nullptr)
            {
                deleteRule->privileges(it->second);
            }
        }
    }

    virtual ~Node() = default;

    OperationMap entityPrivileges;

    crow::DynamicRule* getRule = nullptr;
    crow::DynamicRule* postRule = nullptr;
    crow::DynamicRule* patchRule = nullptr;
    crow::DynamicRule* putRule = nullptr;
    crow::DynamicRule* deleteRule = nullptr;

  protected:
    App& app;
    // Node is designed to be an abstract class, so doGet is pure virtual
    virtual void doGet(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const crow::Request&, const std::vector<std::string>&)
    {
        asyncResp->res.result(boost::beast::http::status::method_not_allowed);
    }

    virtual void doPatch(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                         const crow::Request&, const std::vector<std::string>&)
    {
        asyncResp->res.result(boost::beast::http::status::method_not_allowed);
    }

    virtual void doPost(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                        const crow::Request&, const std::vector<std::string>&)
    {
        asyncResp->res.result(boost::beast::http::status::method_not_allowed);
    }

    virtual void doPut(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                       const crow::Request&, const std::vector<std::string>&)
    {
        asyncResp->res.result(boost::beast::http::status::method_not_allowed);
    }

    virtual void doDelete(const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
                          const crow::Request&, const std::vector<std::string>&)
    {
        asyncResp->res.result(boost::beast::http::status::method_not_allowed);
    }

    /* @brief Would the operation be allowed if the user did not have the
     * ConfigureSelf Privilege?  Also honors session.isConfigureSelfOnly.
     *
     * @param req      the request
     *
     * @returns        True if allowed, false otherwise
     */
    inline bool isAllowedWithoutConfigureSelf(const crow::Request& req)
    {
        const std::string& userRole = req.userRole;
        BMCWEB_LOG_DEBUG << "isAllowedWithoutConfigureSelf for the role "
                         << req.userRole;
        Privileges effectiveUserPrivileges;
        if (req.session && req.session->isConfigureSelfOnly)
        {
            // The session has no privileges because it is limited to
            // configureSelfOnly and we are disregarding that privilege.
            // Note that some operations do not require any privilege.
        }
        else
        {
            effectiveUserPrivileges = redfish::getUserPrivileges(userRole);
            effectiveUserPrivileges.resetSinglePrivilege("ConfigureSelf");
        }
        const auto& requiredPrivilegesIt = entityPrivileges.find(req.method());
        return (requiredPrivilegesIt != entityPrivileges.end()) &&
               isOperationAllowedWithPrivileges(requiredPrivilegesIt->second,
                                                effectiveUserPrivileges);
    }
};

} // namespace redfish