blob: 175912d577faa9f390563de2f4ff1edca9acc808 [file] [log] [blame]
Ed Tanous7045c8d2017-04-03 10:04:37 -07001#pragma once
Ed Tanous75312982021-02-11 14:26:02 -08002#include "bmcweb_config.h"
Adriana Kobylak0e1cf262019-12-05 13:57:57 -06003
Ed Tanousd093c992023-01-19 19:01:49 -08004#include "async_resp.hpp"
Nan Zhoud055a342022-05-25 01:15:34 +00005#include "authentication.hpp"
Ed Tanoused5f8952023-06-22 14:06:22 -07006#include "complete_response_fields.hpp"
Ed Tanousfca2cbe2021-01-28 14:49:59 -08007#include "http2_connection.hpp"
Ed Tanous04e438c2020-10-03 08:06:26 -07008#include "http_response.hpp"
Ed Tanous1abe55e2018-09-05 08:30:59 -07009#include "http_utility.hpp"
Ed Tanous04e438c2020-10-03 08:06:26 -070010#include "logging.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080011#include "mutual_tls.hpp"
Ed Tanous3ccb3ad2023-01-13 17:40:03 -080012#include "ssl_key_handler.hpp"
Ed Tanous04e438c2020-10-03 08:06:26 -070013#include "utility.hpp"
Ed Tanous1abe55e2018-09-05 08:30:59 -070014
Ed Tanous257f5792018-03-17 14:40:09 -070015#include <boost/algorithm/string/predicate.hpp>
Ed Tanous8f626352018-12-19 14:51:54 -080016#include <boost/asio/io_context.hpp>
Ed Tanous3112a142018-11-29 15:45:10 -080017#include <boost/asio/ip/tcp.hpp>
Ed Tanousd43cd0c2020-09-30 20:46:53 -070018#include <boost/asio/ssl/stream.hpp>
Ed Tanous5dfb5b22021-12-03 11:24:53 -080019#include <boost/asio/steady_timer.hpp>
Ed Tanous4fa45df2023-09-01 14:20:50 -070020#include <boost/beast/_experimental/test/stream.hpp>
Ed Tanous27b0cf92023-08-07 12:02:40 -070021#include <boost/beast/core/buffers_generator.hpp>
Ed Tanous3112a142018-11-29 15:45:10 -080022#include <boost/beast/core/flat_static_buffer.hpp>
Myung Baea4326fe2023-01-10 14:29:24 -060023#include <boost/beast/http/error.hpp>
Ed Tanous918ef252022-05-25 10:40:41 -070024#include <boost/beast/http/parser.hpp>
25#include <boost/beast/http/read.hpp>
Ed Tanous918ef252022-05-25 10:40:41 -070026#include <boost/beast/http/write.hpp>
Manojkiran Eda44250442020-06-16 12:51:38 +053027#include <boost/beast/ssl/ssl_stream.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050028#include <boost/beast/websocket.hpp>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050029
Manojkiran Eda44250442020-06-16 12:51:38 +053030#include <atomic>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050031#include <chrono>
32#include <vector>
33
Ed Tanous1abe55e2018-09-05 08:30:59 -070034namespace crow
35{
Ed Tanous257f5792018-03-17 14:40:09 -070036
Ed Tanouscf9e4172022-12-21 09:30:16 -080037// NOLINTNEXTLINE(cppcoreguidelines-avoid-non-const-global-variables)
Ed Tanous6fbdbca2021-12-06 14:36:06 -080038static int connectionCount = 0;
Jennifer Leeacb7cfb2018-06-07 16:08:15 -070039
Ed Tanous0260d9d2021-02-07 19:31:07 +000040// request body limit size set by the bmcwebHttpReqBodyLimitMb option
Patrick Williams89492a12023-05-10 07:51:34 -050041constexpr uint64_t httpReqBodyLimit = 1024UL * 1024UL *
42 bmcwebHttpReqBodyLimitMb;
Jennifer Leeacb7cfb2018-06-07 16:08:15 -070043
James Feist3909dc82020-04-03 10:58:55 -070044constexpr uint64_t loggedOutPostBodyLimit = 4096;
45
46constexpr uint32_t httpHeaderLimit = 8192;
47
Ed Tanous4fa45df2023-09-01 14:20:50 -070048template <typename>
49struct IsTls : std::false_type
50{};
51
52template <typename T>
53struct IsTls<boost::beast::ssl_stream<T>> : std::true_type
54{};
55
Ed Tanous52cc1122020-07-18 13:51:21 -070056template <typename Adaptor, typename Handler>
Gunnar Mills1214b7e2020-06-04 10:11:30 -050057class Connection :
Ed Tanous52cc1122020-07-18 13:51:21 -070058 public std::enable_shared_from_this<Connection<Adaptor, Handler>>
Ed Tanous1abe55e2018-09-05 08:30:59 -070059{
Ed Tanous7c8e0642022-02-21 12:11:14 -080060 using self_type = Connection<Adaptor, Handler>;
61
Ed Tanous1abe55e2018-09-05 08:30:59 -070062 public:
Ed Tanous5dfb5b22021-12-03 11:24:53 -080063 Connection(Handler* handlerIn, boost::asio::steady_timer&& timerIn,
Ed Tanous81ce6092020-12-17 16:54:55 +000064 std::function<std::string()>& getCachedDateStrF,
Ed Tanous5dfb5b22021-12-03 11:24:53 -080065 Adaptor adaptorIn) :
Ed Tanousceac6f72018-12-02 11:58:47 -080066 adaptor(std::move(adaptorIn)),
Ed Tanous5dfb5b22021-12-03 11:24:53 -080067 handler(handlerIn), timer(std::move(timerIn)),
68 getCachedDateStr(getCachedDateStrF)
Ed Tanous1abe55e2018-09-05 08:30:59 -070069 {
70 parser.emplace(std::piecewise_construct, std::make_tuple());
Ed Tanous1abe55e2018-09-05 08:30:59 -070071 parser->body_limit(httpReqBodyLimit);
James Feist3909dc82020-04-03 10:58:55 -070072 parser->header_limit(httpHeaderLimit);
Kowalski, Kamil55e43f62019-07-10 13:12:57 +020073
74#ifdef BMCWEB_ENABLE_MUTUAL_TLS_AUTHENTICATION
Ed Tanous40aa0582021-07-14 13:24:40 -070075 prepareMutualTls();
76#endif // BMCWEB_ENABLE_MUTUAL_TLS_AUTHENTICATION
77
Ed Tanous40aa0582021-07-14 13:24:40 -070078 connectionCount++;
Ed Tanous6fbdbca2021-12-06 14:36:06 -080079
Ed Tanous62598e32023-07-17 17:06:25 -070080 BMCWEB_LOG_DEBUG("{} Connection open, total {}", logPtr(this),
81 connectionCount);
Ed Tanous40aa0582021-07-14 13:24:40 -070082 }
83
84 ~Connection()
85 {
John Edward Broadbent4147b8a2021-07-19 16:52:24 -070086 res.setCompleteRequestHandler(nullptr);
Ed Tanous40aa0582021-07-14 13:24:40 -070087 cancelDeadlineTimer();
Ed Tanous6fbdbca2021-12-06 14:36:06 -080088
Ed Tanous40aa0582021-07-14 13:24:40 -070089 connectionCount--;
Ed Tanous62598e32023-07-17 17:06:25 -070090 BMCWEB_LOG_DEBUG("{} Connection closed, total {}", logPtr(this),
91 connectionCount);
Ed Tanous40aa0582021-07-14 13:24:40 -070092 }
93
Ed Tanousecd6a3a2022-01-07 09:18:40 -080094 Connection(const Connection&) = delete;
95 Connection(Connection&&) = delete;
96 Connection& operator=(const Connection&) = delete;
97 Connection& operator=(Connection&&) = delete;
98
Ed Tanous7c8e0642022-02-21 12:11:14 -080099 bool tlsVerifyCallback(bool preverified,
100 boost::asio::ssl::verify_context& ctx)
101 {
102 // We always return true to allow full auth flow for resources that
103 // don't require auth
104 if (preverified)
105 {
Michal Orzel7aa9ab02023-08-18 16:59:11 +0200106 boost::asio::ip::address ipAddress;
107 if (getClientIp(ipAddress))
Ed Tanouse01d0c32023-06-30 13:21:32 -0700108 {
Michal Orzel7aa9ab02023-08-18 16:59:11 +0200109 return true;
Ed Tanouse01d0c32023-06-30 13:21:32 -0700110 }
Michal Orzel7aa9ab02023-08-18 16:59:11 +0200111
112 mtlsSession = verifyMtlsUser(ipAddress, ctx);
Boleslaw Ogonczyk Makowskib4963072023-02-06 09:59:58 +0100113 if (mtlsSession)
Ed Tanous7c8e0642022-02-21 12:11:14 -0800114 {
Ed Tanous62598e32023-07-17 17:06:25 -0700115 BMCWEB_LOG_DEBUG("{} Generating TLS session: {}", logPtr(this),
116 mtlsSession->uniqueId);
Ed Tanous7c8e0642022-02-21 12:11:14 -0800117 }
118 }
119 return true;
120 }
121
Ed Tanous40aa0582021-07-14 13:24:40 -0700122 void prepareMutualTls()
123 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700124 if constexpr (IsTls<Adaptor>::value)
Zbigniew Kurzynski009c2a42019-11-14 13:37:15 +0100125 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700126 std::error_code error;
127 std::filesystem::path caPath(ensuressl::trustStorePath);
128 auto caAvailable = !std::filesystem::is_empty(caPath, error);
129 caAvailable = caAvailable && !error;
130 if (caAvailable && persistent_data::SessionStore::getInstance()
131 .getAuthMethodsConfig()
132 .tls)
Ed Tanouse7d1a1c2020-09-28 09:36:35 -0700133 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700134 adaptor.set_verify_mode(boost::asio::ssl::verify_peer);
135 std::string id = "bmcweb";
Zbigniew Kurzynski009c2a42019-11-14 13:37:15 +0100136
Ed Tanous4fa45df2023-09-01 14:20:50 -0700137 const char* cStr = id.c_str();
138 // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
139 const auto* idC = reinterpret_cast<const unsigned char*>(cStr);
140 int ret = SSL_set_session_id_context(
141 adaptor.native_handle(), idC,
142 static_cast<unsigned int>(id.length()));
143 if (ret == 0)
144 {
145 BMCWEB_LOG_ERROR("{} failed to set SSL id", logPtr(this));
146 }
147 }
148
149 adaptor.set_verify_callback(
150 std::bind_front(&self_type::tlsVerifyCallback, this));
151 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700152 }
153
Ed Tanousceac6f72018-12-02 11:58:47 -0800154 Adaptor& socket()
Ed Tanous1abe55e2018-09-05 08:30:59 -0700155 {
Ed Tanousceac6f72018-12-02 11:58:47 -0800156 return adaptor;
Ed Tanous7045c8d2017-04-03 10:04:37 -0700157 }
158
Ed Tanous1abe55e2018-09-05 08:30:59 -0700159 void start()
160 {
Ed Tanous6fbdbca2021-12-06 14:36:06 -0800161 if (connectionCount >= 100)
162 {
Ed Tanous62598e32023-07-17 17:06:25 -0700163 BMCWEB_LOG_CRITICAL("{}Max connection count exceeded.",
164 logPtr(this));
Ed Tanous6fbdbca2021-12-06 14:36:06 -0800165 return;
166 }
167
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800168 startDeadline();
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500169
Ed Tanousceac6f72018-12-02 11:58:47 -0800170 // TODO(ed) Abstract this to a more clever class with the idea of an
171 // asynchronous "start"
Ed Tanous4fa45df2023-09-01 14:20:50 -0700172 if constexpr (IsTls<Adaptor>::value)
Ed Tanousceac6f72018-12-02 11:58:47 -0800173 {
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000174 adaptor.async_handshake(boost::asio::ssl::stream_base::server,
175 [this, self(shared_from_this())](
176 const boost::system::error_code& ec) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700177 if (ec)
178 {
179 return;
180 }
Ed Tanousfca2cbe2021-01-28 14:49:59 -0800181 afterSslHandshake();
Ed Tanous002d39b2022-05-31 08:59:27 -0700182 });
Ed Tanousceac6f72018-12-02 11:58:47 -0800183 }
184 else
185 {
186 doReadHeaders();
187 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700188 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700189
Ed Tanousfca2cbe2021-01-28 14:49:59 -0800190 void afterSslHandshake()
191 {
192 // If http2 is enabled, negotiate the protocol
193 if constexpr (bmcwebEnableHTTP2)
194 {
195 const unsigned char* alpn = nullptr;
196 unsigned int alpnlen = 0;
197 SSL_get0_alpn_selected(adaptor.native_handle(), &alpn, &alpnlen);
198 if (alpn != nullptr)
199 {
200 std::string_view selectedProtocol(
201 std::bit_cast<const char*>(alpn), alpnlen);
Ed Tanous62598e32023-07-17 17:06:25 -0700202 BMCWEB_LOG_DEBUG("ALPN selected protocol \"{}\" len: {}",
203 selectedProtocol, alpnlen);
Ed Tanousfca2cbe2021-01-28 14:49:59 -0800204 if (selectedProtocol == "h2")
205 {
206 auto http2 =
207 std::make_shared<HTTP2Connection<Adaptor, Handler>>(
208 std::move(adaptor), handler, getCachedDateStr);
209 http2->start();
210 return;
211 }
212 }
213 }
214
215 doReadHeaders();
216 }
217
Ed Tanous1abe55e2018-09-05 08:30:59 -0700218 void handle()
219 {
Ed Tanousf79b7a52021-09-22 19:04:29 -0700220 std::error_code reqEc;
Ed Tanouse01d0c32023-06-30 13:21:32 -0700221 if (!parser)
222 {
223 return;
224 }
Ed Tanousf79b7a52021-09-22 19:04:29 -0700225 crow::Request& thisReq = req.emplace(parser->release(), reqEc);
226 if (reqEc)
227 {
Ed Tanous62598e32023-07-17 17:06:25 -0700228 BMCWEB_LOG_DEBUG("Request failed to construct{}", reqEc.message());
Gunnar Mills262f1152022-12-20 15:18:47 -0600229 res.result(boost::beast::http::status::bad_request);
230 completeRequest(res);
Ed Tanousf79b7a52021-09-22 19:04:29 -0700231 return;
232 }
Ed Tanous596b2032021-09-13 10:32:22 -0700233 thisReq.session = userSession;
234
Ivan Mikhaylovf65b0be2021-04-19 10:05:30 +0000235 // Fetch the client IP address
236 readClientIp();
237
Ed Tanous1abe55e2018-09-05 08:30:59 -0700238 // Check for HTTP version 1.1.
Ed Tanous596b2032021-09-13 10:32:22 -0700239 if (thisReq.version() == 11)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700240 {
Ed Tanous596b2032021-09-13 10:32:22 -0700241 if (thisReq.getHeaderValue(boost::beast::http::field::host).empty())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700242 {
Ed Tanousde5c9f32019-03-26 09:17:55 -0700243 res.result(boost::beast::http::status::bad_request);
Nan Zhou72374eb2022-01-27 17:06:51 -0800244 completeRequest(res);
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700245 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700246 }
247 }
Ed Tanous7045c8d2017-04-03 10:04:37 -0700248
Ed Tanous62598e32023-07-17 17:06:25 -0700249 BMCWEB_LOG_INFO("Request: {} HTTP/{}.{} {} {} {}", logPtr(this),
250 thisReq.version() / 10, thisReq.version() % 10,
251 thisReq.methodString(), thisReq.target(),
252 thisReq.ipAddress.to_string());
Ed Tanousd32c4fa2021-09-14 13:16:51 -0700253
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700254 res.isAliveHelper = [this]() -> bool { return isAlive(); };
Ed Tanous7045c8d2017-04-03 10:04:37 -0700255
Ed Tanous596b2032021-09-13 10:32:22 -0700256 thisReq.ioService = static_cast<decltype(thisReq.ioService)>(
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700257 &adaptor.get_executor().context());
Kowalski, Kamil55e43f62019-07-10 13:12:57 +0200258
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700259 if (res.completed)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700260 {
Nan Zhou72374eb2022-01-27 17:06:51 -0800261 completeRequest(res);
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700262 return;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700263 }
Ed Tanous4cdc2e82023-01-13 10:03:22 -0800264 keepAlive = thisReq.keepAlive();
Ed Tanous4fa45df2023-09-01 14:20:50 -0700265 if constexpr (!std::is_same_v<Adaptor, boost::beast::test::stream>)
Ed Tanous1d3c14a2021-09-22 18:54:40 -0700266 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700267#ifndef BMCWEB_INSECURE_DISABLE_AUTHX
268 if (!crow::authentication::isOnAllowlist(req->url().path(),
269 req->method()) &&
270 thisReq.session == nullptr)
271 {
272 BMCWEB_LOG_WARNING("Authentication failed");
273 forward_unauthorized::sendUnauthorized(
274 req->url().encoded_path(),
275 req->getHeaderValue("X-Requested-With"),
276 req->getHeaderValue("Accept"), res);
277 completeRequest(res);
278 return;
279 }
Nan Zhoua43ea822022-05-27 00:42:44 +0000280#endif // BMCWEB_INSECURE_DISABLE_AUTHX
Ed Tanous4fa45df2023-09-01 14:20:50 -0700281 }
Nan Zhou72374eb2022-01-27 17:06:51 -0800282 auto asyncResp = std::make_shared<bmcweb::AsyncResp>();
Ed Tanous62598e32023-07-17 17:06:25 -0700283 BMCWEB_LOG_DEBUG("Setting completion handler");
Nan Zhou72374eb2022-01-27 17:06:51 -0800284 asyncResp->res.setCompleteRequestHandler(
285 [self(shared_from_this())](crow::Response& thisRes) {
Ed Tanous002d39b2022-05-31 08:59:27 -0700286 self->completeRequest(thisRes);
287 });
Ed Tanous6fde95f2023-06-01 07:33:34 -0700288 bool isSse =
289 isContentTypeAllowed(req->getHeaderValue("Accept"),
290 http_helpers::ContentType::EventStream, false);
V-Sanjana88ada3b2023-04-13 15:18:31 +0530291 if ((thisReq.isUpgrade() &&
292 boost::iequals(
293 thisReq.getHeaderValue(boost::beast::http::field::upgrade),
294 "websocket")) ||
Ed Tanous6fde95f2023-06-01 07:33:34 -0700295 isSse)
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700296 {
P Dheeraj Srujan Kumara9f076e2021-10-18 22:45:37 +0530297 asyncResp->res.setCompleteRequestHandler(
298 [self(shared_from_this())](crow::Response& thisRes) {
299 if (thisRes.result() != boost::beast::http::status::ok)
300 {
301 // When any error occurs before handle upgradation,
302 // the result in response will be set to respective
303 // error. By default the Result will be OK (200),
304 // which implies successful handle upgrade. Response
305 // needs to be sent over this connection only on
306 // failure.
307 self->completeRequest(thisRes);
308 return;
309 }
310 });
311 handler->handleUpgrade(thisReq, asyncResp, std::move(adaptor));
Ed Tanous6c7f01d2021-08-25 13:42:35 -0700312 return;
313 }
Ed Tanous291d7092022-04-13 12:34:57 -0700314 std::string_view expected =
315 req->getHeaderValue(boost::beast::http::field::if_none_match);
316 if (!expected.empty())
317 {
318 res.setExpectedHash(expected);
319 }
Ed Tanous596b2032021-09-13 10:32:22 -0700320 handler->handle(thisReq, asyncResp);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700321 }
Ed Tanouse0d918b2018-03-27 17:41:04 -0700322
Ed Tanouse278c182019-03-13 16:23:37 -0700323 bool isAlive()
324 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700325 if constexpr (IsTls<Adaptor>::value)
Ed Tanouse278c182019-03-13 16:23:37 -0700326 {
327 return adaptor.next_layer().is_open();
328 }
Ed Tanous4fa45df2023-09-01 14:20:50 -0700329 else if constexpr (std::is_same_v<Adaptor, boost::beast::test::stream>)
330 {
331 return true;
332 }
Ed Tanouse278c182019-03-13 16:23:37 -0700333 else
334 {
335 return adaptor.is_open();
336 }
337 }
338 void close()
339 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700340 if constexpr (IsTls<Adaptor>::value)
Ed Tanouse278c182019-03-13 16:23:37 -0700341 {
342 adaptor.next_layer().close();
Boleslaw Ogonczyk Makowskib4963072023-02-06 09:59:58 +0100343 if (mtlsSession != nullptr)
Kowalski, Kamil55e43f62019-07-10 13:12:57 +0200344 {
Ed Tanous62598e32023-07-17 17:06:25 -0700345 BMCWEB_LOG_DEBUG("{} Removing TLS session: {}", logPtr(this),
346 mtlsSession->uniqueId);
John Edward Broadbent59b98b22021-07-13 15:36:32 -0700347 persistent_data::SessionStore::getInstance().removeSession(
Boleslaw Ogonczyk Makowskib4963072023-02-06 09:59:58 +0100348 mtlsSession);
Kowalski, Kamil55e43f62019-07-10 13:12:57 +0200349 }
Ed Tanouse278c182019-03-13 16:23:37 -0700350 }
351 else
352 {
353 adaptor.close();
354 }
355 }
356
Nan Zhou72374eb2022-01-27 17:06:51 -0800357 void completeRequest(crow::Response& thisRes)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700358 {
Ed Tanousf79b7a52021-09-22 19:04:29 -0700359 if (!req)
360 {
361 return;
362 }
Nan Zhou72374eb2022-01-27 17:06:51 -0800363 res = std::move(thisRes);
Ed Tanous4cdc2e82023-01-13 10:03:22 -0800364 res.keepAlive(keepAlive);
Ed Tanous5ae6f922023-01-09 10:45:53 -0800365
Ed Tanoused5f8952023-06-22 14:06:22 -0700366 completeResponseFields(*req, res);
Ed Tanous998e0cb2023-09-06 13:57:30 -0700367 res.addHeader(boost::beast::http::field::date, getCachedDateStr());
Ed Tanouse278c182019-03-13 16:23:37 -0700368 if (!isAlive())
Ed Tanous1abe55e2018-09-05 08:30:59 -0700369 {
John Edward Broadbent4147b8a2021-07-19 16:52:24 -0700370 res.setCompleteRequestHandler(nullptr);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700371 return;
372 }
Ed Tanous291d7092022-04-13 12:34:57 -0700373
Nan Zhou72374eb2022-01-27 17:06:51 -0800374 doWrite(res);
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000375
376 // delete lambda with self shared_ptr
377 // to enable connection destruction
John Edward Broadbent4147b8a2021-07-19 16:52:24 -0700378 res.setCompleteRequestHandler(nullptr);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700379 }
380
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500381 void readClientIp()
382 {
John Edward Broadbent59b98b22021-07-13 15:36:32 -0700383 boost::asio::ip::address ip;
384 boost::system::error_code ec = getClientIp(ip);
385 if (ec)
386 {
387 return;
388 }
Ed Tanouse01d0c32023-06-30 13:21:32 -0700389 if (!req)
390 {
391 return;
392 }
John Edward Broadbent59b98b22021-07-13 15:36:32 -0700393 req->ipAddress = ip;
394 }
395
396 boost::system::error_code getClientIp(boost::asio::ip::address& ip)
397 {
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500398 boost::system::error_code ec;
Ed Tanous62598e32023-07-17 17:06:25 -0700399 BMCWEB_LOG_DEBUG("Fetch the client IP address");
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500400
Ed Tanous4fa45df2023-09-01 14:20:50 -0700401 if constexpr (!std::is_same_v<Adaptor, boost::beast::test::stream>)
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500402 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700403 boost::asio::ip::tcp::endpoint endpoint =
404 boost::beast::get_lowest_layer(adaptor).remote_endpoint(ec);
405
406 if (ec)
407 {
408 // If remote endpoint fails keep going. "ClientOriginIPAddress"
409 // will be empty.
410 BMCWEB_LOG_ERROR(
411 "Failed to get the client's IP Address. ec : {}", ec);
412 return ec;
413 }
414 ip = endpoint.address();
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500415 }
John Edward Broadbent59b98b22021-07-13 15:36:32 -0700416 return ec;
Sunitha Harishc0ea7ae2020-10-30 02:37:30 -0500417 }
418
Ed Tanous1abe55e2018-09-05 08:30:59 -0700419 private:
420 void doReadHeaders()
421 {
Ed Tanous62598e32023-07-17 17:06:25 -0700422 BMCWEB_LOG_DEBUG("{} doReadHeaders", logPtr(this));
Ed Tanouse01d0c32023-06-30 13:21:32 -0700423 if (!parser)
424 {
425 return;
426 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700427 // Clean up any previous Connection.
428 boost::beast::http::async_read_header(
Ed Tanousceac6f72018-12-02 11:58:47 -0800429 adaptor, buffer, *parser,
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000430 [this,
431 self(shared_from_this())](const boost::system::error_code& ec,
Ed Tanous81ce6092020-12-17 16:54:55 +0000432 std::size_t bytesTransferred) {
Ed Tanous62598e32023-07-17 17:06:25 -0700433 BMCWEB_LOG_DEBUG("{} async_read_header {} Bytes", logPtr(this),
434 bytesTransferred);
Ed Tanous002d39b2022-05-31 08:59:27 -0700435 bool errorWhileReading = false;
436 if (ec)
437 {
438 errorWhileReading = true;
Myung Baea4326fe2023-01-10 14:29:24 -0600439 if (ec == boost::beast::http::error::end_of_stream)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700440 {
Ed Tanous62598e32023-07-17 17:06:25 -0700441 BMCWEB_LOG_WARNING("{} Error while reading: {}",
442 logPtr(this), ec.message());
Ed Tanous1abe55e2018-09-05 08:30:59 -0700443 }
444 else
445 {
Ed Tanous62598e32023-07-17 17:06:25 -0700446 BMCWEB_LOG_ERROR("{} Error while reading: {}", logPtr(this),
447 ec.message());
Ed Tanous1abe55e2018-09-05 08:30:59 -0700448 }
Ed Tanous002d39b2022-05-31 08:59:27 -0700449 }
450 else
451 {
452 // if the adaptor isn't open anymore, and wasn't handed to a
453 // websocket, treat as an error
454 if (!isAlive() &&
455 !boost::beast::websocket::is_upgrade(parser->get()))
Ed Tanous1abe55e2018-09-05 08:30:59 -0700456 {
Ed Tanous002d39b2022-05-31 08:59:27 -0700457 errorWhileReading = true;
458 }
459 }
460
461 cancelDeadlineTimer();
462
463 if (errorWhileReading)
464 {
465 close();
Ed Tanous62598e32023-07-17 17:06:25 -0700466 BMCWEB_LOG_DEBUG("{} from read(1)", logPtr(this));
Ed Tanous002d39b2022-05-31 08:59:27 -0700467 return;
468 }
469
470 readClientIp();
471
472 boost::asio::ip::address ip;
473 if (getClientIp(ip))
474 {
Ed Tanous62598e32023-07-17 17:06:25 -0700475 BMCWEB_LOG_DEBUG("Unable to get client IP");
Ed Tanous002d39b2022-05-31 08:59:27 -0700476 }
Ed Tanous4fa45df2023-09-01 14:20:50 -0700477 if constexpr (!std::is_same_v<Adaptor, boost::beast::test::stream>)
Ed Tanous002d39b2022-05-31 08:59:27 -0700478 {
Ed Tanous4fa45df2023-09-01 14:20:50 -0700479#ifndef BMCWEB_INSECURE_DISABLE_AUTHX
480 boost::beast::http::verb method = parser->get().method();
481 userSession = crow::authentication::authenticate(
482 ip, res, method, parser->get().base(), mtlsSession);
Ed Tanous1abe55e2018-09-05 08:30:59 -0700483
Ed Tanous4fa45df2023-09-01 14:20:50 -0700484 bool loggedIn = userSession != nullptr;
485 if (!loggedIn)
486 {
487 const boost::optional<uint64_t> contentLength =
488 parser->content_length();
489 if (contentLength &&
490 *contentLength > loggedOutPostBodyLimit)
491 {
492 BMCWEB_LOG_DEBUG("Content length greater than limit {}",
493 *contentLength);
494 close();
495 return;
496 }
497
498 BMCWEB_LOG_DEBUG("Starting quick deadline");
499 }
Nan Zhoua43ea822022-05-27 00:42:44 +0000500#endif // BMCWEB_INSECURE_DISABLE_AUTHX
Ed Tanous4fa45df2023-09-01 14:20:50 -0700501 }
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800502
Ed Tanous7d243eb2023-01-23 15:57:41 -0800503 if (parser->is_done())
504 {
505 handle();
506 return;
507 }
508
Ed Tanous002d39b2022-05-31 08:59:27 -0700509 doRead();
Patrick Williams5a39f772023-10-20 11:20:21 -0500510 });
Ed Tanous1abe55e2018-09-05 08:30:59 -0700511 }
512
513 void doRead()
514 {
Ed Tanous62598e32023-07-17 17:06:25 -0700515 BMCWEB_LOG_DEBUG("{} doRead", logPtr(this));
Ed Tanouse01d0c32023-06-30 13:21:32 -0700516 if (!parser)
517 {
518 return;
519 }
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800520 startDeadline();
Ed Tanous7d243eb2023-01-23 15:57:41 -0800521 boost::beast::http::async_read_some(
522 adaptor, buffer, *parser,
523 [this,
524 self(shared_from_this())](const boost::system::error_code& ec,
525 std::size_t bytesTransferred) {
Ed Tanous62598e32023-07-17 17:06:25 -0700526 BMCWEB_LOG_DEBUG("{} async_read_some {} Bytes", logPtr(this),
527 bytesTransferred);
Ed Tanous7d243eb2023-01-23 15:57:41 -0800528
Ed Tanous002d39b2022-05-31 08:59:27 -0700529 if (ec)
530 {
Ed Tanous62598e32023-07-17 17:06:25 -0700531 BMCWEB_LOG_ERROR("{} Error while reading: {}", logPtr(this),
532 ec.message());
Ed Tanous002d39b2022-05-31 08:59:27 -0700533 close();
Ed Tanous62598e32023-07-17 17:06:25 -0700534 BMCWEB_LOG_DEBUG("{} from read(1)", logPtr(this));
Ed Tanous002d39b2022-05-31 08:59:27 -0700535 return;
536 }
Ed Tanous7d243eb2023-01-23 15:57:41 -0800537
538 // If the user is logged in, allow them to send files incrementally
539 // one piece at a time. If authentication is disabled then there is
540 // no user session hence always allow to send one piece at a time.
541 if (userSession != nullptr)
542 {
543 cancelDeadlineTimer();
544 }
545 if (!parser->is_done())
546 {
547 doRead();
548 return;
549 }
550
551 cancelDeadlineTimer();
Ed Tanous002d39b2022-05-31 08:59:27 -0700552 handle();
Patrick Williams5a39f772023-10-20 11:20:21 -0500553 });
Ed Tanous1abe55e2018-09-05 08:30:59 -0700554 }
555
Ed Tanous27b0cf92023-08-07 12:02:40 -0700556 void afterDoWrite(const std::shared_ptr<self_type>& /*self*/,
557 const boost::system::error_code& ec,
558 std::size_t bytesTransferred)
559 {
560 BMCWEB_LOG_DEBUG("{} async_write {} bytes", logPtr(this),
561 bytesTransferred);
562
563 cancelDeadlineTimer();
564
565 if (ec)
566 {
567 BMCWEB_LOG_DEBUG("{} from write(2)", logPtr(this));
568 return;
569 }
570 if (!keepAlive)
571 {
572 close();
573 BMCWEB_LOG_DEBUG("{} from write(1)", logPtr(this));
574 return;
575 }
576
577 BMCWEB_LOG_DEBUG("{} Clearing response", logPtr(this));
578 res.clear();
579 parser.emplace(std::piecewise_construct, std::make_tuple());
580 parser->body_limit(httpReqBodyLimit); // reset body limit for
581 // newly created parser
582 buffer.consume(buffer.size());
583
584 userSession = nullptr;
585
586 // Destroy the Request via the std::optional
587 req.reset();
588 doReadHeaders();
589 }
590
Nan Zhou72374eb2022-01-27 17:06:51 -0800591 void doWrite(crow::Response& thisRes)
Ed Tanous1abe55e2018-09-05 08:30:59 -0700592 {
Ed Tanous62598e32023-07-17 17:06:25 -0700593 BMCWEB_LOG_DEBUG("{} doWrite", logPtr(this));
Nan Zhou72374eb2022-01-27 17:06:51 -0800594 thisRes.preparePayload();
Ed Tanous27b0cf92023-08-07 12:02:40 -0700595
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800596 startDeadline();
Ed Tanous27b0cf92023-08-07 12:02:40 -0700597 boost::beast::async_write(adaptor, thisRes.generator(),
598 std::bind_front(&self_type::afterDoWrite,
599 this, shared_from_this()));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700600 }
601
Ed Tanous1abe55e2018-09-05 08:30:59 -0700602 void cancelDeadlineTimer()
603 {
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800604 timer.cancel();
Ed Tanous1abe55e2018-09-05 08:30:59 -0700605 }
606
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800607 void startDeadline()
Ed Tanous1abe55e2018-09-05 08:30:59 -0700608 {
Ed Tanous7d243eb2023-01-23 15:57:41 -0800609 // Timer is already started so no further action is required.
610 if (timerStarted)
611 {
612 return;
613 }
Ed Tanous1abe55e2018-09-05 08:30:59 -0700614
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800615 std::chrono::seconds timeout(15);
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800616
617 std::weak_ptr<Connection<Adaptor, Handler>> weakSelf = weak_from_this();
618 timer.expires_after(timeout);
Ed Tanous81c4e332023-05-18 10:30:34 -0700619 timer.async_wait([weakSelf](const boost::system::error_code& ec) {
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800620 // Note, we are ignoring other types of errors here; If the timer
621 // failed for any reason, we should still close the connection
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800622 std::shared_ptr<Connection<Adaptor, Handler>> self =
623 weakSelf.lock();
624 if (!self)
625 {
Ed Tanous62598e32023-07-17 17:06:25 -0700626 BMCWEB_LOG_CRITICAL("{} Failed to capture connection",
627 logPtr(self.get()));
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800628 return;
629 }
Ed Tanous7d243eb2023-01-23 15:57:41 -0800630
631 self->timerStarted = false;
632
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800633 if (ec == boost::asio::error::operation_aborted)
634 {
635 // Canceled wait means the path succeeeded.
636 return;
637 }
638 if (ec)
639 {
Ed Tanous62598e32023-07-17 17:06:25 -0700640 BMCWEB_LOG_CRITICAL("{} timer failed {}", logPtr(self.get()),
641 ec);
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800642 }
643
Ed Tanous62598e32023-07-17 17:06:25 -0700644 BMCWEB_LOG_WARNING("{}Connection timed out, closing",
645 logPtr(self.get()));
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800646
647 self->close();
648 });
649
Ed Tanous7d243eb2023-01-23 15:57:41 -0800650 timerStarted = true;
Ed Tanous62598e32023-07-17 17:06:25 -0700651 BMCWEB_LOG_DEBUG("{} timer started", logPtr(this));
Ed Tanous1abe55e2018-09-05 08:30:59 -0700652 }
653
Ed Tanous1abe55e2018-09-05 08:30:59 -0700654 Adaptor adaptor;
655 Handler* handler;
Ed Tanousa24526d2018-12-10 15:17:59 -0800656 // Making this a std::optional allows it to be efficiently destroyed and
Ed Tanous1abe55e2018-09-05 08:30:59 -0700657 // re-created on Connection reset
Ed Tanousa24526d2018-12-10 15:17:59 -0800658 std::optional<
Ed Tanous1abe55e2018-09-05 08:30:59 -0700659 boost::beast::http::request_parser<boost::beast::http::string_body>>
660 parser;
661
Ed Tanous3112a142018-11-29 15:45:10 -0800662 boost::beast::flat_static_buffer<8192> buffer;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700663
Ed Tanousa24526d2018-12-10 15:17:59 -0800664 std::optional<crow::Request> req;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700665 crow::Response res;
Ed Tanous52cc1122020-07-18 13:51:21 -0700666
John Edward Broadbent59b98b22021-07-13 15:36:32 -0700667 std::shared_ptr<persistent_data::UserSession> userSession;
Boleslaw Ogonczyk Makowskib4963072023-02-06 09:59:58 +0100668 std::shared_ptr<persistent_data::UserSession> mtlsSession;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700669
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800670 boost::asio::steady_timer timer;
Ed Tanous1abe55e2018-09-05 08:30:59 -0700671
Ed Tanous4cdc2e82023-01-13 10:03:22 -0800672 bool keepAlive = true;
673
Ed Tanous7d243eb2023-01-23 15:57:41 -0800674 bool timerStarted = false;
675
Ed Tanous1abe55e2018-09-05 08:30:59 -0700676 std::function<std::string()>& getCachedDateStr;
Jan Sowinskiee52ae12020-01-09 16:28:32 +0000677
678 using std::enable_shared_from_this<
Ed Tanous52cc1122020-07-18 13:51:21 -0700679 Connection<Adaptor, Handler>>::shared_from_this;
Ed Tanous5dfb5b22021-12-03 11:24:53 -0800680
681 using std::enable_shared_from_this<
682 Connection<Adaptor, Handler>>::weak_from_this;
Ed Tanous3112a142018-11-29 15:45:10 -0800683};
Ed Tanous1abe55e2018-09-05 08:30:59 -0700684} // namespace crow