1 //
2 // Copyright 2015 gRPC authors.
3 //
4 // Licensed under the Apache License, Version 2.0 (the "License");
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 #include <grpc/support/port_platform.h>
18
19 #include <algorithm>
20 #include <memory>
21 #include <string>
22 #include <utility>
23
24 #include "absl/status/statusor.h"
25 #include "absl/strings/str_split.h"
26 #include "absl/strings/string_view.h"
27
28 #include <grpc/support/log.h>
29
30 #include "src/core/lib/address_utils/parse_address.h"
31 #include "src/core/lib/channel/channel_args.h"
32 #include "src/core/lib/config/core_configuration.h"
33 #include "src/core/lib/gprpp/orphanable.h"
34 #include "src/core/lib/iomgr/port.h"
35 #include "src/core/lib/iomgr/resolved_address.h"
36 #include "src/core/resolver/endpoint_addresses.h"
37 #include "src/core/resolver/resolver.h"
38 #include "src/core/resolver/resolver_factory.h"
39 #include "src/core/lib/uri/uri_parser.h"
40
41 namespace grpc_core {
42
43 namespace {
44
45 class SockaddrResolver final : public Resolver {
46 public:
47 SockaddrResolver(EndpointAddressesList addresses, ResolverArgs args);
48
49 void StartLocked() override;
50
ShutdownLocked()51 void ShutdownLocked() override {}
52
53 private:
54 std::unique_ptr<ResultHandler> result_handler_;
55 EndpointAddressesList addresses_;
56 ChannelArgs channel_args_;
57 };
58
SockaddrResolver(EndpointAddressesList addresses,ResolverArgs args)59 SockaddrResolver::SockaddrResolver(EndpointAddressesList addresses,
60 ResolverArgs args)
61 : result_handler_(std::move(args.result_handler)),
62 addresses_(std::move(addresses)),
63 channel_args_(std::move(args.args)) {}
64
StartLocked()65 void SockaddrResolver::StartLocked() {
66 Result result;
67 result.addresses = std::move(addresses_);
68 result.args = std::move(channel_args_);
69 result_handler_->ReportResult(std::move(result));
70 }
71
72 //
73 // Factory
74 //
75
ParseUri(const URI & uri,bool parse (const URI & uri,grpc_resolved_address * dst),EndpointAddressesList * addresses)76 bool ParseUri(const URI& uri,
77 bool parse(const URI& uri, grpc_resolved_address* dst),
78 EndpointAddressesList* addresses) {
79 if (!uri.authority().empty()) {
80 gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
81 uri.scheme().c_str());
82 return false;
83 }
84 // Construct addresses.
85 bool errors_found = false;
86 for (absl::string_view ith_path : absl::StrSplit(uri.path(), ',')) {
87 if (ith_path.empty()) {
88 // Skip targets which are empty.
89 continue;
90 }
91 auto ith_uri = URI::Create(uri.scheme(), "", std::string(ith_path), {}, "");
92 grpc_resolved_address addr;
93 if (!ith_uri.ok() || !parse(*ith_uri, &addr)) {
94 errors_found = true;
95 break;
96 }
97 if (addresses != nullptr) {
98 addresses->emplace_back(addr, ChannelArgs());
99 }
100 }
101 return !errors_found;
102 }
103
CreateSockaddrResolver(ResolverArgs args,bool parse (const URI & uri,grpc_resolved_address * dst))104 OrphanablePtr<Resolver> CreateSockaddrResolver(
105 ResolverArgs args, bool parse(const URI& uri, grpc_resolved_address* dst)) {
106 EndpointAddressesList addresses;
107 if (!ParseUri(args.uri, parse, &addresses)) return nullptr;
108 // Instantiate resolver.
109 return MakeOrphanable<SockaddrResolver>(std::move(addresses),
110 std::move(args));
111 }
112
113 class IPv4ResolverFactory final : public ResolverFactory {
114 public:
scheme() const115 absl::string_view scheme() const override { return "ipv4"; }
116
IsValidUri(const URI & uri) const117 bool IsValidUri(const URI& uri) const override {
118 return ParseUri(uri, grpc_parse_ipv4, nullptr);
119 }
120
CreateResolver(ResolverArgs args) const121 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
122 return CreateSockaddrResolver(std::move(args), grpc_parse_ipv4);
123 }
124 };
125
126 class IPv6ResolverFactory final : public ResolverFactory {
127 public:
scheme() const128 absl::string_view scheme() const override { return "ipv6"; }
129
IsValidUri(const URI & uri) const130 bool IsValidUri(const URI& uri) const override {
131 return ParseUri(uri, grpc_parse_ipv6, nullptr);
132 }
133
CreateResolver(ResolverArgs args) const134 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
135 return CreateSockaddrResolver(std::move(args), grpc_parse_ipv6);
136 }
137 };
138
139 #ifdef GRPC_HAVE_UNIX_SOCKET
140 class UnixResolverFactory final : public ResolverFactory {
141 public:
scheme() const142 absl::string_view scheme() const override { return "unix"; }
143
IsValidUri(const URI & uri) const144 bool IsValidUri(const URI& uri) const override {
145 return ParseUri(uri, grpc_parse_unix, nullptr);
146 }
147
CreateResolver(ResolverArgs args) const148 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
149 return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
150 }
151 };
152
153 class UnixAbstractResolverFactory final : public ResolverFactory {
154 public:
scheme() const155 absl::string_view scheme() const override { return "unix-abstract"; }
156
IsValidUri(const URI & uri) const157 bool IsValidUri(const URI& uri) const override {
158 return ParseUri(uri, grpc_parse_unix_abstract, nullptr);
159 }
160
CreateResolver(ResolverArgs args) const161 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
162 return CreateSockaddrResolver(std::move(args), grpc_parse_unix_abstract);
163 }
164 };
165 #endif // GRPC_HAVE_UNIX_SOCKET
166
167 #ifdef GRPC_HAVE_VSOCK
168 class VSockResolverFactory final : public ResolverFactory {
169 public:
scheme() const170 absl::string_view scheme() const override { return "vsock"; }
171
IsValidUri(const URI & uri) const172 bool IsValidUri(const URI& uri) const override {
173 return ParseUri(uri, grpc_parse_vsock, nullptr);
174 }
175
CreateResolver(ResolverArgs args) const176 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
177 return CreateSockaddrResolver(std::move(args), grpc_parse_vsock);
178 }
179 };
180
181 #endif // GRPC_HAVE_VSOCK
182
183 } // namespace
184
RegisterSockaddrResolver(CoreConfiguration::Builder * builder)185 void RegisterSockaddrResolver(CoreConfiguration::Builder* builder) {
186 builder->resolver_registry()->RegisterResolverFactory(
187 std::make_unique<IPv4ResolverFactory>());
188 builder->resolver_registry()->RegisterResolverFactory(
189 std::make_unique<IPv6ResolverFactory>());
190 #ifdef GRPC_HAVE_UNIX_SOCKET
191 builder->resolver_registry()->RegisterResolverFactory(
192 std::make_unique<UnixResolverFactory>());
193 builder->resolver_registry()->RegisterResolverFactory(
194 std::make_unique<UnixAbstractResolverFactory>());
195 #endif
196 #ifdef GRPC_HAVE_VSOCK
197 builder->resolver_registry()->RegisterResolverFactory(
198 std::make_unique<VSockResolverFactory>());
199 #endif
200 }
201
202 } // namespace grpc_core
203