Grcov report - socket

1

#pragma once

2

3

#include "envoy/network/listener.h"

4

#include "envoy/network/socket.h"

5

#include "envoy/network/socket_interface.h"

6

7

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

8

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

9

10

namespace Envoy {

11

namespace Network {

12

13

class ConnectionInfoSetterImpl : public ConnectionInfoSetter {

14

public:

15

  ConnectionInfoSetterImpl(const Address::InstanceConstSharedPtr& local_address,

16

                           const Address::InstanceConstSharedPtr& remote_address)

17

188312

      : local_address_(local_address), direct_local_address_(local_address),

18

188312

        remote_address_(remote_address), direct_remote_address_(remote_address) {}

19

20

5

  void setDirectLocalAddressForTest(const Address::InstanceConstSharedPtr& direct_local_address) {

21

5

    direct_local_address_ = direct_local_address;

22

5

23

21694

  void setDirectRemoteAddressForTest(const Address::InstanceConstSharedPtr& direct_remote_address) {

24

21694

    direct_remote_address_ = direct_remote_address;

25

21694

26

27

4

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

28

4

    const char* spaces = spacesForLevel(indent_level);

29

4

    os << spaces << "ConnectionInfoSetterImpl " << this

30

4

       << DUMP_NULLABLE_MEMBER(remote_address_, remote_address_->asStringView())

31

4

       << DUMP_NULLABLE_MEMBER(direct_remote_address_, direct_remote_address_->asStringView())

32

4

       << DUMP_NULLABLE_MEMBER(local_address_, local_address_->asStringView())

33

4

       << DUMP_MEMBER(server_name_) << "\n";

34

4

35

36

  // ConnectionInfoSetter

37

1002323

  const Address::InstanceConstSharedPtr& localAddress() const override { return local_address_; }

38

56

  const Address::InstanceConstSharedPtr& directLocalAddress() const override {

39

56

    return direct_local_address_;

40

56

41

145381

  void setLocalAddress(const Address::InstanceConstSharedPtr& local_address) override {

42

145381

    local_address_ = local_address;

43

145381

44

158

  void restoreLocalAddress(const Address::InstanceConstSharedPtr& local_address) override {

45

158

    setLocalAddress(local_address);

46

158

    local_address_restored_ = true;

47

158

48

184

  bool localAddressRestored() const override { return local_address_restored_; }

49

608905

  const Address::InstanceConstSharedPtr& remoteAddress() const override { return remote_address_; }

50

9681

  void setRemoteAddress(const Address::InstanceConstSharedPtr& remote_address) override {

51

9681

    remote_address_ = remote_address;

52

9681

53

27837

  const Address::InstanceConstSharedPtr& directRemoteAddress() const override {

54

27837

    return direct_remote_address_;

55

27837

56

27784

  absl::string_view requestedServerName() const override { return server_name_; }

57

8295

  void setRequestedServerName(const absl::string_view requested_server_name) override {

58

8295

    server_name_ = std::string(requested_server_name);

59

8295

60

27496

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

61

27496

    return application_protocols_;

62

27496

63

7822

  void setRequestedApplicationProtocols(const std::vector<absl::string_view>& protocols) override {

64

7822

    application_protocols_.clear();

65

7824

    for (const auto& protocol : protocols) {

66

7824

      application_protocols_.emplace_back(protocol);

67

7824

68

7822

69

189926

  absl::optional<uint64_t> connectionID() const override { return connection_id_; }

70

122855

  void setConnectionID(uint64_t id) override { connection_id_ = id; }

71

100188

  absl::optional<absl::string_view> interfaceName() const override { return interface_name_; }

72

30694

  void enableSettingInterfaceName(const bool enable) override {

73

30694

    allow_syscall_for_interface_name_ = enable;

74

30694

75

53321

  void maybeSetInterfaceName(IoHandle& io_handle) override {

76

53321

    if (allow_syscall_for_interface_name_) {

77

9

      interface_name_ = io_handle.interfaceName();

78

9

79

53321

80

242168

  Ssl::ConnectionInfoConstSharedPtr sslConnection() const override { return ssl_info_; }

81

115091

  void setSslConnection(const Ssl::ConnectionInfoConstSharedPtr& ssl_connection_info) override {

82

115091

    ssl_info_ = ssl_connection_info;

83

115091

84

  absl::string_view ja3Hash() const override { return ja3_hash_; }

85

12

  void setJA3Hash(const absl::string_view ja3_hash) override { ja3_hash_ = std::string(ja3_hash); }

86

14

  absl::string_view ja4Hash() const override { return ja4_hash_; }

87

12

  void setJA4Hash(const absl::string_view ja4_hash) override { ja4_hash_ = std::string(ja4_hash); }

88

719

  const absl::optional<std::chrono::milliseconds>& roundTripTime() const override {

89

719

    return round_trip_time_;

90

719

91

54167

  void setRoundTripTime(std::chrono::milliseconds round_trip_time) override {

92

54167

    round_trip_time_ = round_trip_time;

93

54167

94

15

  OptRef<const FilterChainInfo> filterChainInfo() const override {

95

15

    return makeOptRefFromPtr<const FilterChainInfo>(filter_chain_info_.get());

96

15

97

54144

  void setFilterChainInfo(FilterChainInfoConstSharedPtr filter_chain_info) override {

98

54144

    filter_chain_info_ = std::move(filter_chain_info);

99

54144

100

19

  OptRef<const ListenerInfo> listenerInfo() const override {

101

19

    return makeOptRefFromPtr<const ListenerInfo>(listener_info_.get());

102

19

103

57249

  void setListenerInfo(ListenerInfoConstSharedPtr listener_info) override {

104

57249

    listener_info_ = std::move(listener_info);

105

57249

106

107

private:

108

  Address::InstanceConstSharedPtr local_address_;

109

  Address::InstanceConstSharedPtr direct_local_address_;

110

  bool local_address_restored_{false};

111

  Address::InstanceConstSharedPtr remote_address_;

112

  Address::InstanceConstSharedPtr direct_remote_address_;

113

  std::string server_name_;

114

  std::vector<std::string> application_protocols_;

115

  absl::optional<uint64_t> connection_id_;

116

  bool allow_syscall_for_interface_name_{false};

117

  absl::optional<std::string> interface_name_;

118

  Ssl::ConnectionInfoConstSharedPtr ssl_info_;

119

  std::string ja3_hash_;

120

  std::string ja4_hash_;

121

  absl::optional<std::chrono::milliseconds> round_trip_time_;

122

  FilterChainInfoConstSharedPtr filter_chain_info_;

123

  ListenerInfoConstSharedPtr listener_info_;

124

};

125

126

class SocketImpl : public virtual Socket {

127

public:

128

  SocketImpl(Socket::Type socket_type, const Address::InstanceConstSharedPtr& address_for_io_handle,

129

             const Address::InstanceConstSharedPtr& remote_address,

130

             const SocketCreationOptions& options);

131

132

  // Network::Socket

133

1497253

  ConnectionInfoSetter& connectionInfoProvider() override { return *connection_info_provider_; }

134

187593

  const ConnectionInfoProvider& connectionInfoProvider() const override {

135

187593

    return *connection_info_provider_;

136

187593

137

365743

  ConnectionInfoProviderSharedPtr connectionInfoProviderSharedPtr() const override {

138

365743

    return connection_info_provider_;

139

365743

140

  SocketPtr duplicate() override {

141

    // Implementing the functionality here for all sockets is tricky because it leads

142

    // into object slicing issues.

143

    return nullptr;

144

145

146

3792661

  IoHandle& ioHandle() override { return *io_handle_; }

147

2

  const IoHandle& ioHandle() const override { return *io_handle_; }

148

114573

  void close() override {

149

114576

    if (io_handle_ && io_handle_->isOpen()) {

150

114566

      io_handle_->close();

151

114566

152

114573

153

7711347

  bool isOpen() const override { return io_handle_ && io_handle_->isOpen(); }

154

60886

  void ensureOptions() {

155

60886

    if (!options_) {

156

46176

      options_ = std::make_shared<std::vector<OptionConstSharedPtr>>();

157

46176

158

60886

159

4

  void addOption(const OptionConstSharedPtr& option) override {

160

4

    ensureOptions();

161

4

    options_->emplace_back(std::move(option));

162

4

163

60882

  void addOptions(const OptionsSharedPtr& options) override {

164

60882

    ensureOptions();

165

60882

    Network::Socket::appendOptions(options_, options);

166

60882

167

168

  Api::SysCallIntResult bind(Network::Address::InstanceConstSharedPtr address) override;

169

  Api::SysCallIntResult listen(int backlog) override;

170

  Api::SysCallIntResult connect(const Address::InstanceConstSharedPtr addr) override;

171

  Api::SysCallIntResult setSocketOption(int level, int optname, const void* optval,

172

                                        socklen_t optlen) override;

173

  Api::SysCallIntResult getSocketOption(int level, int optname, void* optval,

174

                                        socklen_t* optlen) const override;

175

  Api::SysCallIntResult ioctl(unsigned long control_code, void* in_buffer,

176

                              unsigned long in_buffer_len, void* out_buffer,

177

                              unsigned long out_buffer_len, unsigned long* bytes_returned) override;

178

179

  Api::SysCallIntResult setBlockingForTest(bool blocking) override;

180

181

67209

  const OptionsSharedPtr& options() const override { return options_; }

182

16

  Socket::Type socketType() const override { return sock_type_; }

183

104469

  Address::Type addressType() const override { return addr_type_; }

184

  absl::optional<Address::IpVersion> ipVersion() const override;

185

186

protected:

187

  SocketImpl(IoHandlePtr&& io_handle, const Address::InstanceConstSharedPtr& local_address,

188

             const Address::InstanceConstSharedPtr& remote_address);

189

190

  const IoHandlePtr io_handle_;

191

  const std::shared_ptr<ConnectionInfoSetterImpl> connection_info_provider_;

192

  OptionsSharedPtr options_;

193

  Socket::Type sock_type_;

194

  Address::Type addr_type_;

195

};

196

197

} // namespace Network

198

} // namespace Envoy