Grcov report - resolver

1

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

2

3

#include "envoy/common/exception.h"

4

#include "envoy/config/core/v3/address.pb.h"

5

#include "envoy/network/address.h"

6

#include "envoy/network/resolver.h"

7

#include "envoy/registry/registry.h"

8

9

#include "source/common/config/well_known_names.h"

10

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

11

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

12

13

namespace Envoy {

14

namespace Network {

15

namespace Address {

16

17

/**

18

 * Implementation of a resolver for IP addresses.

19

*/

20

class IpResolver : public Resolver {

21

22

public:

23

  absl::StatusOr<InstanceConstSharedPtr>

24

53464

  resolve(const envoy::config::core::v3::SocketAddress& socket_address) override {

25

53464

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

26

53464

    if (!socket_address.network_namespace_filepath().empty()) {

27

9

      netns = socket_address.network_namespace_filepath();

28

9

29

30

53464

    switch (socket_address.port_specifier_case()) {

31

53428

    case envoy::config::core::v3::SocketAddress::PortSpecifierCase::kPortValue:

32

    // Default to port 0 if no port value is specified.

33

53463

    case envoy::config::core::v3::SocketAddress::PortSpecifierCase::PORT_SPECIFIER_NOT_SET: {

34

53463

      auto addr = Network::Utility::parseInternetAddressNoThrow(

35

53463

          socket_address.address(), socket_address.port_value(), !socket_address.ipv4_compat(),

36

53463

          netns);

37

53463

      if (!addr) {

38

5

        return absl::InvalidArgumentError(

39

5

            absl::StrCat("malformed IP address: ", socket_address.address()));

40

5

41

53458

      return addr;

42

53463

43

1

    case envoy::config::core::v3::SocketAddress::PortSpecifierCase::kNamedPort:

44

1

      break;

45

53464

46

1

    return absl::InvalidArgumentError(

47

1

        fmt::format("IP resolver can't handle port specifier type {}",

48

1

                    static_cast<int>(socket_address.port_specifier_case())));

49

53464

50

51

1312

  std::string name() const override { return Config::AddressResolverNames::get().IP; }

52

};

53

54

/**

55

 * Static registration for the IP resolver. @see RegisterFactory.

56

*/

57

REGISTER_FACTORY(IpResolver, Resolver);

58

59

absl::StatusOr<InstanceConstSharedPtr>

60

53560

resolveProtoAddress(const envoy::config::core::v3::Address& address) {

61

53560

  switch (address.address_case()) {

62

1

  case envoy::config::core::v3::Address::AddressCase::ADDRESS_NOT_SET:

63

1

    return absl::InvalidArgumentError("Address must be set: " + address.DebugString());

64

53436

  case envoy::config::core::v3::Address::AddressCase::kSocketAddress:

65

53436

    return resolveProtoSocketAddress(address.socket_address());

66

83

  case envoy::config::core::v3::Address::AddressCase::kPipe:

67

83

    return PipeInstance::create(address.pipe().path(), address.pipe().mode());

68

40

  case envoy::config::core::v3::Address::AddressCase::kEnvoyInternalAddress:

69

40

    switch (address.envoy_internal_address().address_name_specifier_case()) {

70

39

    case envoy::config::core::v3::EnvoyInternalAddress::AddressNameSpecifierCase::

71

39

        kServerListenerName:

72

39

      return std::make_shared<EnvoyInternalInstance>(

73

39

          address.envoy_internal_address().server_listener_name(),

74

39

          address.envoy_internal_address().endpoint_id());

75

1

    case envoy::config::core::v3::EnvoyInternalAddress::AddressNameSpecifierCase::

76

1

        ADDRESS_NAME_SPECIFIER_NOT_SET:

77

1

      break;

78

40

79

53560

80

1

  return absl::InvalidArgumentError("Failed to resolve address:" + address.DebugString());

81

53560

82

83

absl::StatusOr<InstanceConstSharedPtr>

84

53491

resolveProtoSocketAddress(const envoy::config::core::v3::SocketAddress& socket_address) {

85

53491

  Resolver* resolver = nullptr;

86

53491

  const std::string& resolver_name = socket_address.resolver_name();

87

53491

  if (resolver_name.empty()) {

88

53462

    resolver =

89

53462

        Registry::FactoryRegistry<Resolver>::getFactory(Config::AddressResolverNames::get().IP);

90

53462

  } else {

91

29

    resolver = Registry::FactoryRegistry<Resolver>::getFactory(resolver_name);

92

29

93

53491

  if (resolver == nullptr) {

94

1

    return absl::InvalidArgumentError(fmt::format("Unknown address resolver: {}", resolver_name));

95

1

96

53490

  auto instance_or_error = resolver->resolve(socket_address);

97

53490

  RETURN_IF_NOT_OK_REF(instance_or_error.status());

98

53485

  return std::move(instance_or_error.value());

99

53490

100

101

} // namespace Address

102

} // namespace Network

103

} // namespace Envoy