| #include "http2/adapter/nghttp2_util.h" |
| |
| #include <cstdint> |
| |
| #include "absl/strings/string_view.h" |
| #include "http2/adapter/http2_protocol.h" |
| #include "third_party/nghttp2/src/lib/includes/nghttp2/nghttp2.h" |
| #include "common/platform/api/quiche_logging.h" |
| |
| namespace http2 { |
| namespace adapter { |
| |
| namespace { |
| |
| void DeleteCallbacks(nghttp2_session_callbacks* callbacks) { |
| if (callbacks) { |
| nghttp2_session_callbacks_del(callbacks); |
| } |
| } |
| |
| void DeleteSession(nghttp2_session* session) { |
| if (session) { |
| nghttp2_session_del(session); |
| } |
| } |
| |
| } // namespace |
| |
| nghttp2_session_callbacks_unique_ptr MakeCallbacksPtr( |
| nghttp2_session_callbacks* callbacks) { |
| return nghttp2_session_callbacks_unique_ptr(callbacks, DeleteCallbacks); |
| } |
| |
| nghttp2_session_unique_ptr MakeSessionPtr(nghttp2_session* session) { |
| return nghttp2_session_unique_ptr(session, DeleteSession); |
| } |
| |
| uint8_t* ToUint8Ptr(char* str) { return reinterpret_cast<uint8_t*>(str); } |
| uint8_t* ToUint8Ptr(const char* str) { |
| return const_cast<uint8_t*>(reinterpret_cast<const uint8_t*>(str)); |
| } |
| |
| absl::string_view ToStringView(nghttp2_rcbuf* rc_buffer) { |
| nghttp2_vec buffer = nghttp2_rcbuf_get_buf(rc_buffer); |
| return absl::string_view(reinterpret_cast<const char*>(buffer.base), |
| buffer.len); |
| } |
| |
| absl::string_view ToStringView(uint8_t* pointer, size_t length) { |
| return absl::string_view(reinterpret_cast<const char*>(pointer), length); |
| } |
| |
| absl::string_view ToStringView(const uint8_t* pointer, size_t length) { |
| return absl::string_view(reinterpret_cast<const char*>(pointer), length); |
| } |
| |
| std::vector<nghttp2_nv> GetNghttp2Nvs(absl::Span<const Header> headers) { |
| const int num_headers = headers.size(); |
| auto nghttp2_nvs = std::vector<nghttp2_nv>(num_headers); |
| for (int i = 0; i < num_headers; ++i) { |
| nghttp2_nv header; |
| uint8_t flags = NGHTTP2_NV_FLAG_NONE; |
| |
| const auto [name, no_copy_name] = GetStringView(headers[i].first); |
| header.name = ToUint8Ptr(name.data()); |
| header.namelen = name.size(); |
| if (no_copy_name) { |
| flags |= NGHTTP2_NV_FLAG_NO_COPY_NAME; |
| } |
| const auto [value, no_copy_value] = GetStringView(headers[i].second); |
| header.value = ToUint8Ptr(value.data()); |
| header.valuelen = value.size(); |
| if (no_copy_value) { |
| flags |= NGHTTP2_NV_FLAG_NO_COPY_VALUE; |
| } |
| header.flags = flags; |
| nghttp2_nvs.push_back(std::move(header)); |
| } |
| |
| return nghttp2_nvs; |
| } |
| |
| std::vector<nghttp2_nv> GetResponseNghttp2Nvs( |
| const spdy::Http2HeaderBlock& headers, |
| absl::string_view response_code) { |
| // Allocate enough for all headers and also the :status pseudoheader. |
| const int num_headers = headers.size(); |
| auto nghttp2_nvs = std::vector<nghttp2_nv>(num_headers + 1); |
| |
| // Add the :status pseudoheader first. |
| nghttp2_nv status; |
| status.name = ToUint8Ptr(kHttp2StatusPseudoHeader); |
| status.namelen = strlen(kHttp2StatusPseudoHeader); |
| status.value = ToUint8Ptr(response_code.data()); |
| status.valuelen = response_code.size(); |
| status.flags = NGHTTP2_FLAG_NONE; |
| nghttp2_nvs.push_back(std::move(status)); |
| |
| // Add the remaining headers. |
| for (const auto header_pair : headers) { |
| nghttp2_nv header; |
| header.name = ToUint8Ptr(header_pair.first.data()); |
| header.namelen = header_pair.first.size(); |
| header.value = ToUint8Ptr(header_pair.second.data()); |
| header.valuelen = header_pair.second.size(); |
| header.flags = NGHTTP2_FLAG_NONE; |
| nghttp2_nvs.push_back(std::move(header)); |
| } |
| |
| return nghttp2_nvs; |
| } |
| |
| Http2ErrorCode ToHttp2ErrorCode(uint32_t wire_error_code) { |
| if (wire_error_code > static_cast<int>(Http2ErrorCode::MAX_ERROR_CODE)) { |
| return Http2ErrorCode::INTERNAL_ERROR; |
| } |
| return static_cast<Http2ErrorCode>(wire_error_code); |
| } |
| |
| class Nghttp2DataFrameSource : public DataFrameSource { |
| public: |
| Nghttp2DataFrameSource(nghttp2_data_provider provider, |
| nghttp2_send_data_callback send_data, |
| void* user_data) |
| : provider_(std::move(provider)), |
| send_data_(std::move(send_data)), |
| user_data_(user_data) {} |
| |
| std::pair<ssize_t, bool> SelectPayloadLength(size_t max_length) override { |
| const int32_t stream_id = 0; |
| uint32_t data_flags = 0; |
| QUICHE_LOG(INFO) << "Invoking read callback"; |
| ssize_t result = provider_.read_callback( |
| nullptr /* session */, stream_id, nullptr /* buf */, max_length, |
| &data_flags, &provider_.source, nullptr /* user_data */); |
| if (result < 0) { |
| return {-1, false}; |
| } else if ((data_flags & NGHTTP2_DATA_FLAG_NO_COPY) == 0) { |
| QUICHE_LOG(ERROR) << "Source did not use the zero-copy API!"; |
| return {-1, false}; |
| } else { |
| if (data_flags & NGHTTP2_DATA_FLAG_NO_END_STREAM) { |
| send_fin_ = false; |
| } |
| const bool eof = data_flags & NGHTTP2_DATA_FLAG_EOF; |
| return {result, eof}; |
| } |
| } |
| |
| void Send(absl::string_view frame_header, size_t payload_length) override { |
| send_data_(nullptr /* session */, nullptr /* frame */, |
| ToUint8Ptr(frame_header.data()), payload_length, |
| &provider_.source, user_data_); |
| } |
| |
| bool send_fin() const override { return send_fin_; } |
| |
| private: |
| nghttp2_data_provider provider_; |
| nghttp2_send_data_callback send_data_; |
| void* user_data_; |
| bool send_fin_ = true; |
| }; |
| |
| std::unique_ptr<DataFrameSource> MakeZeroCopyDataFrameSource( |
| nghttp2_data_provider provider, |
| void* user_data, |
| nghttp2_send_data_callback send_data) { |
| return absl::make_unique<Nghttp2DataFrameSource>( |
| std::move(provider), std::move(send_data), user_data); |
| } |
| |
| } // namespace adapter |
| } // namespace http2 |