3 * Copyright 2015-2016 gRPC authors.
5 * Licensed under the Apache License, Version 2.0 (the "License");
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
19 #include <grpc/support/port_platform.h>
26 #include "absl/strings/str_split.h"
28 #include <grpc/support/alloc.h>
29 #include <grpc/support/string_util.h>
31 #include "src/core/ext/filters/client_channel/resolver_registry.h"
32 #include "src/core/ext/filters/client_channel/server_address.h"
33 #include "src/core/lib/channel/channel_args.h"
34 #include "src/core/lib/gpr/string.h"
35 #include "src/core/lib/iomgr/parse_address.h"
36 #include "src/core/lib/iomgr/resolve_address.h"
37 #include "src/core/lib/iomgr/unix_sockets_posix.h"
38 #include "src/core/lib/slice/slice_internal.h"
39 #include "src/core/lib/slice/slice_string_helpers.h"
45 class SockaddrResolver : public Resolver {
47 SockaddrResolver(ServerAddressList addresses, ResolverArgs args);
48 ~SockaddrResolver() override;
50 void StartLocked() override;
52 void ShutdownLocked() override {}
55 std::unique_ptr<ResultHandler> result_handler_;
56 ServerAddressList addresses_;
57 const grpc_channel_args* channel_args_ = nullptr;
60 SockaddrResolver::SockaddrResolver(ServerAddressList addresses,
62 : result_handler_(std::move(args.result_handler)),
63 addresses_(std::move(addresses)),
64 channel_args_(grpc_channel_args_copy(args.args)) {}
66 SockaddrResolver::~SockaddrResolver() {
67 grpc_channel_args_destroy(channel_args_);
70 void SockaddrResolver::StartLocked() {
72 result.addresses = std::move(addresses_);
73 // TODO(roth): Use std::move() once channel args is converted to C++.
74 result.args = channel_args_;
75 channel_args_ = nullptr;
76 result_handler_->ReturnResult(std::move(result));
83 bool ParseUri(const URI& uri,
84 bool parse(const URI& uri, grpc_resolved_address* dst),
85 ServerAddressList* addresses) {
86 if (!uri.authority().empty()) {
87 gpr_log(GPR_ERROR, "authority-based URIs not supported by the %s scheme",
88 uri.scheme().c_str());
91 // Construct addresses.
92 bool errors_found = false;
93 for (absl::string_view ith_path : absl::StrSplit(uri.path(), ',')) {
94 URI ith_uri(uri.scheme(), "", std::string(ith_path), {}, "");
95 grpc_resolved_address addr;
96 if (!parse(ith_uri, &addr)) {
100 if (addresses != nullptr) {
101 addresses->emplace_back(addr, nullptr /* args */);
104 return !errors_found;
107 OrphanablePtr<Resolver> CreateSockaddrResolver(
108 ResolverArgs args, bool parse(const URI& uri, grpc_resolved_address* dst)) {
109 ServerAddressList addresses;
110 if (!ParseUri(args.uri, parse, &addresses)) return nullptr;
111 // Instantiate resolver.
112 return MakeOrphanable<SockaddrResolver>(std::move(addresses),
116 class IPv4ResolverFactory : public ResolverFactory {
118 bool IsValidUri(const URI& uri) const override {
119 return ParseUri(uri, grpc_parse_ipv4, nullptr);
122 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
123 return CreateSockaddrResolver(std::move(args), grpc_parse_ipv4);
126 const char* scheme() const override { return "ipv4"; }
129 class IPv6ResolverFactory : public ResolverFactory {
131 bool IsValidUri(const URI& uri) const override {
132 return ParseUri(uri, grpc_parse_ipv6, nullptr);
135 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
136 return CreateSockaddrResolver(std::move(args), grpc_parse_ipv6);
139 const char* scheme() const override { return "ipv6"; }
142 #ifdef GRPC_HAVE_UNIX_SOCKET
143 class UnixResolverFactory : public ResolverFactory {
145 bool IsValidUri(const URI& uri) const override {
146 return ParseUri(uri, grpc_parse_unix, nullptr);
149 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
150 return CreateSockaddrResolver(std::move(args), grpc_parse_unix);
153 std::string GetDefaultAuthority(const URI& /*uri*/) const override {
157 const char* scheme() const override { return "unix"; }
160 class UnixAbstractResolverFactory : public ResolverFactory {
162 bool IsValidUri(const URI& uri) const override {
163 return ParseUri(uri, grpc_parse_unix_abstract, nullptr);
166 OrphanablePtr<Resolver> CreateResolver(ResolverArgs args) const override {
167 return CreateSockaddrResolver(std::move(args), grpc_parse_unix_abstract);
170 std::string GetDefaultAuthority(const URI& /*uri*/) const override {
174 const char* scheme() const override { return "unix-abstract"; }
176 #endif // GRPC_HAVE_UNIX_SOCKET
180 } // namespace grpc_core
182 void grpc_resolver_sockaddr_init() {
183 grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
184 absl::make_unique<grpc_core::IPv4ResolverFactory>());
185 grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
186 absl::make_unique<grpc_core::IPv6ResolverFactory>());
187 #ifdef GRPC_HAVE_UNIX_SOCKET
188 grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
189 absl::make_unique<grpc_core::UnixResolverFactory>());
190 grpc_core::ResolverRegistry::Builder::RegisterResolverFactory(
191 absl::make_unique<grpc_core::UnixAbstractResolverFactory>());
195 void grpc_resolver_sockaddr_shutdown() {}