Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 1 | /* |
| 2 | // Copyright (c) 2018 Intel Corporation |
| 3 | // |
| 4 | // Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | // you may not use this file except in compliance with the License. |
| 6 | // You may obtain a copy of the License at |
| 7 | // |
| 8 | // http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | // |
| 10 | // Unless required by applicable law or agreed to in writing, software |
| 11 | // distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | // See the License for the specific language governing permissions and |
| 14 | // limitations under the License. |
| 15 | */ |
| 16 | #pragma once |
Borawski.Lukasz | 43a095a | 2018-02-19 15:39:01 +0100 | [diff] [blame] | 17 | |
Kowalski, Kamil | f4c4dcf | 2018-01-29 14:55:35 +0100 | [diff] [blame] | 18 | #include "error_messages.hpp" |
Ed Tanous | 52cc112 | 2020-07-18 13:51:21 -0700 | [diff] [blame] | 19 | #include "persistent_data.hpp" |
Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 20 | |
John Edward Broadbent | 7e860f1 | 2021-04-08 15:57:16 -0700 | [diff] [blame] | 21 | #include <app.hpp> |
Ed Tanous | ace85d6 | 2021-10-26 12:45:59 -0700 | [diff] [blame] | 22 | #include <http/utility.hpp> |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 23 | #include <query.hpp> |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 24 | #include <registries/privilege_registry.hpp> |
John Edward Broadbent | 7e860f1 | 2021-04-08 15:57:16 -0700 | [diff] [blame] | 25 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 26 | namespace redfish |
| 27 | { |
Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 28 | |
Ed Tanous | 4f48d5f | 2021-06-21 08:27:45 -0700 | [diff] [blame] | 29 | inline void fillSessionObject(crow::Response& res, |
| 30 | const persistent_data::UserSession& session) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 31 | { |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 32 | res.jsonValue["Id"] = session.uniqueId; |
| 33 | res.jsonValue["UserName"] = session.username; |
| 34 | res.jsonValue["@odata.id"] = |
| 35 | "/redfish/v1/SessionService/Sessions/" + session.uniqueId; |
| 36 | res.jsonValue["@odata.type"] = "#Session.v1_3_0.Session"; |
| 37 | res.jsonValue["Name"] = "User Session"; |
| 38 | res.jsonValue["Description"] = "Manager User Session"; |
| 39 | res.jsonValue["ClientOriginIPAddress"] = session.clientIp; |
Sunitha Harish | c0ea7ae | 2020-10-30 02:37:30 -0500 | [diff] [blame] | 40 | #ifdef BMCWEB_ENABLE_IBM_MANAGEMENT_CONSOLE |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 41 | res.jsonValue["Oem"]["OpenBMC"]["@odata.type"] = |
| 42 | "#OemSession.v1_0_0.Session"; |
| 43 | res.jsonValue["Oem"]["OpenBMC"]["ClientID"] = session.clientId; |
Sunitha Harish | 08bdcc7 | 2020-05-12 05:17:57 -0500 | [diff] [blame] | 44 | #endif |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 45 | } |
Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 46 | |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 47 | inline void |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 48 | handleSessionGet(crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 49 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| 50 | const std::string& sessionId) |
| 51 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 52 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 53 | { |
| 54 | return; |
| 55 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 56 | // Note that control also reaches here via doPost and doDelete. |
| 57 | auto session = |
| 58 | persistent_data::SessionStore::getInstance().getSessionByUid(sessionId); |
| 59 | |
| 60 | if (session == nullptr) |
| 61 | { |
| 62 | messages::resourceNotFound(asyncResp->res, "Session", sessionId); |
| 63 | return; |
| 64 | } |
| 65 | |
| 66 | fillSessionObject(asyncResp->res, *session); |
| 67 | } |
| 68 | |
| 69 | inline void |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 70 | handleSessionDelete(crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 71 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp, |
| 72 | const std::string& sessionId) |
| 73 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 74 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 75 | { |
| 76 | return; |
| 77 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 78 | auto session = |
| 79 | persistent_data::SessionStore::getInstance().getSessionByUid(sessionId); |
| 80 | |
| 81 | if (session == nullptr) |
| 82 | { |
| 83 | messages::resourceNotFound(asyncResp->res, "Session", sessionId); |
| 84 | return; |
| 85 | } |
| 86 | |
| 87 | // Perform a proper ConfigureSelf authority check. If a |
| 88 | // session is being used to DELETE some other user's session, |
| 89 | // then the ConfigureSelf privilege does not apply. In that |
| 90 | // case, perform the authority check again without the user's |
| 91 | // ConfigureSelf privilege. |
wukaihua-fii-na | 0fd2986 | 2022-05-18 09:19:16 +0800 | [diff] [blame] | 92 | if (req.session != nullptr && !session->username.empty() && |
| 93 | session->username != req.session->username) |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 94 | { |
| 95 | Privileges effectiveUserPrivileges = |
| 96 | redfish::getUserPrivileges(req.userRole); |
| 97 | |
| 98 | if (!effectiveUserPrivileges.isSupersetOf({"ConfigureUsers"})) |
| 99 | { |
| 100 | messages::insufficientPrivilege(asyncResp->res); |
| 101 | return; |
| 102 | } |
| 103 | } |
| 104 | |
| 105 | persistent_data::SessionStore::getInstance().removeSession(session); |
| 106 | messages::success(asyncResp->res); |
| 107 | } |
| 108 | |
| 109 | inline nlohmann::json getSessionCollectionMembers() |
| 110 | { |
| 111 | std::vector<const std::string*> sessionIds = |
| 112 | persistent_data::SessionStore::getInstance().getUniqueIds( |
| 113 | false, persistent_data::PersistenceType::TIMEOUT); |
| 114 | nlohmann::json ret = nlohmann::json::array(); |
| 115 | for (const std::string* uid : sessionIds) |
| 116 | { |
Ed Tanous | 1476687 | 2022-03-15 10:44:42 -0700 | [diff] [blame] | 117 | nlohmann::json::object_t session; |
| 118 | session["@odata.id"] = "/redfish/v1/SessionService/Sessions/" + *uid; |
| 119 | ret.push_back(std::move(session)); |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 120 | } |
| 121 | return ret; |
| 122 | } |
| 123 | |
| 124 | inline void handleSessionCollectionGet( |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 125 | crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 126 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| 127 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 128 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 129 | { |
| 130 | return; |
| 131 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 132 | asyncResp->res.jsonValue["Members"] = getSessionCollectionMembers(); |
| 133 | asyncResp->res.jsonValue["Members@odata.count"] = |
| 134 | asyncResp->res.jsonValue["Members"].size(); |
| 135 | asyncResp->res.jsonValue["@odata.type"] = |
| 136 | "#SessionCollection.SessionCollection"; |
| 137 | asyncResp->res.jsonValue["@odata.id"] = |
| 138 | "/redfish/v1/SessionService/Sessions/"; |
| 139 | asyncResp->res.jsonValue["Name"] = "Session Collection"; |
| 140 | asyncResp->res.jsonValue["Description"] = "Session Collection"; |
| 141 | } |
| 142 | |
| 143 | inline void handleSessionCollectionMembersGet( |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 144 | crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 145 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| 146 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 147 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 148 | { |
| 149 | return; |
| 150 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 151 | asyncResp->res.jsonValue = getSessionCollectionMembers(); |
| 152 | } |
| 153 | |
Ed Tanous | 4ee8e21 | 2022-05-28 09:42:51 -0700 | [diff] [blame] | 154 | inline void handleSessionCollectionPost( |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 155 | crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 156 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| 157 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 158 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 159 | { |
| 160 | return; |
| 161 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 162 | std::string username; |
| 163 | std::string password; |
| 164 | std::optional<nlohmann::json> oemObject; |
| 165 | std::string clientId; |
| 166 | if (!json_util::readJsonPatch(req, asyncResp->res, "UserName", username, |
| 167 | "Password", password, "Oem", oemObject)) |
| 168 | { |
| 169 | return; |
| 170 | } |
| 171 | |
| 172 | if (password.empty() || username.empty() || |
| 173 | asyncResp->res.result() != boost::beast::http::status::ok) |
| 174 | { |
| 175 | if (username.empty()) |
| 176 | { |
| 177 | messages::propertyMissing(asyncResp->res, "UserName"); |
| 178 | } |
| 179 | |
| 180 | if (password.empty()) |
| 181 | { |
| 182 | messages::propertyMissing(asyncResp->res, "Password"); |
| 183 | } |
| 184 | |
| 185 | return; |
| 186 | } |
| 187 | |
| 188 | int pamrc = pamAuthenticateUser(username, password); |
| 189 | bool isConfigureSelfOnly = pamrc == PAM_NEW_AUTHTOK_REQD; |
| 190 | if ((pamrc != PAM_SUCCESS) && !isConfigureSelfOnly) |
| 191 | { |
| 192 | messages::resourceAtUriUnauthorized(asyncResp->res, req.urlView, |
| 193 | "Invalid username or password"); |
| 194 | return; |
| 195 | } |
| 196 | #ifdef BMCWEB_ENABLE_IBM_MANAGEMENT_CONSOLE |
| 197 | if (oemObject) |
| 198 | { |
| 199 | std::optional<nlohmann::json> bmcOem; |
| 200 | if (!json_util::readJson(*oemObject, asyncResp->res, "OpenBMC", bmcOem)) |
| 201 | { |
| 202 | return; |
| 203 | } |
| 204 | if (!json_util::readJson(*bmcOem, asyncResp->res, "ClientID", clientId)) |
| 205 | { |
| 206 | BMCWEB_LOG_ERROR << "Could not read ClientId"; |
| 207 | return; |
| 208 | } |
| 209 | } |
| 210 | #endif |
| 211 | |
| 212 | // User is authenticated - create session |
| 213 | std::shared_ptr<persistent_data::UserSession> session = |
| 214 | persistent_data::SessionStore::getInstance().generateUserSession( |
| 215 | username, req.ipAddress, clientId, |
| 216 | persistent_data::PersistenceType::TIMEOUT, isConfigureSelfOnly); |
| 217 | asyncResp->res.addHeader("X-Auth-Token", session->sessionToken); |
| 218 | asyncResp->res.addHeader( |
| 219 | "Location", "/redfish/v1/SessionService/Sessions/" + session->uniqueId); |
| 220 | asyncResp->res.result(boost::beast::http::status::created); |
| 221 | if (session->isConfigureSelfOnly) |
| 222 | { |
| 223 | messages::passwordChangeRequired( |
| 224 | asyncResp->res, |
| 225 | crow::utility::urlFromPieces("redfish", "v1", "AccountService", |
| 226 | "Accounts", req.session->username)); |
| 227 | } |
| 228 | |
| 229 | fillSessionObject(asyncResp->res, *session); |
| 230 | } |
| 231 | inline void |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 232 | handleSessionServiceGet(crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 233 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| 234 | |
| 235 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 236 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 237 | { |
| 238 | return; |
| 239 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 240 | asyncResp->res.jsonValue["@odata.type"] = |
| 241 | "#SessionService.v1_0_2.SessionService"; |
| 242 | asyncResp->res.jsonValue["@odata.id"] = "/redfish/v1/SessionService/"; |
| 243 | asyncResp->res.jsonValue["Name"] = "Session Service"; |
| 244 | asyncResp->res.jsonValue["Id"] = "SessionService"; |
| 245 | asyncResp->res.jsonValue["Description"] = "Session Service"; |
| 246 | asyncResp->res.jsonValue["SessionTimeout"] = |
| 247 | persistent_data::SessionStore::getInstance().getTimeoutInSeconds(); |
| 248 | asyncResp->res.jsonValue["ServiceEnabled"] = true; |
| 249 | |
Ed Tanous | 1476687 | 2022-03-15 10:44:42 -0700 | [diff] [blame] | 250 | asyncResp->res.jsonValue["Sessions"]["@odata.id"] = |
| 251 | "/redfish/v1/SessionService/Sessions"; |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 252 | } |
| 253 | |
| 254 | inline void handleSessionServicePatch( |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 255 | crow::App& app, const crow::Request& req, |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 256 | const std::shared_ptr<bmcweb::AsyncResp>& asyncResp) |
| 257 | { |
Carson Labrado | 3ba0007 | 2022-06-06 19:40:56 +0000 | [diff] [blame] | 258 | if (!redfish::setUpRedfishRoute(app, req, asyncResp)) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 259 | { |
| 260 | return; |
| 261 | } |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 262 | std::optional<int64_t> sessionTimeout; |
| 263 | if (!json_util::readJsonPatch(req, asyncResp->res, "SessionTimeout", |
| 264 | sessionTimeout)) |
| 265 | { |
| 266 | return; |
| 267 | } |
| 268 | |
| 269 | if (sessionTimeout) |
| 270 | { |
| 271 | // The mininum & maximum allowed values for session timeout |
| 272 | // are 30 seconds and 86400 seconds respectively as per the |
| 273 | // session service schema mentioned at |
| 274 | // https://redfish.dmtf.org/schemas/v1/SessionService.v1_1_7.json |
| 275 | |
| 276 | if (*sessionTimeout <= 86400 && *sessionTimeout >= 30) |
| 277 | { |
| 278 | std::chrono::seconds sessionTimeoutInseconds(*sessionTimeout); |
| 279 | persistent_data::SessionStore::getInstance().updateSessionTimeout( |
| 280 | sessionTimeoutInseconds); |
| 281 | messages::propertyValueModified(asyncResp->res, "SessionTimeOut", |
| 282 | std::to_string(*sessionTimeout)); |
| 283 | } |
| 284 | else |
| 285 | { |
| 286 | messages::propertyValueNotInList(asyncResp->res, |
| 287 | std::to_string(*sessionTimeout), |
| 288 | "SessionTimeOut"); |
| 289 | } |
| 290 | } |
| 291 | } |
| 292 | |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 293 | inline void requestRoutesSession(App& app) |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 294 | { |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 295 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/<str>/") |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 296 | .privileges(redfish::privileges::getSession) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 297 | .methods(boost::beast::http::verb::get)( |
| 298 | std::bind_front(handleSessionGet, std::ref(app))); |
Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 299 | |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 300 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/<str>/") |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 301 | .privileges(redfish::privileges::deleteSession) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 302 | .methods(boost::beast::http::verb::delete_)( |
| 303 | std::bind_front(handleSessionDelete, std::ref(app))); |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 304 | |
| 305 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/") |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 306 | .privileges(redfish::privileges::getSessionCollection) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 307 | .methods(boost::beast::http::verb::get)( |
| 308 | std::bind_front(handleSessionCollectionGet, std::ref(app))); |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 309 | |
Ed Tanous | e76cd86 | 2022-03-14 09:12:00 -0700 | [diff] [blame] | 310 | // Note, the next two routes technically don't match the privilege |
Ed Tanous | 724340d | 2022-03-14 09:10:07 -0700 | [diff] [blame] | 311 | // registry given the way login mechanisms work. The base privilege |
| 312 | // registry lists this endpoint as requiring login privilege, but because |
| 313 | // this is the endpoint responsible for giving the login privilege, and it |
| 314 | // is itself its own route, it needs to not require Login |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 315 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/") |
| 316 | .privileges({}) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 317 | .methods(boost::beast::http::verb::post)( |
| 318 | std::bind_front(handleSessionCollectionPost, std::ref(app))); |
Kowalski, Kamil | 2b7981f | 2018-01-31 13:24:59 +0100 | [diff] [blame] | 319 | |
Ed Tanous | e76cd86 | 2022-03-14 09:12:00 -0700 | [diff] [blame] | 320 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/Sessions/Members/") |
| 321 | .privileges({}) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 322 | .methods(boost::beast::http::verb::post)( |
| 323 | std::bind_front(handleSessionCollectionPost, std::ref(app))); |
Ed Tanous | e76cd86 | 2022-03-14 09:12:00 -0700 | [diff] [blame] | 324 | |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 325 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/") |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 326 | .privileges(redfish::privileges::getSessionService) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 327 | .methods(boost::beast::http::verb::get)( |
| 328 | std::bind_front(handleSessionServiceGet, std::ref(app))); |
Borawski.Lukasz | 5d27b85 | 2018-02-08 13:24:24 +0100 | [diff] [blame] | 329 | |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 330 | BMCWEB_ROUTE(app, "/redfish/v1/SessionService/") |
Ed Tanous | ed39821 | 2021-06-09 17:05:54 -0700 | [diff] [blame] | 331 | .privileges(redfish::privileges::patchSessionService) |
Ed Tanous | 45ca1b8 | 2022-03-25 13:07:27 -0700 | [diff] [blame] | 332 | .methods(boost::beast::http::verb::patch)( |
| 333 | std::bind_front(handleSessionServicePatch, std::ref(app))); |
Ed Tanous | faa34cc | 2021-06-03 13:27:02 -0700 | [diff] [blame] | 334 | } |
Borawski.Lukasz | 5d27b85 | 2018-02-08 13:24:24 +0100 | [diff] [blame] | 335 | |
Ed Tanous | 1abe55e | 2018-09-05 08:30:59 -0700 | [diff] [blame] | 336 | } // namespace redfish |