blob: b39442bd3a62d12e441a2e46e29077b3cec9728b [file] [log] [blame]
Ed Tanous7045c8d2017-04-03 10:04:37 -07001#pragma once
2
Ed Tanous04e438c2020-10-03 08:06:26 -07003#include "common.hpp"
Ed Tanous168e20c2021-12-13 14:39:53 -08004#include "dbus_utility.hpp"
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06005#include "error_messages.hpp"
Ed Tanous04e438c2020-10-03 08:06:26 -07006#include "http_request.hpp"
7#include "http_response.hpp"
8#include "logging.hpp"
Tanousf00032d2018-11-05 01:18:10 -03009#include "privileges.hpp"
Ratan Gupta6f359562019-04-03 10:39:08 +053010#include "sessions.hpp"
Ed Tanous04e438c2020-10-03 08:06:26 -070011#include "utility.hpp"
12#include "websocket.hpp"
Ed Tanous1abe55e2018-09-05 08:30:59 -070013
Iwona Klimaszewskac0a1c8a2019-07-12 18:26:38 +020014#include <async_resp.hpp>
Tanousf00032d2018-11-05 01:18:10 -030015#include <boost/container/flat_map.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050016
Ed Tanouse0d918b2018-03-27 17:41:04 -070017#include <cerrno>
Ed Tanous7045c8d2017-04-03 10:04:37 -070018#include <cstdint>
Ed Tanouse0d918b2018-03-27 17:41:04 -070019#include <cstdlib>
Ed Tanous3dac7492017-08-02 13:46:20 -070020#include <limits>
Ed Tanous7045c8d2017-04-03 10:04:37 -070021#include <memory>
22#include <tuple>
Ed Tanous7045c8d2017-04-03 10:04:37 -070023#include <utility>
24#include <vector>
Ed Tanous9140a672017-04-24 17:01:32 -070025
Ed Tanous1abe55e2018-09-05 08:30:59 -070026namespace crow
27{
Tanousf00032d2018-11-05 01:18:10 -030028
Ed Tanous1abe55e2018-09-05 08:30:59 -070029class BaseRule
30{
31 public:
Ed Tanousf23b7292020-10-15 09:41:17 -070032 BaseRule(const std::string& thisRule) : rule(thisRule)
Gunnar Mills1214b7e2020-06-04 10:11:30 -050033 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -070034
Ed Tanous0c0084a2019-10-24 15:57:51 -070035 virtual ~BaseRule() = default;
Ed Tanous7045c8d2017-04-03 10:04:37 -070036
Ed Tanousecd6a3a2022-01-07 09:18:40 -080037 BaseRule(const BaseRule&) = delete;
38 BaseRule(BaseRule&&) = delete;
39 BaseRule& operator=(const BaseRule&) = delete;
40 BaseRule& operator=(const BaseRule&&) = delete;
41
Ed Tanous1abe55e2018-09-05 08:30:59 -070042 virtual void validate() = 0;
43 std::unique_ptr<BaseRule> upgrade()
44 {
45 if (ruleToUpgrade)
Ed Tanous3174e4d2020-10-07 11:41:22 -070046 {
Ed Tanous1abe55e2018-09-05 08:30:59 -070047 return std::move(ruleToUpgrade);
Ed Tanous3174e4d2020-10-07 11:41:22 -070048 }
Ed Tanous1abe55e2018-09-05 08:30:59 -070049 return {};
50 }
Ed Tanous7045c8d2017-04-03 10:04:37 -070051
Ed Tanous104f09c2022-01-25 09:56:04 -080052 virtual void handle(const Request& /*req*/,
zhanghch058d1b46d2021-04-01 11:18:24 +080053 const std::shared_ptr<bmcweb::AsyncResp>&,
54 const RoutingParams&) = 0;
Ed Tanous104f09c2022-01-25 09:56:04 -080055 virtual void handleUpgrade(const Request& /*req*/, Response& res,
56 boost::asio::ip::tcp::socket&& /*adaptor*/)
Ed Tanous1abe55e2018-09-05 08:30:59 -070057 {
Ed Tanousde5c9f32019-03-26 09:17:55 -070058 res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -070059 res.end();
60 }
Ed Tanous55c7b7a2018-05-22 15:27:24 -070061#ifdef BMCWEB_ENABLE_SSL
Ed Tanous104f09c2022-01-25 09:56:04 -080062 virtual void handleUpgrade(
63 const Request& /*req*/, Response& res,
64 boost::beast::ssl_stream<boost::asio::ip::tcp::socket>&& /*adaptor*/)
Ed Tanous1abe55e2018-09-05 08:30:59 -070065 {
Ed Tanousde5c9f32019-03-26 09:17:55 -070066 res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -070067 res.end();
68 }
Ed Tanous7045c8d2017-04-03 10:04:37 -070069#endif
70
Ed Tanous9eb808c2022-01-25 10:19:23 -080071 size_t getMethods() const
Ed Tanous1abe55e2018-09-05 08:30:59 -070072 {
73 return methodsBitfield;
74 }
Ed Tanous7045c8d2017-04-03 10:04:37 -070075
Tanousf00032d2018-11-05 01:18:10 -030076 bool checkPrivileges(const redfish::Privileges& userPrivileges)
77 {
78 // If there are no privileges assigned, assume no privileges
79 // required
80 if (privilegesSet.empty())
81 {
82 return true;
83 }
84
85 for (const redfish::Privileges& requiredPrivileges : privilegesSet)
86 {
87 if (userPrivileges.isSupersetOf(requiredPrivileges))
88 {
89 return true;
90 }
91 }
92 return false;
93 }
94
Ed Tanous271584a2019-07-09 16:24:22 -070095 size_t methodsBitfield{
96 1 << static_cast<size_t>(boost::beast::http::verb::get)};
Ed Tanous7045c8d2017-04-03 10:04:37 -070097
Tanousf00032d2018-11-05 01:18:10 -030098 std::vector<redfish::Privileges> privilegesSet;
99
Ed Tanous1abe55e2018-09-05 08:30:59 -0700100 std::string rule;
101 std::string nameStr;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700102
Ed Tanous1abe55e2018-09-05 08:30:59 -0700103 std::unique_ptr<BaseRule> ruleToUpgrade;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700104
Ed Tanous1abe55e2018-09-05 08:30:59 -0700105 friend class Router;
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500106 template <typename T>
107 friend struct RuleParameterTraits;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700108};
109
Ed Tanous1abe55e2018-09-05 08:30:59 -0700110namespace detail
111{
112namespace routing_handler_call_helper
113{
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500114template <typename T, int Pos>
115struct CallPair
Ed Tanous1abe55e2018-09-05 08:30:59 -0700116{
117 using type = T;
118 static const int pos = Pos;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700119};
120
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500121template <typename H1>
122struct CallParams
Ed Tanous1abe55e2018-09-05 08:30:59 -0700123{
124 H1& handler;
125 const RoutingParams& params;
126 const Request& req;
zhanghch058d1b46d2021-04-01 11:18:24 +0800127 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700128};
129
130template <typename F, int NInt, int NUint, int NDouble, int NString,
131 typename S1, typename S2>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700132struct Call
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500133{};
Ed Tanous7045c8d2017-04-03 10:04:37 -0700134
135template <typename F, int NInt, int NUint, int NDouble, int NString,
136 typename... Args1, typename... Args2>
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700137struct Call<F, NInt, NUint, NDouble, NString, black_magic::S<int64_t, Args1...>,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700138 black_magic::S<Args2...>>
139{
140 void operator()(F cparams)
141 {
142 using pushed = typename black_magic::S<Args2...>::template push_back<
143 CallPair<int64_t, NInt>>;
144 Call<F, NInt + 1, NUint, NDouble, NString, black_magic::S<Args1...>,
145 pushed>()(cparams);
146 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700147};
148
149template <typename F, int NInt, int NUint, int NDouble, int NString,
150 typename... Args1, typename... Args2>
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700151struct Call<F, NInt, NUint, NDouble, NString,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700152 black_magic::S<uint64_t, Args1...>, black_magic::S<Args2...>>
153{
154 void operator()(F cparams)
155 {
156 using pushed = typename black_magic::S<Args2...>::template push_back<
157 CallPair<uint64_t, NUint>>;
158 Call<F, NInt, NUint + 1, NDouble, NString, black_magic::S<Args1...>,
159 pushed>()(cparams);
160 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700161};
162
163template <typename F, int NInt, int NUint, int NDouble, int NString,
164 typename... Args1, typename... Args2>
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700165struct Call<F, NInt, NUint, NDouble, NString, black_magic::S<double, Args1...>,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700166 black_magic::S<Args2...>>
167{
168 void operator()(F cparams)
169 {
170 using pushed = typename black_magic::S<Args2...>::template push_back<
171 CallPair<double, NDouble>>;
172 Call<F, NInt, NUint, NDouble + 1, NString, black_magic::S<Args1...>,
173 pushed>()(cparams);
174 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700175};
176
177template <typename F, int NInt, int NUint, int NDouble, int NString,
178 typename... Args1, typename... Args2>
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700179struct Call<F, NInt, NUint, NDouble, NString,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700180 black_magic::S<std::string, Args1...>, black_magic::S<Args2...>>
181{
182 void operator()(F cparams)
183 {
184 using pushed = typename black_magic::S<Args2...>::template push_back<
185 CallPair<std::string, NString>>;
186 Call<F, NInt, NUint, NDouble, NString + 1, black_magic::S<Args1...>,
187 pushed>()(cparams);
188 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700189};
190
191template <typename F, int NInt, int NUint, int NDouble, int NString,
192 typename... Args1>
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700193struct Call<F, NInt, NUint, NDouble, NString, black_magic::S<>,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700194 black_magic::S<Args1...>>
195{
196 void operator()(F cparams)
197 {
198 cparams.handler(
zhanghch058d1b46d2021-04-01 11:18:24 +0800199 cparams.req, cparams.asyncResp,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700200 cparams.params.template get<typename Args1::type>(Args1::pos)...);
201 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700202};
203
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500204template <typename Func, typename... ArgsWrapped>
205struct Wrapped
Ed Tanous1abe55e2018-09-05 08:30:59 -0700206{
207 template <typename... Args>
208 void set(
209 Func f,
210 typename std::enable_if<
211 !std::is_same<
212 typename std::tuple_element<0, std::tuple<Args..., void>>::type,
213 const Request&>::value,
Ed Tanous104f09c2022-01-25 09:56:04 -0800214 int>::type /*enable*/
215 = 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700216 {
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800217 handler = [f = std::forward<Func>(f)](
zhanghch058d1b46d2021-04-01 11:18:24 +0800218 const Request&,
219 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
220 Args... args) { asyncResp->res.result(f(args...)); };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700221 }
222
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500223 template <typename Req, typename... Args>
224 struct ReqHandlerWrapper
Ed Tanous1abe55e2018-09-05 08:30:59 -0700225 {
Ed Tanous23a21a12020-07-25 04:45:05 +0000226 ReqHandlerWrapper(Func fIn) : f(std::move(fIn))
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500227 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -0700228
zhanghch058d1b46d2021-04-01 11:18:24 +0800229 void operator()(const Request& req,
230 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
231 Args... args)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700232 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800233 asyncResp->res.result(f(req, args...));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700234 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700235
Ed Tanous1abe55e2018-09-05 08:30:59 -0700236 Func f;
237 };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700238
Ed Tanous1abe55e2018-09-05 08:30:59 -0700239 template <typename... Args>
240 void set(
241 Func f,
242 typename std::enable_if<
243 std::is_same<
244 typename std::tuple_element<0, std::tuple<Args..., void>>::type,
245 const Request&>::value &&
246 !std::is_same<typename std::tuple_element<
247 1, std::tuple<Args..., void, void>>::type,
zhanghch058d1b46d2021-04-01 11:18:24 +0800248 const std::shared_ptr<bmcweb::AsyncResp>&>::value,
Ed Tanous104f09c2022-01-25 09:56:04 -0800249 int>::type /*enable*/
250 = 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700251 {
252 handler = ReqHandlerWrapper<Args...>(std::move(f));
253 /*handler = (
254 [f = std::move(f)]
255 (const Request& req, Response& res, Args... args){
Ed Tanousde5c9f32019-03-26 09:17:55 -0700256 res.result(f(req, args...));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700257 res.end();
258 });*/
259 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700260
Ed Tanous1abe55e2018-09-05 08:30:59 -0700261 template <typename... Args>
262 void set(
263 Func f,
264 typename std::enable_if<
265 std::is_same<
266 typename std::tuple_element<0, std::tuple<Args..., void>>::type,
267 const Request&>::value &&
268 std::is_same<typename std::tuple_element<
269 1, std::tuple<Args..., void, void>>::type,
zhanghch058d1b46d2021-04-01 11:18:24 +0800270 const std::shared_ptr<bmcweb::AsyncResp>&>::value,
Ed Tanous104f09c2022-01-25 09:56:04 -0800271 int>::type /*enable*/
272 = 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700273 {
274 handler = std::move(f);
275 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700276
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500277 template <typename... Args>
278 struct HandlerTypeHelper
Ed Tanous1abe55e2018-09-05 08:30:59 -0700279 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800280 using type = std::function<void(
Ed Tanous104f09c2022-01-25 09:56:04 -0800281 const crow::Request& /*req*/,
282 const std::shared_ptr<bmcweb::AsyncResp>&, Args...)>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700283 using args_type =
Ed Tanous988403c2020-08-24 11:29:49 -0700284 black_magic::S<typename black_magic::PromoteT<Args>...>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700285 };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700286
Ed Tanous1abe55e2018-09-05 08:30:59 -0700287 template <typename... Args>
288 struct HandlerTypeHelper<const Request&, Args...>
289 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800290 using type = std::function<void(
Ed Tanous104f09c2022-01-25 09:56:04 -0800291 const crow::Request& /*req*/,
292 const std::shared_ptr<bmcweb::AsyncResp>&, Args...)>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700293 using args_type =
Ed Tanous988403c2020-08-24 11:29:49 -0700294 black_magic::S<typename black_magic::PromoteT<Args>...>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700295 };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700296
Ed Tanous1abe55e2018-09-05 08:30:59 -0700297 template <typename... Args>
zhanghch058d1b46d2021-04-01 11:18:24 +0800298 struct HandlerTypeHelper<const Request&,
299 const std::shared_ptr<bmcweb::AsyncResp>&, Args...>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700300 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800301 using type = std::function<void(
Ed Tanous104f09c2022-01-25 09:56:04 -0800302 const crow::Request& /*req*/,
303 const std::shared_ptr<bmcweb::AsyncResp>&, Args...)>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700304 using args_type =
Ed Tanous988403c2020-08-24 11:29:49 -0700305 black_magic::S<typename black_magic::PromoteT<Args>...>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700306 };
307
308 typename HandlerTypeHelper<ArgsWrapped...>::type handler;
309
zhanghch058d1b46d2021-04-01 11:18:24 +0800310 void operator()(const Request& req,
311 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700312 const RoutingParams& params)
313 {
314 detail::routing_handler_call_helper::Call<
315 detail::routing_handler_call_helper::CallParams<decltype(handler)>,
316 0, 0, 0, 0, typename HandlerTypeHelper<ArgsWrapped...>::args_type,
317 black_magic::S<>>()(
318 detail::routing_handler_call_helper::CallParams<decltype(handler)>{
zhanghch058d1b46d2021-04-01 11:18:24 +0800319 handler, params, req, asyncResp});
Ed Tanous1abe55e2018-09-05 08:30:59 -0700320 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700321};
Ed Tanous1abe55e2018-09-05 08:30:59 -0700322} // namespace routing_handler_call_helper
323} // namespace detail
Ed Tanous7045c8d2017-04-03 10:04:37 -0700324
Ed Tanous1abe55e2018-09-05 08:30:59 -0700325class WebSocketRule : public BaseRule
326{
327 using self_t = WebSocketRule;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700328
Ed Tanous1abe55e2018-09-05 08:30:59 -0700329 public:
Ed Tanousf23b7292020-10-15 09:41:17 -0700330 WebSocketRule(const std::string& ruleIn) : BaseRule(ruleIn)
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500331 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -0700332
Ed Tanous1abe55e2018-09-05 08:30:59 -0700333 void validate() override
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500334 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -0700335
Ed Tanous104f09c2022-01-25 09:56:04 -0800336 void handle(const Request& /*req*/,
zhanghch058d1b46d2021-04-01 11:18:24 +0800337 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous104f09c2022-01-25 09:56:04 -0800338 const RoutingParams& /*params*/) override
Ed Tanous1abe55e2018-09-05 08:30:59 -0700339 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800340 asyncResp->res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700341 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700342
Ed Tanous104f09c2022-01-25 09:56:04 -0800343 void handleUpgrade(const Request& req, Response& /*res*/,
Ed Tanousceac6f72018-12-02 11:58:47 -0800344 boost::asio::ip::tcp::socket&& adaptor) override
Ed Tanous1abe55e2018-09-05 08:30:59 -0700345 {
Nan Zhou93c02022022-02-24 18:21:07 -0800346 BMCWEB_LOG_DEBUG << "Websocket handles upgrade";
Ratan Gupta02453b12019-10-22 14:43:36 +0530347 std::shared_ptr<
348 crow::websocket::ConnectionImpl<boost::asio::ip::tcp::socket>>
349 myConnection = std::make_shared<
350 crow::websocket::ConnectionImpl<boost::asio::ip::tcp::socket>>(
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000351 req, std::move(adaptor), openHandler, messageHandler,
Ratan Gupta02453b12019-10-22 14:43:36 +0530352 closeHandler, errorHandler);
353 myConnection->start();
Ed Tanous1abe55e2018-09-05 08:30:59 -0700354 }
355#ifdef BMCWEB_ENABLE_SSL
Ed Tanous104f09c2022-01-25 09:56:04 -0800356 void handleUpgrade(const Request& req, Response& /*res*/,
Ed Tanousceac6f72018-12-02 11:58:47 -0800357 boost::beast::ssl_stream<boost::asio::ip::tcp::socket>&&
358 adaptor) override
Ed Tanous1abe55e2018-09-05 08:30:59 -0700359 {
Nan Zhou93c02022022-02-24 18:21:07 -0800360 BMCWEB_LOG_DEBUG << "Websocket handles upgrade";
Ed Tanousceac6f72018-12-02 11:58:47 -0800361 std::shared_ptr<crow::websocket::ConnectionImpl<
362 boost::beast::ssl_stream<boost::asio::ip::tcp::socket>>>
363 myConnection = std::make_shared<crow::websocket::ConnectionImpl<
364 boost::beast::ssl_stream<boost::asio::ip::tcp::socket>>>(
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000365 req, std::move(adaptor), openHandler, messageHandler,
Ed Tanousceac6f72018-12-02 11:58:47 -0800366 closeHandler, errorHandler);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700367 myConnection->start();
368 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700369#endif
370
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500371 template <typename Func>
372 self_t& onopen(Func f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700373 {
374 openHandler = f;
375 return *this;
376 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700377
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500378 template <typename Func>
379 self_t& onmessage(Func f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700380 {
381 messageHandler = f;
382 return *this;
383 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700384
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500385 template <typename Func>
386 self_t& onclose(Func f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700387 {
388 closeHandler = f;
389 return *this;
390 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700391
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500392 template <typename Func>
393 self_t& onerror(Func f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700394 {
395 errorHandler = f;
396 return *this;
397 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700398
Ed Tanous1abe55e2018-09-05 08:30:59 -0700399 protected:
Gunnar Millsccd584f2021-11-16 11:36:33 -0600400 std::function<void(crow::websocket::Connection&,
401 std::shared_ptr<bmcweb::AsyncResp>)>
402 openHandler;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700403 std::function<void(crow::websocket::Connection&, const std::string&, bool)>
404 messageHandler;
405 std::function<void(crow::websocket::Connection&, const std::string&)>
406 closeHandler;
407 std::function<void(crow::websocket::Connection&)> errorHandler;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700408};
409
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500410template <typename T>
411struct RuleParameterTraits
Ed Tanous1abe55e2018-09-05 08:30:59 -0700412{
413 using self_t = T;
414 WebSocketRule& websocket()
415 {
Ed Tanous271584a2019-07-09 16:24:22 -0700416 self_t* self = static_cast<self_t*>(this);
417 WebSocketRule* p = new WebSocketRule(self->rule);
418 self->ruleToUpgrade.reset(p);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700419 return *p;
420 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700421
Ed Tanousf23b7292020-10-15 09:41:17 -0700422 self_t& name(const std::string_view name) noexcept
Ed Tanous1abe55e2018-09-05 08:30:59 -0700423 {
Ed Tanous271584a2019-07-09 16:24:22 -0700424 self_t* self = static_cast<self_t*>(this);
Ed Tanousf23b7292020-10-15 09:41:17 -0700425 self->nameStr = name;
Ed Tanous271584a2019-07-09 16:24:22 -0700426 return *self;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700427 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700428
Ed Tanous1abe55e2018-09-05 08:30:59 -0700429 self_t& methods(boost::beast::http::verb method)
430 {
Ed Tanous271584a2019-07-09 16:24:22 -0700431 self_t* self = static_cast<self_t*>(this);
432 self->methodsBitfield = 1U << static_cast<size_t>(method);
433 return *self;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700434 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700435
Ed Tanous1abe55e2018-09-05 08:30:59 -0700436 template <typename... MethodArgs>
Ed Tanous81ce6092020-12-17 16:54:55 +0000437 self_t& methods(boost::beast::http::verb method, MethodArgs... argsMethod)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700438 {
Ed Tanous271584a2019-07-09 16:24:22 -0700439 self_t* self = static_cast<self_t*>(this);
Ed Tanous81ce6092020-12-17 16:54:55 +0000440 methods(argsMethod...);
Ed Tanous271584a2019-07-09 16:24:22 -0700441 self->methodsBitfield |= 1U << static_cast<size_t>(method);
442 return *self;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700443 }
Tanousf00032d2018-11-05 01:18:10 -0300444
Ed Tanous432a8902021-06-14 15:28:56 -0700445 self_t& privileges(
446 const std::initializer_list<std::initializer_list<const char*>>& p)
Tanousf00032d2018-11-05 01:18:10 -0300447 {
Ed Tanous271584a2019-07-09 16:24:22 -0700448 self_t* self = static_cast<self_t*>(this);
Ed Tanous432a8902021-06-14 15:28:56 -0700449 for (const std::initializer_list<const char*>& privilege : p)
Tanousf00032d2018-11-05 01:18:10 -0300450 {
Ed Tanous271584a2019-07-09 16:24:22 -0700451 self->privilegesSet.emplace_back(privilege);
Tanousf00032d2018-11-05 01:18:10 -0300452 }
Ed Tanous271584a2019-07-09 16:24:22 -0700453 return *self;
Tanousf00032d2018-11-05 01:18:10 -0300454 }
Ed Tanoused398212021-06-09 17:05:54 -0700455
456 template <size_t N, typename... MethodArgs>
457 self_t& privileges(const std::array<redfish::Privileges, N>& p)
458 {
459 self_t* self = static_cast<self_t*>(this);
460 for (const redfish::Privileges& privilege : p)
461 {
462 self->privilegesSet.emplace_back(privilege);
463 }
464 return *self;
465 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700466};
467
Ed Tanous1abe55e2018-09-05 08:30:59 -0700468class DynamicRule : public BaseRule, public RuleParameterTraits<DynamicRule>
469{
470 public:
Ed Tanousf23b7292020-10-15 09:41:17 -0700471 DynamicRule(const std::string& ruleIn) : BaseRule(ruleIn)
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500472 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -0700473
Ed Tanous1abe55e2018-09-05 08:30:59 -0700474 void validate() override
475 {
476 if (!erasedHandler)
477 {
478 throw std::runtime_error(nameStr + (!nameStr.empty() ? ": " : "") +
479 "no handler for url " + rule);
480 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700481 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700482
zhanghch058d1b46d2021-04-01 11:18:24 +0800483 void handle(const Request& req,
484 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700485 const RoutingParams& params) override
486 {
zhanghch058d1b46d2021-04-01 11:18:24 +0800487 erasedHandler(req, asyncResp, params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700488 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700489
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500490 template <typename Func>
491 void operator()(Func f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700492 {
493 using function_t = utility::function_traits<Func>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700494 erasedHandler =
Ed Tanous988403c2020-08-24 11:29:49 -0700495 wrap(std::move(f),
496 std::make_integer_sequence<unsigned, function_t::arity>{});
Ed Tanous1abe55e2018-09-05 08:30:59 -0700497 }
498
499 // enable_if Arg1 == request && Arg2 == Response
Gunnar Mills6be0e402020-07-08 13:21:51 -0500500 // enable_if Arg1 == request && Arg2 != response
Ed Tanous1abe55e2018-09-05 08:30:59 -0700501 // enable_if Arg1 != request
502
503 template <typename Func, unsigned... Indices>
zhanghch058d1b46d2021-04-01 11:18:24 +0800504 std::function<void(const Request&,
505 const std::shared_ptr<bmcweb::AsyncResp>&,
506 const RoutingParams&)>
Ed Tanous104f09c2022-01-25 09:56:04 -0800507 wrap(Func f, std::integer_sequence<unsigned, Indices...> /*is*/)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700508 {
Ed Tanous988403c2020-08-24 11:29:49 -0700509 using function_t = crow::utility::function_traits<Func>;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700510
511 if (!black_magic::isParameterTagCompatible(
Ed Tanous988403c2020-08-24 11:29:49 -0700512 black_magic::getParameterTag(rule.c_str()),
513 black_magic::computeParameterTagFromArgsList<
Ed Tanous1abe55e2018-09-05 08:30:59 -0700514 typename function_t::template arg<Indices>...>::value))
515 {
516 throw std::runtime_error("routeDynamic: Handler type is mismatched "
517 "with URL parameters: " +
518 rule);
519 }
520 auto ret = detail::routing_handler_call_helper::Wrapped<
521 Func, typename function_t::template arg<Indices>...>();
522 ret.template set<typename function_t::template arg<Indices>...>(
523 std::move(f));
524 return ret;
525 }
526
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500527 template <typename Func>
528 void operator()(std::string name, Func&& f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700529 {
530 nameStr = std::move(name);
531 (*this).template operator()<Func>(std::forward(f));
532 }
533
534 private:
zhanghch058d1b46d2021-04-01 11:18:24 +0800535 std::function<void(const Request&,
536 const std::shared_ptr<bmcweb::AsyncResp>&,
537 const RoutingParams&)>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700538 erasedHandler;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700539};
540
541template <typename... Args>
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500542class TaggedRule :
543 public BaseRule,
544 public RuleParameterTraits<TaggedRule<Args...>>
Ed Tanous1abe55e2018-09-05 08:30:59 -0700545{
546 public:
547 using self_t = TaggedRule<Args...>;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700548
Ed Tanousf23b7292020-10-15 09:41:17 -0700549 TaggedRule(const std::string& ruleIn) : BaseRule(ruleIn)
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500550 {}
Ed Tanous7045c8d2017-04-03 10:04:37 -0700551
Ed Tanous1abe55e2018-09-05 08:30:59 -0700552 void validate() override
553 {
554 if (!handler)
555 {
556 throw std::runtime_error(nameStr + (!nameStr.empty() ? ": " : "") +
557 "no handler for url " + rule);
558 }
559 }
560
561 template <typename Func>
562 typename std::enable_if<
563 black_magic::CallHelper<Func, black_magic::S<Args...>>::value,
564 void>::type
565 operator()(Func&& f)
566 {
567 static_assert(
568 black_magic::CallHelper<Func, black_magic::S<Args...>>::value ||
569 black_magic::CallHelper<
570 Func, black_magic::S<crow::Request, Args...>>::value,
571 "Handler type is mismatched with URL parameters");
572 static_assert(
573 !std::is_same<void, decltype(f(std::declval<Args>()...))>::value,
574 "Handler function cannot have void return type; valid return "
575 "types: "
Gunnar Mills6be0e402020-07-08 13:21:51 -0500576 "string, int, crow::response, nlohmann::json");
Ed Tanous1abe55e2018-09-05 08:30:59 -0700577
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800578 handler = [f = std::forward<Func>(f)](
zhanghch058d1b46d2021-04-01 11:18:24 +0800579 const Request&,
580 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
581 Args... args) { asyncResp->res.result(f(args...)); };
Ed Tanous1abe55e2018-09-05 08:30:59 -0700582 }
583
584 template <typename Func>
585 typename std::enable_if<
586 !black_magic::CallHelper<Func, black_magic::S<Args...>>::value &&
Ed Tanous7045c8d2017-04-03 10:04:37 -0700587 black_magic::CallHelper<
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700588 Func, black_magic::S<crow::Request, Args...>>::value,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700589 void>::type
590 operator()(Func&& f)
591 {
592 static_assert(
593 black_magic::CallHelper<Func, black_magic::S<Args...>>::value ||
594 black_magic::CallHelper<
595 Func, black_magic::S<crow::Request, Args...>>::value,
596 "Handler type is mismatched with URL parameters");
597 static_assert(
598 !std::is_same<void, decltype(f(std::declval<crow::Request>(),
599 std::declval<Args>()...))>::value,
600 "Handler function cannot have void return type; valid return "
601 "types: "
Gunnar Mills6be0e402020-07-08 13:21:51 -0500602 "string, int, crow::response,nlohmann::json");
Ed Tanous7045c8d2017-04-03 10:04:37 -0700603
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800604 handler = [f = std::forward<Func>(f)](
zhanghch058d1b46d2021-04-01 11:18:24 +0800605 const crow::Request& req,
606 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
607 Args... args) { asyncResp->res.result(f(req, args...)); };
Ed Tanous1abe55e2018-09-05 08:30:59 -0700608 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700609
Ed Tanous1abe55e2018-09-05 08:30:59 -0700610 template <typename Func>
611 typename std::enable_if<
612 !black_magic::CallHelper<Func, black_magic::S<Args...>>::value &&
613 !black_magic::CallHelper<
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700614 Func, black_magic::S<crow::Request, Args...>>::value,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700615 void>::type
616 operator()(Func&& f)
617 {
618 static_assert(
619 black_magic::CallHelper<Func, black_magic::S<Args...>>::value ||
620 black_magic::CallHelper<
621 Func, black_magic::S<crow::Request, Args...>>::value ||
622 black_magic::CallHelper<
zhanghch058d1b46d2021-04-01 11:18:24 +0800623 Func, black_magic::S<crow::Request,
624 std::shared_ptr<bmcweb::AsyncResp>&,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700625 Args...>>::value,
626 "Handler type is mismatched with URL parameters");
627 static_assert(
zhanghch058d1b46d2021-04-01 11:18:24 +0800628 std::is_same<
629 void,
630 decltype(f(std::declval<crow::Request>(),
631 std::declval<std::shared_ptr<bmcweb::AsyncResp>&>(),
632 std::declval<Args>()...))>::value,
Tanousf00032d2018-11-05 01:18:10 -0300633 "Handler function with response argument should have void "
634 "return "
Ed Tanous1abe55e2018-09-05 08:30:59 -0700635 "type");
Ed Tanous7045c8d2017-04-03 10:04:37 -0700636
Ed Tanousf94c4ec2022-01-06 12:44:41 -0800637 handler = std::forward<Func>(f);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700638 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700639
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500640 template <typename Func>
Ed Tanousf23b7292020-10-15 09:41:17 -0700641 void operator()(const std::string_view name, Func&& f)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700642 {
Ed Tanousf23b7292020-10-15 09:41:17 -0700643 nameStr = name;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700644 (*this).template operator()<Func>(std::forward(f));
645 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700646
zhanghch058d1b46d2021-04-01 11:18:24 +0800647 void handle(const Request& req,
648 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp,
Ed Tanous1abe55e2018-09-05 08:30:59 -0700649 const RoutingParams& params) override
650 {
651 detail::routing_handler_call_helper::Call<
652 detail::routing_handler_call_helper::CallParams<decltype(handler)>,
653 0, 0, 0, 0, black_magic::S<Args...>, black_magic::S<>>()(
654 detail::routing_handler_call_helper::CallParams<decltype(handler)>{
zhanghch058d1b46d2021-04-01 11:18:24 +0800655 handler, params, req, asyncResp});
Ed Tanous1abe55e2018-09-05 08:30:59 -0700656 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700657
Ed Tanous1abe55e2018-09-05 08:30:59 -0700658 private:
zhanghch058d1b46d2021-04-01 11:18:24 +0800659 std::function<void(const crow::Request&,
660 const std::shared_ptr<bmcweb::AsyncResp>&, Args...)>
661 handler;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700662};
663
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700664const int ruleSpecialRedirectSlash = 1;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700665
Ed Tanous1abe55e2018-09-05 08:30:59 -0700666class Trie
667{
668 public:
669 struct Node
670 {
671 unsigned ruleIndex{};
Ed Tanous271584a2019-07-09 16:24:22 -0700672 std::array<size_t, static_cast<size_t>(ParamType::MAX)>
673 paramChildrens{};
Ed Tanous1abe55e2018-09-05 08:30:59 -0700674 boost::container::flat_map<std::string, unsigned> children;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700675
Ed Tanous1abe55e2018-09-05 08:30:59 -0700676 bool isSimpleNode() const
677 {
Ed Tanouse662eae2022-01-25 10:39:19 -0800678 return ruleIndex == 0 &&
679 std::all_of(std::begin(paramChildrens),
680 std::end(paramChildrens),
681 [](size_t x) { return x == 0U; });
Ed Tanous7045c8d2017-04-03 10:04:37 -0700682 }
Ed Tanous55c7b7a2018-05-22 15:27:24 -0700683 };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700684
Ed Tanous1abe55e2018-09-05 08:30:59 -0700685 Trie() : nodes(1)
Gunnar Mills1214b7e2020-06-04 10:11:30 -0500686 {}
Ed Tanous1abe55e2018-09-05 08:30:59 -0700687
688 private:
689 void optimizeNode(Node* node)
690 {
Ed Tanous271584a2019-07-09 16:24:22 -0700691 for (size_t x : node->paramChildrens)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700692 {
Ed Tanousdbb59d42022-01-25 11:09:55 -0800693 if (x == 0U)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700694 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700695 continue;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700696 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700697 Node* child = &nodes[x];
698 optimizeNode(child);
Ed Tanous7045c8d2017-04-03 10:04:37 -0700699 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700700 if (node->children.empty())
Ed Tanous3174e4d2020-10-07 11:41:22 -0700701 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700702 return;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700703 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700704 bool mergeWithChild = true;
Tanousf00032d2018-11-05 01:18:10 -0300705 for (const std::pair<std::string, unsigned>& kv : node->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700706 {
707 Node* child = &nodes[kv.second];
708 if (!child->isSimpleNode())
709 {
710 mergeWithChild = false;
711 break;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700712 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700713 }
714 if (mergeWithChild)
715 {
716 decltype(node->children) merged;
Tanousf00032d2018-11-05 01:18:10 -0300717 for (const std::pair<std::string, unsigned>& kv : node->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700718 {
719 Node* child = &nodes[kv.second];
Tanousf00032d2018-11-05 01:18:10 -0300720 for (const std::pair<std::string, unsigned>& childKv :
721 child->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700722 {
723 merged[kv.first + childKv.first] = childKv.second;
724 }
725 }
726 node->children = std::move(merged);
727 optimizeNode(node);
728 }
729 else
730 {
Tanousf00032d2018-11-05 01:18:10 -0300731 for (const std::pair<std::string, unsigned>& kv : node->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700732 {
733 Node* child = &nodes[kv.second];
734 optimizeNode(child);
735 }
736 }
737 }
738
739 void optimize()
740 {
741 optimizeNode(head());
742 }
743
744 public:
745 void validate()
746 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700747 optimize();
748 }
749
Ed Tanous81ce6092020-12-17 16:54:55 +0000750 void findRouteIndexes(const std::string& reqUrl,
751 std::vector<unsigned>& routeIndexes,
Tanousf00032d2018-11-05 01:18:10 -0300752 const Node* node = nullptr, unsigned pos = 0) const
Ed Tanous1abe55e2018-09-05 08:30:59 -0700753 {
754 if (node == nullptr)
755 {
756 node = head();
757 }
Tanousf00032d2018-11-05 01:18:10 -0300758 for (const std::pair<std::string, unsigned>& kv : node->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700759 {
760 const std::string& fragment = kv.first;
761 const Node* child = &nodes[kv.second];
Ed Tanous81ce6092020-12-17 16:54:55 +0000762 if (pos >= reqUrl.size())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700763 {
764 if (child->ruleIndex != 0 && fragment != "/")
765 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000766 routeIndexes.push_back(child->ruleIndex);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700767 }
Ed Tanous81ce6092020-12-17 16:54:55 +0000768 findRouteIndexes(reqUrl, routeIndexes, child,
Ed Tanous271584a2019-07-09 16:24:22 -0700769 static_cast<unsigned>(pos + fragment.size()));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700770 }
771 else
772 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000773 if (reqUrl.compare(pos, fragment.size(), fragment) == 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700774 {
Ed Tanous271584a2019-07-09 16:24:22 -0700775 findRouteIndexes(
Ed Tanous81ce6092020-12-17 16:54:55 +0000776 reqUrl, routeIndexes, child,
Ed Tanous271584a2019-07-09 16:24:22 -0700777 static_cast<unsigned>(pos + fragment.size()));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700778 }
779 }
780 }
781 }
782
783 std::pair<unsigned, RoutingParams>
Ed Tanous81ce6092020-12-17 16:54:55 +0000784 find(const std::string_view reqUrl, const Node* node = nullptr,
Ed Tanous271584a2019-07-09 16:24:22 -0700785 size_t pos = 0, RoutingParams* params = nullptr) const
Ed Tanous1abe55e2018-09-05 08:30:59 -0700786 {
787 RoutingParams empty;
788 if (params == nullptr)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700789 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700790 params = &empty;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700791 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700792
793 unsigned found{};
794 RoutingParams matchParams;
795
796 if (node == nullptr)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700797 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700798 node = head();
Ed Tanous3174e4d2020-10-07 11:41:22 -0700799 }
Ed Tanous81ce6092020-12-17 16:54:55 +0000800 if (pos == reqUrl.size())
Ed Tanous3174e4d2020-10-07 11:41:22 -0700801 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700802 return {node->ruleIndex, *params};
Ed Tanous3174e4d2020-10-07 11:41:22 -0700803 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700804
805 auto updateFound =
806 [&found, &matchParams](std::pair<unsigned, RoutingParams>& ret) {
Ed Tanouse662eae2022-01-25 10:39:19 -0800807 if (ret.first != 0U && (found == 0U || found > ret.first))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700808 {
809 found = ret.first;
810 matchParams = std::move(ret.second);
811 }
812 };
813
Ed Tanouse662eae2022-01-25 10:39:19 -0800814 if (node->paramChildrens[static_cast<size_t>(ParamType::INT)] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700815 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000816 char c = reqUrl[pos];
Ed Tanous1abe55e2018-09-05 08:30:59 -0700817 if ((c >= '0' && c <= '9') || c == '+' || c == '-')
818 {
Ed Tanous543f4402022-01-06 13:12:53 -0800819 char* eptr = nullptr;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700820 errno = 0;
821 long long int value =
Ed Tanous81ce6092020-12-17 16:54:55 +0000822 std::strtoll(reqUrl.data() + pos, &eptr, 10);
823 if (errno != ERANGE && eptr != reqUrl.data() + pos)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700824 {
825 params->intParams.push_back(value);
Ed Tanous81ce6092020-12-17 16:54:55 +0000826 std::pair<unsigned, RoutingParams> ret =
827 find(reqUrl,
828 &nodes[node->paramChildrens[static_cast<size_t>(
829 ParamType::INT)]],
830 static_cast<size_t>(eptr - reqUrl.data()), params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700831 updateFound(ret);
832 params->intParams.pop_back();
833 }
834 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700835 }
836
Ed Tanouse662eae2022-01-25 10:39:19 -0800837 if (node->paramChildrens[static_cast<size_t>(ParamType::UINT)] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700838 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000839 char c = reqUrl[pos];
Ed Tanous1abe55e2018-09-05 08:30:59 -0700840 if ((c >= '0' && c <= '9') || c == '+')
841 {
Ed Tanous543f4402022-01-06 13:12:53 -0800842 char* eptr = nullptr;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700843 errno = 0;
844 unsigned long long int value =
Ed Tanous81ce6092020-12-17 16:54:55 +0000845 std::strtoull(reqUrl.data() + pos, &eptr, 10);
846 if (errno != ERANGE && eptr != reqUrl.data() + pos)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700847 {
848 params->uintParams.push_back(value);
Ed Tanous81ce6092020-12-17 16:54:55 +0000849 std::pair<unsigned, RoutingParams> ret =
850 find(reqUrl,
851 &nodes[node->paramChildrens[static_cast<size_t>(
852 ParamType::UINT)]],
853 static_cast<size_t>(eptr - reqUrl.data()), params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700854 updateFound(ret);
855 params->uintParams.pop_back();
856 }
857 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700858 }
859
Ed Tanouse662eae2022-01-25 10:39:19 -0800860 if (node->paramChildrens[static_cast<size_t>(ParamType::DOUBLE)] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700861 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000862 char c = reqUrl[pos];
Ed Tanous1abe55e2018-09-05 08:30:59 -0700863 if ((c >= '0' && c <= '9') || c == '+' || c == '-' || c == '.')
864 {
Ed Tanous543f4402022-01-06 13:12:53 -0800865 char* eptr = nullptr;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700866 errno = 0;
Ed Tanous81ce6092020-12-17 16:54:55 +0000867 double value = std::strtod(reqUrl.data() + pos, &eptr);
868 if (errno != ERANGE && eptr != reqUrl.data() + pos)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700869 {
870 params->doubleParams.push_back(value);
Ed Tanous81ce6092020-12-17 16:54:55 +0000871 std::pair<unsigned, RoutingParams> ret =
872 find(reqUrl,
873 &nodes[node->paramChildrens[static_cast<size_t>(
874 ParamType::DOUBLE)]],
875 static_cast<size_t>(eptr - reqUrl.data()), params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700876 updateFound(ret);
877 params->doubleParams.pop_back();
878 }
879 }
880 }
881
Ed Tanouse662eae2022-01-25 10:39:19 -0800882 if (node->paramChildrens[static_cast<size_t>(ParamType::STRING)] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700883 {
Ed Tanousb01bf292019-03-25 19:25:26 +0000884 size_t epos = pos;
Ed Tanous81ce6092020-12-17 16:54:55 +0000885 for (; epos < reqUrl.size(); epos++)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700886 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000887 if (reqUrl[epos] == '/')
Ed Tanous3174e4d2020-10-07 11:41:22 -0700888 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700889 break;
Ed Tanous3174e4d2020-10-07 11:41:22 -0700890 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700891 }
892
893 if (epos != pos)
894 {
895 params->stringParams.emplace_back(
Ed Tanous81ce6092020-12-17 16:54:55 +0000896 reqUrl.substr(pos, epos - pos));
Tanousf00032d2018-11-05 01:18:10 -0300897 std::pair<unsigned, RoutingParams> ret =
Ed Tanous81ce6092020-12-17 16:54:55 +0000898 find(reqUrl,
Ed Tanous271584a2019-07-09 16:24:22 -0700899 &nodes[node->paramChildrens[static_cast<size_t>(
900 ParamType::STRING)]],
Ed Tanousb01bf292019-03-25 19:25:26 +0000901 epos, params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700902 updateFound(ret);
903 params->stringParams.pop_back();
904 }
905 }
906
Ed Tanouse662eae2022-01-25 10:39:19 -0800907 if (node->paramChildrens[static_cast<size_t>(ParamType::PATH)] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700908 {
Ed Tanous81ce6092020-12-17 16:54:55 +0000909 size_t epos = reqUrl.size();
Ed Tanous1abe55e2018-09-05 08:30:59 -0700910
911 if (epos != pos)
912 {
913 params->stringParams.emplace_back(
Ed Tanous81ce6092020-12-17 16:54:55 +0000914 reqUrl.substr(pos, epos - pos));
Ed Tanous271584a2019-07-09 16:24:22 -0700915 std::pair<unsigned, RoutingParams> ret =
Ed Tanous81ce6092020-12-17 16:54:55 +0000916 find(reqUrl,
Ed Tanous271584a2019-07-09 16:24:22 -0700917 &nodes[node->paramChildrens[static_cast<size_t>(
918 ParamType::PATH)]],
919 epos, params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700920 updateFound(ret);
921 params->stringParams.pop_back();
922 }
923 }
924
Tanousf00032d2018-11-05 01:18:10 -0300925 for (const std::pair<std::string, unsigned>& kv : node->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700926 {
927 const std::string& fragment = kv.first;
928 const Node* child = &nodes[kv.second];
929
Ed Tanous81ce6092020-12-17 16:54:55 +0000930 if (reqUrl.compare(pos, fragment.size(), fragment) == 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700931 {
Tanousf00032d2018-11-05 01:18:10 -0300932 std::pair<unsigned, RoutingParams> ret =
Ed Tanous81ce6092020-12-17 16:54:55 +0000933 find(reqUrl, child, pos + fragment.size(), params);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700934 updateFound(ret);
935 }
936 }
937
938 return {found, matchParams};
Ed Tanous7045c8d2017-04-03 10:04:37 -0700939 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700940
941 void add(const std::string& url, unsigned ruleIndex)
942 {
Ed Tanous271584a2019-07-09 16:24:22 -0700943 size_t idx = 0;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700944
945 for (unsigned i = 0; i < url.size(); i++)
946 {
947 char c = url[i];
948 if (c == '<')
949 {
Tanousf00032d2018-11-05 01:18:10 -0300950 const static std::array<std::pair<ParamType, std::string>, 7>
951 paramTraits = {{
952 {ParamType::INT, "<int>"},
953 {ParamType::UINT, "<uint>"},
954 {ParamType::DOUBLE, "<float>"},
955 {ParamType::DOUBLE, "<double>"},
956 {ParamType::STRING, "<str>"},
957 {ParamType::STRING, "<string>"},
958 {ParamType::PATH, "<path>"},
959 }};
Ed Tanous1abe55e2018-09-05 08:30:59 -0700960
Tanousf00032d2018-11-05 01:18:10 -0300961 for (const std::pair<ParamType, std::string>& x : paramTraits)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700962 {
Tanousf00032d2018-11-05 01:18:10 -0300963 if (url.compare(i, x.second.size(), x.second) == 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700964 {
Ed Tanous271584a2019-07-09 16:24:22 -0700965 size_t index = static_cast<size_t>(x.first);
Ed Tanouse662eae2022-01-25 10:39:19 -0800966 if (nodes[idx].paramChildrens[index] == 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700967 {
Tanousf00032d2018-11-05 01:18:10 -0300968 unsigned newNodeIdx = newNode();
Ed Tanous271584a2019-07-09 16:24:22 -0700969 nodes[idx].paramChildrens[index] = newNodeIdx;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700970 }
Ed Tanous271584a2019-07-09 16:24:22 -0700971 idx = nodes[idx].paramChildrens[index];
972 i += static_cast<unsigned>(x.second.size());
Ed Tanous1abe55e2018-09-05 08:30:59 -0700973 break;
974 }
975 }
976
977 i--;
978 }
979 else
980 {
981 std::string piece(&c, 1);
Ed Tanouse662eae2022-01-25 10:39:19 -0800982 if (nodes[idx].children.count(piece) == 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700983 {
Tanousf00032d2018-11-05 01:18:10 -0300984 unsigned newNodeIdx = newNode();
Ed Tanous1abe55e2018-09-05 08:30:59 -0700985 nodes[idx].children.emplace(piece, newNodeIdx);
986 }
987 idx = nodes[idx].children[piece];
988 }
989 }
Ed Tanouse662eae2022-01-25 10:39:19 -0800990 if (nodes[idx].ruleIndex != 0U)
Ed Tanous3174e4d2020-10-07 11:41:22 -0700991 {
Ed Tanous1abe55e2018-09-05 08:30:59 -0700992 throw std::runtime_error("handler already exists for " + url);
Ed Tanous3174e4d2020-10-07 11:41:22 -0700993 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700994 nodes[idx].ruleIndex = ruleIndex;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700995 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700996
Ed Tanous1abe55e2018-09-05 08:30:59 -0700997 private:
Ed Tanous271584a2019-07-09 16:24:22 -0700998 void debugNodePrint(Node* n, size_t level)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700999 {
Ed Tanous271584a2019-07-09 16:24:22 -07001000 for (size_t i = 0; i < static_cast<size_t>(ParamType::MAX); i++)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001001 {
Ed Tanouse662eae2022-01-25 10:39:19 -08001002 if (n->paramChildrens[i] != 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001003 {
1004 BMCWEB_LOG_DEBUG << std::string(
Ed Tanous271584a2019-07-09 16:24:22 -07001005 2U * level, ' ') /*<< "("<<n->paramChildrens[i]<<") "*/;
1006 switch (static_cast<ParamType>(i))
Ed Tanous1abe55e2018-09-05 08:30:59 -07001007 {
1008 case ParamType::INT:
1009 BMCWEB_LOG_DEBUG << "<int>";
1010 break;
1011 case ParamType::UINT:
1012 BMCWEB_LOG_DEBUG << "<uint>";
1013 break;
1014 case ParamType::DOUBLE:
1015 BMCWEB_LOG_DEBUG << "<float>";
1016 break;
1017 case ParamType::STRING:
1018 BMCWEB_LOG_DEBUG << "<str>";
1019 break;
1020 case ParamType::PATH:
1021 BMCWEB_LOG_DEBUG << "<path>";
1022 break;
Ed Tanous23a21a12020-07-25 04:45:05 +00001023 case ParamType::MAX:
Ed Tanous1abe55e2018-09-05 08:30:59 -07001024 BMCWEB_LOG_DEBUG << "<ERROR>";
1025 break;
1026 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001027
Ed Tanous1abe55e2018-09-05 08:30:59 -07001028 debugNodePrint(&nodes[n->paramChildrens[i]], level + 1);
1029 }
1030 }
Tanousf00032d2018-11-05 01:18:10 -03001031 for (const std::pair<std::string, unsigned>& kv : n->children)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001032 {
1033 BMCWEB_LOG_DEBUG
Ed Tanous271584a2019-07-09 16:24:22 -07001034 << std::string(2U * level, ' ') /*<< "(" << kv.second << ") "*/
Ed Tanous1abe55e2018-09-05 08:30:59 -07001035 << kv.first;
1036 debugNodePrint(&nodes[kv.second], level + 1);
1037 }
1038 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001039
Ed Tanous1abe55e2018-09-05 08:30:59 -07001040 public:
1041 void debugPrint()
1042 {
Ed Tanous271584a2019-07-09 16:24:22 -07001043 debugNodePrint(head(), 0U);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001044 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001045
Ed Tanous1abe55e2018-09-05 08:30:59 -07001046 private:
1047 const Node* head() const
1048 {
1049 return &nodes.front();
1050 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001051
Ed Tanous1abe55e2018-09-05 08:30:59 -07001052 Node* head()
1053 {
1054 return &nodes.front();
1055 }
1056
1057 unsigned newNode()
1058 {
1059 nodes.resize(nodes.size() + 1);
Ed Tanous271584a2019-07-09 16:24:22 -07001060 return static_cast<unsigned>(nodes.size() - 1);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001061 }
1062
1063 std::vector<Node> nodes;
Ed Tanous7045c8d2017-04-03 10:04:37 -07001064};
1065
Ed Tanous1abe55e2018-09-05 08:30:59 -07001066class Router
1067{
1068 public:
Ed Tanous0c0084a2019-10-24 15:57:51 -07001069 Router() = default;
Ed Tanous7045c8d2017-04-03 10:04:37 -07001070
Ed Tanous1abe55e2018-09-05 08:30:59 -07001071 DynamicRule& newRuleDynamic(const std::string& rule)
1072 {
1073 std::unique_ptr<DynamicRule> ruleObject =
1074 std::make_unique<DynamicRule>(rule);
1075 DynamicRule* ptr = ruleObject.get();
Tanousf00032d2018-11-05 01:18:10 -03001076 allRules.emplace_back(std::move(ruleObject));
Ed Tanous7045c8d2017-04-03 10:04:37 -07001077
Ed Tanous1abe55e2018-09-05 08:30:59 -07001078 return *ptr;
Ed Tanous7045c8d2017-04-03 10:04:37 -07001079 }
1080
Ed Tanous1abe55e2018-09-05 08:30:59 -07001081 template <uint64_t N>
1082 typename black_magic::Arguments<N>::type::template rebind<TaggedRule>&
1083 newRuleTagged(const std::string& rule)
1084 {
1085 using RuleT = typename black_magic::Arguments<N>::type::template rebind<
1086 TaggedRule>;
1087 std::unique_ptr<RuleT> ruleObject = std::make_unique<RuleT>(rule);
1088 RuleT* ptr = ruleObject.get();
Tanousf00032d2018-11-05 01:18:10 -03001089 allRules.emplace_back(std::move(ruleObject));
Ed Tanous1abe55e2018-09-05 08:30:59 -07001090
1091 return *ptr;
Ed Tanous7045c8d2017-04-03 10:04:37 -07001092 }
1093
Tanousf00032d2018-11-05 01:18:10 -03001094 void internalAddRuleObject(const std::string& rule, BaseRule* ruleObject)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001095 {
Tanousf00032d2018-11-05 01:18:10 -03001096 if (ruleObject == nullptr)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001097 {
Tanousf00032d2018-11-05 01:18:10 -03001098 return;
1099 }
Ed Tanous888880a2020-08-24 13:48:50 -07001100 for (size_t method = 0, methodBit = 1; method < maxHttpVerbCount;
Ed Tanous2c70f802020-09-28 14:29:23 -07001101 method++, methodBit <<= 1)
Tanousf00032d2018-11-05 01:18:10 -03001102 {
Ed Tanouse662eae2022-01-25 10:39:19 -08001103 if ((ruleObject->methodsBitfield & methodBit) > 0U)
Tanousf00032d2018-11-05 01:18:10 -03001104 {
1105 perMethods[method].rules.emplace_back(ruleObject);
1106 perMethods[method].trie.add(
Ed Tanous271584a2019-07-09 16:24:22 -07001107 rule, static_cast<unsigned>(
1108 perMethods[method].rules.size() - 1U));
Tanousf00032d2018-11-05 01:18:10 -03001109 // directory case:
1110 // request to `/about' url matches `/about/' rule
1111 if (rule.size() > 2 && rule.back() == '/')
1112 {
1113 perMethods[method].trie.add(
1114 rule.substr(0, rule.size() - 1),
Ed Tanous271584a2019-07-09 16:24:22 -07001115 static_cast<unsigned>(perMethods[method].rules.size() -
1116 1));
Tanousf00032d2018-11-05 01:18:10 -03001117 }
1118 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001119 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001120 }
1121
Ed Tanous1abe55e2018-09-05 08:30:59 -07001122 void validate()
1123 {
Tanousf00032d2018-11-05 01:18:10 -03001124 for (std::unique_ptr<BaseRule>& rule : allRules)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001125 {
1126 if (rule)
1127 {
Tanousf00032d2018-11-05 01:18:10 -03001128 std::unique_ptr<BaseRule> upgraded = rule->upgrade();
Ed Tanous1abe55e2018-09-05 08:30:59 -07001129 if (upgraded)
Ed Tanous3174e4d2020-10-07 11:41:22 -07001130 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001131 rule = std::move(upgraded);
Ed Tanous3174e4d2020-10-07 11:41:22 -07001132 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001133 rule->validate();
Tanousf00032d2018-11-05 01:18:10 -03001134 internalAddRuleObject(rule->rule, rule.get());
Ed Tanous1abe55e2018-09-05 08:30:59 -07001135 }
1136 }
Tanousf00032d2018-11-05 01:18:10 -03001137 for (PerMethod& perMethod : perMethods)
1138 {
1139 perMethod.trie.validate();
1140 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001141 }
1142
Ed Tanous1abe55e2018-09-05 08:30:59 -07001143 template <typename Adaptor>
1144 void handleUpgrade(const Request& req, Response& res, Adaptor&& adaptor)
1145 {
Ed Tanous271584a2019-07-09 16:24:22 -07001146 if (static_cast<size_t>(req.method()) >= perMethods.size())
Ed Tanous888880a2020-08-24 13:48:50 -07001147 {
1148 res.result(boost::beast::http::status::not_found);
1149 res.end();
Tanousf00032d2018-11-05 01:18:10 -03001150 return;
Ed Tanous888880a2020-08-24 13:48:50 -07001151 }
Tanousf00032d2018-11-05 01:18:10 -03001152
Ed Tanous271584a2019-07-09 16:24:22 -07001153 PerMethod& perMethod = perMethods[static_cast<size_t>(req.method())];
Tanousf00032d2018-11-05 01:18:10 -03001154 Trie& trie = perMethod.trie;
1155 std::vector<BaseRule*>& rules = perMethod.rules;
1156
1157 const std::pair<unsigned, RoutingParams>& found = trie.find(req.url);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001158 unsigned ruleIndex = found.first;
Ed Tanouse662eae2022-01-25 10:39:19 -08001159 if (ruleIndex == 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001160 {
1161 BMCWEB_LOG_DEBUG << "Cannot match rules " << req.url;
Ed Tanousde5c9f32019-03-26 09:17:55 -07001162 res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001163 res.end();
1164 return;
1165 }
1166
1167 if (ruleIndex >= rules.size())
Ed Tanous3174e4d2020-10-07 11:41:22 -07001168 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001169 throw std::runtime_error("Trie internal structure corrupted!");
Ed Tanous3174e4d2020-10-07 11:41:22 -07001170 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001171
1172 if (ruleIndex == ruleSpecialRedirectSlash)
1173 {
1174 BMCWEB_LOG_INFO << "Redirecting to a url with trailing slash: "
1175 << req.url;
Ed Tanousde5c9f32019-03-26 09:17:55 -07001176 res.result(boost::beast::http::status::moved_permanently);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001177
1178 // TODO absolute url building
1179 if (req.getHeaderValue("Host").empty())
1180 {
1181 res.addHeader("Location", std::string(req.url) + "/");
1182 }
1183 else
1184 {
1185 res.addHeader(
1186 "Location",
1187 req.isSecure
1188 ? "https://"
1189 : "http://" + std::string(req.getHeaderValue("Host")) +
1190 std::string(req.url) + "/");
1191 }
1192 res.end();
1193 return;
1194 }
1195
Ed Tanous271584a2019-07-09 16:24:22 -07001196 if ((rules[ruleIndex]->getMethods() &
1197 (1U << static_cast<size_t>(req.method()))) == 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001198 {
1199 BMCWEB_LOG_DEBUG << "Rule found but method mismatch: " << req.url
1200 << " with " << req.methodString() << "("
Ed Tanous271584a2019-07-09 16:24:22 -07001201 << static_cast<uint32_t>(req.method()) << ") / "
Ed Tanous1abe55e2018-09-05 08:30:59 -07001202 << rules[ruleIndex]->getMethods();
Ed Tanousde5c9f32019-03-26 09:17:55 -07001203 res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001204 res.end();
1205 return;
1206 }
1207
1208 BMCWEB_LOG_DEBUG << "Matched rule (upgrade) '" << rules[ruleIndex]->rule
Ed Tanous271584a2019-07-09 16:24:22 -07001209 << "' " << static_cast<uint32_t>(req.method()) << " / "
Ed Tanous1abe55e2018-09-05 08:30:59 -07001210 << rules[ruleIndex]->getMethods();
1211
1212 // any uncaught exceptions become 500s
1213 try
1214 {
Ed Tanousf94c4ec2022-01-06 12:44:41 -08001215 rules[ruleIndex]->handleUpgrade(req, res,
1216 std::forward<Adaptor>(adaptor));
Ed Tanous1abe55e2018-09-05 08:30:59 -07001217 }
Patrick Williamsc5967042021-10-06 12:39:54 -05001218 catch (const std::exception& e)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001219 {
1220 BMCWEB_LOG_ERROR << "An uncaught exception occurred: " << e.what();
Ed Tanousde5c9f32019-03-26 09:17:55 -07001221 res.result(boost::beast::http::status::internal_server_error);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001222 res.end();
1223 return;
1224 }
1225 catch (...)
1226 {
1227 BMCWEB_LOG_ERROR
1228 << "An uncaught exception occurred. The type was unknown "
1229 "so no information was available.";
Ed Tanousde5c9f32019-03-26 09:17:55 -07001230 res.result(boost::beast::http::status::internal_server_error);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001231 res.end();
1232 return;
1233 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001234 }
1235
zhanghch058d1b46d2021-04-01 11:18:24 +08001236 void handle(Request& req,
1237 const std::shared_ptr<bmcweb::AsyncResp>& asyncResp)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001238 {
Ed Tanous271584a2019-07-09 16:24:22 -07001239 if (static_cast<size_t>(req.method()) >= perMethods.size())
Ed Tanous888880a2020-08-24 13:48:50 -07001240 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001241 asyncResp->res.result(boost::beast::http::status::not_found);
Tanousf00032d2018-11-05 01:18:10 -03001242 return;
Ed Tanous888880a2020-08-24 13:48:50 -07001243 }
Ed Tanous271584a2019-07-09 16:24:22 -07001244 PerMethod& perMethod = perMethods[static_cast<size_t>(req.method())];
Tanousf00032d2018-11-05 01:18:10 -03001245 Trie& trie = perMethod.trie;
1246 std::vector<BaseRule*>& rules = perMethod.rules;
1247
1248 const std::pair<unsigned, RoutingParams>& found = trie.find(req.url);
Ed Tanous7045c8d2017-04-03 10:04:37 -07001249
Ed Tanous1abe55e2018-09-05 08:30:59 -07001250 unsigned ruleIndex = found.first;
1251
Ed Tanouse662eae2022-01-25 10:39:19 -08001252 if (ruleIndex == 0U)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001253 {
Ed Tanous2634dcd2019-03-26 09:28:06 -07001254 // Check to see if this url exists at any verb
1255 for (const PerMethod& p : perMethods)
1256 {
Ed Tanous23a21a12020-07-25 04:45:05 +00001257 const std::pair<unsigned, RoutingParams>& found2 =
Ed Tanous2634dcd2019-03-26 09:28:06 -07001258 p.trie.find(req.url);
Ed Tanous23a21a12020-07-25 04:45:05 +00001259 if (found2.first > 0)
Ed Tanous2634dcd2019-03-26 09:28:06 -07001260 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001261 asyncResp->res.result(
1262 boost::beast::http::status::method_not_allowed);
Ed Tanous2634dcd2019-03-26 09:28:06 -07001263 return;
1264 }
1265 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001266 BMCWEB_LOG_DEBUG << "Cannot match rules " << req.url;
zhanghch058d1b46d2021-04-01 11:18:24 +08001267 asyncResp->res.result(boost::beast::http::status::not_found);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001268 return;
1269 }
1270
1271 if (ruleIndex >= rules.size())
Ed Tanous3174e4d2020-10-07 11:41:22 -07001272 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001273 throw std::runtime_error("Trie internal structure corrupted!");
Ed Tanous3174e4d2020-10-07 11:41:22 -07001274 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001275
1276 if (ruleIndex == ruleSpecialRedirectSlash)
1277 {
1278 BMCWEB_LOG_INFO << "Redirecting to a url with trailing slash: "
1279 << req.url;
zhanghch058d1b46d2021-04-01 11:18:24 +08001280 asyncResp->res.result(
1281 boost::beast::http::status::moved_permanently);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001282
1283 // TODO absolute url building
1284 if (req.getHeaderValue("Host").empty())
1285 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001286 asyncResp->res.addHeader("Location",
1287 std::string(req.url) + "/");
Ed Tanous1abe55e2018-09-05 08:30:59 -07001288 }
1289 else
1290 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001291 asyncResp->res.addHeader(
1292 "Location", (req.isSecure ? "https://" : "http://") +
1293 std::string(req.getHeaderValue("Host")) +
1294 std::string(req.url) + "/");
Ed Tanous1abe55e2018-09-05 08:30:59 -07001295 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001296 return;
1297 }
1298
Ed Tanous271584a2019-07-09 16:24:22 -07001299 if ((rules[ruleIndex]->getMethods() &
1300 (1U << static_cast<uint32_t>(req.method()))) == 0)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001301 {
1302 BMCWEB_LOG_DEBUG << "Rule found but method mismatch: " << req.url
1303 << " with " << req.methodString() << "("
Ed Tanous271584a2019-07-09 16:24:22 -07001304 << static_cast<uint32_t>(req.method()) << ") / "
Ed Tanous1abe55e2018-09-05 08:30:59 -07001305 << rules[ruleIndex]->getMethods();
zhanghch058d1b46d2021-04-01 11:18:24 +08001306 asyncResp->res.result(
1307 boost::beast::http::status::method_not_allowed);
Ed Tanous1abe55e2018-09-05 08:30:59 -07001308 return;
1309 }
1310
1311 BMCWEB_LOG_DEBUG << "Matched rule '" << rules[ruleIndex]->rule << "' "
Ed Tanous271584a2019-07-09 16:24:22 -07001312 << static_cast<uint32_t>(req.method()) << " / "
Ed Tanous1abe55e2018-09-05 08:30:59 -07001313 << rules[ruleIndex]->getMethods();
1314
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001315 if (req.session == nullptr)
James Feist7166bf02019-12-10 16:52:14 +00001316 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001317 rules[ruleIndex]->handle(req, asyncResp, found.second);
James Feist7166bf02019-12-10 16:52:14 +00001318 return;
1319 }
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001320
1321 crow::connections::systemBus->async_method_call(
Ed Tanous168e20c2021-12-13 14:39:53 -08001322 [&req, asyncResp, &rules, ruleIndex,
1323 found](const boost::system::error_code ec,
1324 const std::map<std::string, dbus::utility::DbusVariantType>&
1325 userInfo) {
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001326 if (ec)
1327 {
1328 BMCWEB_LOG_ERROR << "GetUserInfo failed...";
zhanghch058d1b46d2021-04-01 11:18:24 +08001329 asyncResp->res.result(
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001330 boost::beast::http::status::internal_server_error);
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001331 return;
1332 }
1333
1334 const std::string* userRolePtr = nullptr;
1335 auto userInfoIter = userInfo.find("UserPrivilege");
1336 if (userInfoIter != userInfo.end())
1337 {
1338 userRolePtr =
1339 std::get_if<std::string>(&userInfoIter->second);
1340 }
1341
1342 std::string userRole{};
1343 if (userRolePtr != nullptr)
1344 {
1345 userRole = *userRolePtr;
1346 BMCWEB_LOG_DEBUG << "userName = " << req.session->username
1347 << " userRole = " << *userRolePtr;
1348 }
1349
Ed Tanous5dc924d2021-12-20 09:17:28 -08001350 const bool* remoteUserPtr = nullptr;
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001351 auto remoteUserIter = userInfo.find("RemoteUser");
1352 if (remoteUserIter != userInfo.end())
1353 {
1354 remoteUserPtr = std::get_if<bool>(&remoteUserIter->second);
1355 }
1356 if (remoteUserPtr == nullptr)
1357 {
1358 BMCWEB_LOG_ERROR
1359 << "RemoteUser property missing or wrong type";
zhanghch058d1b46d2021-04-01 11:18:24 +08001360 asyncResp->res.result(
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001361 boost::beast::http::status::internal_server_error);
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001362 return;
1363 }
1364 bool remoteUser = *remoteUserPtr;
1365
1366 bool passwordExpired = false; // default for remote user
1367 if (!remoteUser)
1368 {
Ed Tanous5dc924d2021-12-20 09:17:28 -08001369 const bool* passwordExpiredPtr = nullptr;
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001370 auto passwordExpiredIter =
1371 userInfo.find("UserPasswordExpired");
1372 if (passwordExpiredIter != userInfo.end())
1373 {
1374 passwordExpiredPtr =
1375 std::get_if<bool>(&passwordExpiredIter->second);
1376 }
1377 if (passwordExpiredPtr != nullptr)
1378 {
1379 passwordExpired = *passwordExpiredPtr;
1380 }
1381 else
1382 {
1383 BMCWEB_LOG_ERROR
1384 << "UserPasswordExpired property is expected for"
1385 " local user but is missing or wrong type";
zhanghch058d1b46d2021-04-01 11:18:24 +08001386 asyncResp->res.result(
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001387 boost::beast::http::status::internal_server_error);
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001388 return;
1389 }
1390 }
1391
Ed Tanous23a21a12020-07-25 04:45:05 +00001392 // Get the userprivileges from the role
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001393 redfish::Privileges userPrivileges =
1394 redfish::getUserPrivileges(userRole);
1395
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001396 // Set isConfigureSelfOnly based on D-Bus results. This
1397 // ignores the results from both pamAuthenticateUser and the
1398 // value from any previous use of this session.
1399 req.session->isConfigureSelfOnly = passwordExpired;
1400
Ed Tanous23a21a12020-07-25 04:45:05 +00001401 // Modifyprivileges if isConfigureSelfOnly.
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001402 if (req.session->isConfigureSelfOnly)
1403 {
Ed Tanous23a21a12020-07-25 04:45:05 +00001404 // Remove allprivileges except ConfigureSelf
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001405 userPrivileges = userPrivileges.intersection(
1406 redfish::Privileges{"ConfigureSelf"});
1407 BMCWEB_LOG_DEBUG << "Operation limited to ConfigureSelf";
1408 }
1409
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001410 if (!rules[ruleIndex]->checkPrivileges(userPrivileges))
1411 {
zhanghch058d1b46d2021-04-01 11:18:24 +08001412 asyncResp->res.result(
1413 boost::beast::http::status::forbidden);
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001414 if (req.session->isConfigureSelfOnly)
1415 {
1416 redfish::messages::passwordChangeRequired(
zhanghch058d1b46d2021-04-01 11:18:24 +08001417 asyncResp->res,
Ed Tanousace85d62021-10-26 12:45:59 -07001418 crow::utility::urlFromPieces(
1419 "redfish", "v1", "AccountService", "Accounts",
1420 req.session->username));
Joseph Reynolds3bf4e632020-02-06 14:44:32 -06001421 }
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001422 return;
1423 }
1424
1425 req.userRole = userRole;
zhanghch058d1b46d2021-04-01 11:18:24 +08001426 rules[ruleIndex]->handle(req, asyncResp, found.second);
RAJESWARAN THILLAIGOVINDAN61dbeef2019-12-13 04:26:54 -06001427 },
1428 "xyz.openbmc_project.User.Manager", "/xyz/openbmc_project/user",
1429 "xyz.openbmc_project.User.Manager", "GetUserInfo",
1430 req.session->username);
Ed Tanous7045c8d2017-04-03 10:04:37 -07001431 }
Ed Tanous7045c8d2017-04-03 10:04:37 -07001432
Ed Tanous1abe55e2018-09-05 08:30:59 -07001433 void debugPrint()
1434 {
Ed Tanous271584a2019-07-09 16:24:22 -07001435 for (size_t i = 0; i < perMethods.size(); i++)
Tanousf00032d2018-11-05 01:18:10 -03001436 {
Ed Tanous23a21a12020-07-25 04:45:05 +00001437 BMCWEB_LOG_DEBUG << boost::beast::http::to_string(
1438 static_cast<boost::beast::http::verb>(i));
Tanousf00032d2018-11-05 01:18:10 -03001439 perMethods[i].trie.debugPrint();
1440 }
Ed Tanous3dac7492017-08-02 13:46:20 -07001441 }
Ed Tanousb4a7bfa2017-04-04 17:23:00 -07001442
Ed Tanous1abe55e2018-09-05 08:30:59 -07001443 std::vector<const std::string*> getRoutes(const std::string& parent)
1444 {
Ed Tanous1abe55e2018-09-05 08:30:59 -07001445 std::vector<const std::string*> ret;
Tanousf00032d2018-11-05 01:18:10 -03001446
1447 for (const PerMethod& pm : perMethods)
Ed Tanous1abe55e2018-09-05 08:30:59 -07001448 {
Tanousf00032d2018-11-05 01:18:10 -03001449 std::vector<unsigned> x;
1450 pm.trie.findRouteIndexes(parent, x);
1451 for (unsigned index : x)
1452 {
1453 ret.push_back(&pm.rules[index]->rule);
1454 }
Ed Tanous1abe55e2018-09-05 08:30:59 -07001455 }
1456 return ret;
1457 }
1458
1459 private:
Tanousf00032d2018-11-05 01:18:10 -03001460 struct PerMethod
1461 {
1462 std::vector<BaseRule*> rules;
1463 Trie trie;
1464 // rule index 0, 1 has special meaning; preallocate it to avoid
1465 // duplication.
1466 PerMethod() : rules(2)
Gunnar Mills1214b7e2020-06-04 10:11:30 -05001467 {}
Tanousf00032d2018-11-05 01:18:10 -03001468 };
Ed Tanous888880a2020-08-24 13:48:50 -07001469
1470 const static size_t maxHttpVerbCount =
Ed Tanouscc090442020-10-07 08:20:50 -07001471 static_cast<size_t>(boost::beast::http::verb::unlink);
Ed Tanous888880a2020-08-24 13:48:50 -07001472
Tanousf00032d2018-11-05 01:18:10 -03001473 std::array<PerMethod, maxHttpVerbCount> perMethods;
1474 std::vector<std::unique_ptr<BaseRule>> allRules;
Ed Tanous7045c8d2017-04-03 10:04:37 -07001475};
Ed Tanous1abe55e2018-09-05 08:30:59 -07001476} // namespace crow