Grcov report - passthrough.h

1

#pragma once

2

3

#include "envoy/network/connection.h"

4

#include "envoy/network/transport_socket.h"

5

6

#include "source/common/buffer/buffer_impl.h"

7

#include "source/common/network/transport_socket_options_impl.h"

8

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

9

10

namespace Envoy {

11

namespace Extensions {

12

namespace TransportSockets {

13

14

class PassthroughFactory : public Network::CommonUpstreamTransportSocketFactory {

15

public:

16

  PassthroughFactory(Network::UpstreamTransportSocketFactoryPtr&& transport_socket_factory)

17

61

      : transport_socket_factory_(std::move(transport_socket_factory)) {

18

61

    ASSERT(transport_socket_factory_ != nullptr);

19

61

20

21

9

  bool implementsSecureTransport() const override {

22

9

    return transport_socket_factory_->implementsSecureTransport();

23

9

24

69

  bool supportsAlpn() const override { return transport_socket_factory_->supportsAlpn(); }

25

28

  absl::string_view defaultServerNameIndication() const override {

26

28

    return transport_socket_factory_->defaultServerNameIndication();

27

28

  void hashKey(std::vector<uint8_t>& key,

29

53

               Network::TransportSocketOptionsConstSharedPtr options) const override {

30

53

    return transport_socket_factory_->hashKey(key, options);

31

53

32

34

  Envoy::Ssl::ClientContextSharedPtr sslCtx() override {

33

34

    return transport_socket_factory_->sslCtx();

34

35

1

  OptRef<const Ssl::ClientContextConfig> clientContextConfig() const override {

36

1

    return transport_socket_factory_->clientContextConfig();

37

1

38

#ifdef ENVOY_ENABLE_QUIC

39

2

  std::shared_ptr<quic::QuicCryptoClientConfig> getCryptoConfig() override {

40

2

    return transport_socket_factory_->getCryptoConfig();

41

2

42

#endif

43

44

protected:

45

  // The wrapped factory.

46

  Network::UpstreamTransportSocketFactoryPtr transport_socket_factory_;

47

};

48

49

class DownstreamPassthroughFactory : public Network::DownstreamTransportSocketFactory {

50

public:

51

  DownstreamPassthroughFactory(

52

      Network::DownstreamTransportSocketFactoryPtr&& transport_socket_factory)

53

7

      : transport_socket_factory_(std::move(transport_socket_factory)) {

54

7

    ASSERT(transport_socket_factory_ != nullptr);

55

7

56

57

1

  bool implementsSecureTransport() const override {

58

1

    return transport_socket_factory_->implementsSecureTransport();

59

1

60

61

protected:

62

  // The wrapped factory.

63

  Network::DownstreamTransportSocketFactoryPtr transport_socket_factory_;

64

};

65

66

class PassthroughSocket : public Network::TransportSocket {

67

public:

68

  PassthroughSocket(Network::TransportSocketPtr&& transport_socket);

69

70

  void setTransportSocketCallbacks(Network::TransportSocketCallbacks& callbacks) override;

71

  std::string protocol() const override;

72

  absl::string_view failureReason() const override;

73

  bool canFlushClose() override;

74

  Api::SysCallIntResult connect(Network::ConnectionSocket& socket) override;

75

  void closeSocket(Network::ConnectionEvent event) override;

76

  Network::IoResult doRead(Buffer::Instance& buffer) override;

77

  Network::IoResult doWrite(Buffer::Instance& buffer, bool end_stream) override;

78

  void onConnected() override;

79

  Ssl::ConnectionInfoConstSharedPtr ssl() const override;

80

  // startSecureTransport method should not be called for this transport socket.

81

1

  bool startSecureTransport() override { return false; }

82

  void configureInitialCongestionWindow(uint64_t bandwidth_bits_per_sec,

83

                                        std::chrono::microseconds rtt) override;

84

85

protected:

86

  Network::TransportSocketPtr transport_socket_;

87

};

88

89

} // namespace TransportSockets

90

} // namespace Extensions

91

} // namespace Envoy