Grcov report - transport_socket_options

1

#pragma once

2

3

#include "envoy/common/optref.h"

4

#include "envoy/network/proxy_protocol.h"

5

#include "envoy/network/transport_socket.h"

6

#include "envoy/stream_info/filter_state.h"

7

8

namespace Envoy {

9

namespace Network {

10

11

// A wrapper around another TransportSocketOptions that overrides the ALPN fallback.

12

class AlpnDecoratingTransportSocketOptions : public TransportSocketOptions {

13

public:

14

  AlpnDecoratingTransportSocketOptions(std::vector<std::string>&& alpn,

15

                                       TransportSocketOptionsConstSharedPtr inner_options)

16

9315

      : alpn_fallback_(std::move(alpn)), inner_options_(std::move(inner_options)) {}

17

  // Network::TransportSocketOptions

18

442

  const absl::optional<std::string>& serverNameOverride() const override {

19

442

    return inner_options_->serverNameOverride();

20

442

21

1449

  const std::vector<std::string>& verifySubjectAltNameListOverride() const override {

22

1449

    return inner_options_->verifySubjectAltNameListOverride();

23

1449

24

1191

  const std::vector<std::string>& applicationProtocolListOverride() const override {

25

1191

    return inner_options_->applicationProtocolListOverride();

26

1191

27

506

  const std::vector<std::string>& applicationProtocolFallback() const override {

28

506

    return alpn_fallback_;

29

506

30

6

  absl::optional<Network::ProxyProtocolData> proxyProtocolOptions() const override {

31

6

    return inner_options_->proxyProtocolOptions();

32

6

33

46966

  OptRef<const Http11ProxyInfo> http11ProxyInfo() const override {

34

46966

    return inner_options_->http11ProxyInfo();

35

46966

36

25410

  const StreamInfo::FilterState::Objects& downstreamSharedFilterStateObjects() const override {

37

25410

    return inner_options_->downstreamSharedFilterStateObjects();

38

25410

39

40

private:

41

  const std::vector<std::string> alpn_fallback_;

42

  const TransportSocketOptionsConstSharedPtr inner_options_;

43

};

44

45

class TransportSocketOptionsImpl : public TransportSocketOptions {

46

public:

47

  TransportSocketOptionsImpl(

48

      absl::string_view override_server_name = "",

49

      std::vector<std::string>&& override_verify_san_list = {},

50

      std::vector<std::string>&& override_alpn = {}, std::vector<std::string>&& fallback_alpn = {},

51

      absl::optional<Network::ProxyProtocolData> proxy_proto_options = absl::nullopt,

52

      StreamInfo::FilterState::ObjectsPtr filter_state_objects =

53

          std::make_unique<StreamInfo::FilterState::Objects>(),

54

      std::unique_ptr<const Http11ProxyInfo>&& proxy_info = nullptr)

55

49853

      : override_server_name_(override_server_name.empty()

56

49853

                                  ? absl::nullopt

57

49853

                                  : absl::optional<std::string>(override_server_name)),

58

49853

        override_verify_san_list_{std::move(override_verify_san_list)},

59

49853

        override_alpn_list_{std::move(override_alpn)}, alpn_fallback_{std::move(fallback_alpn)},

60

49853

        proxy_protocol_options_(proxy_proto_options),

61

49853

        filter_state_objects_(std::move(filter_state_objects)), proxy_info_(std::move(proxy_info)) {

62

49853

63

64

  // Network::TransportSocketOptions

65

59048

  const absl::optional<std::string>& serverNameOverride() const override {

66

59048

    return override_server_name_;

67

59048

68

48362

  const std::vector<std::string>& verifySubjectAltNameListOverride() const override {

69

48362

    return override_verify_san_list_;

70

48362

71

47859

  const std::vector<std::string>& applicationProtocolListOverride() const override {

72

47859

    return override_alpn_list_;

73

47859

74

46810

  const std::vector<std::string>& applicationProtocolFallback() const override {

75

46810

    return alpn_fallback_;

76

46810

77

93

  absl::optional<Network::ProxyProtocolData> proxyProtocolOptions() const override {

78

93

    return proxy_protocol_options_;

79

93

80

95770

  OptRef<const Http11ProxyInfo> http11ProxyInfo() const override {

81

95770

    if (!proxy_info_) {

82

95633

      return {};

83

95633

84

137

    return {*proxy_info_};

85

95770

86

75847

  const StreamInfo::FilterState::Objects& downstreamSharedFilterStateObjects() const override {

87

75847

    return *filter_state_objects_;

88

75847

89

90

private:

91

  const absl::optional<std::string> override_server_name_;

92

  const std::vector<std::string> override_verify_san_list_;

93

  const std::vector<std::string> override_alpn_list_;

94

  const std::vector<std::string> alpn_fallback_;

95

  const absl::optional<Network::ProxyProtocolData> proxy_protocol_options_;

96

  const StreamInfo::FilterState::ObjectsPtr filter_state_objects_;

97

  const StreamInfo::FilterStateSharedPtr filter_state_;

98

  std::unique_ptr<const Http11ProxyInfo> proxy_info_;

99

};

100

101

class TransportSocketOptionsUtility {

102

public:

103

/**

104

   * Construct TransportSocketOptions from StreamInfo::FilterState, using UpstreamServerName

105

   * and ApplicationProtocols key in the filter state.

106

   * @returns TransportSocketOptionsConstSharedPtr a shared pointer to the transport socket options,

107

   * nullptr if nothing is in the filter state.

108

*/

109

  static TransportSocketOptionsConstSharedPtr

110

  fromFilterState(const StreamInfo::FilterState& stream_info);

111

};

112

113

class CommonUpstreamTransportSocketFactory : public UpstreamTransportSocketFactory {

114

public:

115

/**

116

   * Compute the generic hash key from the transport socket options.

117

*/

118

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

119

               TransportSocketOptionsConstSharedPtr options) const override;

120

};

121

122

} // namespace Network

123

} // namespace Envoy