Grcov report - connection_socket

1

#pragma once

2

3

#include <memory>

4

#include <string>

5

#include <vector>

6

7

#include "envoy/common/platform.h"

8

#include "envoy/network/connection.h"

9

#include "envoy/network/listen_socket.h"

10

#include "envoy/network/socket.h"

11

#include "envoy/network/socket_interface.h"

12

13

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

14

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

15

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

16

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

17

18

namespace Envoy {

19

namespace Network {

20

21

/**

22

 * Wraps a unix socket.

23

*/

24

template <Socket::Type T> struct NetworkSocketTrait {};

25

26

template <> struct NetworkSocketTrait<Socket::Type::Stream> {

27

  static constexpr Socket::Type type = Socket::Type::Stream;

28

};

29

30

template <> struct NetworkSocketTrait<Socket::Type::Datagram> {

31

  static constexpr Socket::Type type = Socket::Type::Datagram;

32

};

33

34

class ConnectionSocketImpl : public SocketImpl, public ConnectionSocket {

35

public:

36

  ConnectionSocketImpl(IoHandlePtr&& io_handle,

37

                       const Address::InstanceConstSharedPtr& local_address,

38

                       const Address::InstanceConstSharedPtr& remote_address)

39

116079

      : SocketImpl(std::move(io_handle), local_address, remote_address) {}

40

41

  ConnectionSocketImpl(Socket::Type type, const Address::InstanceConstSharedPtr& local_address,

42

                       const Address::InstanceConstSharedPtr& remote_address,

43

                       const SocketCreationOptions& options)

44

3132

      : SocketImpl(type, local_address, remote_address, options) {

45

3132

    connection_info_provider_->setLocalAddress(local_address);

46

3132

47

48

  // Network::ConnectionSocket

49

64930

  void setDetectedTransportProtocol(absl::string_view protocol) override {

50

64930

    transport_protocol_ = std::string(protocol);

51

64930

52

81474

  absl::string_view detectedTransportProtocol() const override { return transport_protocol_; }

53

54

7827

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

55

7827

    connectionInfoProvider().setRequestedApplicationProtocols(protocols);

56

7827

57

27463

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

58

27463

    return connectionInfoProvider().requestedApplicationProtocols();

59

27463

60

61

7887

  void setRequestedServerName(absl::string_view server_name) override {

62

    // Always keep the server_name_ as lower case.

63

7887

    connectionInfoProvider().setRequestedServerName(absl::AsciiStrToLower(server_name));

64

7887

65

27539

  absl::string_view requestedServerName() const override {

66

27539

    return connectionInfoProvider().requestedServerName();

67

27539

68

69

11

  void setJA3Hash(absl::string_view ja3_hash) override {

70

11

    connectionInfoProvider().setJA3Hash(ja3_hash);

71

11

72

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

73

74

11

  void setJA4Hash(absl::string_view ja4_hash) override {

75

11

    connectionInfoProvider().setJA4Hash(ja4_hash);

76

11

77

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

78

79

54105

  absl::optional<std::chrono::milliseconds> lastRoundTripTime() override {

80

54105

    return ioHandle().lastRoundTripTime();

81

54105

82

83

2

  absl::optional<uint64_t> congestionWindowInBytes() const override {

84

2

    return ioHandle().congestionWindowInBytes();

85

2

86

87

2

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

88

2

    const char* spaces = spacesForLevel(indent_level);

89

2

    os << spaces << "ListenSocketImpl " << this << DUMP_MEMBER(transport_protocol_) << "\n";

90

2

    DUMP_DETAILS(connection_info_provider_);

91

2

92

93

protected:

94

  std::string transport_protocol_;

95

};

96

97

// ConnectionSocket used with client connections.

98

class ClientSocketImpl : public ConnectionSocketImpl {

99

public:

100

  ClientSocketImpl(const Address::InstanceConstSharedPtr& remote_address,

101

                   const OptionsSharedPtr& options)

102

53640

      : ConnectionSocketImpl(Network::ioHandleForAddr(Socket::Type::Stream, remote_address, {}),

103

53640

                             nullptr, remote_address) {

104

53640

    if (options) {

105

30270

      addOptions(options);

106

30270

107

53640

108

};

109

110

} // namespace Network

111

} // namespace Envoy