xref: /openbmc/bmcweb/http/http2_connection.hpp (revision ebe4c574caac9dfd8b2754bda51c0cf869f1978f) 
1 // SPDX-License-Identifier: Apache-2.0
2 // SPDX-FileCopyrightText: Copyright OpenBMC Authors
3 #pragma once
4 #include "bmcweb_config.h"
5 
6 #include "async_resp.hpp"
7 #include "authentication.hpp"
8 #include "complete_response_fields.hpp"
9 #include "forward_unauthorized.hpp"
10 #include "http_body.hpp"
11 #include "http_connect_types.hpp"
12 #include "http_request.hpp"
13 #include "http_response.hpp"
14 #include "logging.hpp"
15 
16 // NOLINTNEXTLINE(misc-include-cleaner)
17 #include "nghttp2_adapters.hpp"
18 
19 #include <nghttp2/nghttp2.h>
20 #include <unistd.h>
21 
22 #include <boost/asio/buffer.hpp>
23 #include <boost/asio/ssl/stream.hpp>
24 #include <boost/beast/core/error.hpp>
25 #include <boost/beast/http/field.hpp>
26 #include <boost/beast/http/fields.hpp>
27 #include <boost/beast/http/message.hpp>
28 #include <boost/beast/http/verb.hpp>
29 #include <boost/optional/optional.hpp>
30 #include <boost/system/error_code.hpp>
31 
32 #include <array>
33 #include <bit>
34 #include <cstddef>
35 #include <cstdint>
36 #include <functional>
37 #include <map>
38 #include <memory>
39 #include <optional>
40 #include <span>
41 #include <string>
42 #include <string_view>
43 #include <type_traits>
44 #include <utility>
45 #include <vector>
46 
47 namespace crow
48 {
49 
50 struct Http2StreamData
51 {
52     std::shared_ptr<Request> req = std::make_shared<Request>();
53     std::optional<bmcweb::HttpBody::reader> reqReader;
54     std::string accept;
55     Response res;
56     std::optional<bmcweb::HttpBody::writer> writer;
57 };
58 
59 template <typename Adaptor, typename Handler>
60 class HTTP2Connection :
61     public std::enable_shared_from_this<HTTP2Connection<Adaptor, Handler>>
62 {
63     using self_type = HTTP2Connection<Adaptor, Handler>;
64 
65   public:
HTTP2Connection(boost::asio::ssl::stream<Adaptor> && adaptorIn,Handler * handlerIn,std::function<std::string ()> & getCachedDateStrF,HttpType httpTypeIn)66     HTTP2Connection(boost::asio::ssl::stream<Adaptor>&& adaptorIn,
67                     Handler* handlerIn,
68                     std::function<std::string()>& getCachedDateStrF,
69                     HttpType httpTypeIn) :
70         httpType(httpTypeIn), adaptor(std::move(adaptorIn)),
71         ngSession(initializeNghttp2Session()), handler(handlerIn),
72         getCachedDateStr(getCachedDateStrF)
73     {}
74 
start()75     void start()
76     {
77         // Create the control stream
78         streams[0];
79 
80         if (sendServerConnectionHeader() != 0)
81         {
82             BMCWEB_LOG_ERROR("send_server_connection_header failed");
83             return;
84         }
85         doRead();
86     }
87 
startFromSettings(std::string_view http2UpgradeSettings)88     void startFromSettings(std::string_view http2UpgradeSettings)
89     {
90         int ret = ngSession.sessionUpgrade2(http2UpgradeSettings,
91                                             false /*head_request*/);
92         if (ret != 0)
93         {
94             BMCWEB_LOG_ERROR("Failed to load upgrade header");
95             return;
96         }
97         // Create the control stream
98         streams[0];
99 
100         if (sendServerConnectionHeader() != 0)
101         {
102             BMCWEB_LOG_ERROR("send_server_connection_header failed");
103             return;
104         }
105         doRead();
106     }
107 
sendServerConnectionHeader()108     int sendServerConnectionHeader()
109     {
110         BMCWEB_LOG_DEBUG("send_server_connection_header()");
111 
112         uint32_t maxStreams = 4;
113         std::array<nghttp2_settings_entry, 2> iv = {
114             {{NGHTTP2_SETTINGS_MAX_CONCURRENT_STREAMS, maxStreams},
115              {NGHTTP2_SETTINGS_ENABLE_PUSH, 0}}};
116         int rv = ngSession.submitSettings(iv);
117         if (rv != 0)
118         {
119             BMCWEB_LOG_ERROR("Fatal error: {}", nghttp2_strerror(rv));
120             return -1;
121         }
122         writeBuffer();
123         return 0;
124     }
125 
fileReadCallback(nghttp2_session *,int32_t streamId,uint8_t * buf,size_t length,uint32_t * dataFlags,nghttp2_data_source *,void * userPtr)126     static ssize_t fileReadCallback(
127         nghttp2_session* /* session */, int32_t streamId, uint8_t* buf,
128         size_t length, uint32_t* dataFlags, nghttp2_data_source* /*source*/,
129         void* userPtr)
130     {
131         self_type& self = userPtrToSelf(userPtr);
132 
133         auto streamIt = self.streams.find(streamId);
134         if (streamIt == self.streams.end())
135         {
136             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
137         }
138         Http2StreamData& stream = streamIt->second;
139         BMCWEB_LOG_DEBUG("File read callback length: {}", length);
140         if (!stream.writer)
141         {
142             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
143         }
144         boost::beast::error_code ec;
145         boost::optional<std::pair<boost::asio::const_buffer, bool>> out =
146             stream.writer->getWithMaxSize(ec, length);
147         if (ec)
148         {
149             BMCWEB_LOG_CRITICAL("Failed to get buffer");
150             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
151         }
152         if (!out)
153         {
154             BMCWEB_LOG_ERROR("Empty file, setting EOF");
155             *dataFlags |= NGHTTP2_DATA_FLAG_EOF;
156             return 0;
157         }
158 
159         BMCWEB_LOG_DEBUG("Send chunk of size: {}", out->first.size());
160         if (length < out->first.size())
161         {
162             BMCWEB_LOG_CRITICAL(
163                 "Buffer overflow that should never happen happened");
164             // Should never happen because of length limit on get() above
165             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
166         }
167         boost::asio::mutable_buffer writeableBuf(buf, length);
168         BMCWEB_LOG_DEBUG("Copying {} bytes to buf", out->first.size());
169         size_t copied = boost::asio::buffer_copy(writeableBuf, out->first);
170         if (copied != out->first.size())
171         {
172             BMCWEB_LOG_ERROR(
173                 "Couldn't copy all {} bytes into buffer, only copied {}",
174                 out->first.size(), copied);
175             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
176         }
177 
178         if (!out->second)
179         {
180             BMCWEB_LOG_DEBUG("Setting EOF flag");
181             *dataFlags |= NGHTTP2_DATA_FLAG_EOF;
182         }
183         return static_cast<ssize_t>(copied);
184     }
185 
headerFromStringViews(std::string_view name,std::string_view value,uint8_t flags)186     nghttp2_nv headerFromStringViews(std::string_view name,
187                                      std::string_view value, uint8_t flags)
188     {
189         uint8_t* nameData = std::bit_cast<uint8_t*>(name.data());
190         uint8_t* valueData = std::bit_cast<uint8_t*>(value.data());
191         return {nameData, valueData, name.size(), value.size(), flags};
192     }
193 
sendResponse(Response & completedRes,int32_t streamId)194     int sendResponse(Response& completedRes, int32_t streamId)
195     {
196         BMCWEB_LOG_DEBUG("send_response stream_id:{}", streamId);
197 
198         auto it = streams.find(streamId);
199         if (it == streams.end())
200         {
201             close();
202             return -1;
203         }
204         Http2StreamData& stream = it->second;
205         Response& res = stream.res;
206         res = std::move(completedRes);
207 
208         completeResponseFields(stream.accept, res);
209         res.addHeader(boost::beast::http::field::date, getCachedDateStr());
210         res.preparePayload();
211 
212         boost::beast::http::fields& fields = res.fields();
213         std::string code = std::to_string(res.resultInt());
214         std::vector<nghttp2_nv> hdr;
215         hdr.emplace_back(
216             headerFromStringViews(":status", code, NGHTTP2_NV_FLAG_NONE));
217         for (const boost::beast::http::fields::value_type& header : fields)
218         {
219             hdr.emplace_back(headerFromStringViews(
220                 header.name_string(), header.value(), NGHTTP2_NV_FLAG_NONE));
221         }
222         http::response<bmcweb::HttpBody>& fbody = res.response;
223         stream.writer.emplace(fbody.base(), fbody.body());
224 
225         nghttp2_data_provider dataPrd{
226             .source = {.fd = 0},
227             .read_callback = fileReadCallback,
228         };
229 
230         int rv = ngSession.submitResponse(streamId, hdr, &dataPrd);
231         if (rv != 0)
232         {
233             BMCWEB_LOG_ERROR("Fatal error: {}", nghttp2_strerror(rv));
234             close();
235             return -1;
236         }
237         writeBuffer();
238 
239         return 0;
240     }
241 
initializeNghttp2Session()242     nghttp2_session initializeNghttp2Session()
243     {
244         nghttp2_session_callbacks callbacks;
245         callbacks.setOnFrameRecvCallback(onFrameRecvCallbackStatic);
246         callbacks.setOnStreamCloseCallback(onStreamCloseCallbackStatic);
247         callbacks.setOnHeaderCallback(onHeaderCallbackStatic);
248         callbacks.setOnBeginHeadersCallback(onBeginHeadersCallbackStatic);
249         callbacks.setOnDataChunkRecvCallback(onDataChunkRecvStatic);
250 
251         nghttp2_session session(callbacks);
252         session.setUserData(this);
253 
254         return session;
255     }
256 
onRequestRecv(int32_t streamId)257     int onRequestRecv(int32_t streamId)
258     {
259         BMCWEB_LOG_DEBUG("on_request_recv");
260 
261         auto it = streams.find(streamId);
262         if (it == streams.end())
263         {
264             close();
265             return -1;
266         }
267         auto& reqReader = it->second.reqReader;
268         if (reqReader)
269         {
270             boost::beast::error_code ec;
271             bmcweb::HttpBody::reader::finish(ec);
272             if (ec)
273             {
274                 BMCWEB_LOG_CRITICAL("Failed to finalize payload");
275                 close();
276                 return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
277             }
278         }
279         crow::Request& thisReq = *it->second.req;
280         it->second.accept = thisReq.getHeaderValue("Accept");
281 
282         BMCWEB_LOG_DEBUG("Handling {} \"{}\"", logPtr(&thisReq),
283                          thisReq.url().encoded_path());
284 
285         crow::Response& thisRes = it->second.res;
286 
287         thisRes.setCompleteRequestHandler(
288             [this, streamId](Response& completeRes) {
289                 BMCWEB_LOG_DEBUG("res.completeRequestHandler called");
290                 if (sendResponse(completeRes, streamId) != 0)
291                 {
292                     close();
293                     return;
294                 }
295             });
296         auto asyncResp =
297             std::make_shared<bmcweb::AsyncResp>(std::move(it->second.res));
298         if constexpr (!BMCWEB_INSECURE_DISABLE_AUTH)
299         {
300             thisReq.session = crow::authentication::authenticate(
301                 {}, asyncResp->res, thisReq.method(), thisReq.req, nullptr);
302             if (!crow::authentication::isOnAllowlist(thisReq.url().path(),
303                                                      thisReq.method()) &&
304                 thisReq.session == nullptr)
305             {
306                 BMCWEB_LOG_WARNING("Authentication failed");
307                 forward_unauthorized::sendUnauthorized(
308                     thisReq.url().encoded_path(),
309                     thisReq.getHeaderValue("X-Requested-With"),
310                     thisReq.getHeaderValue("Accept"), asyncResp->res);
311                 return 0;
312             }
313         }
314         std::string_view expected =
315             thisReq.getHeaderValue(boost::beast::http::field::if_none_match);
316         BMCWEB_LOG_DEBUG("Setting expected hash {}", expected);
317         if (!expected.empty())
318         {
319             asyncResp->res.setExpectedHash(expected);
320         }
321         handler->handle(it->second.req, asyncResp);
322         return 0;
323     }
324 
onDataChunkRecvCallback(uint8_t,int32_t streamId,const uint8_t * data,size_t len)325     int onDataChunkRecvCallback(uint8_t /*flags*/, int32_t streamId,
326                                 const uint8_t* data, size_t len)
327     {
328         auto thisStream = streams.find(streamId);
329         if (thisStream == streams.end())
330         {
331             BMCWEB_LOG_ERROR("Unknown stream{}", streamId);
332             close();
333             return -1;
334         }
335 
336         std::optional<bmcweb::HttpBody::reader>& reqReader =
337             thisStream->second.reqReader;
338         if (!reqReader)
339         {
340             reqReader.emplace(
341                 bmcweb::HttpBody::reader(thisStream->second.req->req.base(),
342                                          thisStream->second.req->req.body()));
343         }
344         boost::beast::error_code ec;
345         reqReader->put(boost::asio::const_buffer(data, len), ec);
346         if (ec)
347         {
348             BMCWEB_LOG_CRITICAL("Failed to write payload");
349             return NGHTTP2_ERR_TEMPORAL_CALLBACK_FAILURE;
350         }
351         return 0;
352     }
353 
onDataChunkRecvStatic(nghttp2_session *,uint8_t flags,int32_t streamId,const uint8_t * data,size_t len,void * userData)354     static int onDataChunkRecvStatic(
355         nghttp2_session* /* session */, uint8_t flags, int32_t streamId,
356         const uint8_t* data, size_t len, void* userData)
357     {
358         BMCWEB_LOG_DEBUG("on_frame_recv_callback");
359         if (userData == nullptr)
360         {
361             BMCWEB_LOG_CRITICAL("user data was null?");
362             return NGHTTP2_ERR_CALLBACK_FAILURE;
363         }
364         return userPtrToSelf(userData).onDataChunkRecvCallback(
365             flags, streamId, data, len);
366     }
367 
onFrameRecvCallback(const nghttp2_frame & frame)368     int onFrameRecvCallback(const nghttp2_frame& frame)
369     {
370         BMCWEB_LOG_DEBUG("frame type {}", static_cast<int>(frame.hd.type));
371         switch (frame.hd.type)
372         {
373             case NGHTTP2_DATA:
374             case NGHTTP2_HEADERS:
375                 // Check that the client request has finished
376                 if ((frame.hd.flags & NGHTTP2_FLAG_END_STREAM) != 0)
377                 {
378                     return onRequestRecv(frame.hd.stream_id);
379                 }
380                 break;
381             default:
382                 break;
383         }
384         return 0;
385     }
386 
onFrameRecvCallbackStatic(nghttp2_session *,const nghttp2_frame * frame,void * userData)387     static int onFrameRecvCallbackStatic(nghttp2_session* /* session */,
388                                          const nghttp2_frame* frame,
389                                          void* userData)
390     {
391         BMCWEB_LOG_DEBUG("on_frame_recv_callback");
392         if (userData == nullptr)
393         {
394             BMCWEB_LOG_CRITICAL("user data was null?");
395             return NGHTTP2_ERR_CALLBACK_FAILURE;
396         }
397         if (frame == nullptr)
398         {
399             BMCWEB_LOG_CRITICAL("frame was null?");
400             return NGHTTP2_ERR_CALLBACK_FAILURE;
401         }
402         return userPtrToSelf(userData).onFrameRecvCallback(*frame);
403     }
404 
userPtrToSelf(void * userData)405     static self_type& userPtrToSelf(void* userData)
406     {
407         // This method exists to keep the unsafe reinterpret cast in one
408         // place.
409         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
410         return *reinterpret_cast<self_type*>(userData);
411     }
412 
onStreamCloseCallbackStatic(nghttp2_session *,int32_t streamId,uint32_t,void * userData)413     static int onStreamCloseCallbackStatic(nghttp2_session* /* session */,
414                                            int32_t streamId,
415                                            uint32_t /*unused*/, void* userData)
416     {
417         BMCWEB_LOG_DEBUG("on_stream_close_callback stream {}", streamId);
418         if (userData == nullptr)
419         {
420             BMCWEB_LOG_CRITICAL("user data was null?");
421             return NGHTTP2_ERR_CALLBACK_FAILURE;
422         }
423         if (userPtrToSelf(userData).streams.erase(streamId) <= 0)
424         {
425             return -1;
426         }
427         return 0;
428     }
429 
onHeaderCallback(const nghttp2_frame & frame,std::span<const uint8_t> name,std::span<const uint8_t> value)430     int onHeaderCallback(const nghttp2_frame& frame,
431                          std::span<const uint8_t> name,
432                          std::span<const uint8_t> value)
433     {
434         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
435         std::string_view nameSv(reinterpret_cast<const char*>(name.data()),
436                                 name.size());
437         // NOLINTNEXTLINE(cppcoreguidelines-pro-type-reinterpret-cast)
438         std::string_view valueSv(reinterpret_cast<const char*>(value.data()),
439                                  value.size());
440 
441         BMCWEB_LOG_DEBUG("on_header_callback name: {} value {}", nameSv,
442                          valueSv);
443         if (frame.hd.type != NGHTTP2_HEADERS)
444         {
445             return 0;
446         }
447         if (frame.headers.cat != NGHTTP2_HCAT_REQUEST)
448         {
449             return 0;
450         }
451         auto thisStream = streams.find(frame.hd.stream_id);
452         if (thisStream == streams.end())
453         {
454             BMCWEB_LOG_ERROR("Unknown stream{}", frame.hd.stream_id);
455             close();
456             return -1;
457         }
458 
459         crow::Request& thisReq = *thisStream->second.req;
460 
461         if (nameSv == ":path")
462         {
463             thisReq.target(valueSv);
464         }
465         else if (nameSv == ":method")
466         {
467             boost::beast::http::verb verb =
468                 boost::beast::http::string_to_verb(valueSv);
469             if (verb == boost::beast::http::verb::unknown)
470             {
471                 BMCWEB_LOG_ERROR("Unknown http verb {}", valueSv);
472                 verb = boost::beast::http::verb::trace;
473             }
474             thisReq.method(verb);
475         }
476         else if (nameSv == ":scheme")
477         {
478             // Nothing to check on scheme
479         }
480         else
481         {
482             thisReq.addHeader(nameSv, valueSv);
483         }
484         return 0;
485     }
486 
onHeaderCallbackStatic(nghttp2_session *,const nghttp2_frame * frame,const uint8_t * name,size_t namelen,const uint8_t * value,size_t vallen,uint8_t,void * userData)487     static int onHeaderCallbackStatic(
488         nghttp2_session* /* session */, const nghttp2_frame* frame,
489         const uint8_t* name, size_t namelen, const uint8_t* value,
490         size_t vallen, uint8_t /* flags */, void* userData)
491     {
492         if (userData == nullptr)
493         {
494             BMCWEB_LOG_CRITICAL("user data was null?");
495             return NGHTTP2_ERR_CALLBACK_FAILURE;
496         }
497         if (frame == nullptr)
498         {
499             BMCWEB_LOG_CRITICAL("frame was null?");
500             return NGHTTP2_ERR_CALLBACK_FAILURE;
501         }
502         if (name == nullptr)
503         {
504             BMCWEB_LOG_CRITICAL("name was null?");
505             return NGHTTP2_ERR_CALLBACK_FAILURE;
506         }
507         if (value == nullptr)
508         {
509             BMCWEB_LOG_CRITICAL("value was null?");
510             return NGHTTP2_ERR_CALLBACK_FAILURE;
511         }
512         return userPtrToSelf(userData).onHeaderCallback(*frame, {name, namelen},
513                                                         {value, vallen});
514     }
515 
onBeginHeadersCallback(const nghttp2_frame & frame)516     int onBeginHeadersCallback(const nghttp2_frame& frame)
517     {
518         if (frame.hd.type == NGHTTP2_HEADERS &&
519             frame.headers.cat == NGHTTP2_HCAT_REQUEST)
520         {
521             BMCWEB_LOG_DEBUG("create stream for id {}", frame.hd.stream_id);
522 
523             streams.emplace(frame.hd.stream_id, Http2StreamData());
524         }
525         return 0;
526     }
527 
onBeginHeadersCallbackStatic(nghttp2_session *,const nghttp2_frame * frame,void * userData)528     static int onBeginHeadersCallbackStatic(nghttp2_session* /* session */,
529                                             const nghttp2_frame* frame,
530                                             void* userData)
531     {
532         BMCWEB_LOG_DEBUG("on_begin_headers_callback");
533         if (userData == nullptr)
534         {
535             BMCWEB_LOG_CRITICAL("user data was null?");
536             return NGHTTP2_ERR_CALLBACK_FAILURE;
537         }
538         if (frame == nullptr)
539         {
540             BMCWEB_LOG_CRITICAL("frame was null?");
541             return NGHTTP2_ERR_CALLBACK_FAILURE;
542         }
543         return userPtrToSelf(userData).onBeginHeadersCallback(*frame);
544     }
545 
afterWriteBuffer(const std::shared_ptr<self_type> & self,const boost::system::error_code & ec,size_t sendLength)546     static void afterWriteBuffer(const std::shared_ptr<self_type>& self,
547                                  const boost::system::error_code& ec,
548                                  size_t sendLength)
549     {
550         self->isWriting = false;
551         BMCWEB_LOG_DEBUG("Sent {}", sendLength);
552         if (ec)
553         {
554             self->close();
555             return;
556         }
557         self->writeBuffer();
558     }
559 
writeBuffer()560     void writeBuffer()
561     {
562         if (isWriting)
563         {
564             return;
565         }
566         std::span<const uint8_t> data = ngSession.memSend();
567         if (data.empty())
568         {
569             return;
570         }
571         isWriting = true;
572         if (httpType == HttpType::HTTPS)
573         {
574             boost::asio::async_write(
575                 adaptor, boost::asio::const_buffer(data.data(), data.size()),
576                 std::bind_front(afterWriteBuffer, shared_from_this()));
577         }
578         else if (httpType == HttpType::HTTP)
579         {
580             boost::asio::async_write(
581                 adaptor.next_layer(),
582                 boost::asio::const_buffer(data.data(), data.size()),
583                 std::bind_front(afterWriteBuffer, shared_from_this()));
584         }
585     }
586 
close()587     void close()
588     {
589         adaptor.next_layer().close();
590     }
591 
afterDoRead(const std::shared_ptr<self_type> &,const boost::system::error_code & ec,size_t bytesTransferred)592     void afterDoRead(const std::shared_ptr<self_type>& /*self*/,
593                      const boost::system::error_code& ec,
594                      size_t bytesTransferred)
595     {
596         BMCWEB_LOG_DEBUG("{} async_read_some {} Bytes", logPtr(this),
597                          bytesTransferred);
598 
599         if (ec)
600         {
601             BMCWEB_LOG_ERROR("{} Error while reading: {}", logPtr(this),
602                              ec.message());
603             close();
604             BMCWEB_LOG_DEBUG("{} from read(1)", logPtr(this));
605             return;
606         }
607         std::span<uint8_t> bufferSpan{inBuffer.data(), bytesTransferred};
608 
609         ssize_t readLen = ngSession.memRecv(bufferSpan);
610         if (readLen < 0)
611         {
612             BMCWEB_LOG_ERROR("nghttp2_session_mem_recv returned {}", readLen);
613             close();
614             return;
615         }
616         writeBuffer();
617 
618         doRead();
619     }
620 
doRead()621     void doRead()
622     {
623         BMCWEB_LOG_DEBUG("{} doRead", logPtr(this));
624         if (httpType == HttpType::HTTPS)
625         {
626             adaptor.async_read_some(boost::asio::buffer(inBuffer),
627                                     std::bind_front(&self_type::afterDoRead,
628                                                     this, shared_from_this()));
629         }
630         else if (httpType == HttpType::HTTP)
631         {
632             adaptor.next_layer().async_read_some(
633                 boost::asio::buffer(inBuffer),
634                 std::bind_front(&self_type::afterDoRead, this,
635                                 shared_from_this()));
636         }
637     }
638 
639     // A mapping from http2 stream ID to Stream Data
640     std::map<int32_t, Http2StreamData> streams;
641 
642     std::array<uint8_t, 8192> inBuffer{};
643 
644     HttpType httpType = HttpType::BOTH;
645     boost::asio::ssl::stream<Adaptor> adaptor;
646     bool isWriting = false;
647 
648     nghttp2_session ngSession;
649 
650     Handler* handler;
651     std::function<std::string()>& getCachedDateStr;
652 
653     using std::enable_shared_from_this<
654         HTTP2Connection<Adaptor, Handler>>::shared_from_this;
655 
656     using std::enable_shared_from_this<
657         HTTP2Connection<Adaptor, Handler>>::weak_from_this;
658 };
659 } // namespace crow
660