Grcov report - codec

1

#include "source/common/http/http2/codec_impl.h"

2

3

#include <algorithm>

4

#include <cstdint>

5

#include <memory>

6

#include <ostream>

7

#include <vector>

8

9

#include "envoy/event/dispatcher.h"

10

#include "envoy/http/codes.h"

11

#include "envoy/http/header_map.h"

12

#include "envoy/network/connection.h"

13

14

#include "source/common/common/assert.h"

15

#include "source/common/common/cleanup.h"

16

#include "source/common/common/dump_state_utils.h"

17

#include "source/common/common/enum_to_int.h"

18

#include "source/common/common/scope_tracker.h"

19

#include "source/common/common/utility.h"

20

#include "source/common/http/codes.h"

21

#include "source/common/http/header_utility.h"

22

#include "source/common/http/headers.h"

23

#include "source/common/http/http2/codec_stats.h"

24

#include "source/common/http/utility.h"

25

#include "source/common/runtime/runtime_features.h"

26

27

#include "absl/cleanup/cleanup.h"

28

#include "absl/container/flat_hash_map.h"

29

#include "quiche/common/quiche_endian.h"

30

#include "quiche/http2/adapter/nghttp2_adapter.h"

31

#include "quiche/http2/adapter/oghttp2_adapter.h"

32

33

namespace Envoy {

34

namespace Http {

35

namespace Http2 {

36

37

namespace {

38

39

// Optimization: Map of well-known header names to Envoy's static LowerCaseString objects.

40

// This allows us to avoid copying header names for common HTTP/2 headers.

41

// The string_views point to compile-time string literals which live forever.

42

class StaticHeaderNameLookup {

43

public:

44

341

  StaticHeaderNameLookup() {

45

341

    const auto& headers = Headers::get();

46

341

    const auto& custom_headers = CustomHeaders::get();

47

48

    // HTTP/2 pseudo-headers (most common).

49

341

    addMapping(":authority", headers.Host);

50

341

    addMapping(":method", headers.Method);

51

341

    addMapping(":path", headers.Path);

52

341

    addMapping(":scheme", headers.Scheme);

53

341

    addMapping(":status", headers.Status);

54

341

    addMapping(":protocol", headers.Protocol);

55

56

    // Common request headers.

57

341

    addMapping("accept", custom_headers.Accept);

58

341

    addMapping("accept-encoding", custom_headers.AcceptEncoding);

59

341

    addMapping("authorization", custom_headers.Authorization);

60

341

    addMapping("cache-control", custom_headers.CacheControl);

61

341

    addMapping("content-encoding", custom_headers.ContentEncoding);

62

341

    addMapping("content-length", headers.ContentLength);

63

341

    addMapping("content-type", headers.ContentType);

64

341

    addMapping("cookie", headers.Cookie);

65

341

    addMapping("date", headers.Date);

66

341

    addMapping("expect", headers.Expect);

67

341

    addMapping("grpc-timeout", headers.GrpcTimeout);

68

341

    addMapping("host", headers.HostLegacy);

69

341

    addMapping("user-agent", headers.UserAgent);

70

71

    // Common response headers.

72

341

    addMapping("location", headers.Location);

73

341

    addMapping("server", headers.Server);

74

341

    addMapping("set-cookie", headers.SetCookie);

75

341

    addMapping("grpc-status", headers.GrpcStatus);

76

341

    addMapping("grpc-message", headers.GrpcMessage);

77

78

    // Common request/response headers.

79

341

    addMapping("connection", headers.Connection);

80

341

    addMapping("keep-alive", headers.KeepAlive);

81

341

    addMapping("proxy-connection", headers.ProxyConnection);

82

341

    addMapping("te", headers.TE);

83

341

    addMapping("transfer-encoding", headers.TransferEncoding);

84

341

    addMapping("upgrade", headers.Upgrade);

85

341

    addMapping("via", headers.Via);

86

341

    addMapping("x-request-id", headers.RequestId);

87

88

    // X-Forwarded headers.

89

341

    addMapping("x-forwarded-for", headers.ForwardedFor);

90

341

    addMapping("x-forwarded-host", headers.ForwardedHost);

91

341

    addMapping("x-forwarded-proto", headers.ForwardedProto);

92

341

    addMapping("x-forwarded-port", headers.ForwardedPort);

93

341

94

95

764114

  const LowerCaseString* lookup(absl::string_view name) const {

96

764114

    auto it = map_.find(name);

97

764114

    return it != map_.end() ? it->second : nullptr;

98

764114

99

100

private:

101

12276

  void addMapping(absl::string_view name, const LowerCaseString& header) {

102

12276

    map_.emplace(name, &header);

103

12276

104

105

  absl::flat_hash_map<absl::string_view, const LowerCaseString*> map_;

106

};

107

108

764115

const StaticHeaderNameLookup& getStaticHeaderNameLookup() {

109

764115

  CONSTRUCT_ON_FIRST_USE(StaticHeaderNameLookup);

110

764115

111

112

} // namespace

113

114

// for nghttp2 compatibility.

115

const int ERR_CALLBACK_FAILURE = -902;

116

const int INITIAL_CONNECTION_WINDOW_SIZE = ((1 << 16) - 1);

117

const int ERR_TEMPORAL_CALLBACK_FAILURE = -521;

118

const int ERR_REFUSED_STREAM = -533;

119

const int ERR_HTTP_HEADER = -531;

120

const int ERR_HTTP_MESSAGING = -532;

121

const int ERR_PROTO = -505;

122

const int ERR_STREAM_CLOSED = -510;

123

const int ERR_FLOW_CONTROL = -524;

124

125

// Changes or additions to details should be reflected in

126

// docs/root/configuration/http/http_conn_man/response_code_details.rst

127

class Http2ResponseCodeDetailValues {

128

public:

129

  // Invalid HTTP header field was received and stream is going to be

130

  // closed.

131

  const absl::string_view ng_http2_err_http_header_ = "http2.invalid.header.field";

132

  // Violation in HTTP messaging rule.

133

  const absl::string_view ng_http2_err_http_messaging_ = "http2.violation.of.messaging.rule";

134

  // none of the above

135

  const absl::string_view ng_http2_err_unknown_ = "http2.unknown.nghttp2.error";

136

  // oghttp2 does not provide details yet.

137

  const absl::string_view oghttp2_err_unknown_ = "http2.unknown.oghttp2.error";

138

  // The number of headers (or trailers) exceeded the configured limits

139

  const absl::string_view too_many_headers = "http2.too_many_headers";

140

  // Envoy detected an HTTP/2 frame flood from the server.

141

  const absl::string_view outbound_frame_flood = "http2.outbound_frames_flood";

142

  // Envoy detected an inbound HTTP/2 frame flood.

143

  const absl::string_view inbound_empty_frame_flood = "http2.inbound_empty_frames_flood";

144

  // Envoy was configured to drop requests with header keys beginning with underscores.

145

  const absl::string_view invalid_underscore = "http2.unexpected_underscore";

146

  // The peer refused the stream.

147

  const absl::string_view remote_refused = "http2.remote_refuse";

148

  // The peer reset the stream.

149

  const absl::string_view remote_reset = "http2.remote_reset";

150

151

#ifdef ENVOY_NGHTTP2

152

1045

  const absl::string_view errorDetails(int error_code) const {

153

1045

    switch (error_code) {

154

871

    case NGHTTP2_ERR_HTTP_HEADER:

155

871

      return ng_http2_err_http_header_;

156

173

    case NGHTTP2_ERR_HTTP_MESSAGING:

157

173

      return ng_http2_err_http_messaging_;

158

1

    default:

159

1

      return ng_http2_err_unknown_;

160

1045

161

1045

162

};

163

832

const char* codecStrError(int error_code) { return nghttp2_strerror(error_code); }

164

#else

165

  const absl::string_view errorDetails(int) const { return oghttp2_err_unknown_; }

166

};

167

const char* codecStrError(int) { return "unknown_error"; }

168

#endif

169

170

/**

171

 * Convert StreamResetReason to HTTP/2 error code.

172

 * @param reason the StreamResetReason to convert

173

 * @param response_end_stream_sent whether END_STREAM has been sent for a server stream.

174

 * True means the response has been fully sent.

175

*/

176

12775

int reasonToReset(StreamResetReason reason, bool response_end_stream_sent) {

177

12775

  switch (reason) {

178

4

  case StreamResetReason::LocalRefusedStreamReset:

179

4

    return OGHTTP2_REFUSED_STREAM;

180

29

  case StreamResetReason::ConnectError:

181

29

    return OGHTTP2_CONNECT_ERROR;

182

106

  case StreamResetReason::ProtocolError:

183

106

    if (!Runtime::runtimeFeatureEnabled("envoy.reloadable_features.reset_with_error")) {

184

2

      return OGHTTP2_NO_ERROR;

185

2

186

104

    return OGHTTP2_PROTOCOL_ERROR;

187

12636

  default:

188

12636

    if (!Runtime::runtimeFeatureEnabled("envoy.reloadable_features.reset_with_error")) {

189

6

      return OGHTTP2_NO_ERROR;

190

6

191

    // If the response has been fully sent then we reset with OGHTTP2_NO_ERROR to tell

192

    // there is no transport level error.

193

12630

    return response_end_stream_sent ? OGHTTP2_NO_ERROR : OGHTTP2_INTERNAL_ERROR;

194

12775

195

12775

196

197

11517

StreamResetReason errorCodeToResetReason(int error_code) {

198

11517

  switch (error_code) {

199

22

  case OGHTTP2_REFUSED_STREAM:

200

22

    return StreamResetReason::RemoteRefusedStreamReset;

201

25

  case OGHTTP2_CONNECT_ERROR:

202

25

    return StreamResetReason::ConnectError;

203

135

  case OGHTTP2_PROTOCOL_ERROR:

204

135

    return StreamResetReason::ProtocolError;

205

11335

  default:

206

11335

    return StreamResetReason::RemoteReset;

207

11517

208

11517

209

210

using Http2ResponseCodeDetails = ConstSingleton<Http2ResponseCodeDetailValues>;

211

using OnHeaderResult = http2::adapter::Http2VisitorInterface::OnHeaderResult;

212

213

enum Settings {

214

  // SETTINGS_HEADER_TABLE_SIZE = 0x01,

215

  // SETTINGS_ENABLE_PUSH = 0x02,

216

  SETTINGS_MAX_CONCURRENT_STREAMS = 0x03,

217

  // SETTINGS_INITIAL_WINDOW_SIZE = 0x04,

218

  // SETTINGS_MAX_FRAME_SIZE = 0x05,

219

  // SETTINGS_MAX_HEADER_LIST_SIZE = 0x06,

220

  // SETTINGS_ENABLE_CONNECT_PROTOCOL = 0x08,

221

  // SETTINGS_NO_RFC7540_PRIORITIES = 0x09

222

};

223

224

enum Flags {

225

  // FLAG_NONE = 0,

226

  FLAG_END_STREAM = 0x01,

227

  // FLAG_END_HEADERS = 0x04,

228

  FLAG_ACK = 0x01,

229

  // FLAG_PADDED = 0x08,

230

  // FLAG_PRIORITY = 0x20

231

};

232

233

ReceivedSettingsImpl::ReceivedSettingsImpl(

234

28245

    absl::Span<const http2::adapter::Http2Setting> settings) {

235

89910

  for (const auto& [id, value] : settings) {

236

89604

    if (id == SETTINGS_MAX_CONCURRENT_STREAMS) {

237

27673

      concurrent_stream_limit_ = value;

238

27673

      break;

239

27673

240

89604

241

28245

242

243

bool Utility::reconstituteCrumbledCookies(const HeaderString& key, const HeaderString& value,

244

764093

                                          HeaderString& cookies) {

245

764093

  if (key != Headers::get().Cookie.get().c_str()) {

246

755771

    return false;

247

755771

248

249

8322

  if (!cookies.empty()) {

250

8064

    cookies.append("; ", 2);

251

8064

252

253

8322

  const absl::string_view value_view = value.getStringView();

254

8322

  cookies.append(value_view.data(), value_view.size());

255

8322

  return true;

256

764093

257

258

std::unique_ptr<http2::adapter::Http2Adapter>

259

ProdNghttp2SessionFactory::create(ConnectionImpl* connection,

260

3506

                                  const http2::adapter::OgHttp2Adapter::Options& options) {

261

3506

  auto visitor = std::make_unique<ConnectionImpl::Http2Visitor>(connection);

262

3506

  std::unique_ptr<http2::adapter::Http2Adapter> adapter =

263

3506

      http2::adapter::OgHttp2Adapter::Create(*visitor, options);

264

3506

  connection->setVisitor(std::move(visitor));

265

3506

  return adapter;

266

3506

267

268

#ifdef ENVOY_NGHTTP2

269

std::unique_ptr<http2::adapter::Http2Adapter>

270

11457

ProdNghttp2SessionFactory::create(ConnectionImpl* connection, const nghttp2_option* options) {

271

11457

  auto visitor = std::make_unique<ConnectionImpl::Http2Visitor>(connection);

272

11457

  auto adapter = http2::adapter::NgHttp2Adapter::CreateClientAdapter(*visitor, options);

273

38537

  auto stream_close_listener = [p = adapter.get()](http2::adapter::Http2StreamId stream_id) {

274

36785

    p->RemoveStream(stream_id);

275

36785

};

276

11457

  visitor->setStreamCloseListener(std::move(stream_close_listener));

277

11457

  connection->setVisitor(std::move(visitor));

278

11457

  return adapter;

279

11457

280

#endif

281

282

void ProdNghttp2SessionFactory::init(ConnectionImpl* connection,

283

14963

                                     const envoy::config::core::v3::Http2ProtocolOptions& options) {

284

14963

  connection->sendSettings(options, true);

285

14963

286

287

/**

288

 * Helper to remove const during a cast. nghttp2 takes non-const pointers for headers even though

289

 * it copies them.

290

*/

291

template <typename T> static T* removeConst(const void* object) {

292

  return const_cast<T*>(reinterpret_cast<const T*>(object));

293

294

295

ConnectionImpl::StreamImpl::StreamImpl(ConnectionImpl& parent, uint32_t buffer_limit)

296

149019

    : MultiplexedStreamImplBase(parent.connection_.dispatcher()), parent_(parent),

297

149019

      pending_recv_data_(parent_.connection_.dispatcher().getWatermarkFactory().createBuffer(

298

149019

          [this]() -> void { this->pendingRecvBufferLowWatermark(); },

299

149019

          [this]() -> void { this->pendingRecvBufferHighWatermark(); },

300

149019

          []() -> void { /* TODO(adisuissa): Handle overflow watermark */ })),

301

149019

      pending_send_data_(parent_.connection_.dispatcher().getWatermarkFactory().createBuffer(

302

149019

          [this]() -> void { this->pendingSendBufferLowWatermark(); },

303

149019

          [this]() -> void { this->pendingSendBufferHighWatermark(); },

304

149019

          []() -> void { /* TODO(adisuissa): Handle overflow watermark */ })),

305

149019

      local_end_stream_sent_(false), remote_end_stream_(false), remote_rst_(false),

306

149019

      data_deferred_(false), received_noninformational_headers_(false),

307

149019

      pending_receive_buffer_high_watermark_called_(false),

308

149019

      pending_send_buffer_high_watermark_called_(false), reset_due_to_messaging_error_(false),

309

149019

      extend_stream_lifetime_flag_(false) {

310

149019

  parent_.stats_.streams_active_.inc();

311

149021

  if (buffer_limit > 0) {

312

149021

    setWriteBufferWatermarks(buffer_limit);

313

149021

314

149019

  stream_manager_.defer_processing_segment_size_ = parent.connection_.bufferLimit();

315

149019

316

317

149021

void ConnectionImpl::StreamImpl::destroy() {

318

  // Cancel any pending buffered data callback for the stream.

319

149021

  process_buffered_data_callback_.reset();

320

321

149021

  MultiplexedStreamImplBase::destroy();

322

149021

  parent_.stats_.streams_active_.dec();

323

149021

  parent_.stats_.pending_send_bytes_.sub(pending_send_data_->length());

324

149021

325

326

95960

void ConnectionImpl::ServerStreamImpl::destroy() {

327

  // Only the downstream stream should clear the downstream of the

328

  // memory account.

329

  // This occurs in destroy as we want to ensure the Stream does not get

330

  // reset called on it from the account.

331

//

332

  // There are cases where a corresponding upstream stream dtor might

333

  // be called, but the downstream stream isn't going to terminate soon

334

  // such as StreamDecoderFilterCallbacks::recreateStream().

335

95960

  if (buffer_memory_account_) {

336

84

    buffer_memory_account_->clearDownstream();

337

84

338

339

95960

  StreamImpl::destroy();

340

95960

341

342

1259860

http2::adapter::HeaderRep getRep(const HeaderString& str) {

343

1259860

  if (str.isReference()) {

344

505906

    return str.getStringView();

345

811808

  } else {

346

753954

    return std::string(str.getStringView());

347

753954

348

1259860

349

350

std::vector<http2::adapter::Header>

351

118963

ConnectionImpl::StreamImpl::buildHeaders(const HeaderMap& headers) {

352

118963

  std::vector<http2::adapter::Header> out;

353

118963

  out.reserve(headers.size());

354

629930

  headers.iterate([&out](const HeaderEntry& header) -> HeaderMap::Iterate {

355

629930

    out.push_back({getRep(header.key()), getRep(header.value())});

356

629930

    return HeaderMap::Iterate::Continue;

357

629930

});

358

118963

  return out;

359

118963

360

361

154

void ConnectionImpl::ServerStreamImpl::encode1xxHeaders(const ResponseHeaderMap& headers) {

362

154

  ASSERT(HeaderUtility::isSpecial1xx(headers));

363

154

  encodeHeaders(headers, false);

364

154

365

366

117325

void ConnectionImpl::StreamImpl::encodeHeadersBase(const HeaderMap& headers, bool end_stream) {

367

117325

  local_end_stream_ = end_stream;

368

369

117325

  bytes_meter_->addDecompressedHeaderBytesSent(headers.byteSize());

370

371

117325

  submitHeaders(headers, end_stream);

372

117325

  if (parent_.sendPendingFramesAndHandleError()) {

373

    // Intended to check through coverage that this error case is tested

374

8

    return;

375

8

376

117325

377

378

Status ConnectionImpl::ClientStreamImpl::encodeHeaders(const RequestHeaderMap& headers,

379

52442

                                                       bool end_stream) {

380

52442

  parent_.updateActiveStreamsOnEncode(*this);

381

52442

#ifndef ENVOY_ENABLE_UHV

382

  // Headers are now validated by UHV before encoding by the codec. Two checks below are not needed

383

  // when UHV is enabled.

384

//

385

  // Required headers must be present. This can only happen by some erroneous processing after the

386

  // downstream codecs decode.

387

52442

  RETURN_IF_ERROR(HeaderUtility::checkRequiredRequestHeaders(headers));

388

  // Verify that a filter hasn't added an invalid header key or value.

389

52428

  RETURN_IF_ERROR(HeaderUtility::checkValidRequestHeaders(headers));

390

  // Extended CONNECT to H/1 upgrade transformation has moved to UHV

391

  // This must exist outside of the scope of isUpgrade as the underlying memory is

392

  // needed until encodeHeadersBase has been called.

393

52424

  Http::RequestHeaderMapPtr modified_headers;

394

52424

  if (Http::Utility::isUpgrade(headers)) {

395

188

    modified_headers = createHeaderMap<RequestHeaderMapImpl>(headers);

396

188

    upgrade_type_ = std::string(headers.getUpgradeValue());

397

188

    Http::Utility::transformUpgradeRequestFromH1toH2(*modified_headers);

398

188

    encodeHeadersBase(*modified_headers, end_stream);

399

52403

  } else if (headers.Method() && headers.Method()->value() == "CONNECT") {

400

600

    modified_headers = createHeaderMap<RequestHeaderMapImpl>(headers);

401

600

    modified_headers->removeScheme();

402

600

    modified_headers->removePath();

403

600

    modified_headers->removeProtocol();

404

600

    encodeHeadersBase(*modified_headers, end_stream);

405

52189

  } else {

406

51636

    encodeHeadersBase(headers, end_stream);

407

51636

408

#else

409

  encodeHeadersBase(headers, end_stream);

410

#endif

411

52424

  return okStatus();

412

52428

413

414

void ConnectionImpl::ServerStreamImpl::encodeHeaders(const ResponseHeaderMap& headers,

415

64902

                                                     bool end_stream) {

416

64902

  parent_.updateActiveStreamsOnEncode(*this);

417

  // The contract is that client codecs must ensure that :status is present.

418

64902

  ASSERT(headers.Status() != nullptr);

419

420

64902

#ifndef ENVOY_ENABLE_UHV

421

  // Extended CONNECT to H/1 upgrade transformation has moved to UHV

422

  // This must exist outside of the scope of isUpgrade as the underlying memory is

423

  // needed until encodeHeadersBase has been called.

424

64902

  Http::ResponseHeaderMapPtr modified_headers;

425

64902

  if (Http::Utility::isUpgrade(headers)) {

426

54

    modified_headers = createHeaderMap<ResponseHeaderMapImpl>(headers);

427

54

    Http::Utility::transformUpgradeResponseFromH1toH2(*modified_headers);

428

54

    encodeHeadersBase(*modified_headers, end_stream);

429

64866

  } else {

430

64848

    encodeHeadersBase(headers, end_stream);

431

64848

432

#else

433

  encodeHeadersBase(headers, end_stream);

434

#endif

435

64902

436

437

6617

void ConnectionImpl::StreamImpl::encodeTrailersBase(const HeaderMap& trailers) {

438

6617

  parent_.updateActiveStreamsOnEncode(*this);

439

6617

  ASSERT(!local_end_stream_);

440

6617

  local_end_stream_ = true;

441

442

6617

  bytes_meter_->addDecompressedHeaderBytesSent(trailers.byteSize());

443

444

6617

  if (pending_send_data_->length() > 0) {

445

    // In this case we want trailers to come after we release all pending body data that is

446

    // waiting on window updates. We need to save the trailers so that we can emit them later.

447

    // However, for empty trailers, we don't need to to save the trailers.

448

24

    ASSERT(!pending_trailers_to_encode_);

449

24

    const bool skip_encoding_empty_trailers = trailers.empty();

450

24

    if (!skip_encoding_empty_trailers) {

451

22

      pending_trailers_to_encode_ = cloneTrailers(trailers);

452

22

      onLocalEndStream();

453

22

454

6593

  } else {

455

6593

    submitTrailers(trailers);

456

6593

    if (parent_.sendPendingFramesAndHandleError()) {

457

      // Intended to check through coverage that this error case is tested

458

4

      return;

459

4

460

6593

461

6617

462

463

2874

void ConnectionImpl::StreamImpl::encodeMetadata(const MetadataMapVector& metadata_map_vector) {

464

2874

  parent_.updateActiveStreamsOnEncode(*this);

465

2874

  ASSERT(parent_.allow_metadata_);

466

2874

  NewMetadataEncoder& metadata_encoder = getMetadataEncoder();

467

2874

  auto sources_vec = metadata_encoder.createSources(metadata_map_vector);

468

2964

  for (auto& source : sources_vec) {

469

2964

    parent_.adapter_->SubmitMetadata(stream_id_, 16 * 1024, std::move(source));

470

2964

471

472

2874

  if (parent_.sendPendingFramesAndHandleError()) {

473

    // Intended to check through coverage that this error case is tested

474

4

    return;

475

4

476

2874

477

478

452414

void ConnectionImpl::StreamImpl::processBufferedData() {

479

452414

  ENVOY_CONN_LOG(debug, "Stream {} processing buffered data.", parent_.connection_, stream_id_);

480

481

  // Restore crash dump context when processing buffered data.

482

452414

  Event::Dispatcher& dispatcher = parent_.connection_.dispatcher();

483

  // This method is only called from a callback placed directly on the

484

  // dispatcher, as such the dispatcher shouldn't have any tracked objects.

485

452414

  ASSERT(dispatcher.trackedObjectStackIsEmpty());

486

452414

  Envoy::ScopeTrackedObjectStack stack;

487

452414

  stack.add(parent_.connection_);

488

489

452414

  absl::Cleanup clear_current_stream_id = [this]() { parent_.current_stream_id_.reset(); };

490

  // TODO(kbaichoo): When we add support to *ConnectionImpl::getStream* for

491

  // deferred closed streams we can use their stream id here.

492

452414

  if (!stream_manager_.buffered_on_stream_close_) {

493

448506

    ASSERT(!parent_.current_stream_id_.has_value());

494

448506

    parent_.current_stream_id_ = stream_id_;

495

448506

496

497

452414

  stack.add(parent_);

498

452414

  ScopeTrackerScopeState scope{&stack, dispatcher};

499

500

452414

  if (stream_manager_.body_buffered_ && continueProcessingBufferedData()) {

501

333864

    decodeData();

502

333864

503

504

452414

  if (stream_manager_.trailers_buffered_ && !stream_manager_.body_buffered_ &&

505

452414

      continueProcessingBufferedData()) {

506

16

    decodeTrailers();

507

16

    ASSERT(!stream_manager_.trailers_buffered_);

508

16

509

510

  // Reset cases are handled by resetStream and directly invoke onStreamClose,

511

  // which consumes the buffered_on_stream_close_ so we don't invoke

512

  // onStreamClose twice.

513

452414

  if (stream_manager_.buffered_on_stream_close_ && !stream_manager_.hasBufferedBodyOrTrailers()) {

514

101

    ASSERT(!reset_reason_.has_value());

515

101

    ENVOY_CONN_LOG(debug, "invoking onStreamClose for stream: {} via processBufferedData",

516

101

                   parent_.connection_, stream_id_);

517

    // We only buffer the onStreamClose if we had no errors.

518

101

    Status status = parent_.onStreamClose(this, 0);

519

101

    ASSERT(status.ok());

520

101

521

452414

522

523

170963

void ConnectionImpl::StreamImpl::grantPeerAdditionalStreamWindow() {

524

170963

  parent_.adapter_->MarkDataConsumedForStream(stream_id_, unconsumed_bytes_);

525

170963

  unconsumed_bytes_ = 0;

526

170963

  if (parent_.sendPendingFramesAndHandleError()) {

527

    // Intended to check through coverage that this error case is tested

528

2

    return;

529

2

530

170963

531

532

419116

void ConnectionImpl::StreamImpl::readDisable(bool disable) {

533

419116

  ENVOY_CONN_LOG(debug, "Stream {} {}, unconsumed_bytes {} read_disable_count {}",

534

419116

                 parent_.connection_, stream_id_, (disable ? "disabled" : "enabled"),

535

419116

                 unconsumed_bytes_, read_disable_count_);

536

419116

  if (disable) {

537

209569

    ++read_disable_count_;

538

209569

  } else {

539

209547

    ASSERT(read_disable_count_ > 0);

540

209547

    --read_disable_count_;

541

209547

    if (!buffersOverrun()) {

542

209497

      scheduleProcessingOfBufferedData(false);

543

209497

      if (shouldAllowPeerAdditionalStreamWindow()) {

544

170423

        grantPeerAdditionalStreamWindow();

545

170423

546

209497

547

209547

548

419116

549

550

470899

void ConnectionImpl::StreamImpl::scheduleProcessingOfBufferedData(bool schedule_next_iteration) {

551

470899

  if (stream_manager_.hasBufferedBodyOrTrailers()) {

552

465979

    if (!process_buffered_data_callback_) {

553

563

      process_buffered_data_callback_ = parent_.connection_.dispatcher().createSchedulableCallback(

554

452416

          [this]() { processBufferedData(); });

555

563

556

557

    // We schedule processing to occur in another callback to avoid

558

    // reentrant and deep call stacks.

559

465979

    if (schedule_next_iteration) {

560

261402

      process_buffered_data_callback_->scheduleCallbackNextIteration();

561

400407

    } else {

562

204577

      process_buffered_data_callback_->scheduleCallbackCurrentIteration();

563

204577

564

465979

565

470899

566

567

544

void ConnectionImpl::StreamImpl::pendingRecvBufferHighWatermark() {

568

  // Due to deferred processing of backed up streams, this is a NOP: read

569

  // disabling here can become dangerous as it can prevent us from processing

570

  // buffered data.

571

544

572

573

540

void ConnectionImpl::StreamImpl::pendingRecvBufferLowWatermark() {

574

  // Due to deferred processing of backed up streams, we don't read disable on

575

  // high watermark, so we shouldn't read disable here.

576

540

  if (shouldAllowPeerAdditionalStreamWindow()) {

577

    // We should grant additional stream window here, in case the

578

    // `pending_recv_buffer_` was blocking flow control updates

579

    // from going to the peer.

580

540

    grantPeerAdditionalStreamWindow();

581

540

582

540

583

584

684789

void ConnectionImpl::StreamImpl::decodeData() {

585

684789

  if (buffersOverrun()) {

586

30252

    ENVOY_CONN_LOG(trace, "Stream {} buffering decodeData() call.", parent_.connection_,

587

30252

                   stream_id_);

588

30252

    stream_manager_.body_buffered_ = true;

589

30252

    return;

590

30252

591

592

  // Some buffered body will be consumed. If there remains buffered body after

593

  // this call, set this to true.

594

654537

  stream_manager_.body_buffered_ = false;

595

596

654537

  bool already_drained_data = false;

597

  // It's possible that we are waiting to send a deferred reset, so only raise data if local

598

  // is not complete.

599

654537

  if (!deferred_reset_) {

600

    // We should decode data in chunks only if we have defer processing enabled

601

    // with a non-zero defer_processing_segment_size, and the buffer holds more

602

    // data than the defer_processing_segment_size. Otherwise, push the

603

    // entire buffer through.

604

654208

    const bool decode_data_in_chunk =

605

654208

        stream_manager_.decodeAsChunks() &&

606

654208

        pending_recv_data_->length() > stream_manager_.defer_processing_segment_size_;

607

608

654208

    StreamDecoder* stream_decoder = decoder();

609

654208

    if (decode_data_in_chunk) {

610

350865

      Buffer::OwnedImpl chunk_buffer;

611

      // TODO(kbaichoo): Consider implementing an approximate move for chunking.

612

350865

      chunk_buffer.move(*pending_recv_data_, stream_manager_.defer_processing_segment_size_);

613

614

      // With the current implementation this should always be true,

615

      // though this can change with approximation.

616

350865

      stream_manager_.body_buffered_ = true;

617

350865

      ASSERT(pending_recv_data_->length() > 0);

618

619

350865

      if (stream_decoder) {

620

350865

        stream_decoder->decodeData(chunk_buffer, sendEndStream());

621

350865

622

350865

      already_drained_data = true;

623

624

350865

      if (!buffersOverrun()) {

625

261402

        scheduleProcessingOfBufferedData(true);

626

261402

627

502962

    } else {

628

      // Send the entire buffer through.

629

303475

      if (stream_decoder) {

630

303475

        stream_decoder->decodeData(*pending_recv_data_, sendEndStream());

631

303475

632

303343

633

654208

634

635

654537

  if (!already_drained_data) {

636

303689

    pending_recv_data_->drain(pending_recv_data_->length());

637

303689

638

654537

639

640

41688

void ConnectionImpl::ClientStreamImpl::decodeHeaders() {

641

41688

  auto& headers = absl::get<ResponseHeaderMapPtr>(headers_or_trailers_);

642

41688

#ifndef ENVOY_ENABLE_UHV

643

41688

  const uint64_t status = Http::Utility::getResponseStatus(*headers);

644

645

  // Extended CONNECT to H/1 upgrade transformation has moved to UHV

646

41688

  if (!upgrade_type_.empty() && headers->Status()) {

647

170

    Http::Utility::transformUpgradeResponseFromH2toH1(*headers, upgrade_type_);

648

170

649

#else

650

  // In UHV mode the :status header at this point can be malformed, as it is validated

651

  // later on in the response_decoder_.decodeHeaders() call.

652

  // Account for this here.

653

  absl::optional<uint64_t> status_opt = Http::Utility::getResponseStatusOrNullopt(*headers);

654

  if (!status_opt.has_value()) {

655

    // In case the status is invalid or missing, the response_decoder_.decodeHeaders() will fail the

656

    // request

657

    response_decoder_.decodeHeaders(std::move(headers), sendEndStream());

658

    return;

659

660

  const uint64_t status = status_opt.value();

661

#endif

662

  // Non-informational headers are non-1xx OR 101-SwitchingProtocols, since 101 implies that further

663

  // proxying is on an upgrade path.

664

  // TODO(#29071) determine how to handle 101, since it is not supported by HTTP/2

665

41688

  received_noninformational_headers_ =

666

41688

      !CodeUtility::is1xx(status) || status == enumToInt(Http::Code::SwitchingProtocols);

667

668

41688

  if (HeaderUtility::isSpecial1xx(*headers)) {

669

160

    response_decoder_.decode1xxHeaders(std::move(headers));

670

41528

  } else {

671

41528

    response_decoder_.decodeHeaders(std::move(headers), sendEndStream());

672

41528

673

41688

674

675

1567

bool ConnectionImpl::StreamImpl::maybeDeferDecodeTrailers() {

676

1567

  ASSERT(!deferred_reset_.has_value());

677

  // Buffer trailers if we're deferring processing and not flushing all data

678

  // through and either

679

  // 1) Buffers are overrun

680

  // 2) There's buffered body which should get processed before these trailers

681

  //    to avoid losing data.

682

1567

  if (buffersOverrun() || stream_manager_.body_buffered_) {

683

17

    stream_manager_.trailers_buffered_ = true;

684

17

    ENVOY_CONN_LOG(trace, "Stream {} buffering decodeTrailers() call.", parent_.connection_,

685

17

                   stream_id_);

686

17

    return true;

687

17

688

689

1550

  return false;

690

1567

691

692

878

void ConnectionImpl::ClientStreamImpl::decodeTrailers() {

693

878

  if (maybeDeferDecodeTrailers()) {

694

12

    return;

695

12

696

697

  // Consume any buffered trailers.

698

866

  stream_manager_.trailers_buffered_ = false;

699

700

866

  response_decoder_.decodeTrailers(

701

866

      std::move(absl::get<ResponseTrailerMapPtr>(headers_or_trailers_)));

702

866

703

704

95097

void ConnectionImpl::ServerStreamImpl::decodeHeaders() {

705

95097

  auto& headers = absl::get<RequestHeaderMapSharedPtr>(headers_or_trailers_);

706

95097

#ifndef ENVOY_ENABLE_UHV

707

  // Extended CONNECT to H/1 upgrade transformation has moved to UHV

708

95097

  if (Http::Utility::isH2UpgradeRequest(*headers)) {

709

186

    Http::Utility::transformUpgradeRequestFromH2toH1(*headers);

710

186

711

95097

#endif

712

95097

  RequestDecoder* request_decoder = request_decoder_handle_->get().ptr();

713

95097

  ENVOY_BUG(request_decoder != nullptr, "Missing request_decoder_");

714

95097

  if (request_decoder) {

715

95097

    request_decoder->decodeHeaders(std::move(headers), sendEndStream());

716

95097

717

95097

718

719

689

void ConnectionImpl::ServerStreamImpl::decodeTrailers() {

720

689

  if (maybeDeferDecodeTrailers()) {

721

5

    return;

722

5

723

724

  // Consume any buffered trailers.

725

684

  stream_manager_.trailers_buffered_ = false;

726

727

684

  RequestDecoder* request_decoder = request_decoder_handle_->get().ptr();

728

684

  ENVOY_BUG(request_decoder != nullptr, "Missing request_decoder_");

729

684

  if (request_decoder) {

730

684

    request_decoder->decodeTrailers(

731

684

        std::move(absl::get<RequestTrailerMapPtr>(headers_or_trailers_)));

732

684

733

684

734

735

67

void ConnectionImpl::StreamImpl::pendingSendBufferHighWatermark() {

736

67

  ENVOY_CONN_LOG(debug, "send buffer over limit ", parent_.connection_);

737

67

  ASSERT(!pending_send_buffer_high_watermark_called_);

738

67

  pending_send_buffer_high_watermark_called_ = true;

739

67

  runHighWatermarkCallbacks();

740

67

741

742

55

void ConnectionImpl::StreamImpl::pendingSendBufferLowWatermark() {

743

55

  ENVOY_CONN_LOG(debug, "send buffer under limit ", parent_.connection_);

744

55

  ASSERT(pending_send_buffer_high_watermark_called_);

745

55

  pending_send_buffer_high_watermark_called_ = false;

746

55

  runLowWatermarkCallbacks();

747

55

748

749

764089

void ConnectionImpl::StreamImpl::saveHeader(HeaderString&& name, HeaderString&& value) {

750

764089

  if (!Utility::reconstituteCrumbledCookies(name, value, cookies_)) {

751

755769

    headers().addViaMove(std::move(name), std::move(value));

752

755769

753

764089

754

755

6613

void ConnectionImpl::StreamImpl::submitTrailers(const HeaderMap& trailers) {

756

6613

  ASSERT(local_end_stream_);

757

6613

  const bool skip_encoding_empty_trailers = trailers.empty();

758

6613

  if (skip_encoding_empty_trailers) {

759

4975

    ENVOY_CONN_LOG(debug, "skipping submitting trailers", parent_.connection_);

760

761

    // Instead of submitting empty trailers, we send empty data instead.

762

4975

    Buffer::OwnedImpl empty_buffer;

763

4975

    encodeDataHelper(empty_buffer, /*end_stream=*/true, skip_encoding_empty_trailers);

764

4975

    return;

765

4975

766

767

1638

  std::vector<http2::adapter::Header> final_headers = buildHeaders(trailers);

768

1638

  parent_.adapter_->SubmitTrailer(stream_id_, final_headers);

769

1638

770

771

52424

void ConnectionImpl::ClientStreamImpl::submitHeaders(const HeaderMap& headers, bool end_stream) {

772

52424

  ASSERT(stream_id_ == -1);

773

52424

  stream_id_ = parent_.adapter_->SubmitRequest(buildHeaders(headers), end_stream, base());

774

52424

  ASSERT(stream_id_ > 0);

775

52424

776

777

42809

Status ConnectionImpl::ClientStreamImpl::onBeginHeaders() {

778

42809

  if (headers_state_ == HeadersState::Headers) {

779

1018

    allocTrailers();

780

1018

781

782

42809

  return okStatus();

783

42809

784

785

42555

void ConnectionImpl::ClientStreamImpl::advanceHeadersState() {

786

42555

  RELEASE_ASSERT(

787

42555

      headers_state_ == HeadersState::Response || headers_state_ == HeadersState::Headers, "");

788

42555

  headers_state_ = HeadersState::Headers;

789

42555

790

791

64902

void ConnectionImpl::ServerStreamImpl::submitHeaders(const HeaderMap& headers, bool end_stream) {

792

64902

  ASSERT(stream_id_ != -1);

793

64902

  parent_.adapter_->SubmitResponse(stream_id_, buildHeaders(headers), end_stream);

794

64902

795

796

96673

Status ConnectionImpl::ServerStreamImpl::onBeginHeaders() {

797

96673

  if (headers_state_ != HeadersState::Request) {

798

713

    parent_.stats_.trailers_.inc();

799

713

    ASSERT(headers_state_ == HeadersState::Headers);

800

801

713

    allocTrailers();

802

713

803

804

96673

  return okStatus();

805

96673

806

807

95785

void ConnectionImpl::ServerStreamImpl::advanceHeadersState() {

808

95785

  RELEASE_ASSERT(headers_state_ == HeadersState::Request || headers_state_ == HeadersState::Headers,

809

95785

                 "");

810

95785

  headers_state_ = HeadersState::Headers;

811

95785

812

813

13

void ConnectionImpl::StreamImpl::onPendingFlushTimer() {

814

13

  ENVOY_CONN_LOG(debug, "pending stream flush timeout", parent_.connection_);

815

13

  MultiplexedStreamImplBase::onPendingFlushTimer();

816

13

  parent_.stats_.tx_flush_timeout_.inc();

817

13

  ASSERT(local_end_stream_ && !local_end_stream_sent_);

818

  // This will emit a reset frame for this stream and close the stream locally.

819

  // Only the stream adapter's reset callback should run as other higher layers

820

  // think the stream is already finished.

821

13

  resetStreamWorker(StreamResetReason::LocalReset);

822

13

  if (parent_.sendPendingFramesAndHandleError()) {

823

    // Intended to check through coverage that this error case is tested

824

4

    return;

825

4

826

13

827

828

416776

void ConnectionImpl::StreamImpl::encodeData(Buffer::Instance& data, bool end_stream) {

829

416776

  parent_.updateActiveStreamsOnEncode(*this);

830

416776

  ASSERT(!local_end_stream_);

831

416776

  encodeDataHelper(data, end_stream,

832

                   /*skip_encoding_empty_trailers=*/

833

416776

                   false);

834

416776

835

836

void ConnectionImpl::StreamImpl::encodeDataHelper(Buffer::Instance& data, bool end_stream,

837

421750

                                                  bool skip_encoding_empty_trailers) {

838

421750

  if (skip_encoding_empty_trailers) {

839

4975

    ASSERT(data.length() == 0 && end_stream);

840

4975

841

842

421750

  local_end_stream_ = end_stream;

843

421750

  parent_.stats_.pending_send_bytes_.add(data.length());

844

421750

  pending_send_data_->move(data);

845

421751

  if (data_deferred_) {

846

419687

    bool success = parent_.adapter_->ResumeStream(stream_id_);

847

419687

    ASSERT(success);

848

849

419687

    data_deferred_ = false;

850

419687

851

852

421750

  if (parent_.sendPendingFramesAndHandleError()) {

853

    // Intended to check through coverage that this error case is tested

854

110

    return;

855

110

856

421640

  if (local_end_stream_) {

857

18935

    onLocalEndStream();

858

18935

859

421640

860

861

1158

void ConnectionImpl::ServerStreamImpl::resetStream(StreamResetReason reason) {

862

  // Clear the downstream on the account since we're resetting the downstream.

863

1158

  if (buffer_memory_account_) {

864

12

    buffer_memory_account_->clearDownstream();

865

12

866

867

1158

  StreamImpl::resetStream(reason);

868

1158

869

870

13591

void ConnectionImpl::StreamImpl::resetStream(StreamResetReason reason) {

871

13591

  reset_reason_ = reason;

872

873

  // Higher layers expect calling resetStream() to immediately raise reset callbacks.

874

13591

  runResetCallbacks(reason, absl::string_view());

875

876

  // If we've bufferedOnStreamClose for this stream, we shouldn't propagate this

877

  // reset as nghttp2 will have forgotten about the stream.

878

13591

  if (stream_manager_.buffered_on_stream_close_) {

879

8

    ENVOY_CONN_LOG(

880

8

        trace, "Stopped propagating reset to codec as we've buffered onStreamClose for stream {}",

881

8

        parent_.connection_, stream_id_);

882

    // The stream didn't originally have an NGHTTP2 error, since we buffered

883

    // its stream close.

884

8

    if (Status status = parent_.onStreamClose(this, 0); !status.ok()) {

885

      ENVOY_CONN_LOG(debug, "error invoking onStreamClose: {}", parent_.connection_,

886

                     status.message()); // LCOV_EXCL_LINE

887

888

8

    return;

889

8

890

891

  // If we submit a reset, the codec may cancel outbound frames that have not yet been sent.

892

  // We want these frames to go out so we defer the reset until we send all of the frames that

893

  // end the local stream. However, if we're resetting the stream due to

894

  // overload, we should reset the stream as soon as possible to free used

895

  // resources.

896

13583

  if (useDeferredReset() && local_end_stream_ && !local_end_stream_sent_ &&

897

13583

      reason != StreamResetReason::OverloadManager) {

898

303

    ASSERT(parent_.getStreamUnchecked(stream_id_) != nullptr);

899

303

    parent_.pending_deferred_reset_streams_.emplace(stream_id_, this);

900

303

    deferred_reset_ = reason;

901

303

    ENVOY_CONN_LOG(trace, "deferred reset stream", parent_.connection_);

902

13418

  } else {

903

13280

    resetStreamWorker(reason);

904

13280

905

906

  // We must still call sendPendingFrames() in both the deferred and not deferred path. This forces

907

  // the cleanup logic to run which will reset the stream in all cases if all data frames could not

908

  // be sent.

909

13583

  if (parent_.sendPendingFramesAndHandleError()) {

910

    // Intended to check through coverage that this error case is tested

911

58

    return;

912

58

913

13583

914

915

13388

void ConnectionImpl::StreamImpl::resetStreamWorker(StreamResetReason reason) {

916

13388

  if (stream_id_ == -1) {

917

    // Handle the case where client streams are reset before headers are created.

918

    // For example, if we send local reply after the stream is created but before

919

    // headers are sent, we will end up here.

920

613

    ENVOY_CONN_LOG(trace, "Stream {} reset before headers sent.", parent_.connection_, stream_id_);

921

613

    Status status = parent_.onStreamClose(this, 0);

922

613

    ASSERT(status.ok());

923

613

    return;

924

613

925

12775

  if (codec_callbacks_) {

926

    // TODO(wbpcode): this ensure that onCodecLowLevelReset is only called once. But

927

    // we should replace this with a better design later.

928

    // See https://github.com/envoyproxy/envoy/issues/42264 for why we need this.

929

27

    if (!codec_low_level_reset_is_called_) {

930

27

      codec_low_level_reset_is_called_ = true;

931

27

      codec_callbacks_->onCodecLowLevelReset();

932

27

933

27

934

935

12775

  const bool response_end_stream_sent =

936

12775

      parent_.adapter_->IsServerSession() ? local_end_stream_sent_ : false;

937

12775

  parent_.adapter_->SubmitRst(stream_id_, static_cast<http2::adapter::Http2ErrorCode>(

938

12775

                                              reasonToReset(reason, response_end_stream_sent)));

939

12775

940

941

2874

NewMetadataEncoder& ConnectionImpl::StreamImpl::getMetadataEncoder() {

942

2874

  if (metadata_encoder_ == nullptr) {

943

254

    metadata_encoder_ = std::make_unique<NewMetadataEncoder>();

944

254

945

2874

  return *metadata_encoder_;

946

2874

947

948

5509

MetadataDecoder& ConnectionImpl::StreamImpl::getMetadataDecoder() {

949

5509

  if (metadata_decoder_ == nullptr) {

950

2355

    auto cb = [this](MetadataMapPtr&& metadata_map_ptr) {

951

2354

      this->onMetadataDecoded(std::move(metadata_map_ptr));

952

2354

};

953

287

    metadata_decoder_ = std::make_unique<MetadataDecoder>(cb, parent_.max_metadata_size_);

954

287

955

5509

  return *metadata_decoder_;

956

5509

957

958

2354

void ConnectionImpl::StreamImpl::onMetadataDecoded(MetadataMapPtr&& metadata_map_ptr) {

959

  // Empty metadata maps should not be decoded.

960

2354

  if (metadata_map_ptr->empty()) {

961

5

    ENVOY_CONN_LOG(debug, "decode metadata called with empty map, skipping", parent_.connection_);

962

5

    parent_.stats_.metadata_empty_frames_.inc();

963

2349

  } else {

964

2349

    StreamDecoder* stream_decoder = decoder();

965

2349

    if (stream_decoder) {

966

2349

      stream_decoder->decodeMetadata(std::move(metadata_map_ptr));

967

2349

968

2349

969

2354

970

971

94280

void ConnectionImpl::StreamImpl::setAccount(Buffer::BufferMemoryAccountSharedPtr account) {

972

94280

  buffer_memory_account_ = account;

973

94280

  pending_recv_data_->bindAccount(buffer_memory_account_);

974

94280

  pending_send_data_->bindAccount(buffer_memory_account_);

975

94280

976

977

ConnectionImpl::ConnectionImpl(Network::Connection& connection, CodecStats& stats,

978

                               Random::RandomGenerator& random_generator,

979

                               const envoy::config::core::v3::Http2ProtocolOptions& http2_options,

980

                               const uint32_t max_headers_kb, const uint32_t max_headers_count)

981

30684

    : stats_(stats), connection_(connection), max_headers_kb_(max_headers_kb),

982

30684

      max_headers_count_(max_headers_count),

983

30684

      per_stream_buffer_limit_(http2_options.initial_stream_window_size().value()),

984

      stream_error_on_invalid_http_messaging_(

985

30684

          http2_options.override_stream_error_on_invalid_http_message().value()),

986

30684

      protocol_constraints_(stats, http2_options), dispatching_(false), raised_goaway_(false),

987

30684

      random_(random_generator),

988

30684

      last_received_data_time_(connection_.dispatcher().timeSource().monotonicTime()) {

989

30684

  if (http2_options.has_use_oghttp2_codec()) {

990

2

    use_oghttp2_library_ = http2_options.use_oghttp2_codec().value();

991

30682

  } else {

992

30682

    use_oghttp2_library_ =

993

30682

        Runtime::runtimeFeatureEnabled("envoy.reloadable_features.http2_use_oghttp2");

994

30682

995

30684

  if (http2_options.has_connection_keepalive()) {

996

14

    keepalive_interval_ = std::chrono::milliseconds(

997

14

        PROTOBUF_GET_MS_OR_DEFAULT(http2_options.connection_keepalive(), interval, 0));

998

14

    keepalive_timeout_ = std::chrono::milliseconds(

999

14

        PROTOBUF_GET_MS_REQUIRED(http2_options.connection_keepalive(), timeout));

1000

14

    keepalive_interval_jitter_percent_ = PROTOBUF_GET_WRAPPED_OR_DEFAULT(

1001

14

        http2_options.connection_keepalive(), interval_jitter, 15.0);

1002

1003

14

    if (keepalive_interval_.count() > 0) {

1004

512

      keepalive_send_timer_ = connection.dispatcher().createTimer([this]() { sendKeepalive(); });

1005

12

1006

14

    keepalive_timeout_timer_ =

1007

14

        connection.dispatcher().createTimer([this]() { onKeepaliveResponseTimeout(); });

1008

1009

    // This call schedules the initial interval, with jitter.

1010

14

    onKeepaliveResponse();

1011

14

1012

30684

1013

1014

30684

ConnectionImpl::~ConnectionImpl() {

1015

81594

  for (const auto& stream : active_streams_) {

1016

57908

    stream->destroy();

1017

57908

1018

30684

1019

1020

512

void ConnectionImpl::sendKeepalive() {

1021

512

  ASSERT(keepalive_timeout_timer_);

1022

512

  if (keepalive_timeout_timer_->enabled()) {

1023

    ENVOY_CONN_LOG(trace, "Skipping PING: already awaiting PING ACK", connection_);

1024

    return;

1025

1026

1027

  // Include the current time as the payload to help with debugging.

1028

512

  SystemTime now = connection_.dispatcher().timeSource().systemTime();

1029

512

  uint64_t ms_since_epoch =

1030

512

      std::chrono::duration_cast<std::chrono::milliseconds>(now.time_since_epoch()).count();

1031

512

  ENVOY_CONN_LOG(trace, "Sending keepalive PING {}", connection_, ms_since_epoch);

1032

1033

512

  adapter_->SubmitPing(ms_since_epoch);

1034

1035

512

  if (sendPendingFramesAndHandleError()) {

1036

    // Intended to check through coverage that this error case is tested

1037

4

    return;

1038

4

1039

508

  keepalive_timeout_timer_->enableTimer(keepalive_timeout_);

1040

508

1041

1042

2522

void ConnectionImpl::onKeepaliveResponse() {

1043

  // Check the timers for nullptr in case the peer sent an unsolicited PING ACK.

1044

2522

  if (keepalive_timeout_timer_ != nullptr) {

1045

518

    keepalive_timeout_timer_->disableTimer();

1046

518

1047

2522

  if (keepalive_send_timer_ != nullptr && keepalive_interval_.count()) {

1048

516

    uint64_t interval_ms = keepalive_interval_.count();

1049

516

    const uint64_t jitter_percent_mod = keepalive_interval_jitter_percent_ * interval_ms / 100;

1050

516

    if (jitter_percent_mod > 0) {

1051

504

      interval_ms += random_.random() % jitter_percent_mod;

1052

504

1053

516

    keepalive_send_timer_->enableTimer(std::chrono::milliseconds(interval_ms));

1054

516

1055

2522

1056

1057

4

void ConnectionImpl::onKeepaliveResponseTimeout() {

1058

4

  ENVOY_CONN_LOG_EVENT(debug, "h2_ping_timeout", "Closing connection due to keepalive timeout",

1059

4

                       connection_);

1060

4

  stats_.keepalive_timeout_.inc();

1061

4

  connection_.close(Network::ConnectionCloseType::NoFlush,

1062

4

                    StreamInfo::LocalCloseReasons::get().Http2PingTimeout);

1063

4

1064

1065

4

bool ConnectionImpl::slowContainsStreamId(int32_t stream_id) const {

1066

4

  for (const auto& stream : active_streams_) {

1067

4

    if (stream->stream_id_ == stream_id) {

1068

2

      return true;

1069

2

1070

4

1071

1072

2

  return false;

1073

4

1074

1075

294641

Http::Status ConnectionImpl::dispatch(Buffer::Instance& data) {

1076

294641

  ScopeTrackerScopeState scope(this, connection_.dispatcher());

1077

294641

  ENVOY_CONN_LOG(trace, "dispatching {} bytes", connection_, data.length());

1078

  // Make sure that dispatching_ is set to false after dispatching, even when

1079

  // ConnectionImpl::dispatch returns early or throws an exception (consider removing if there is a

1080

  // single return after exception removal (#10878)).

1081

294643

  Cleanup cleanup([this]() {

1082

294642

    dispatching_ = false;

1083

294642

    current_slice_ = nullptr;

1084

294642

    current_stream_id_.reset();

1085

294642

});

1086

294641

  last_received_data_time_ = connection_.dispatcher().timeSource().monotonicTime();

1087

393074

  for (const Buffer::RawSlice& slice : data.getRawSlices()) {

1088

393021

    current_slice_ = &slice;

1089

393021

    dispatching_ = true;

1090

393021

    ssize_t rc;

1091

393021

    rc = adapter_->ProcessBytes(absl::string_view(static_cast<char*>(slice.mem_), slice.len_));

1092

393021

    if (!codec_callback_status_.ok()) {

1093

476

      return codec_callback_status_;

1094

476

1095

392545

#ifdef ENVOY_NGHTTP2

1096

    // This error is returned when nghttp2 library detected a frame flood by one of its

1097

    // internal mechanisms. Most flood protection is done by Envoy's codec and this error

1098

    // should never be returned. However it is handled here in case nghttp2 has some flood

1099

    // protections that Envoy's codec does not have.

1100

392545

    static const int ERR_FLOODED = -904;

1101

392545

    if (rc == ERR_FLOODED) {

1102

      return bufferFloodError(

1103

          "Flooding was detected in this HTTP/2 session, and it must be closed"); // LCOV_EXCL_LINE

1104

1105

392545

#endif

1106

392545

    if (rc != static_cast<ssize_t>(slice.len_)) {

1107

762

      return codecProtocolError(codecStrError(rc));

1108

762

1109

1110

391783

    current_slice_ = nullptr;

1111

391783

    dispatching_ = false;

1112

391783

    current_stream_id_.reset();

1113

391783

1114

1115

293403

  ENVOY_CONN_LOG(trace, "dispatched {} bytes", connection_, data.length());

1116

293403

  data.drain(data.length());

1117

1118

  // Decoding incoming frames can generate outbound frames so flush pending.

1119

293403

  return sendPendingFrames();

1120

294641

1121

1122

6

const ConnectionImpl::StreamImpl* ConnectionImpl::getStream(int32_t stream_id) const {

1123

  // Delegate to the non-const version.

1124

6

  return const_cast<ConnectionImpl*>(this)->getStream(stream_id);

1125

6

1126

1127

2089109

ConnectionImpl::StreamImpl* ConnectionImpl::getStream(int32_t stream_id) {

1128

2089109

  StreamImpl* stream = getStreamUnchecked(stream_id);

1129

2089109

  SLOW_ASSERT(stream != nullptr || !slowContainsStreamId(stream_id));

1130

2089109

  return stream;

1131

2089109

1132

1133

2

const ConnectionImpl::StreamImpl* ConnectionImpl::getStreamUnchecked(int32_t stream_id) const {

1134

  // Delegate to the non-const version.

1135

2

  return const_cast<ConnectionImpl*>(this)->getStreamUnchecked(stream_id);

1136

2

1137

1138

4822125

ConnectionImpl::StreamImpl* ConnectionImpl::getStreamUnchecked(int32_t stream_id) {

1139

4822125

  return static_cast<StreamImpl*>(adapter_->GetStreamUserData(stream_id));

1140

4822125

1141

1142

457461

int ConnectionImpl::onData(int32_t stream_id, const uint8_t* data, size_t len) {

1143

457461

  ASSERT(connection_.state() == Network::Connection::State::Open);

1144

457461

  StreamImpl* stream = getStream(stream_id);

1145

  // If this results in buffering too much data, the watermark buffer will call

1146

  // pendingRecvBufferHighWatermark, resulting in ++read_disable_count_

1147

457461

  stream->pending_recv_data_->add(data, len);

1148

  // Update the window to the peer unless some consumer of this stream's data has hit a flow control

1149

  // limit and disabled reads on this stream

1150

457462

  if (stream->shouldAllowPeerAdditionalStreamWindow()) {

1151

394887

    adapter_->MarkDataConsumedForStream(stream_id, len);

1152

416425

  } else {

1153

62575

    stream->unconsumed_bytes_ += len;

1154

62575

1155

457461

  return 0;

1156

457461

1157

1158

114

void ConnectionImpl::goAway() {

1159

114

  adapter_->SubmitGoAway(adapter_->GetHighestReceivedStreamId(),

1160

114

                         http2::adapter::Http2ErrorCode::HTTP2_NO_ERROR, "");

1161

114

  stats_.goaway_sent_.inc();

1162

114

  if (sendPendingFramesAndHandleError()) {

1163

    // Intended to check through coverage that this error case is tested

1164

4

    return;

1165

4

1166

114

1167

1168

119

void ConnectionImpl::shutdownNotice() {

1169

119

  adapter_->SubmitShutdownNotice();

1170

1171

119

  if (sendPendingFramesAndHandleError()) {

1172

    // Intended to check through coverage that this error case is tested

1173

8

    return;

1174

8

1175

119

1176

1177

3

Status ConnectionImpl::protocolErrorForTest() {

1178

3

  adapter_->SubmitGoAway(adapter_->GetHighestReceivedStreamId(),

1179

3

                         http2::adapter::Http2ErrorCode::PROTOCOL_ERROR, "");

1180

1181

3

  return sendPendingFrames();

1182

3

1183

1184

Status ConnectionImpl::onBeforeFrameReceived(int32_t stream_id, size_t length, uint8_t type,

1185

619972

                                             uint8_t flags) {

1186

619972

  ENVOY_CONN_LOG(trace, "about to recv frame type={}, flags={}, stream_id={}", connection_,

1187

619972

                 static_cast<uint64_t>(type), static_cast<uint64_t>(flags), stream_id);

1188

619972

  ASSERT(connection_.state() == Network::Connection::State::Open);

1189

1190

619972

  current_stream_id_ = stream_id;

1191

619972

  if (type == OGHTTP2_PING_FRAME_TYPE && (flags & FLAG_ACK)) {

1192

2508

    return okStatus();

1193

2508

1194

1195

  // In slow networks, HOL blocking can prevent the ping response from coming in a reasonable

1196

  // amount of time. To avoid HOL blocking influence, if we receive *any* frame extend the

1197

  // timeout for another timeout period. This will still timeout the connection if there is no

1198

  // activity, but if there is frame activity we assume the connection is still healthy and the

1199

  // PING ACK may be delayed behind other frames.

1200

617464

  if (keepalive_timeout_timer_ != nullptr && keepalive_timeout_timer_->enabled()) {

1201

2

    keepalive_timeout_timer_->enableTimer(keepalive_timeout_);

1202

2

1203

1204

  // Track all the frames without padding here, since this is the only callback we receive

1205

  // for some of them (e.g. CONTINUATION frame, frames sent on closed streams, etc.).

1206

  // DATA frame is tracked in onFrameReceived().

1207

617464

  auto status = okStatus();

1208

617464

  if (type != OGHTTP2_DATA_FRAME_TYPE) {

1209

266432

    status = trackInboundFrames(stream_id, length, type, flags, 0);

1210

266432

1211

1212

617464

  return status;

1213

619972

1214

1215

ABSL_MUST_USE_RESULT

1216

155

enum GoAwayErrorCode ngHttp2ErrorCodeToErrorCode(uint32_t code) noexcept {

1217

155

  switch (code) {

1218

146

  case OGHTTP2_NO_ERROR:

1219

146

    return GoAwayErrorCode::NoError;

1220

9

  default:

1221

9

    return GoAwayErrorCode::Other;

1222

155

1223

155

1224

1225

12376

Status ConnectionImpl::onPing(uint64_t opaque_data, bool is_ack) {

1226

12376

  ENVOY_CONN_LOG(trace, "recv frame type=PING", connection_);

1227

12376

  ASSERT(connection_.state() == Network::Connection::State::Open);

1228

1229

12376

  if (is_ack) {

1230

2508

    ENVOY_CONN_LOG(trace, "recv PING ACK {}", connection_, opaque_data);

1231

1232

2508

    onKeepaliveResponse();

1233

2508

1234

12376

  return okStatus();

1235

12376

1236

1237

Status ConnectionImpl::onBeginData(int32_t stream_id, size_t length, uint8_t flags,

1238

350947

                                   size_t padding) {

1239

350947

  ENVOY_CONN_LOG(trace, "recv frame type=DATA stream_id={}", connection_, stream_id);

1240

350947

  RETURN_IF_ERROR(trackInboundFrames(stream_id, length, OGHTTP2_DATA_FRAME_TYPE, flags, padding));

1241

1242

350934

  StreamImpl* stream = getStreamUnchecked(stream_id);

1243

350934

  if (!stream) {

1244

    return okStatus();

1245

1246

1247

  // Track bytes received.

1248

350934

  stream->bytes_meter_->addWireBytesReceived(length + H2_FRAME_HEADER_SIZE);

1249

1250

350934

  stream->remote_end_stream_ = flags & FLAG_END_STREAM;

1251

350934

  stream->decodeData();

1252

350934

  return okStatus();

1253

350934

1254

1255

192

Status ConnectionImpl::onGoAway(uint32_t error_code) {

1256

192

  ENVOY_CONN_LOG(trace, "recv frame type=GOAWAY", connection_);

1257

  // Only raise GOAWAY once, since we don't currently expose stream information. Shutdown

1258

  // notifications are the same as a normal GOAWAY.

1259

  // TODO: handle multiple GOAWAY frames.

1260

192

  if (!raised_goaway_) {

1261

155

    raised_goaway_ = true;

1262

155

    callbacks().onGoAway(ngHttp2ErrorCodeToErrorCode(error_code));

1263

155

1264

192

  return okStatus();

1265

192

1266

1267

138340

Status ConnectionImpl::onHeaders(int32_t stream_id, size_t length, uint8_t flags) {

1268

138340

  StreamImpl* stream = getStreamUnchecked(stream_id);

1269

138340

  if (!stream) {

1270

    return okStatus();

1271

1272

  // Track bytes received.

1273

138340

  stream->bytes_meter_->addWireBytesReceived(length + H2_FRAME_HEADER_SIZE);

1274

138340

  stream->bytes_meter_->addHeaderBytesReceived(length + H2_FRAME_HEADER_SIZE);

1275

1276

138340

  stream->remote_end_stream_ = flags & FLAG_END_STREAM;

1277

138340

  if (!stream->cookies_.empty()) {

1278

252

    HeaderString key(Headers::get().Cookie);

1279

252

    stream->headers().addViaMove(std::move(key), std::move(stream->cookies_));

1280

252

1281

1282

138340

  StreamImpl::HeadersState headers_state = stream->headersState();

1283

138340

  switch (headers_state) {

1284

41543

  case StreamImpl::HeadersState::Response:

1285

136640

  case StreamImpl::HeadersState::Request: {

1286

136640

    stream->decodeHeaders();

1287

136640

    break;

1288

41543

1289

1290

1700

  case StreamImpl::HeadersState::Headers: {

1291

    // It's possible that we are waiting to send a deferred reset, so only raise headers/trailers

1292

    // if local is not complete.

1293

1700

    if (!stream->deferred_reset_) {

1294

1696

      if (adapter_->IsServerSession() || stream->received_noninformational_headers_) {

1295

1551

        ASSERT(stream->remote_end_stream_);

1296

1551

        stream->decodeTrailers();

1297

1583

      } else {

1298

        // We're a client session and still waiting for non-informational headers.

1299

145

        stream->decodeHeaders();

1300

145

1301

1696

1302

1700

    break;

1303

41543

1304

1305

  default:

1306

    // We do not currently support push.

1307

    ENVOY_BUG(false, "push not supported"); // LCOV_EXCL_LINE

1308

138340

1309

1310

138340

  stream->advanceHeadersState();

1311

138340

  return okStatus();

1312

138340

1313

1314

4350

Status ConnectionImpl::onRstStream(int32_t stream_id, uint32_t error_code) {

1315

4350

  ENVOY_CONN_LOG(trace, "recv frame type=RST_STREAM stream_id={}", connection_, stream_id);

1316

4350

  StreamImpl* stream = getStreamUnchecked(stream_id);

1317

4350

  if (!stream) {

1318

51

    return okStatus();

1319

51

1320

4299

  ENVOY_CONN_LOG(trace, "remote reset: {} {}", connection_, stream_id, error_code);

1321

  // Track bytes received.

1322

4299

  stream->bytes_meter_->addWireBytesReceived(/*frame_length=*/4 + H2_FRAME_HEADER_SIZE);

1323

4299

  stream->remote_rst_ = true;

1324

4299

  stats_.rx_reset_.inc();

1325

4299

  return okStatus();

1326

4350

1327

1328

int ConnectionImpl::onFrameSend(int32_t stream_id, size_t length, uint8_t type, uint8_t flags,

1329

768818

                                uint32_t error_code) {

1330

  // The codec library does not cleanly give us a way to determine whether we received invalid

1331

  // data from our peer. Sometimes it raises the invalid frame callback, and sometimes it does not.

1332

  // In all cases however it will attempt to send a GOAWAY frame with an error status. If we see

1333

  // an outgoing frame of this type, we will return an error code so that we can abort execution.

1334

768818

  ENVOY_CONN_LOG(trace, "sent frame type={}, stream_id={}, length={}", connection_,

1335

768818

                 static_cast<uint64_t>(type), stream_id, length);

1336

768818

  StreamImpl* stream = getStreamUnchecked(stream_id);

1337

768818

  if (stream != nullptr) {

1338

663230

    if (type != METADATA_FRAME_TYPE) {

1339

660156

      stream->bytes_meter_->addWireBytesSent(length + H2_FRAME_HEADER_SIZE);

1340

660156

1341

663230

    if (type == OGHTTP2_HEADERS_FRAME_TYPE || type == OGHTTP2_CONTINUATION_FRAME_TYPE) {

1342

118955

      stream->bytes_meter_->addHeaderBytesSent(length + H2_FRAME_HEADER_SIZE);

1343

118955

1344

663230

1345

768818

  switch (type) {

1346

284

  case OGHTTP2_GOAWAY_FRAME_TYPE: {

1347

284

    ENVOY_CONN_LOG(debug, "sent goaway code={}", connection_, error_code);

1348

284

    if (error_code != OGHTTP2_NO_ERROR) {

1349

      // TODO(mattklein123): Returning this error code abandons standard nghttp2 frame accounting.

1350

      // As such, it is not reliable to call sendPendingFrames() again after this and we assume

1351

      // that the connection is going to get torn down immediately. One byproduct of this is that

1352

      // we need to cancel all pending flush stream timeouts since they can race with connection

1353

      // teardown. As part of the work to remove exceptions we should aim to clean up all of this

1354

      // error handling logic and only handle this type of case at the end of dispatch.

1355

68

      for (auto& stream : active_streams_) {

1356

58

        stream->disarmStreamFlushTimer();

1357

58

1358

68

      return ERR_CALLBACK_FAILURE;

1359

68

1360

216

    break;

1361

284

1362

1363

7413

  case OGHTTP2_RST_STREAM_FRAME_TYPE: {

1364

7350

    ENVOY_CONN_LOG(debug, "sent reset code={}", connection_, error_code);

1365

7350

    stats_.tx_reset_.inc();

1366

7350

    if (stream != nullptr && !stream->local_end_stream_sent_) {

1367

      // The RST_STREAM may preempt further DATA frames, and serves as the

1368

      // notification of the end of the stream.

1369

6045

      stream->onResetEncoded(error_code);

1370

6045

      stream->local_end_stream_sent_ = true;

1371

6045

1372

7350

    break;

1373

284

1374

1375

118955

  case OGHTTP2_HEADERS_FRAME_TYPE:

1376

647388

  case OGHTTP2_DATA_FRAME_TYPE: {

1377

    // This should be the case since we're sending these frames. It's possible

1378

    // that codec fuzzers would incorrectly send frames for non-existent streams

1379

    // which is why this is not an assert.

1380

647389

    if (stream != nullptr) {

1381

647389

      const bool end_stream_sent = flags & FLAG_END_STREAM;

1382

647389

      stream->local_end_stream_sent_ = end_stream_sent;

1383

647389

      if (end_stream_sent) {

1384

82905

        stream->onEndStreamEncoded();

1385

82905

1386

647389

1387

647388

    break;

1388

118955

1389

768818

1390

1391

768745

  return 0;

1392

768818

1393

1394

668

int ConnectionImpl::onError(absl::string_view error) {

1395

668

  ENVOY_CONN_LOG(debug, "invalid http2: {}", connection_, error);

1396

668

  return 0;

1397

668

1398

1399

1064

int ConnectionImpl::onInvalidFrame(int32_t stream_id, int error_code) {

1400

1064

  ENVOY_CONN_LOG(debug, "invalid frame: {} on stream {}", connection_, codecStrError(error_code),

1401

1064

                 stream_id);

1402

1403

  // Set details of error_code in the stream whenever we have one.

1404

1064

  StreamImpl* stream = getStreamUnchecked(stream_id);

1405

1064

  if (stream != nullptr) {

1406

1045

    stream->setDetails(Http2ResponseCodeDetails::get().errorDetails(error_code));

1407

1045

1408

1409

1064

  switch (error_code) {

1410

4

  case ERR_REFUSED_STREAM:

1411

1412

4

    stats_.stream_refused_errors_.inc();

1413

4

    return 0;

1414

1415

871

  case ERR_HTTP_HEADER:

1416

1044

  case ERR_HTTP_MESSAGING:

1417

1044

    stats_.rx_messaging_error_.inc();

1418

1044

    if (stream_error_on_invalid_http_messaging_) {

1419

      // The stream is about to be closed due to an invalid header or messaging. Don't kill the

1420

      // entire connection if one stream has bad headers or messaging.

1421

308

      if (stream != nullptr) {

1422

        // See comment below in onStreamClose() for why we do this.

1423

308

        stream->reset_due_to_messaging_error_ = true;

1424

308

1425

308

      return 0;

1426

308

1427

736

    break;

1428

1429

736

  case ERR_FLOW_CONTROL:

1430

16

  case ERR_PROTO:

1431

16

  case ERR_STREAM_CLOSED:

1432

    // Known error conditions that should trigger connection close.

1433

16

    break;

1434

1435

  default:

1436

    // Unknown error conditions. Trigger ENVOY_BUG and connection close.

1437

    ENVOY_BUG(false, absl::StrCat("Unexpected error_code: ", error_code)); // LCOV_EXCL_LINE

1438

    break;

1439

1064

1440

1441

  // Cause dispatch to return with an error code.

1442

752

  return ERR_CALLBACK_FAILURE;

1443

1064

1444

1445

int ConnectionImpl::onBeforeFrameSend(int32_t /*stream_id*/, size_t /*length*/, uint8_t type,

1446

240383

                                      uint8_t flags) {

1447

240383

  ENVOY_CONN_LOG(trace, "about to send frame type={}, flags={}", connection_,

1448

240383

                 static_cast<uint64_t>(type), static_cast<uint64_t>(flags));

1449

240383

  ASSERT(!is_outbound_flood_monitored_control_frame_);

1450

  // Flag flood monitored outbound control frames.

1451

240383

  is_outbound_flood_monitored_control_frame_ =

1452

240384

      ((type == OGHTTP2_PING_FRAME_TYPE || type == OGHTTP2_SETTINGS_FRAME_TYPE) &&

1453

240383

       flags & FLAG_ACK) ||

1454

240383

      type == OGHTTP2_RST_STREAM_FRAME_TYPE;

1455

240383

  return 0;

1456

240383

1457

1458

void ConnectionImpl::addOutboundFrameFragment(Buffer::OwnedImpl& output, const uint8_t* data,

1459

787423

                                              size_t length) {

1460

  // Reset the outbound frame type (set in the onBeforeFrameSend callback) since the

1461

  // onBeforeFrameSend callback is not called for DATA frames.

1462

787423

  bool is_outbound_flood_monitored_control_frame = false;

1463

787423

  std::swap(is_outbound_flood_monitored_control_frame, is_outbound_flood_monitored_control_frame_);

1464

787423

  auto releasor =

1465

787423

      protocol_constraints_.incrementOutboundFrameCount(is_outbound_flood_monitored_control_frame);

1466

787423

  output.add(data, length);

1467

787423

  output.addDrainTracker(releasor);

1468

787423

1469

1470

Status ConnectionImpl::trackInboundFrames(int32_t stream_id, size_t length, uint8_t type,

1471

617376

                                          uint8_t flags, uint32_t padding_length) {

1472

617376

  Status result;

1473

617376

  ENVOY_CONN_LOG(trace, "track inbound frame type={} flags={} length={} padding_length={}",

1474

617376

                 connection_, static_cast<uint64_t>(type), static_cast<uint64_t>(flags),

1475

617376

                 static_cast<uint64_t>(length), padding_length);

1476

1477

617376

  const bool end_stream = (type == OGHTTP2_DATA_FRAME_TYPE || type == OGHTTP2_HEADERS_FRAME_TYPE) &&

1478

617376

                          (flags & FLAG_END_STREAM);

1479

617376

  const bool is_empty = (length - padding_length) == 0;

1480

617376

  result = protocol_constraints_.trackInboundFrame(type, end_stream, is_empty);

1481

617376

  if (!result.ok()) {

1482

32

    ENVOY_CONN_LOG(trace, "error reading frame: {} received in this HTTP/2 session.", connection_,

1483

32

                   result.message());

1484

32

    if (isInboundFramesWithEmptyPayloadError(result)) {

1485

14

      ConnectionImpl::StreamImpl* stream = getStreamUnchecked(stream_id);

1486

14

      if (stream) {

1487

12

        stream->setDetails(Http2ResponseCodeDetails::get().inbound_empty_frame_flood);

1488

12

1489

      // Above if is defensive, because the stream has just been created and therefore always

1490

      // exists.

1491

14

1492

32

1493

617376

  return result;

1494

617376

1495

1496

258985

ssize_t ConnectionImpl::onSend(const uint8_t* data, size_t length) {

1497

258985

  ENVOY_CONN_LOG(trace, "send data: bytes={}", connection_, length);

1498

258985

  Buffer::OwnedImpl buffer;

1499

258985

  addOutboundFrameFragment(buffer, data, length);

1500

1501

  // While the buffer is transient the fragment it contains will be moved into the

1502

  // write_buffer_ of the underlying connection_ by the write method below.

1503

  // This creates lifetime dependency between the write_buffer_ of the underlying connection

1504

  // and the codec object. Specifically the write_buffer_ MUST be either fully drained or

1505

  // deleted before the codec object is deleted. This is presently guaranteed by the

1506

  // destruction order of the Network::ConnectionImpl object where write_buffer_ is

1507

  // destroyed before the filter_manager_ which owns the codec through Http::ConnectionManagerImpl.

1508

258985

  connection_.write(buffer, false);

1509

258985

  return length;

1510

258985

1511

1512

91236

Status ConnectionImpl::onStreamClose(StreamImpl* stream, uint32_t error_code) {

1513

91236

  if (stream) {

1514

91222

    const int32_t stream_id = stream->stream_id_;

1515

1516

    // Consume buffered on stream_close.

1517

91222

    if (stream->stream_manager_.buffered_on_stream_close_) {

1518

109

      stream->stream_manager_.buffered_on_stream_close_ = false;

1519

109

      stats_.deferred_stream_close_.dec();

1520

109

1521

1522

91222

    ENVOY_CONN_LOG(debug, "stream {} closed: {}", connection_, stream_id, error_code);

1523

1524

    // Even if we have received both the remote_end_stream and the

1525

    // local_end_stream (e.g. we have all the data for the response), if we've

1526

    // received a remote reset we should reset the stream.

1527

    // We only do so currently for server side streams by checking for

1528

    // extend_stream_lifetime_flag_ as its observers all unregisters stream

1529

    // callbacks.

1530

91222

    bool should_reset_stream = !stream->remote_end_stream_ || !stream->local_end_stream_;

1531

91222

    if (stream->extend_stream_lifetime_flag_) {

1532

30667

      should_reset_stream = should_reset_stream || stream->remote_rst_;

1533

30667

1534

1535

91222

    if (should_reset_stream) {

1536

11841

      StreamResetReason reason;

1537

11841

      if (stream->reset_due_to_messaging_error_) {

1538

        // Unfortunately, the nghttp2 API makes it incredibly difficult to clearly understand

1539

        // the flow of resets. I.e., did the reset originate locally? Was it remote? Here,

1540

        // we attempt to track cases in which we sent a reset locally due to an invalid frame

1541

        // received from the remote. We only do that in two cases currently (HTTP messaging layer

1542

        // errors from https://tools.ietf.org/html/rfc7540#section-8 which nghttp2 is very strict

1543

        // about). In other cases we treat invalid frames as a protocol error and just kill

1544

        // the connection.

1545

1546

        // Get ClientConnectionImpl or ServerConnectionImpl specific stream reset reason,

1547

        // depending whether the connection is upstream or downstream.

1548

308

        reason = getMessagingErrorResetReason();

1549

11735

      } else {

1550

11533

        if (Runtime::runtimeFeatureEnabled("envoy.reloadable_features.reset_with_error")) {

1551

11517

          reason = errorCodeToResetReason(error_code);

1552

11517

          if (error_code == OGHTTP2_REFUSED_STREAM) {

1553

22

            stream->setDetails(Http2ResponseCodeDetails::get().remote_refused);

1554

11495

          } else {

1555

11495

            stream->setDetails(Http2ResponseCodeDetails::get().remote_reset);

1556

11495

1557

11517

        } else {

1558

16

          if (error_code == OGHTTP2_REFUSED_STREAM) {

1559

            reason = StreamResetReason::RemoteRefusedStreamReset;

1560

            stream->setDetails(Http2ResponseCodeDetails::get().remote_refused);

1561

16

          } else {

1562

16

            if (error_code == OGHTTP2_CONNECT_ERROR) {

1563

              reason = StreamResetReason::ConnectError;

1564

16

            } else {

1565

16

              reason = StreamResetReason::RemoteReset;

1566

16

1567

16

            stream->setDetails(Http2ResponseCodeDetails::get().remote_reset);

1568

16

1569

16

1570

11533

1571

11841

      stream->runResetCallbacks(reason, absl::string_view());

1572

1573

84817

    } else if (!stream->reset_reason_.has_value() &&

1574

79381

               stream->stream_manager_.hasBufferedBodyOrTrailers()) {

1575

109

      ENVOY_CONN_LOG(debug, "buffered onStreamClose for stream: {}", connection_, stream_id);

1576

      // Buffer the call, rely on the stream->process_buffered_data_callback_

1577

      // to end up invoking.

1578

109

      stream->stream_manager_.buffered_on_stream_close_ = true;

1579

109

      stats_.deferred_stream_close_.inc();

1580

109

      return okStatus();

1581

109

1582

1583

91113

    stream->destroy();

1584

91113

    current_stream_id_.reset();

1585

    // TODO(antoniovicente) Test coverage for onCloseStream before deferred reset handling happens.

1586

91113

    pending_deferred_reset_streams_.erase(stream->stream_id_);

1587

1588

91113

    connection_.dispatcher().deferredDelete(stream->removeFromList(active_streams_));

1589

    // Any unconsumed data must be consumed before the stream is deleted.

1590

    // nghttp2 does not appear to track this internally, and any stream deleted

1591

    // with outstanding window will contribute to a slow connection-window leak.

1592

91113

    ENVOY_CONN_LOG(debug, "Recouping {} bytes of flow control window for stream {}.", connection_,

1593

91113

                   stream->unconsumed_bytes_, stream_id);

1594

91113

    adapter_->MarkDataConsumedForStream(stream_id, stream->unconsumed_bytes_);

1595

91113

    stream->unconsumed_bytes_ = 0;

1596

91113

    adapter_->SetStreamUserData(stream->stream_id_, nullptr);

1597

91113

1598

1599

91127

  return okStatus();

1600

91236

1601

1602

90514

Status ConnectionImpl::onStreamClose(int32_t stream_id, uint32_t error_code) {

1603

90514

  return onStreamClose(getStreamUnchecked(stream_id), error_code);

1604

90514

1605

1606

3160

int ConnectionImpl::onMetadataReceived(int32_t stream_id, const uint8_t* data, size_t len) {

1607

3160

  ENVOY_CONN_LOG(trace, "recv {} bytes METADATA", connection_, len);

1608

1609

3160

  StreamImpl* stream = getStreamUnchecked(stream_id);

1610

3160

  if (!stream || stream->remote_end_stream_) {

1611

7

    if (!stream) {

1612

3

      ENVOY_CONN_LOG(debug, "no stream for stream_id {} while receiving METADATA", connection_,

1613

3

                     stream_id);

1614

3

1615

7

    return 0;

1616

7

1617

1618

3153

  bool success = stream->getMetadataDecoder().receiveMetadata(data, len);

1619

3153

  return success ? 0 : ERR_CALLBACK_FAILURE;

1620

3160

1621

1622

2363

int ConnectionImpl::onMetadataFrameComplete(int32_t stream_id, bool end_metadata) {

1623

2363

  ENVOY_CONN_LOG(trace, "recv METADATA frame on stream {}, end_metadata: {}", connection_,

1624

2363

                 stream_id, end_metadata);

1625

1626

2363

  StreamImpl* stream = getStreamUnchecked(stream_id);

1627

2363

  if (!stream || stream->remote_end_stream_) {

1628

7

    if (!stream) {

1629

3

      ENVOY_CONN_LOG(debug, "no stream for stream_id {} while completing METADATA", connection_,

1630

3

                     stream_id);

1631

3

1632

7

    return 0;

1633

7

1634

1635

2356

  bool result = stream->getMetadataDecoder().onMetadataFrameComplete(end_metadata);

1636

2356

  return result ? 0 : ERR_CALLBACK_FAILURE;

1637

2363

1638

1639

764109

int ConnectionImpl::saveHeader(int32_t stream_id, HeaderString&& name, HeaderString&& value) {

1640

764109

  StreamImpl* stream = getStreamUnchecked(stream_id);

1641

764109

  if (!stream) {

1642

    // We have seen 1 or 2 crashes where we get a headers callback but there is no associated

1643

    // stream data. I honestly am not sure how this can happen. However, from reading the nghttp2

1644

    // code it looks possible that inflate_header_block() can safely inflate headers for an already

1645

    // closed stream, but will still call the headers callback. Since that seems possible, we should

1646

    // ignore this case here.

1647

    // TODO(mattklein123): Figure out a test case that can hit this.

1648

    stats_.headers_cb_no_stream_.inc();

1649

    return 0;

1650

1651

1652

764109

  stream->bytes_meter_->addDecompressedHeaderBytesReceived(name.size() + value.size());

1653

1654

  // TODO(10646): Switch to use HeaderUtility::checkHeaderNameForUnderscores().

1655

764109

  auto should_return = checkHeaderNameForUnderscores(name.getStringView());

1656

764109

  if (should_return) {

1657

22

    stream->setDetails(Http2ResponseCodeDetails::get().invalid_underscore);

1658

22

    name.clear();

1659

22

    value.clear();

1660

22

    return should_return.value();

1661

22

1662

1663

764087

  stream->saveHeader(std::move(name), std::move(value));

1664

1665

764087

  if (stream->headers().byteSize() > max_headers_kb_ * 1024 ||

1666

764088

      stream->headers().size() > max_headers_count_) {

1667

25

    stream->setDetails(Http2ResponseCodeDetails::get().too_many_headers);

1668

25

    stats_.header_overflow_.inc();

1669

    // This will cause the library to reset/close the stream.

1670

25

    return ERR_TEMPORAL_CALLBACK_FAILURE;

1671

764062

  } else {

1672

764062

    return 0;

1673

764062

1674

764087

1675

1676

1027265

Status ConnectionImpl::sendPendingFrames() {

1677

1027265

  if (dispatching_ || connection_.state() == Network::Connection::State::Closed) {

1678

14722

    return okStatus();

1679

14722

1680

1681

1012543

  const int rc = adapter_->Send();

1682

1012543

  if (rc != 0) {

1683

69

    ASSERT(rc == ERR_CALLBACK_FAILURE);

1684

69

    return codecProtocolError(codecStrError(rc));

1685

69

1686

1687

  // See ConnectionImpl::StreamImpl::resetStream() for why we do this. This is an uncommon event,

1688

  // so iterating through every stream to find the ones that have a deferred reset is not a big

1689

  // deal. Furthermore, queueing a reset frame does not actually invoke the close stream callback.

1690

  // This is only done when the reset frame is sent. Thus, it's safe to work directly with the

1691

  // stream map.

1692

  // NOTE: The way we handle deferred reset is essentially best effort. If we intend to do a

1693

  //       deferred reset, we try to finish the stream, including writing any pending data frames.

1694

  //       If we cannot do this (potentially due to not enough window), we just reset the stream.

1695

  //       In general this behavior occurs only when we are trying to send immediate error messages

1696

  //       to short circuit requests. In the best effort case, we complete the stream before

1697

  //       resetting. In other cases, we just do the reset now which will blow away pending data

1698

  //       frames and release any memory associated with the stream.

1699

1012474

  if (!pending_deferred_reset_streams_.empty()) {

1700

190

    while (!pending_deferred_reset_streams_.empty()) {

1701

95

      auto it = pending_deferred_reset_streams_.begin();

1702

95

      auto* stream = it->second;

1703

      // Sanity check: the stream's id matches the map key.

1704

95

      ASSERT(it->first == stream->stream_id_);

1705

95

      pending_deferred_reset_streams_.erase(it);

1706

95

      ASSERT(stream->deferred_reset_);

1707

95

      stream->resetStreamWorker(stream->deferred_reset_.value());

1708

95

1709

95

    RETURN_IF_ERROR(sendPendingFrames());

1710

95

1711

1712

  // After all pending frames have been written into the outbound buffer check if any of

1713

  // protocol constraints had been violated.

1714

1012474

  Status status = protocol_constraints_.checkOutboundFrameLimits();

1715

1012474

  if (!status.ok()) {

1716

234

    ENVOY_CONN_LOG(debug, "error sending frames: Too many frames in the outbound queue.",

1717

234

                   connection_);

1718

234

1719

1012474

  return status;

1720

1012474

1721

1722

733847

bool ConnectionImpl::sendPendingFramesAndHandleError() {

1723

733847

  if (!sendPendingFrames().ok()) {

1724

206

    scheduleProtocolConstraintViolationCallback();

1725

206

    return true;

1726

206

1727

733641

  return false;

1728

733847

1729

1730

void ConnectionImpl::sendSettingsHelper(

1731

30684

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options, bool disable_push) {

1732

30684

  absl::InlinedVector<http2::adapter::Http2Setting, 10> settings;

1733

30684

  auto insertParameter = [&settings](const http2::adapter::Http2Setting& entry) mutable -> bool {

1734

    // Consider using a set as an intermediate data structure, rather than this ad-hoc

1735

    // deduplication.

1736

8

    const auto it = std::find_if(

1737

8

        settings.cbegin(), settings.cend(),

1738

10

        [&entry](const http2::adapter::Http2Setting& existing) { return entry.id == existing.id; });

1739

8

    if (it != settings.end()) {

1740

      return false;

1741

1742

8

    settings.push_back(entry);

1743

8

    return true;

1744

8

};

1745

1746

  // Universally disable receiving push promise frames as we don't currently

1747

  // support them.

1748

  // NOTE: This is a special case with respect to custom parameter overrides in

1749

  // that server push is not supported and therefore not end user configurable.

1750

30684

  if (disable_push) {

1751

14963

    settings.push_back({static_cast<int32_t>(http2::adapter::ENABLE_PUSH), disable_push ? 0U : 1U});

1752

14963

1753

1754

30684

  for (const auto& it : http2_options.custom_settings_parameters()) {

1755

8

    ASSERT(it.identifier().value() <= std::numeric_limits<uint16_t>::max());

1756

8

    const bool result =

1757

8

        insertParameter({static_cast<http2::adapter::Http2SettingsId>(it.identifier().value()),

1758

8

                         it.value().value()});

1759

8

    ASSERT(result);

1760

8

    ENVOY_CONN_LOG(debug, "adding custom settings parameter with id {:#x} to {}", connection_,

1761

8

                   it.identifier().value(), it.value().value());

1762

8

1763

1764

  // Insert named parameters.

1765

30684

  settings.insert(

1766

30684

      settings.end(),

1767

30684

      {{http2::adapter::HEADER_TABLE_SIZE, http2_options.hpack_table_size().value()},

1768

30684

       {http2::adapter::ENABLE_CONNECT_PROTOCOL, http2_options.allow_connect()},

1769

30684

       {http2::adapter::MAX_CONCURRENT_STREAMS, http2_options.max_concurrent_streams().value()},

1770

30684

       {http2::adapter::INITIAL_WINDOW_SIZE, http2_options.initial_stream_window_size().value()}});

1771

30684

  adapter_->SubmitSettings(settings);

1772

30684

1773

1774

void ConnectionImpl::sendSettings(

1775

30684

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options, bool disable_push) {

1776

30684

  sendSettingsHelper(http2_options, disable_push);

1777

1778

30684

  const uint32_t initial_connection_window_size =

1779

30684

      http2_options.initial_connection_window_size().value();

1780

  // Increase connection window size up to our default size.

1781

30684

  if (initial_connection_window_size != INITIAL_CONNECTION_WINDOW_SIZE) {

1782

30105

    ENVOY_CONN_LOG(debug, "updating connection-level initial window size to {}", connection_,

1783

30105

                   initial_connection_window_size);

1784

30105

    adapter_->SubmitWindowUpdate(0,

1785

30105

                                 initial_connection_window_size - INITIAL_CONNECTION_WINDOW_SIZE);

1786

30105

1787

30684

1788

1789

1351818

int ConnectionImpl::setAndCheckCodecCallbackStatus(Status&& status) {

1790

  // Keep the error status that caused the original failure. Subsequent

1791

  // error statuses are silently discarded.

1792

1351818

  codec_callback_status_.Update(std::move(status));

1793

1351820

  if (codec_callback_status_.ok() && connection_.state() != Network::Connection::State::Open) {

1794

445

    if (!active_streams_.empty() || !raised_goaway_) {

1795

418

      codec_callback_status_ = codecProtocolError("Connection was closed while dispatching frames");

1796

431

    } else {

1797

27

      codec_callback_status_ = goAwayGracefulCloseError();

1798

27

1799

445

1800

1801

1347648

  return codec_callback_status_.ok() ? 0 : ERR_CALLBACK_FAILURE;

1802

1351818

1803

1804

206

void ConnectionImpl::scheduleProtocolConstraintViolationCallback() {

1805

206

  if (!protocol_constraint_violation_callback_) {

1806

52

    protocol_constraint_violation_callback_ = connection_.dispatcher().createSchedulableCallback(

1807

52

        [this]() { onProtocolConstraintViolation(); });

1808

52

    protocol_constraint_violation_callback_->scheduleCallbackCurrentIteration();

1809

52

1810

206

1811

1812

52

void ConnectionImpl::onProtocolConstraintViolation() {

1813

  // Flooded outbound queue implies that peer is not reading and it does not

1814

  // make sense to try to flush pending bytes.

1815

52

  connection_.close(Envoy::Network::ConnectionCloseType::NoFlush,

1816

52

                    StreamInfo::LocalCloseReasons::get().Http2ConnectionProtocolViolation);

1817

52

1818

1819

76502

void ConnectionImpl::onUnderlyingConnectionBelowWriteBufferLowWatermark() {

1820

  // Notify the streams based on least recently encoding to the connection.

1821

254704

  for (auto it = active_streams_.rbegin(); it != active_streams_.rend(); ++it) {

1822

178202

    (*it)->runLowWatermarkCallbacks();

1823

178202

1824

76502

1825

1826

30684

ConnectionImpl::Http2Visitor::Http2Visitor(ConnectionImpl* connection) : connection_(connection) {}

1827

1828

258990

int64_t ConnectionImpl::Http2Visitor::OnReadyToSend(absl::string_view serialized) {

1829

258990

  return connection_->onSend(reinterpret_cast<const uint8_t*>(serialized.data()),

1830

258990

                             serialized.size());

1831

258990

1832

1833

ConnectionImpl::Http2Visitor::DataFrameHeaderInfo

1834

ConnectionImpl::Http2Visitor::OnReadyToSendDataForStream(Http2StreamId stream_id,

1835

963676

                                                         size_t max_length) {

1836

963676

  StreamImpl* stream = connection_->getStream(stream_id);

1837

963676

  if (stream == nullptr) {

1838

    return {/*payload_length=*/-1, /*end_data=*/false, /*end_stream=*/false};

1839

1840

963676

  if (stream->pending_send_data_->length() == 0 && !stream->local_end_stream_) {

1841

435243

    stream->data_deferred_ = true;

1842

435243

    return {/*payload_length=*/0, /*end_data=*/false, /*end_stream=*/false};

1843

435243

1844

528433

  const size_t length = std::min<size_t>(max_length, stream->pending_send_data_->length());

1845

528433

  bool end_data = false;

1846

528433

  bool end_stream = false;

1847

528433

  if (stream->local_end_stream_ && length == stream->pending_send_data_->length()) {

1848

18592

    end_data = true;

1849

18592

    if (stream->pending_trailers_to_encode_) {

1850

20

      stream->submitTrailers(*stream->pending_trailers_to_encode_);

1851

20

      stream->pending_trailers_to_encode_.reset();

1852

18572

    } else {

1853

18572

      end_stream = true;

1854

18572

1855

18592

1856

528433

  return {static_cast<int64_t>(length), end_data, end_stream};

1857

963676

1858

1859

bool ConnectionImpl::Http2Visitor::SendDataFrame(Http2StreamId stream_id,

1860

                                                 absl::string_view frame_header,

1861

528434

                                                 size_t payload_length) {

1862

528434

  connection_->protocol_constraints_.incrementOutboundDataFrameCount();

1863

1864

528434

  StreamImpl* stream = connection_->getStream(stream_id);

1865

528434

  if (stream == nullptr) {

1866

    ENVOY_CONN_LOG(error, "error sending data frame: stream {} not found", connection_->connection_,

1867

                   stream_id);

1868

    return false;

1869

1870

528434

  Buffer::OwnedImpl output;

1871

528434

  connection_->addOutboundFrameFragment(

1872

528434

      output, reinterpret_cast<const uint8_t*>(frame_header.data()), frame_header.size());

1873

528434

  if (!connection_->protocol_constraints_.checkOutboundFrameLimits().ok()) {

1874

112

    ENVOY_CONN_LOG(debug, "error sending data frame: Too many frames in the outbound queue",

1875

112

                   connection_->connection_);

1876

112

    stream->setDetails(Http2ResponseCodeDetails::get().outbound_frame_flood);

1877

112

1878

1879

528434

  connection_->stats_.pending_send_bytes_.sub(payload_length);

1880

528434

  output.move(*stream->pending_send_data_, payload_length);

1881

528434

  connection_->connection_.write(output, false);

1882

528434

  return true;

1883

528434

1884

1885

bool ConnectionImpl::Http2Visitor::OnFrameHeader(Http2StreamId stream_id, size_t length,

1886

619975

                                                 uint8_t type, uint8_t flags) {

1887

619975

  ENVOY_CONN_LOG(trace, "Http2Visitor::OnFrameHeader({}, {}, {}, {})", connection_->connection_,

1888

619975

                 stream_id, length, int(type), int(flags));

1889

1890

619975

  if (type == OGHTTP2_CONTINUATION_FRAME_TYPE) {

1891

8596

    if (current_frame_.stream_id != stream_id) {

1892

      return false;

1893

1894

8596

    current_frame_.length += length;

1895

8596

    current_frame_.flags |= flags;

1896

611955

  } else {

1897

611379

    current_frame_ = {stream_id, length, type, flags};

1898

611379

    padding_length_ = 0;

1899

611379

    remaining_data_payload_ = 0;

1900

611379

1901

619975

  Status status = connection_->onBeforeFrameReceived(stream_id, length, type, flags);

1902

619975

  return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1903

619975

1904

1905

139482

bool ConnectionImpl::Http2Visitor::OnBeginHeadersForStream(Http2StreamId stream_id) {

1906

139482

  Status status = connection_->onBeginHeaders(stream_id);

1907

139482

  return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1908

139482

1909

1910

OnHeaderResult ConnectionImpl::Http2Visitor::OnHeaderForStream(Http2StreamId stream_id,

1911

                                                               absl::string_view name_view,

1912

764115

                                                               absl::string_view value_view) {

1913

  // We use reference counting to avoid copying well-known header names.

1914

  // For common HTTP/2 headers (e.g., :method, :path, :status), we reference Envoy's

1915

  // static LowerCaseString objects instead of allocating and copying the name string.

1916

  // This significantly reduces memory allocations and copy operations for typical requests.

1917

764115

  HeaderString name;

1918

764115

  const LowerCaseString* static_name = getStaticHeaderNameLookup().lookup(name_view);

1919

764115

  if (static_name != nullptr) {

1920

    // Header name matches a well-known header. Use setReference to avoid copying.

1921

552861

    name.setReference(static_name->get());

1922

663372

  } else {

1923

    // Unknown header name. Copy the data.

1924

211254

    name.setCopy(name_view.data(), name_view.size());

1925

211254

1926

1927

  // Always copy the value, as header values are highly variable and the data from

1928

  // the HTTP/2 adapter is only valid during this callback.

1929

764115

  HeaderString value;

1930

764115

  value.setCopy(value_view.data(), value_view.size());

1931

1932

764115

  const int result = connection_->onHeader(stream_id, std::move(name), std::move(value));

1933

764115

  switch (result) {

1934

764078

  case 0:

1935

764078

    return OnHeaderResult::HEADER_OK;

1936

35

  case ERR_TEMPORAL_CALLBACK_FAILURE:

1937

35

    return OnHeaderResult::HEADER_RST_STREAM;

1938

  default:

1939

    return OnHeaderResult::HEADER_CONNECTION_ERROR;

1940

764115

1941

764115

1942

1943

138340

bool ConnectionImpl::Http2Visitor::OnEndHeadersForStream(Http2StreamId stream_id) {

1944

138340

  ENVOY_CONN_LOG(trace, "Http2Visitor::OnEndHeadersForStream({})", connection_->connection_,

1945

138340

                 stream_id);

1946

138340

  Status status = connection_->onHeaders(stream_id, current_frame_.length, current_frame_.flags);

1947

138340

  return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1948

138340

1949

1950

bool ConnectionImpl::Http2Visitor::OnBeginDataForStream(Http2StreamId stream_id,

1951

350965

                                                        size_t payload_length) {

1952

350965

  ENVOY_CONN_LOG(trace, "Http2Visitor::OnBeginDataForStream({}, {})", connection_->connection_,

1953

350965

                 stream_id, payload_length);

1954

350965

  remaining_data_payload_ = payload_length;

1955

350965

  padding_length_ = 0;

1956

350965

  if (remaining_data_payload_ == 0 && (current_frame_.flags & FLAG_END_STREAM) == 0) {

1957

16

    ENVOY_CONN_LOG(trace, "Http2Visitor dispatching DATA for stream {}", connection_->connection_,

1958

16

                   stream_id);

1959

16

    Status status = connection_->onBeginData(stream_id, current_frame_.length, current_frame_.flags,

1960

16

                                             padding_length_);

1961

16

    return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1962

16

1963

350949

  ENVOY_CONN_LOG(debug, "Http2Visitor: remaining data payload: {}, stream_id: {}, end_stream: {}",

1964

350949

                 connection_->connection_, remaining_data_payload_, stream_id,

1965

350949

                 bool(current_frame_.flags & FLAG_END_STREAM));

1966

350949

  return true;

1967

350965

1968

1969

bool ConnectionImpl::Http2Visitor::OnDataPaddingLength(Http2StreamId stream_id,

1970

2

                                                       size_t padding_length) {

1971

2

  padding_length_ = padding_length;

1972

2

  remaining_data_payload_ -= padding_length;

1973

2

  if (remaining_data_payload_ == 0 && (current_frame_.flags & FLAG_END_STREAM) == 0) {

1974

1

    ENVOY_CONN_LOG(trace, "Http2Visitor dispatching DATA for stream {}", connection_->connection_,

1975

1

                   stream_id);

1976

1

    Status status = connection_->onBeginData(stream_id, current_frame_.length, current_frame_.flags,

1977

1

                                             padding_length_);

1978

1

    return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1979

1

1980

1

  ENVOY_CONN_LOG(trace, "Http2Visitor: remaining data payload: {}, stream_id: {}, end_stream: {}",

1981

1

                 connection_->connection_, remaining_data_payload_, stream_id,

1982

1

                 bool(current_frame_.flags & FLAG_END_STREAM));

1983

1

  return true;

1984

2

1985

1986

bool ConnectionImpl::Http2Visitor::OnDataForStream(Http2StreamId stream_id,

1987

457461

                                                   absl::string_view data) {

1988

457461

  const int result =

1989

457461

      connection_->onData(stream_id, reinterpret_cast<const uint8_t*>(data.data()), data.size());

1990

457461

  remaining_data_payload_ -= data.size();

1991

457468

  if (result == 0 && remaining_data_payload_ == 0 &&

1992

457461

      (current_frame_.flags & FLAG_END_STREAM) == 0) {

1993

332016

    ENVOY_CONN_LOG(trace, "Http2Visitor dispatching DATA for stream {}", connection_->connection_,

1994

332016

                   stream_id);

1995

332016

    Status status = connection_->onBeginData(stream_id, current_frame_.length, current_frame_.flags,

1996

332016

                                             padding_length_);

1997

332016

    return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

1998

332016

1999

125445

  ENVOY_CONN_LOG(trace, "Http2Visitor: remaining data payload: {}, stream_id: {}, end_stream: {}",

2000

125445

                 connection_->connection_, remaining_data_payload_, stream_id,

2001

125445

                 bool(current_frame_.flags & FLAG_END_STREAM));

2002

125445

  return result == 0;

2003

457461

2004

2005

122762

bool ConnectionImpl::Http2Visitor::OnEndStream(Http2StreamId stream_id) {

2006

122762

  ENVOY_CONN_LOG(trace, "Http2Visitor::OnEndStream({})", connection_->connection_, stream_id);

2007

122762

  if (current_frame_.type == OGHTTP2_DATA_FRAME_TYPE) {

2008

    // `onBeginData` is invoked here to ensure that the connection has successfully validated and

2009

    // processed the entire DATA frame.

2010

18914

    ENVOY_CONN_LOG(trace, "Http2Visitor dispatching DATA for stream {}", connection_->connection_,

2011

18914

                   stream_id);

2012

18914

    Status status = connection_->onBeginData(stream_id, current_frame_.length, current_frame_.flags,

2013

18914

                                             padding_length_);

2014

18914

    return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

2015

18914

2016

103848

  return true;

2017

122762

2018

2019

4350

void ConnectionImpl::Http2Visitor::OnRstStream(Http2StreamId stream_id, Http2ErrorCode error_code) {

2020

4350

  (void)connection_->onRstStream(stream_id, static_cast<uint32_t>(error_code));

2021

4350

2022

2023

bool ConnectionImpl::Http2Visitor::OnCloseStream(Http2StreamId stream_id,

2024

90514

                                                 Http2ErrorCode error_code) {

2025

90514

  Status status = connection_->onStreamClose(stream_id, static_cast<uint32_t>(error_code));

2026

90514

  ASSERT(status.ok());

2027

90514

  if (stream_close_listener_) {

2028

73194

    ENVOY_CONN_LOG(trace, "Http2Visitor invoking stream close listener for stream {}",

2029

73194

                   connection_->connection_, stream_id);

2030

73194

    stream_close_listener_(stream_id);

2031

73194

2032

90514

  return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

2033

90514

2034

2035

12376

void ConnectionImpl::Http2Visitor::OnPing(Http2PingId ping_id, bool is_ack) {

2036

12376

  const uint64_t network_order_opaque_data = quiche::QuicheEndian::HostToNet64(ping_id);

2037

12376

  Status status = connection_->onPing(network_order_opaque_data, is_ack);

2038

12376

  connection_->setAndCheckCodecCallbackStatus(std::move(status));

2039

12376

2040

2041

bool ConnectionImpl::Http2Visitor::OnGoAway(Http2StreamId /*last_accepted_stream_id*/,

2042

                                            Http2ErrorCode error_code,

2043

192

                                            absl::string_view /*opaque_data*/) {

2044

192

  Status status = connection_->onGoAway(static_cast<uint32_t>(error_code));

2045

192

  return 0 == connection_->setAndCheckCodecCallbackStatus(std::move(status));

2046

192

2047

2048

int ConnectionImpl::Http2Visitor::OnBeforeFrameSent(uint8_t frame_type, Http2StreamId stream_id,

2049

240383

                                                    size_t length, uint8_t flags) {

2050

240383

  return connection_->onBeforeFrameSend(stream_id, length, frame_type, flags);

2051

240383

2052

2053

int ConnectionImpl::Http2Visitor::OnFrameSent(uint8_t frame_type, Http2StreamId stream_id,

2054

768818

                                              size_t length, uint8_t flags, uint32_t error_code) {

2055

768818

  return connection_->onFrameSend(stream_id, length, frame_type, flags, error_code);

2056

768818

2057

2058

bool ConnectionImpl::Http2Visitor::OnInvalidFrame(Http2StreamId stream_id,

2059

1064

                                                  InvalidFrameError error) {

2060

1064

  return 0 == connection_->onInvalidFrame(stream_id, http2::adapter::ToNgHttp2ErrorCode(error));

2061

1064

2062

2063

bool ConnectionImpl::Http2Visitor::OnMetadataForStream(Http2StreamId stream_id,

2064

3160

                                                       absl::string_view metadata) {

2065

3160

  return 0 == connection_->onMetadataReceived(

2066

3160

                  stream_id, reinterpret_cast<const uint8_t*>(metadata.data()), metadata.size());

2067

3160

2068

2069

2363

bool ConnectionImpl::Http2Visitor::OnMetadataEndForStream(Http2StreamId stream_id) {

2070

2363

  return 0 == connection_->onMetadataFrameComplete(stream_id, true);

2071

2363

2072

2073

668

void ConnectionImpl::Http2Visitor::OnErrorDebug(absl::string_view message) {

2074

668

  connection_->onError(message);

2075

668

2076

2077

ConnectionImpl::Http2Options::Http2Options(

2078

30684

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options, uint32_t max_headers_kb) {

2079

30684

  og_options_.perspective = http2::adapter::Perspective::kServer;

2080

30684

  og_options_.max_hpack_encoding_table_capacity = http2_options.hpack_table_size().value();

2081

30684

  og_options_.max_header_list_bytes = max_headers_kb * 1024;

2082

30684

  og_options_.max_header_field_size = max_headers_kb * 1024;

2083

30684

  og_options_.allow_extended_connect = http2_options.allow_connect();

2084

30684

  og_options_.allow_different_host_and_authority = true;

2085

30684

  if (!PROTOBUF_GET_WRAPPED_OR_DEFAULT(http2_options, enable_huffman_encoding, true)) {

2086

2

    if (http2_options.has_hpack_table_size() && http2_options.hpack_table_size().value() == 0) {

2087

      og_options_.compression_option = http2::adapter::OgHttp2Session::Options::DISABLE_COMPRESSION;

2088

2

    } else {

2089

2

      og_options_.compression_option = http2::adapter::OgHttp2Session::Options::DISABLE_HUFFMAN;

2090

2

2091

2

2092

2093

#ifdef ENVOY_ENABLE_UHV

2094

  // UHV - disable header validations in oghttp2

2095

  og_options_.validate_http_headers = false;

2096

#endif

2097

2098

30684

#ifdef ENVOY_NGHTTP2

2099

30684

  nghttp2_option_new(&options_);

2100

  // Currently we do not do anything with stream priority. Setting the following option prevents

2101

  // nghttp2 from keeping around closed streams for use during stream priority dependency graph

2102

  // calculations. This saves a tremendous amount of memory in cases where there are a large

2103

  // number of kept alive HTTP/2 connections.

2104

30684

  nghttp2_option_set_no_closed_streams(options_, 1);

2105

30684

  nghttp2_option_set_no_auto_window_update(options_, 1);

2106

2107

  // RFC9113 invalidates trailing whitespace in header values but this is a new validation which

2108

  // can break existing deployments.

2109

  // Disable this validation for now.

2110

30684

  nghttp2_option_set_no_rfc9113_leading_and_trailing_ws_validation(options_, 1);

2111

2112

  // The max send header block length is configured to an arbitrarily high number so as to never

2113

  // trigger the check within nghttp2, as we check request headers length in

2114

  // codec_impl::saveHeader.

2115

30684

  nghttp2_option_set_max_send_header_block_length(options_, 0x2000000);

2116

2117

30684

  if (http2_options.hpack_table_size().value() != NGHTTP2_DEFAULT_HEADER_TABLE_SIZE) {

2118

1024

    nghttp2_option_set_max_deflate_dynamic_table_size(options_,

2119

1024

                                                      http2_options.hpack_table_size().value());

2120

1024

2121

2122

30684

  if (!PROTOBUF_GET_WRAPPED_OR_DEFAULT(http2_options, enable_huffman_encoding, true)) {

2123

2

    nghttp2_option_set_disable_huffman_encoding(options_, 1);

2124

2

2125

2126

30684

  if (http2_options.has_max_header_field_size_kb()) {

2127

5

    nghttp2_option_set_max_hd_nv_size(options_,

2128

5

                                      http2_options.max_header_field_size_kb().value() * 1024);

2129

5

2130

2131

30684

  if (http2_options.allow_metadata()) {

2132

14382

    nghttp2_option_set_user_recv_extension_type(options_, METADATA_FRAME_TYPE);

2133

17327

  } else {

2134

16302

    ENVOY_LOG(trace, "Codec does not have Metadata frame support.");

2135

16302

2136

2137

  // nghttp2 v1.39.2 lowered the internal flood protection limit from 10K to 1K of ACK frames.

2138

  // This new limit may cause the internal nghttp2 mitigation to trigger more often (as it

2139

  // requires just 9K of incoming bytes for smallest 9 byte SETTINGS frame), bypassing the same

2140

  // mitigation and its associated behavior in the envoy HTTP/2 codec. Since envoy does not rely

2141

  // on this mitigation, set back to the old 10K number to avoid any changes in the HTTP/2 codec

2142

  // behavior.

2143

30684

  nghttp2_option_set_max_outbound_ack(options_, 10000);

2144

2145

  // nghttp2 REQUIRES setting max number of CONTINUATION frames.

2146

  // 512 is chosen to accommodate Envoy's 8Mb max limit of max_request_headers_kb

2147

  // in both headers and trailers

2148

30684

  nghttp2_option_set_max_continuations(options_, 512);

2149

30684

#endif

2150

30684

2151

2152

30684

ConnectionImpl::Http2Options::~Http2Options() {

2153

30684

#ifdef ENVOY_NGHTTP2

2154

30684

  nghttp2_option_del(options_);

2155

30684

#endif

2156

30684

2157

2158

ConnectionImpl::ClientHttp2Options::ClientHttp2Options(

2159

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options, uint32_t max_headers_kb)

2160

14963

    : Http2Options(http2_options, max_headers_kb) {

2161

14963

  og_options_.perspective = http2::adapter::Perspective::kClient;

2162

14963

  og_options_.remote_max_concurrent_streams =

2163

14963

      ::Envoy::Http2::Utility::OptionsLimits::MAX_MAX_CONCURRENT_STREAMS;

2164

2165

14963

#ifdef ENVOY_NGHTTP2

2166

  // Temporarily disable initial max streams limit/protection, since we might want to create

2167

  // more than 100 streams before receiving the HTTP/2 SETTINGS frame from the server.

2168

//

2169

  // TODO(PiotrSikora): remove this once multiple upstream connections or queuing are implemented.

2170

14963

  nghttp2_option_set_peer_max_concurrent_streams(

2171

14963

      options_, ::Envoy::Http2::Utility::OptionsLimits::MAX_MAX_CONCURRENT_STREAMS);

2172

2173

  // nghttp2 REQUIRES setting max number of CONTINUATION frames.

2174

  // 1024 is chosen to accommodate Envoy's 8Mb max limit of max_request_headers_kb

2175

  // in both headers and trailers

2176

14963

  nghttp2_option_set_max_continuations(options_, 1024);

2177

14963

#endif

2178

14963

2179

2180

OptRef<const StreamInfo::StreamInfo> ConnectionImpl::trackedStream() const {

2181

  return connection_.trackedStream();

2182

2183

2184

12

void ConnectionImpl::dumpState(std::ostream& os, int indent_level) const {

2185

12

  const char* spaces = spacesForLevel(indent_level);

2186

12

  os << spaces << "Http2::ConnectionImpl " << this << DUMP_MEMBER(max_headers_kb_)

2187

12

     << DUMP_MEMBER(max_headers_count_) << DUMP_MEMBER(per_stream_buffer_limit_)

2188

12

     << DUMP_MEMBER(allow_metadata_) << DUMP_MEMBER(stream_error_on_invalid_http_messaging_)

2189

12

     << DUMP_MEMBER(is_outbound_flood_monitored_control_frame_) << DUMP_MEMBER(dispatching_)

2190

12

     << DUMP_MEMBER(raised_goaway_) << DUMP_MEMBER(pending_deferred_reset_streams_.size()) << '\n';

2191

2192

  // Dump the protocol constraints

2193

12

  DUMP_DETAILS(&protocol_constraints_);

2194

2195

  // Dump either a targeted stream or several of the active streams.

2196

12

  dumpStreams(os, indent_level);

2197

2198

  // Dump the active slice

2199

12

  if (current_slice_ == nullptr) {

2200

    // No current slice, use macro for consistent formatting.

2201

8

    os << spaces << "current_slice_: null\n";

2202

8

  } else {

2203

4

    auto slice_view =

2204

4

        absl::string_view(static_cast<const char*>(current_slice_->mem_), current_slice_->len_);

2205

2206

4

    os << spaces << "current slice length: " << slice_view.length() << " contents: \"";

2207

4

    StringUtil::escapeToOstream(os, slice_view);

2208

4

    os << "\"\n";

2209

4

2210

12

2211

2212

12

void ConnectionImpl::dumpStreams(std::ostream& os, int indent_level) const {

2213

12

  const char* spaces = spacesForLevel(indent_level);

2214

2215

  // Try to dump details for the current stream.

2216

  // If none, dump a subset of our active streams.

2217

12

  os << spaces << "Number of active streams: " << active_streams_.size()

2218

12

     << DUMP_OPTIONAL_MEMBER(current_stream_id_);

2219

2220

12

  if (current_stream_id_.has_value()) {

2221

6

    os << " Dumping current stream:\n";

2222

6

    const ConnectionImpl::StreamImpl* stream = getStream(current_stream_id_.value());

2223

6

    DUMP_DETAILS(stream);

2224

8

  } else {

2225

6

    os << " Dumping " << std::min<size_t>(25, active_streams_.size()) << " Active Streams:\n";

2226

6

    size_t count = 0;

2227

6

    for (auto& stream : active_streams_) {

2228

4

      DUMP_DETAILS(stream);

2229

4

      if (++count >= 25) {

2230

        break;

2231

2232

4

2233

6

2234

12

2235

2236

4

void ClientConnectionImpl::dumpStreams(std::ostream& os, int indent_level) const {

2237

4

  ConnectionImpl::dumpStreams(os, indent_level);

2238

2239

4

  if (!current_stream_id_.has_value()) {

2240

2

    return;

2241

2

2242

2243

  // Try to dump the downstream request information, corresponding to the

2244

  // stream we were processing.

2245

2

  const char* spaces = spacesForLevel(indent_level);

2246

2

  os << spaces << "Dumping corresponding downstream request for upstream stream "

2247

2

     << current_stream_id_.value() << ":\n";

2248

2249

2

  const ClientStreamImpl* client_stream =

2250

2

      static_cast<const ClientStreamImpl*>(getStreamUnchecked(current_stream_id_.value()));

2251

2

  if (client_stream) {

2252

2

    client_stream->response_decoder_.dumpState(os, indent_level + 1);

2253

2

  } else {

2254

    os << spaces

2255

       << " Failed to get the upstream stream with stream id: " << current_stream_id_.value()

2256

       << " Unable to dump downstream request.\n";

2257

2258

2

2259

2260

10

void ConnectionImpl::StreamImpl::dumpState(std::ostream& os, int indent_level) const {

2261

10

  const char* spaces = spacesForLevel(indent_level);

2262

10

  os << spaces << "ConnectionImpl::StreamImpl " << this << DUMP_MEMBER(stream_id_)

2263

10

     << DUMP_MEMBER(unconsumed_bytes_) << DUMP_MEMBER(read_disable_count_)

2264

10

     << DUMP_MEMBER(local_end_stream_) << DUMP_MEMBER(local_end_stream_sent_)

2265

10

     << DUMP_MEMBER(remote_end_stream_) << DUMP_MEMBER(data_deferred_)

2266

10

     << DUMP_MEMBER(received_noninformational_headers_)

2267

10

     << DUMP_MEMBER(pending_receive_buffer_high_watermark_called_)

2268

10

     << DUMP_MEMBER(pending_send_buffer_high_watermark_called_)

2269

10

     << DUMP_MEMBER(reset_due_to_messaging_error_)

2270

10

     << DUMP_MEMBER_AS(cookies_, cookies_.getStringView());

2271

2272

10

  DUMP_DETAILS(pending_trailers_to_encode_);

2273

10

2274

2275

4

void ConnectionImpl::ClientStreamImpl::dumpState(std::ostream& os, int indent_level) const {

2276

4

  const char* spaces = spacesForLevel(indent_level);

2277

4

  StreamImpl::dumpState(os, indent_level);

2278

2279

  // Dump header map

2280

4

  if (absl::holds_alternative<ResponseHeaderMapPtr>(headers_or_trailers_)) {

2281

4

    DUMP_DETAILS(absl::get<ResponseHeaderMapPtr>(headers_or_trailers_));

2282

4

  } else {

2283

    DUMP_DETAILS(absl::get<ResponseTrailerMapPtr>(headers_or_trailers_));

2284

2285

4

2286

2287

6

void ConnectionImpl::ServerStreamImpl::dumpState(std::ostream& os, int indent_level) const {

2288

6

  const char* spaces = spacesForLevel(indent_level);

2289

6

  StreamImpl::dumpState(os, indent_level);

2290

2291

  // Dump header map

2292

6

  if (absl::holds_alternative<RequestHeaderMapSharedPtr>(headers_or_trailers_)) {

2293

6

    DUMP_DETAILS(absl::get<RequestHeaderMapSharedPtr>(headers_or_trailers_));

2294

6

  } else {

2295

    DUMP_DETAILS(absl::get<RequestTrailerMapPtr>(headers_or_trailers_));

2296

2297

6

2298

2299

ClientConnectionImpl::ClientConnectionImpl(

2300

    Network::Connection& connection, Http::ConnectionCallbacks& callbacks, CodecStats& stats,

2301

    Random::RandomGenerator& random_generator,

2302

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options,

2303

    const uint32_t max_response_headers_kb, const uint32_t max_response_headers_count,

2304

    Http2SessionFactory& http2_session_factory)

2305

14963

    : ConnectionImpl(connection, stats, random_generator, http2_options, max_response_headers_kb,

2306

14963

                     max_response_headers_count),

2307

14963

      callbacks_(callbacks) {

2308

14963

  ClientHttp2Options client_http2_options(http2_options, max_response_headers_kb);

2309

14963

  if (!use_oghttp2_library_) {

2310

11457

#ifdef ENVOY_NGHTTP2

2311

11457

    adapter_ = http2_session_factory.create(base(), client_http2_options.options());

2312

11457

#endif

2313

11457

2314

14963

  if (!adapter_) {

2315

3506

    adapter_ = http2_session_factory.create(base(), client_http2_options.ogOptions());

2316

3506

2317

14963

  http2_session_factory.init(base(), http2_options);

2318

14963

  allow_metadata_ = http2_options.allow_metadata();

2319

14963

  max_metadata_size_ =

2320

14963

      PROTOBUF_GET_WRAPPED_OR_DEFAULT(http2_options, max_metadata_size, 1024 * 1024);

2321

14963

  idle_session_requires_ping_interval_ = std::chrono::milliseconds(PROTOBUF_GET_MS_OR_DEFAULT(

2322

14963

      http2_options.connection_keepalive(), connection_idle_interval, 0));

2323

14963

2324

2325

53061

RequestEncoder& ClientConnectionImpl::newStream(ResponseDecoder& decoder) {

2326

  // If the connection has been idle long enough to trigger a ping, send one

2327

  // ahead of creating the stream.

2328

53061

  if (idle_session_requires_ping_interval_.count() != 0 &&

2329

53061

      (connection_.dispatcher().timeSource().monotonicTime() - lastReceivedDataTime() >

2330

4

       idle_session_requires_ping_interval_)) {

2331

    sendKeepalive();

2332

2333

2334

53061

  ClientStreamImplPtr stream(new ClientStreamImpl(*this, per_stream_buffer_limit_, decoder));

2335

  // If the connection is currently above the high watermark, make sure to inform the new stream.

2336

  // The connection can not pass this on automatically as it has no awareness that a new stream is

2337

  // created.

2338

53061

  if (connection_.aboveHighWatermark()) {

2339

29

    stream->runHighWatermarkCallbacks();

2340

29

2341

53061

  ClientStreamImpl& stream_ref = *stream;

2342

53061

  LinkedList::moveIntoList(std::move(stream), active_streams_);

2343

53061

  protocol_constraints_.incrementOpenedStreamCount();

2344

53061

  return stream_ref;

2345

53061

2346

2347

42811

Status ClientConnectionImpl::onBeginHeaders(int32_t stream_id) {

2348

42811

  StreamImpl* stream = getStream(stream_id);

2349

42811

  if (stream != nullptr) {

2350

42809

    return stream->onBeginHeaders();

2351

42809

2352

2

  return codecClientError(absl::StrFormat("stream %d is already gone", stream_id));

2353

42811

2354

2355

154607

int ClientConnectionImpl::onHeader(int32_t stream_id, HeaderString&& name, HeaderString&& value) {

2356

154607

  ASSERT(connection_.state() == Network::Connection::State::Open);

2357

154607

  return saveHeader(stream_id, std::move(name), std::move(value));

2358

154607

2359

2360

23

StreamResetReason ClientConnectionImpl::getMessagingErrorResetReason() const {

2361

23

  connection_.streamInfo().setResponseFlag(StreamInfo::CoreResponseFlag::UpstreamProtocolError);

2362

2363

23

  return StreamResetReason::ProtocolError;

2364

23

2365

2366

ServerConnectionImpl::ServerConnectionImpl(

2367

    Network::Connection& connection, Http::ServerConnectionCallbacks& callbacks, CodecStats& stats,

2368

    Random::RandomGenerator& random_generator,

2369

    const envoy::config::core::v3::Http2ProtocolOptions& http2_options,

2370

    const uint32_t max_request_headers_kb, const uint32_t max_request_headers_count,

2371

    envoy::config::core::v3::HttpProtocolOptions::HeadersWithUnderscoresAction

2372

        headers_with_underscores_action,

2373

    Server::OverloadManager& overload_manager)

2374

15721

    : ConnectionImpl(connection, stats, random_generator, http2_options, max_request_headers_kb,

2375

15721

                     max_request_headers_count),

2376

15721

      callbacks_(callbacks), headers_with_underscores_action_(headers_with_underscores_action),

2377

15721

      should_send_go_away_on_dispatch_(overload_manager.getLoadShedPoint(

2378

15721

          Server::LoadShedPointName::get().H2ServerGoAwayOnDispatch)),

2379

15721

      should_send_go_away_and_close_on_dispatch_(overload_manager.getLoadShedPoint(

2380

15721

          Server::LoadShedPointName::get().H2ServerGoAwayAndCloseOnDispatch)) {

2381

15721

  ENVOY_LOG_ONCE_IF(trace, should_send_go_away_on_dispatch_ == nullptr,

2382

15721

                    "LoadShedPoint envoy.load_shed_points.http2_server_go_away_on_dispatch is not "

2383

15721

                    "found. Is it configured?");

2384

15721

  ENVOY_LOG_ONCE_IF(

2385

15721

      trace, should_send_go_away_and_close_on_dispatch_ == nullptr,

2386

15721

      "LoadShedPoint envoy.load_shed_points.http2_server_go_away_and_close_on_dispatch is not "

2387

15721

      "found. Is it configured?");

2388

15721

  Http2Options h2_options(http2_options, max_request_headers_kb);

2389

2390

15721

  auto direct_visitor = std::make_unique<Http2Visitor>(this);

2391

2392

15721

#ifdef ENVOY_NGHTTP2

2393

15721

  if (use_oghttp2_library_) {

2394

3502

#endif

2395

3502

    visitor_ = std::move(direct_visitor);

2396

3502

    adapter_ = http2::adapter::OgHttp2Adapter::Create(*visitor_, h2_options.ogOptions());

2397

3502

#ifdef ENVOY_NGHTTP2

2398

13655

  } else {

2399

12219

    auto adapter =

2400

12219

        http2::adapter::NgHttp2Adapter::CreateServerAdapter(*direct_visitor, h2_options.options());

2401

38461

    auto stream_close_listener = [p = adapter.get()](http2::adapter::Http2StreamId stream_id) {

2402

36409

      p->RemoveStream(stream_id);

2403

36409

};

2404

12219

    direct_visitor->setStreamCloseListener(std::move(stream_close_listener));

2405

12219

    visitor_ = std::move(direct_visitor);

2406

12219

    adapter_ = std::move(adapter);

2407

12219

2408

15721

#endif

2409

15721

  sendSettings(http2_options, false);

2410

15721

  allow_metadata_ = http2_options.allow_metadata();

2411

15721

  max_metadata_size_ =

2412

15721

      PROTOBUF_GET_WRAPPED_OR_DEFAULT(http2_options, max_metadata_size, 1024 * 1024);

2413

15721

2414

2415

96673

Status ServerConnectionImpl::onBeginHeaders(int32_t stream_id) {

2416

96673

  ASSERT(connection_.state() == Network::Connection::State::Open);

2417

2418

96673

  StreamImpl* stream_ptr = getStream(stream_id);

2419

96673

  if (stream_ptr != nullptr) {

2420

713

    return stream_ptr->onBeginHeaders();

2421

713

2422

95960

  ServerStreamImplPtr stream(new ServerStreamImpl(*this, per_stream_buffer_limit_));

2423

95960

  if (connection_.aboveHighWatermark()) {

2424

7

    stream->runHighWatermarkCallbacks();

2425

7

2426

95960

  stream->setRequestDecoder(callbacks_.newStream(*stream));

2427

95960

  stream->stream_id_ = stream_id;

2428

95960

  LinkedList::moveIntoList(std::move(stream), active_streams_);

2429

95960

  adapter_->SetStreamUserData(stream_id, active_streams_.front().get());

2430

95960

  protocol_constraints_.incrementOpenedStreamCount();

2431

95960

  return active_streams_.front()->onBeginHeaders();

2432

96673

2433

2434

609505

int ServerConnectionImpl::onHeader(int32_t stream_id, HeaderString&& name, HeaderString&& value) {

2435

609507

  if (Runtime::runtimeFeatureEnabled("envoy.reloadable_features.http2_discard_host_header")) {

2436

609483

    StreamImpl* stream = getStreamUnchecked(stream_id);

2437

609484

    if (stream && name == static_cast<absl::string_view>(Http::Headers::get().HostLegacy)) {

2438

      // Check if there is already the :authority header

2439

6

      const auto result = stream->headers().get(Http::Headers::get().Host);

2440

6

      if (!result.empty()) {

2441

        // Discard the host header value

2442

4

        return 0;

2443

4

2444

      // Otherwise use host value as :authority

2445

6

2446

609483

2447

609501

  return saveHeader(stream_id, std::move(name), std::move(value));

2448

609505

2449

2450

220786

Http::Status ServerConnectionImpl::dispatch(Buffer::Instance& data) {

2451

  // Make sure downstream outbound queue was not flooded by the upstream frames.

2452

220786

  RETURN_IF_ERROR(protocol_constraints_.checkOutboundFrameLimits());

2453

220783

  if (should_send_go_away_and_close_on_dispatch_ != nullptr &&

2454

220783

      should_send_go_away_and_close_on_dispatch_->shouldShedLoad()) {

2455

4

    ConnectionImpl::goAway();

2456

4

    sent_go_away_on_dispatch_ = true;

2457

4

    return envoyOverloadError(

2458

4

        "Load shed point http2_server_go_away_and_close_on_dispatch triggered");

2459

4

2460

220779

  if (should_send_go_away_on_dispatch_ != nullptr && !sent_go_away_on_dispatch_ &&

2461

220779

      should_send_go_away_on_dispatch_->shouldShedLoad()) {

2462

4

    ConnectionImpl::goAway();

2463

4

    sent_go_away_on_dispatch_ = true;

2464

4

2465

220779

  return ConnectionImpl::dispatch(data);

2466

220783

2467

2468

absl::optional<int> ServerConnectionImpl::checkHeaderNameForUnderscores(

2469

609503

    [[maybe_unused]] absl::string_view header_name) {

2470

609503

#ifndef ENVOY_ENABLE_UHV

2471

  // This check has been moved to UHV

2472

609503

  if (headers_with_underscores_action_ != envoy::config::core::v3::HttpProtocolOptions::ALLOW &&

2473

609503

      Http::HeaderUtility::headerNameContainsUnderscore(header_name)) {

2474

22

    if (headers_with_underscores_action_ ==

2475

22

        envoy::config::core::v3::HttpProtocolOptions::DROP_HEADER) {

2476

12

      ENVOY_CONN_LOG(debug, "Dropping header with invalid characters in its name: {}", connection_,

2477

12

                     header_name);

2478

12

      stats_.incDroppedHeadersWithUnderscores();

2479

12

      return 0;

2480

12

2481

10

    ENVOY_CONN_LOG(debug, "Rejecting request due to header name with underscores: {}", connection_,

2482

10

                   header_name);

2483

10

    stats_.incRequestsRejectedWithUnderscoresInHeaders();

2484

10

    return ERR_TEMPORAL_CALLBACK_FAILURE;

2485

22

2486

#else

2487

  // Workaround for gcc not understanding [[maybe_unused]] for class members.

2488

  (void)headers_with_underscores_action_;

2489

#endif

2490

609481

  return absl::nullopt;

2491

609503

2492

2493

} // namespace Http2

2494

} // namespace Http

2495

} // namespace Envoy