Make resolv_integration_test run on Q devices
use libbinder_ndk for resolv_intergration_test
Also statically link other libs
Bug: 144850003
Test: atest
manual test in Q + M4 resolv module
Change-Id: I1c8a880495afa3764fe6f720e58f46bde18ce872
diff --git a/Android.bp b/Android.bp
index 5e4a50f..24115c6 100644
--- a/Android.bp
+++ b/Android.bp
@@ -152,45 +152,7 @@
],
}
-cc_test {
- name: "resolv_integration_test",
- test_suites: ["device-tests"],
- require_root: true,
- defaults: ["netd_defaults"],
- tidy: false, // cuts test build time by > 1m30s
- srcs: [
- "tests/dns_responder/dns_responder.cpp",
- "dnsresolver_binder_test.cpp",
- "resolv_integration_test.cpp",
- ],
- header_libs: [
- "libnetd_resolv_headers",
- ],
- shared_libs: [
- "libbpf_android",
- "libbinder",
- "libcrypto",
- "liblog",
- "libnetd_client",
- "libssl",
- "libutils",
- ],
- static_libs: [
- "dnsresolver_aidl_interface-unstable-cpp",
- "libbase",
- "libgmock",
- "libnetd_test_dnsresponder",
- "libnetd_test_metrics_listener",
- "libnetd_test_resolv_utils",
- "libnetd_test_tun_interface",
- "libnetd_test_utils",
- "libnetdutils",
- "netd_aidl_interface-cpp",
- "netd_event_listener_interface-cpp",
- ],
- compile_multilib: "both",
-}
-
+// TODO: Move this test to tests/
cc_test {
name: "resolv_unit_test",
test_suites: ["device-tests"],
diff --git a/tests/Android.bp b/tests/Android.bp
index 4a38a71..0259aac 100644
--- a/tests/Android.bp
+++ b/tests/Android.bp
@@ -15,7 +15,6 @@
static_libs: [
"libnetd_test_dnsresponder",
"libnetdutils",
- "dnsresolver_aidl_interface-cpp",
],
}
@@ -79,22 +78,60 @@
],
shared_libs: [
"libbase",
- "libbinder",
+ "libbinder_ndk",
"libnetd_client",
"libutils",
],
static_libs: [
+ "dnsresolver_aidl_interface-ndk_platform",
"libgmock",
- "libnetd_test_dnsresponder",
+ "libnetd_test_dnsresponder_ndk",
"libnetd_test_resolv_utils",
"libnetdutils",
- "netd_aidl_interface-cpp",
- "netd_event_listener_interface-cpp",
- "dnsresolver_aidl_interface-cpp",
+ "netd_event_listener_interface-ndk_platform",
+ "netd_aidl_interface-ndk_platform",
],
compile_multilib: "both",
- sanitize: {
- address: true,
- recover: ["all"],
- },
+}
+
+cc_test {
+ name: "resolv_integration_test",
+ test_suites: ["device-tests"],
+ require_root: true,
+ defaults: ["netd_defaults"],
+ tidy: false, // cuts test build time by > 1m30s
+ srcs: [
+ "dns_responder/dns_responder.cpp",
+ "dnsresolver_binder_test.cpp",
+ "resolv_integration_test.cpp",
+ ],
+ header_libs: [
+ "libnetd_resolv_headers",
+ "libnetd_resolv_internal_headers",
+ ],
+ // TODO: make static link libc++ work.
+ //stl: "libc++_static",
+ shared_libs: [
+ "libbinder_ndk",
+ "libnetd_client",
+ ],
+ static_libs: [
+ "dnsresolver_aidl_interface-unstable-ndk_platform",
+ "libbase",
+ "libbpf_android",
+ "libcrypto_static",
+ "libgmock",
+ "liblog",
+ "libnetdutils",
+ "libnetd_test_resolv_utils",
+ "libnetd_test_tun_interface",
+ "libnetd_test_utils",
+ "libnetd_test_metrics_listener",
+ "libnetd_test_dnsresponder_ndk",
+ "libssl",
+ "libutils",
+ "netd_aidl_interface-ndk_platform",
+ "netd_event_listener_interface-ndk_platform",
+ ],
+ compile_multilib: "both",
}
diff --git a/tests/dns_metrics_listener/Android.bp b/tests/dns_metrics_listener/Android.bp
index f4c1e26..8a957d6 100644
--- a/tests/dns_metrics_listener/Android.bp
+++ b/tests/dns_metrics_listener/Android.bp
@@ -7,11 +7,11 @@
"test_metrics.cpp",
],
shared_libs: [
- "libbase",
- "libbinder",
- "libutils",
+ "libbinder_ndk",
],
static_libs: [
- "netd_event_listener_interface-cpp",
+ "libbase",
+ "libutils",
+ "netd_event_listener_interface-ndk_platform",
],
}
diff --git a/tests/dns_metrics_listener/base_metrics_listener.cpp b/tests/dns_metrics_listener/base_metrics_listener.cpp
index e6dbb32..f93e7c4 100644
--- a/tests/dns_metrics_listener/base_metrics_listener.cpp
+++ b/tests/dns_metrics_listener/base_metrics_listener.cpp
@@ -20,51 +20,51 @@
namespace net {
namespace metrics {
-android::binder::Status BaseMetricsListener::onDnsEvent(
+::ndk::ScopedAStatus BaseMetricsListener::onDnsEvent(
int32_t /*netId*/, int32_t /*eventType*/, int32_t /*returnCode*/, int32_t /*latencyMs*/,
const std::string& /*hostname*/, const ::std::vector<std::string>& /*ipAddresses*/,
int32_t /*ipAddressesCount*/, int32_t /*uid*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
-android::binder::Status BaseMetricsListener::onPrivateDnsValidationEvent(
- int32_t /*netId*/, const ::android::String16& /*ipAddress*/,
- const ::android::String16& /*hostname*/, bool /*validated*/) {
+::ndk::ScopedAStatus BaseMetricsListener::onPrivateDnsValidationEvent(
+ int32_t /*netId*/, const std::string& /*ipAddress*/, const std::string& /*hostname*/,
+ bool /*validated*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
-android::binder::Status BaseMetricsListener::onConnectEvent(int32_t /*netId*/, int32_t /*error*/,
- int32_t /*latencyMs*/,
- const ::android::String16& /*ipAddr*/,
- int32_t /*port*/, int32_t /*uid*/) {
+::ndk::ScopedAStatus BaseMetricsListener::onConnectEvent(int32_t /*netId*/, int32_t /*error*/,
+ int32_t /*latencyMs*/,
+ const std::string& /*ipAddr*/,
+ int32_t /*port*/, int32_t /*uid*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
-android::binder::Status BaseMetricsListener::onWakeupEvent(
- const ::android::String16& /*prefix*/, int32_t /*uid*/, int32_t /*ethertype*/,
- int32_t /*ipNextHeader*/, const ::std::vector<uint8_t>& /*dstHw*/,
- const ::android::String16& /*srcIp*/, const ::android::String16& /*dstIp*/,
- int32_t /*srcPort*/, int32_t /*dstPort*/, int64_t /*timestampNs*/) {
+::ndk::ScopedAStatus BaseMetricsListener::onWakeupEvent(
+ const std::string& /*prefix*/, int32_t /*uid*/, int32_t /*ethertype*/,
+ int32_t /*ipNextHeader*/, const ::std::vector<int8_t>& /*dstHw*/,
+ const std::string& /*srcIp*/, const std::string& /*dstIp*/, int32_t /*srcPort*/,
+ int32_t /*dstPort*/, int64_t /*timestampNs*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
-android::binder::Status BaseMetricsListener::onTcpSocketStatsEvent(
+::ndk::ScopedAStatus BaseMetricsListener::onTcpSocketStatsEvent(
const ::std::vector<int32_t>& /*networkIds*/, const ::std::vector<int32_t>& /*sentPackets*/,
const ::std::vector<int32_t>& /*lostPackets*/, const ::std::vector<int32_t>& /*rttUs*/,
const ::std::vector<int32_t>& /*sentAckDiffMs*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
-android::binder::Status BaseMetricsListener::onNat64PrefixEvent(
- int32_t /*netId*/, bool /*added*/, const ::std::string& /*prefixString*/,
- int32_t /*prefixLength*/) {
+::ndk::ScopedAStatus BaseMetricsListener::onNat64PrefixEvent(int32_t /*netId*/, bool /*added*/,
+ const ::std::string& /*prefixString*/,
+ int32_t /*prefixLength*/) {
// default no-op
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
} // namespace metrics
diff --git a/tests/dns_metrics_listener/base_metrics_listener.h b/tests/dns_metrics_listener/base_metrics_listener.h
index 9ba8423..7ac9f11 100644
--- a/tests/dns_metrics_listener/base_metrics_listener.h
+++ b/tests/dns_metrics_listener/base_metrics_listener.h
@@ -19,43 +19,45 @@
#include <string>
#include <vector>
-#include "android/net/metrics/BnNetdEventListener.h"
+#include <aidl/android/net/metrics/BnNetdEventListener.h>
namespace android {
namespace net {
namespace metrics {
-class BaseMetricsListener : public BnNetdEventListener {
+class BaseMetricsListener : public aidl::android::net::metrics::BnNetdEventListener {
public:
BaseMetricsListener() = default;
~BaseMetricsListener() = default;
- virtual android::binder::Status onDnsEvent(int32_t /*netId*/, int32_t /*eventType*/,
- int32_t /*returnCode*/, int32_t /*latencyMs*/,
- const std::string& /*hostname*/,
- const ::std::vector<std::string>& /*ipAddresses*/,
- int32_t /*ipAddressesCount*/,
- int32_t /*uid*/) override;
- virtual android::binder::Status onPrivateDnsValidationEvent(
- int32_t /*netId*/, const ::android::String16& /*ipAddress*/,
- const ::android::String16& /*hostname*/, bool /*validated*/) override;
- virtual android::binder::Status onConnectEvent(int32_t /*netId*/, int32_t /*error*/,
- int32_t /*latencyMs*/,
- const ::android::String16& /*ipAddr*/,
- int32_t /*port*/, int32_t /*uid*/) override;
- virtual android::binder::Status onWakeupEvent(
- const ::android::String16& /*prefix*/, int32_t /*uid*/, int32_t /*ethertype*/,
- int32_t /*ipNextHeader*/, const ::std::vector<uint8_t>& /*dstHw*/,
- const ::android::String16& /*srcIp*/, const ::android::String16& /*dstIp*/,
- int32_t /*srcPort*/, int32_t /*dstPort*/, int64_t /*timestampNs*/) override;
- virtual android::binder::Status onTcpSocketStatsEvent(
+ virtual ::ndk::ScopedAStatus onDnsEvent(int32_t /*netId*/, int32_t /*eventType*/,
+ int32_t /*returnCode*/, int32_t /*latencyMs*/,
+ const std::string& /*hostname*/,
+ const ::std::vector<std::string>& /*ipAddresses*/,
+ int32_t /*ipAddressesCount*/, int32_t /*uid*/) override;
+ virtual ::ndk::ScopedAStatus onPrivateDnsValidationEvent(int32_t /*netId*/,
+ const std::string& /*ipAddress*/,
+ const std::string& /*hostname*/,
+ bool /*validated*/) override;
+ virtual ::ndk::ScopedAStatus onConnectEvent(int32_t /*netId*/, int32_t /*error*/,
+ int32_t /*latencyMs*/,
+ const std::string& /*ipAddr*/, int32_t /*port*/,
+ int32_t /*uid*/) override;
+ virtual ::ndk::ScopedAStatus onWakeupEvent(const std::string& /*prefix*/, int32_t /*uid*/,
+ int32_t /*ethertype*/, int32_t /*ipNextHeader*/,
+ const ::std::vector<int8_t>& /*dstHw*/,
+ const std::string& /*srcIp*/,
+ const std::string& /*dstIp*/, int32_t /*srcPort*/,
+ int32_t /*dstPort*/,
+ int64_t /*timestampNs*/) override;
+ virtual ::ndk::ScopedAStatus onTcpSocketStatsEvent(
const ::std::vector<int32_t>& /*networkIds*/,
const ::std::vector<int32_t>& /*sentPackets*/,
const ::std::vector<int32_t>& /*lostPackets*/, const ::std::vector<int32_t>& /*rttUs*/,
const ::std::vector<int32_t>& /*sentAckDiffMs*/) override;
- virtual android::binder::Status onNat64PrefixEvent(int32_t /*netId*/, bool /*added*/,
- const ::std::string& /*prefixString*/,
- int32_t /*prefixLength*/) override;
+ virtual ::ndk::ScopedAStatus onNat64PrefixEvent(int32_t /*netId*/, bool /*added*/,
+ const ::std::string& /*prefixString*/,
+ int32_t /*prefixLength*/) override;
};
} // namespace metrics
diff --git a/tests/dns_metrics_listener/dns_metrics_listener.cpp b/tests/dns_metrics_listener/dns_metrics_listener.cpp
index acfb416..b5a5a8d 100644
--- a/tests/dns_metrics_listener/dns_metrics_listener.cpp
+++ b/tests/dns_metrics_listener/dns_metrics_listener.cpp
@@ -29,26 +29,24 @@
constexpr milliseconds kRetryIntervalMs{20};
constexpr milliseconds kEventTimeoutMs{5000};
-android::binder::Status DnsMetricsListener::onNat64PrefixEvent(int32_t netId, bool added,
- const std::string& prefixString,
- int32_t /*prefixLength*/) {
+::ndk::ScopedAStatus DnsMetricsListener::onNat64PrefixEvent(int32_t netId, bool added,
+ const std::string& prefixString,
+ int32_t /*prefixLength*/) {
std::lock_guard lock(mMutex);
if (netId == mNetId) mNat64Prefix = added ? prefixString : "";
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
}
-android::binder::Status DnsMetricsListener::onPrivateDnsValidationEvent(
- int32_t netId, const ::android::String16& ipAddress,
- const ::android::String16& /*hostname*/, bool validated) {
+::ndk::ScopedAStatus DnsMetricsListener::onPrivateDnsValidationEvent(
+ int32_t netId, const std::string& ipAddress, const std::string& /*hostname*/,
+ bool validated) {
{
std::lock_guard lock(mMutex);
- std::string serverAddr(String8(ipAddress.string()));
-
// keep updating the server to have latest validation status.
- mValidationRecords.insert_or_assign({netId, serverAddr}, validated);
+ mValidationRecords.insert_or_assign({netId, ipAddress}, validated);
}
mCv.notify_one();
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
}
bool DnsMetricsListener::waitForNat64Prefix(ExpectNat64PrefixStatus status,
diff --git a/tests/dns_metrics_listener/dns_metrics_listener.h b/tests/dns_metrics_listener/dns_metrics_listener.h
index d933b13..d6268e2 100644
--- a/tests/dns_metrics_listener/dns_metrics_listener.h
+++ b/tests/dns_metrics_listener/dns_metrics_listener.h
@@ -42,14 +42,13 @@
DnsMetricsListener(int32_t netId) : mNetId(netId){};
// Override DNS metrics event(s).
- android::binder::Status onNat64PrefixEvent(int32_t netId, bool added,
- const std::string& prefixString,
- int32_t /*prefixLength*/) override;
+ ::ndk::ScopedAStatus onNat64PrefixEvent(int32_t netId, bool added,
+ const std::string& prefixString,
+ int32_t /*prefixLength*/) override;
- android::binder::Status onPrivateDnsValidationEvent(int32_t netId,
- const ::android::String16& ipAddress,
- const ::android::String16& /*hostname*/,
- bool validated) override;
+ ::ndk::ScopedAStatus onPrivateDnsValidationEvent(int32_t netId, const std::string& ipAddress,
+ const std::string& /*hostname*/,
+ bool validated) override;
// Wait for expected NAT64 prefix status until timeout.
bool waitForNat64Prefix(ExpectNat64PrefixStatus status,
diff --git a/tests/dns_metrics_listener/test_metrics.cpp b/tests/dns_metrics_listener/test_metrics.cpp
index 094c3a8..14897f6 100644
--- a/tests/dns_metrics_listener/test_metrics.cpp
+++ b/tests/dns_metrics_listener/test_metrics.cpp
@@ -33,11 +33,11 @@
}
// Derived class TestOnDnsEvent.
-android::binder::Status TestOnDnsEvent::onDnsEvent(int32_t netId, int32_t eventType,
- int32_t returnCode, int32_t /*latencyMs*/,
- const std::string& hostname,
- const ::std::vector<std::string>& ipAddresses,
- int32_t ipAddressesCount, int32_t /*uid*/) {
+::ndk::ScopedAStatus TestOnDnsEvent::onDnsEvent(int32_t netId, int32_t eventType,
+ int32_t returnCode, int32_t /*latencyMs*/,
+ const std::string& hostname,
+ const ::std::vector<std::string>& ipAddresses,
+ int32_t ipAddressesCount, int32_t /*uid*/) {
// A bitwise-OR combination of all expected test cases.
// Currently, the maximum number of test case is 32 because a 32-bits bitwise-OR combination
// is used for checking and recording verified test cases.
@@ -77,7 +77,7 @@
notify();
}
- return android::binder::Status::ok();
+ return ::ndk::ScopedAStatus(AStatus_newOk());
};
} // namespace metrics
diff --git a/tests/dns_metrics_listener/test_metrics.h b/tests/dns_metrics_listener/test_metrics.h
index d098aca..03c9842 100644
--- a/tests/dns_metrics_listener/test_metrics.h
+++ b/tests/dns_metrics_listener/test_metrics.h
@@ -83,10 +83,10 @@
bool isVerified() override { return (getVerified() & EventFlag::onDnsEvent) != 0; }
// Override for testing verification.
- android::binder::Status onDnsEvent(int32_t netId, int32_t eventType, int32_t returnCode,
- int32_t /*latencyMs*/, const std::string& hostname,
- const std::vector<std::string>& ipAddresses,
- int32_t ipAddressesCount, int32_t /*uid*/) override;
+ ::ndk::ScopedAStatus onDnsEvent(int32_t netId, int32_t eventType, int32_t returnCode,
+ int32_t /*latencyMs*/, const std::string& hostname,
+ const std::vector<std::string>& ipAddresses,
+ int32_t ipAddressesCount, int32_t /*uid*/) override;
private:
const std::vector<TestResult>& mResults; // Expected results for test verification.
diff --git a/tests/dns_responder/Android.bp b/tests/dns_responder/Android.bp
index 57f9f58..bce678e 100644
--- a/tests/dns_responder/Android.bp
+++ b/tests/dns_responder/Android.bp
@@ -17,3 +17,32 @@
],
export_include_dirs: ["."],
}
+
+cc_library {
+ name: "libnetd_test_dnsresponder_ndk",
+ defaults: ["netd_defaults"],
+ shared_libs: [
+ "libbinder_ndk",
+ "libnetd_client",
+ ],
+ header_libs: [
+ "libnetd_resolv_headers",
+ "libnetd_resolv_internal_headers",
+ ],
+ static_libs: [
+ "dnsresolver_aidl_interface-unstable-ndk_platform",
+ "libbase",
+ "libcrypto_static",
+ "liblog",
+ "libnetdutils",
+ "libssl",
+ "netd_event_listener_interface-ndk_platform",
+ "netd_aidl_interface-ndk_platform",
+ ],
+ srcs: [
+ "dns_responder.cpp",
+ "dns_responder_client_ndk.cpp",
+ "dns_tls_frontend.cpp",
+ ],
+ export_include_dirs: ["."],
+}
diff --git a/tests/dns_responder/dns_responder_client.h b/tests/dns_responder/dns_responder_client.h
index a07bd88..6254fd0 100644
--- a/tests/dns_responder/dns_responder_client.h
+++ b/tests/dns_responder/dns_responder_client.h
@@ -36,6 +36,7 @@
2, // retry count
};
+// TODO: Remove this after finishing all tests migration from libbinder to libbinder_ndk
class DnsResponderClient {
public:
struct Mapping {
diff --git a/tests/dns_responder/dns_responder_client_ndk.cpp b/tests/dns_responder/dns_responder_client_ndk.cpp
new file mode 100644
index 0000000..c52fbeb
--- /dev/null
+++ b/tests/dns_responder/dns_responder_client_ndk.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "dns_responder_client"
+
+#include "dns_responder_client_ndk.h"
+
+#include <android-base/logging.h>
+#include <android-base/stringprintf.h>
+
+#include <android/binder_manager.h>
+#include "NetdClient.h"
+
+// TODO: make this dynamic and stop depending on implementation details.
+#define TEST_OEM_NETWORK "oem29"
+#define TEST_NETID 30
+
+// TODO: move this somewhere shared.
+static const char* ANDROID_DNS_MODE = "ANDROID_DNS_MODE";
+
+using aidl::android::net::IDnsResolver;
+using aidl::android::net::INetd;
+using aidl::android::net::ResolverParamsParcel;
+using android::base::StringPrintf;
+using android::net::ResolverStats;
+
+static const char kCaCert[] = R"(
+-----BEGIN CERTIFICATE-----
+MIIC4TCCAcmgAwIBAgIUQUHZnWhL6M4qcS+I0lLkMyqf3VMwDQYJKoZIhvcNAQEL
+BQAwADAeFw0xOTA2MTAwODM3MzlaFw0yOTA2MDcwODM3MzlaMAAwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQCapRbBg6dRT4id4DxmlyktomE8gpm4W+VA
+ZOivhKat4CvGfVjVIAUYxV7LOGREkkT8Qhn5/gU0lShsnURzEDWY+IjMDDw+kRAm
+iFAlMRnCobTp/tenseNRB2tDuUhkRbzaT6qaidPbKy099p909gxf4YqsgY2NfsY2
+JkideqIkVq2hvLehsu3BgiK06TGUgxOHfj74vx7iGyujq1v38J1hlox5vj/svJF6
+jVdDw8p2UkJbO2N9u3al0nNSMG+MCgd3cvKUySTnjedYXsYB0WyH/JZn//KDq6o+
+as6eQVHuH1fu+8XPzBNATlkHzy+YAs7T+UWbkoa1F8wIElVQg66lAgMBAAGjUzBR
+MB0GA1UdDgQWBBShu/e54D3VdqdLOWo9Ou5hbjaIojAfBgNVHSMEGDAWgBShu/e5
+4D3VdqdLOWo9Ou5hbjaIojAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUA
+A4IBAQBFkEGqqzzdQlhP5m1kzh+SiUCwekzSump0CSk0JAXAdeLNbWs3H+pE1/hM
+Fx7oFonoX5O6pi68JfcIP0u7wNuZkKqubUl4gG6aHDkAad2oeTov0Be7EKt8Ekwf
+tmFWVQQrF9otlG3Stn4vmE5zVNGQXDgRsNKPekSo0XJz757q5WgblauB71Rekvio
+TCUXXt3jf3SuovcUFjgBkaohikBRbLiPWZrW4y0XUsgBKI6sLtiSZOPiNevY2xAR
+y7mCSmi4wP7vtUQ5G8znkAMKoo0FzyfjSogGQeREUM8Oe9Mmh/D39sq/D4TsiAxt
+Pwl59DlzlHHJhmOL+SCGciBX4X7p
+-----END CERTIFICATE-----
+)";
+
+void DnsResponderClient::SetupMappings(unsigned num_hosts, const std::vector<std::string>& domains,
+ std::vector<Mapping>* mappings) {
+ mappings->resize(num_hosts * domains.size());
+ auto mappings_it = mappings->begin();
+ for (unsigned i = 0; i < num_hosts; ++i) {
+ for (const auto& domain : domains) {
+ mappings_it->host = StringPrintf("host%u", i);
+ mappings_it->entry = StringPrintf("%s.%s.", mappings_it->host.c_str(), domain.c_str());
+ mappings_it->ip4 = StringPrintf("192.0.2.%u", i % 253 + 1);
+ mappings_it->ip6 = StringPrintf("2001:db8::%x", i % 65534 + 1);
+ ++mappings_it;
+ }
+ }
+}
+
+// TODO: Use SetResolverConfiguration() with ResolverParamsParcel struct directly.
+// DEPRECATED: Use SetResolverConfiguration() in new code
+ResolverParamsParcel DnsResponderClient::makeResolverParamsParcel(
+ int netId, const std::vector<int>& params, const std::vector<std::string>& servers,
+ const std::vector<std::string>& domains, const std::string& tlsHostname,
+ const std::vector<std::string>& tlsServers, const std::string& caCert) {
+ ResolverParamsParcel paramsParcel;
+
+ paramsParcel.netId = netId;
+ paramsParcel.sampleValiditySeconds = params[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY];
+ paramsParcel.successThreshold = params[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD];
+ paramsParcel.minSamples = params[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES];
+ paramsParcel.maxSamples = params[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES];
+ if (params.size() > IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC) {
+ paramsParcel.baseTimeoutMsec = params[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC];
+ } else {
+ paramsParcel.baseTimeoutMsec = 0;
+ }
+ if (params.size() > IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT) {
+ paramsParcel.retryCount = params[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT];
+ } else {
+ paramsParcel.retryCount = 0;
+ }
+ paramsParcel.servers = servers;
+ paramsParcel.domains = domains;
+ paramsParcel.tlsName = tlsHostname;
+ paramsParcel.tlsServers = tlsServers;
+ paramsParcel.tlsFingerprints = {};
+ paramsParcel.caCertificate = caCert;
+ paramsParcel.tlsConnectTimeoutMs = 1000;
+
+ return paramsParcel;
+}
+
+bool DnsResponderClient::GetResolverInfo(aidl::android::net::IDnsResolver* dnsResolverService,
+ unsigned netId, std::vector<std::string>* servers,
+ std::vector<std::string>* domains,
+ std::vector<std::string>* tlsServers, res_params* params,
+ std::vector<ResolverStats>* stats,
+ int* wait_for_pending_req_timeout_count) {
+ using aidl::android::net::IDnsResolver;
+ std::vector<int32_t> params32;
+ std::vector<int32_t> stats32;
+ std::vector<int32_t> wait_for_pending_req_timeout_count32{0};
+ auto rv = dnsResolverService->getResolverInfo(netId, servers, domains, tlsServers, ¶ms32,
+ &stats32, &wait_for_pending_req_timeout_count32);
+
+ if (!rv.isOk() || params32.size() != static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT)) {
+ return false;
+ }
+ *params = res_params{
+ .sample_validity =
+ static_cast<uint16_t>(params32[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY]),
+ .success_threshold =
+ static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD]),
+ .min_samples =
+ static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES]),
+ .max_samples =
+ static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES]),
+ .base_timeout_msec = params32[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
+ .retry_count = params32[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT],
+ };
+ *wait_for_pending_req_timeout_count = wait_for_pending_req_timeout_count32[0];
+ return ResolverStats::decodeAll(stats32, stats);
+}
+
+bool DnsResponderClient::SetResolversForNetwork(const std::vector<std::string>& servers,
+ const std::vector<std::string>& domains,
+ const std::vector<int>& params) {
+ const auto& resolverParams =
+ makeResolverParamsParcel(TEST_NETID, params, servers, domains, "", {}, "");
+ const auto rv = mDnsResolvSrv->setResolverConfiguration(resolverParams);
+ return rv.isOk();
+}
+
+bool DnsResponderClient::SetResolversWithTls(const std::vector<std::string>& servers,
+ const std::vector<std::string>& domains,
+ const std::vector<int>& params,
+ const std::vector<std::string>& tlsServers,
+ const std::string& name) {
+ const auto& resolverParams = makeResolverParamsParcel(TEST_NETID, params, servers, domains,
+ name, tlsServers, kCaCert);
+ const auto rv = mDnsResolvSrv->setResolverConfiguration(resolverParams);
+ if (!rv.isOk()) LOG(ERROR) << "SetResolversWithTls() -> " << rv.getExceptionCode();
+ return rv.isOk();
+}
+
+bool DnsResponderClient::SetResolversFromParcel(const ResolverParamsParcel& resolverParams) {
+ const auto rv = mDnsResolvSrv->setResolverConfiguration(resolverParams);
+ if (!rv.isOk()) LOG(ERROR) << "SetResolversFromParcel() -> " << rv.getExceptionCode();
+ return rv.isOk();
+}
+
+ResolverParamsParcel DnsResponderClient::GetDefaultResolverParamsParcel() {
+ return makeResolverParamsParcel(TEST_NETID, kDefaultParams, kDefaultServers,
+ kDefaultSearchDomains, {} /* tlsHostname */, kDefaultServers,
+ kCaCert);
+}
+
+void DnsResponderClient::SetupDNSServers(unsigned num_servers, const std::vector<Mapping>& mappings,
+ std::vector<std::unique_ptr<test::DNSResponder>>* dns,
+ std::vector<std::string>* servers) {
+ const char* listen_srv = "53";
+ dns->resize(num_servers);
+ servers->resize(num_servers);
+ for (unsigned i = 0; i < num_servers; ++i) {
+ auto& server = (*servers)[i];
+ auto& d = (*dns)[i];
+ server = StringPrintf("127.0.0.%u", i + 100);
+ d = std::make_unique<test::DNSResponder>(server, listen_srv, ns_rcode::ns_r_servfail);
+ for (const auto& mapping : mappings) {
+ d->addMapping(mapping.entry.c_str(), ns_type::ns_t_a, mapping.ip4.c_str());
+ d->addMapping(mapping.entry.c_str(), ns_type::ns_t_aaaa, mapping.ip6.c_str());
+ }
+ d->startServer();
+ }
+}
+
+int DnsResponderClient::SetupOemNetwork() {
+ mNetdSrv->networkDestroy(TEST_NETID);
+ mDnsResolvSrv->destroyNetworkCache(TEST_NETID);
+ auto ret = mNetdSrv->networkCreatePhysical(TEST_NETID, INetd::PERMISSION_NONE);
+ if (!ret.isOk()) {
+ fprintf(stderr, "Creating physical network %d failed, %d\n", TEST_NETID,
+ ret.getExceptionCode());
+ return -1;
+ }
+ ret = mDnsResolvSrv->createNetworkCache(TEST_NETID);
+ if (!ret.isOk()) {
+ fprintf(stderr, "Creating network cache %d failed, %d\n", TEST_NETID,
+ ret.getExceptionCode());
+ return -1;
+ }
+ setNetworkForProcess(TEST_NETID);
+ if ((unsigned)TEST_NETID != getNetworkForProcess()) {
+ return -1;
+ }
+ return TEST_NETID;
+}
+
+void DnsResponderClient::TearDownOemNetwork(int oemNetId) {
+ if (oemNetId != -1) {
+ mNetdSrv->networkDestroy(oemNetId);
+ mDnsResolvSrv->destroyNetworkCache(oemNetId);
+ }
+}
+
+void DnsResponderClient::SetUp() {
+ // binder setup
+ ndk::SpAIBinder netdBinder = ndk::SpAIBinder(AServiceManager_getService("netd"));
+ mNetdSrv = INetd::fromBinder(netdBinder);
+ // mNetdSrv = android::interface_cast<aidl::android::net::INetd>(netdBinder);
+ if (mNetdSrv.get() == nullptr) {
+ LOG(FATAL) << "Can't connect to service 'netd'. Missing root privileges? uid=" << getuid();
+ }
+
+ // auto resolvBinder = AServiceManager_getService("dnsresolver");
+ // mDnsResolvSrv = android::interface_cast<aidl::android::net::IDnsResolver>(resolvBinder);
+ ndk::SpAIBinder resolvBinder = ndk::SpAIBinder(AServiceManager_getService("dnsresolver"));
+ mDnsResolvSrv = IDnsResolver::fromBinder(resolvBinder);
+ if (mDnsResolvSrv.get() == nullptr) {
+ LOG(FATAL) << "Can't connect to service 'dnsresolver'. Missing root privileges? uid="
+ << getuid();
+ }
+
+ // Ensure resolutions go via proxy.
+ setenv(ANDROID_DNS_MODE, "", 1);
+ mOemNetId = SetupOemNetwork();
+}
+
+void DnsResponderClient::TearDown() {
+ TearDownOemNetwork(mOemNetId);
+}
diff --git a/tests/dns_responder/dns_responder_client_ndk.h b/tests/dns_responder/dns_responder_client_ndk.h
new file mode 100644
index 0000000..cf17546
--- /dev/null
+++ b/tests/dns_responder/dns_responder_client_ndk.h
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2019 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#pragma once
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <aidl/android/net/IDnsResolver.h>
+#include <aidl/android/net/INetd.h>
+#include "ResolverStats.h"
+#include "dns_responder.h"
+#include "params.h"
+
+inline const std::vector<std::string> kDefaultServers = {"127.0.0.3"};
+inline const std::vector<std::string> kDefaultSearchDomains = {"example.com"};
+inline const std::vector<int> kDefaultParams = {
+ 300, // sample validity in seconds
+ 25, // success threshod in percent
+ 8, 8, // {MIN,MAX}_SAMPLES
+ 1000, // BASE_TIMEOUT_MSEC
+ 2, // retry count
+};
+
+class DnsResponderClient {
+ public:
+ struct Mapping {
+ std::string host;
+ std::string entry;
+ std::string ip4;
+ std::string ip6;
+ };
+
+ virtual ~DnsResponderClient() = default;
+
+ static void SetupMappings(unsigned num_hosts, const std::vector<std::string>& domains,
+ std::vector<Mapping>* mappings);
+
+ bool SetResolversForNetwork(const std::vector<std::string>& servers = kDefaultServers,
+ const std::vector<std::string>& domains = kDefaultSearchDomains,
+ const std::vector<int>& params = kDefaultParams);
+
+ bool SetResolversForNetwork(const std::vector<std::string>& servers,
+ const std::vector<std::string>& searchDomains,
+ const std::string& params);
+
+ bool SetResolversWithTls(const std::vector<std::string>& servers,
+ const std::vector<std::string>& searchDomains,
+ const std::vector<int>& params, const std::string& name) {
+ // Pass servers as both network-assigned and TLS servers. Tests can
+ // determine on which server and by which protocol queries arrived.
+ return SetResolversWithTls(servers, searchDomains, params, servers, name);
+ }
+
+ bool SetResolversWithTls(const std::vector<std::string>& servers,
+ const std::vector<std::string>& searchDomains,
+ const std::vector<int>& params,
+ const std::vector<std::string>& tlsServers, const std::string& name);
+
+ bool SetResolversFromParcel(const aidl::android::net::ResolverParamsParcel& resolverParams);
+
+ static bool GetResolverInfo(aidl::android::net::IDnsResolver* dnsResolverService,
+ unsigned netId, std::vector<std::string>* servers,
+ std::vector<std::string>* domains,
+ std::vector<std::string>* tlsServers, res_params* params,
+ std::vector<android::net::ResolverStats>* stats,
+ int* wait_for_pending_req_timeout_count);
+
+ // Return a default resolver configuration for opportunistic mode.
+ static aidl::android::net::ResolverParamsParcel GetDefaultResolverParamsParcel();
+
+ static void SetupDNSServers(unsigned num_servers, const std::vector<Mapping>& mappings,
+ std::vector<std::unique_ptr<test::DNSResponder>>* dns,
+ std::vector<std::string>* servers);
+
+ static aidl::android::net::ResolverParamsParcel makeResolverParamsParcel(
+ int netId, const std::vector<int>& params, const std::vector<std::string>& servers,
+ const std::vector<std::string>& domains, const std::string& tlsHostname,
+ const std::vector<std::string>& tlsServers, const std::string& caCert = "");
+
+ int SetupOemNetwork();
+
+ void TearDownOemNetwork(int oemNetId);
+
+ virtual void SetUp();
+ virtual void TearDown();
+
+ aidl::android::net::IDnsResolver* resolvService() const { return mDnsResolvSrv.get(); }
+ aidl::android::net::INetd* netdService() const { return mNetdSrv.get(); }
+
+ private:
+ std::shared_ptr<aidl::android::net::INetd> mNetdSrv;
+ std::shared_ptr<aidl::android::net::IDnsResolver> mDnsResolvSrv;
+ int mOemNetId = -1;
+};
diff --git a/dnsresolver_binder_test.cpp b/tests/dnsresolver_binder_test.cpp
similarity index 71%
rename from dnsresolver_binder_test.cpp
rename to tests/dnsresolver_binder_test.cpp
index 81c1cf7..b2c5e11 100644
--- a/dnsresolver_binder_test.cpp
+++ b/tests/dnsresolver_binder_test.cpp
@@ -23,33 +23,27 @@
#include <iostream>
#include <vector>
+#include <aidl/android/net/IDnsResolver.h>
+#include <android-base/stringprintf.h>
#include <android-base/strings.h>
-#include <android/net/IDnsResolver.h>
-#include <binder/IPCThreadState.h>
-#include <binder/IServiceManager.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
#include <gmock/gmock-matchers.h>
#include <gtest/gtest.h>
#include <netdutils/Stopwatch.h>
-#include "tests/dns_metrics_listener/base_metrics_listener.h"
-#include "tests/dns_metrics_listener/test_metrics.h"
+#include "dns_metrics_listener/base_metrics_listener.h"
+#include "dns_metrics_listener/test_metrics.h"
#include "ResolverStats.h"
#include "dns_responder.h"
-#include "dns_responder_client.h"
+#include "dns_responder_client_ndk.h"
-namespace binder = android::binder;
-
-using android::IBinder;
-using android::IServiceManager;
-using android::ProcessState;
-using android::sp;
-using android::String16;
-using android::String8;
-using android::net::IDnsResolver;
-using android::net::ResolverParamsParcel;
+using aidl::android::net::IDnsResolver;
+using aidl::android::net::ResolverParamsParcel;
+using aidl::android::net::metrics::INetdEventListener;
+using android::base::StringPrintf;
using android::net::ResolverStats;
-using android::net::metrics::INetdEventListener;
using android::net::metrics::TestOnDnsEvent;
using android::netdutils::Stopwatch;
@@ -60,11 +54,9 @@
class DnsResolverBinderTest : public ::testing::Test {
public:
DnsResolverBinderTest() {
- sp<IServiceManager> sm = android::defaultServiceManager();
- sp<IBinder> binder = sm->getService(String16("dnsresolver"));
- if (binder != nullptr) {
- mDnsResolver = android::interface_cast<IDnsResolver>(binder);
- }
+ ndk::SpAIBinder resolvBinder = ndk::SpAIBinder(AServiceManager_getService("dnsresolver"));
+
+ mDnsResolver = IDnsResolver::fromBinder(resolvBinder);
// This could happen when the test isn't running as root, or if netd isn't running.
assert(nullptr != mDnsResolver.get());
// Create cache for test
@@ -77,7 +69,7 @@
}
protected:
- sp<IDnsResolver> mDnsResolver;
+ std::shared_ptr<aidl::android::net::IDnsResolver> mDnsResolver;
};
class TimedOperation : public Stopwatch {
@@ -91,43 +83,6 @@
std::string mName;
};
-namespace {
-
-// TODO: Convert tests to ResolverParamsParcel and delete this stub.
-ResolverParamsParcel makeResolverParamsParcel(int netId, const std::vector<int>& params,
- const std::vector<std::string>& servers,
- const std::vector<std::string>& domains,
- const std::string& tlsHostname,
- const std::vector<std::string>& tlsServers) {
- using android::net::IDnsResolver;
- ResolverParamsParcel paramsParcel;
-
- paramsParcel.netId = netId;
- paramsParcel.sampleValiditySeconds = params[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY];
- paramsParcel.successThreshold = params[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD];
- paramsParcel.minSamples = params[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES];
- paramsParcel.maxSamples = params[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES];
- if (params.size() > IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC) {
- paramsParcel.baseTimeoutMsec = params[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC];
- } else {
- paramsParcel.baseTimeoutMsec = 0;
- }
- if (params.size() > IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT) {
- paramsParcel.retryCount = params[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT];
- } else {
- paramsParcel.retryCount = 0;
- }
- paramsParcel.servers = servers;
- paramsParcel.domains = domains;
- paramsParcel.tlsName = tlsHostname;
- paramsParcel.tlsServers = tlsServers;
- paramsParcel.tlsFingerprints = {};
-
- return paramsParcel;
-}
-
-} // namespace
-
TEST_F(DnsResolverBinderTest, IsAlive) {
TimedOperation t("isAlive RPC");
bool isAlive = false;
@@ -136,26 +91,23 @@
}
TEST_F(DnsResolverBinderTest, RegisterEventListener_NullListener) {
- android::binder::Status status = mDnsResolver->registerEventListener(
- android::interface_cast<INetdEventListener>(nullptr));
+ ::ndk::ScopedAStatus status = mDnsResolver->registerEventListener(nullptr);
ASSERT_FALSE(status.isOk());
- ASSERT_EQ(EINVAL, status.serviceSpecificErrorCode());
+ ASSERT_EQ(EINVAL, status.getServiceSpecificError());
}
TEST_F(DnsResolverBinderTest, RegisterEventListener_DuplicateSubscription) {
class DummyListener : public android::net::metrics::BaseMetricsListener {};
// Expect to subscribe successfully.
- android::sp<DummyListener> dummyListener = new DummyListener();
- android::binder::Status status = mDnsResolver->registerEventListener(
- android::interface_cast<INetdEventListener>(dummyListener));
- ASSERT_TRUE(status.isOk()) << status.exceptionMessage();
+ std::shared_ptr<DummyListener> dummyListener = ndk::SharedRefBase::make<DummyListener>();
+ ::ndk::ScopedAStatus status = mDnsResolver->registerEventListener(dummyListener);
+ ASSERT_TRUE(status.isOk()) << status.getExceptionCode();
// Expect to subscribe failed with registered listener instance.
- status = mDnsResolver->registerEventListener(
- android::interface_cast<INetdEventListener>(dummyListener));
+ status = mDnsResolver->registerEventListener(dummyListener);
ASSERT_FALSE(status.isOk());
- ASSERT_EQ(EEXIST, status.serviceSpecificErrorCode());
+ ASSERT_EQ(EEXIST, status.getServiceSpecificError());
}
// TODO: Move this test to resolv_integration_test.cpp
@@ -178,7 +130,7 @@
// Start the Binder thread pool.
// TODO: Consider doing this once if there has another event listener unit test.
- android::ProcessState::self()->startThreadPool();
+ ABinderProcess_startThreadPool();
// Setup network.
// TODO: Setup device configuration and DNS responser server as resolver test does.
@@ -204,10 +156,10 @@
dns.clearQueries();
// Register event listener.
- android::sp<TestOnDnsEvent> testOnDnsEvent = new TestOnDnsEvent(expectedResults);
- android::binder::Status status = mDnsResolver->registerEventListener(
- android::interface_cast<INetdEventListener>(testOnDnsEvent));
- ASSERT_TRUE(status.isOk()) << status.exceptionMessage();
+ std::shared_ptr<TestOnDnsEvent> testOnDnsEvent =
+ ndk::SharedRefBase::make<TestOnDnsEvent>(expectedResults);
+ ::ndk::ScopedAStatus status = mDnsResolver->registerEventListener(testOnDnsEvent);
+ ASSERT_TRUE(status.isOk()) << status.getExceptionCode();
// DNS queries.
// Once all expected events of expectedResults are received by the listener, the unit test will
@@ -277,18 +229,18 @@
for (size_t i = 0; i < std::size(kTlsTestData); i++) {
const auto& td = kTlsTestData[i];
- const auto resolverParams = makeResolverParamsParcel(
+ const auto resolverParams = DnsResponderClient::makeResolverParamsParcel(
TEST_NETID, test_params, LOCALLY_ASSIGNED_DNS, {}, td.tlsName, td.servers);
- binder::Status status = mDnsResolver->setResolverConfiguration(resolverParams);
+ ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);
if (td.expectedReturnCode == 0) {
- SCOPED_TRACE(String8::format("test case %zu should have passed", i));
- SCOPED_TRACE(status.toString8());
- EXPECT_EQ(0, status.exceptionCode());
+ SCOPED_TRACE(StringPrintf("test case %zu should have passed", i));
+ SCOPED_TRACE(status.getExceptionCode());
+ EXPECT_EQ(0, status.getExceptionCode());
} else {
- SCOPED_TRACE(String8::format("test case %zu should have failed", i));
- EXPECT_EQ(binder::Status::EX_SERVICE_SPECIFIC, status.exceptionCode());
- EXPECT_EQ(td.expectedReturnCode, status.serviceSpecificErrorCode());
+ SCOPED_TRACE(StringPrintf("test case %zu should have failed", i));
+ EXPECT_EQ(EX_SERVICE_SPECIFIC, status.getExceptionCode());
+ EXPECT_EQ(td.expectedReturnCode, status.getServiceSpecificError());
}
}
}
@@ -303,10 +255,10 @@
100, // BASE_TIMEOUT_MSEC
3, // retry count
};
- const auto resolverParams =
- makeResolverParamsParcel(TEST_NETID, testParams, servers, domains, "", {});
- binder::Status status = mDnsResolver->setResolverConfiguration(resolverParams);
- EXPECT_TRUE(status.isOk()) << status.exceptionMessage();
+ const auto resolverParams = DnsResponderClient::makeResolverParamsParcel(
+ TEST_NETID, testParams, servers, domains, "", {});
+ ::ndk::ScopedAStatus status = mDnsResolver->setResolverConfiguration(resolverParams);
+ EXPECT_TRUE(status.isOk()) << status.getExceptionCode();
std::vector<std::string> res_servers;
std::vector<std::string> res_domains;
@@ -318,7 +270,7 @@
¶ms32, &stats32,
&wait_for_pending_req_timeout_count32);
- EXPECT_TRUE(status.isOk()) << status.exceptionMessage();
+ EXPECT_TRUE(status.isOk()) << status.getExceptionCode();
EXPECT_EQ(servers.size(), res_servers.size());
EXPECT_EQ(domains.size(), res_domains.size());
EXPECT_EQ(0U, res_tls_servers.size());
@@ -354,7 +306,7 @@
// create it again, expect a EEXIST.
EXPECT_EQ(EEXIST,
- mDnsResolver->createNetworkCache(ANOTHER_TEST_NETID).serviceSpecificErrorCode());
+ mDnsResolver->createNetworkCache(ANOTHER_TEST_NETID).getServiceSpecificError());
// destroy it.
EXPECT_TRUE(mDnsResolver->destroyNetworkCache(ANOTHER_TEST_NETID).isOk());
@@ -372,12 +324,12 @@
TEST_F(DnsResolverBinderTest, FlushNetworkCache) {
// cache has beed created in DnsResolverBinderTest constructor
EXPECT_TRUE(mDnsResolver->flushNetworkCache(TEST_NETID).isOk());
- EXPECT_EQ(ENONET, mDnsResolver->flushNetworkCache(-1).serviceSpecificErrorCode());
+ EXPECT_EQ(ENONET, mDnsResolver->flushNetworkCache(-1).getServiceSpecificError());
}
TEST_F(DnsResolverBinderTest, setLogSeverity) {
// Expect fail
- EXPECT_EQ(EINVAL, mDnsResolver->setLogSeverity(-1).serviceSpecificErrorCode());
+ EXPECT_EQ(EINVAL, mDnsResolver->setLogSeverity(-1).getServiceSpecificError());
// Test set different log level
EXPECT_TRUE(mDnsResolver->setLogSeverity(IDnsResolver::DNS_RESOLVER_LOG_VERBOSE).isOk());
diff --git a/resolv_integration_test.cpp b/tests/resolv_integration_test.cpp
similarity index 95%
rename from resolv_integration_test.cpp
rename to tests/resolv_integration_test.cpp
index 76b2344..e68fab6 100644
--- a/resolv_integration_test.cpp
+++ b/tests/resolv_integration_test.cpp
@@ -54,16 +54,17 @@
#include <numeric>
#include <thread>
+#include <aidl/android/net/IDnsResolver.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
#include "NetdClient.h"
#include "ResolverStats.h"
-#include "android/net/IDnsResolver.h"
-#include "binder/IServiceManager.h"
-#include "netid_client.h" // NETID_UNSET
-#include "params.h" // MAXNS
+#include "netid_client.h" // NETID_UNSET
+#include "params.h" // MAXNS
#include "test_utils.h"
#include "tests/dns_metrics_listener/dns_metrics_listener.h"
#include "tests/dns_responder/dns_responder.h"
-#include "tests/dns_responder/dns_responder_client.h"
+#include "tests/dns_responder/dns_responder_client_ndk.h"
#include "tests/dns_responder/dns_tls_frontend.h"
#include "tests/resolv_test_utils.h"
@@ -85,11 +86,10 @@
const addrinfo* hints, unsigned netid, unsigned mark,
struct addrinfo** result);
+using aidl::android::net::INetd;
using android::base::ParseInt;
using android::base::StringPrintf;
using android::base::unique_fd;
-using android::net::INetd;
-using android::net::ResolverParamsParcel;
using android::net::ResolverStats;
using android::net::metrics::DnsMetricsListener;
using android::netdutils::enableSockopt;
@@ -127,24 +127,32 @@
// Note that |mDnsClient| is not used for getting binder service in this static function.
// The reason is that wants to keep |mDnsClient| as a non-static data member. |mDnsClient|
// which sets up device network configuration could be independent from every test.
- // TODO: Perhaps add a static function in resolv_test_utils.{cpp,h} to get binder service.
- auto resolvBinder =
- android::defaultServiceManager()->getService(android::String16("dnsresolver"));
- auto resolvService = android::interface_cast<android::net::IDnsResolver>(resolvBinder);
+ // TODO: Perhaps add a static function in resolv_test_binder_utils.{cpp,h} to get binder
+ // service.
+
+ AIBinder* binder = AServiceManager_getService("dnsresolver");
+ ndk::SpAIBinder resolvBinder = ndk::SpAIBinder(binder);
+ auto resolvService = aidl::android::net::IDnsResolver::fromBinder(resolvBinder);
ASSERT_NE(nullptr, resolvService.get());
// Subscribe the death recipient to the service IDnsResolver for detecting Netd death.
- sResolvDeathRecipient = new ResolvDeathRecipient();
- ASSERT_EQ(android::NO_ERROR, resolvBinder->linkToDeath(sResolvDeathRecipient));
+ sResolvDeathRecipient = AIBinder_DeathRecipient_new([](void*) {
+ constexpr char errorMessage[] = "Netd died";
+ LOG(ERROR) << errorMessage;
+ GTEST_LOG_(FATAL) << errorMessage;
+ });
+ ASSERT_EQ(STATUS_OK, AIBinder_linkToDeath(binder, sResolvDeathRecipient, nullptr));
// Subscribe the DNS listener for verifying DNS metrics event contents.
- sDnsMetricsListener = new DnsMetricsListener(TEST_NETID /*monitor specific network*/);
+ sDnsMetricsListener = ndk::SharedRefBase::make<DnsMetricsListener>(
+ TEST_NETID /*monitor specific network*/);
ASSERT_TRUE(resolvService->registerEventListener(sDnsMetricsListener).isOk());
// Start the binder thread pool for listening DNS metrics events and receiving death
// recipient.
- android::ProcessState::self()->startThreadPool();
+ ABinderProcess_startThreadPool();
}
+ static void TearDownTestCase() { AIBinder_DeathRecipient_delete(sResolvDeathRecipient); }
protected:
struct DnsRecord {
@@ -198,17 +206,17 @@
// may temporarily hold lots of dead listeners until the unit test process terminates.
// TODO: Perhaps add an unregistering listener binder call or fork a listener process which
// could be terminated earlier.
- static android::sp<DnsMetricsListener> sDnsMetricsListener; // Initialized in SetUpTestCase.
+ static std::shared_ptr<DnsMetricsListener>
+ sDnsMetricsListener; // Initialized in SetUpTestCase.
// Use a shared static death recipient to monitor the service death. The static death
// recipient could monitor the death not only during the test but also between tests.
- static android::sp<ResolvDeathRecipient>
- sResolvDeathRecipient; // Initialized in SetUpTestCase.
+ static AIBinder_DeathRecipient* sResolvDeathRecipient; // Initialized in SetUpTestCase.
};
// Initialize static member of class.
-android::sp<DnsMetricsListener> ResolverTest::sDnsMetricsListener;
-android::sp<ResolverTest::ResolvDeathRecipient> ResolverTest::sResolvDeathRecipient;
+std::shared_ptr<DnsMetricsListener> ResolverTest::sDnsMetricsListener;
+AIBinder_DeathRecipient* ResolverTest::sResolvDeathRecipient;
TEST_F(ResolverTest, GetHostByName) {
constexpr char nonexistent_host_name[] = "nonexistent.example.com.";
@@ -406,7 +414,7 @@
}
TEST_F(ResolverTest, BinderSerialization) {
- using android::net::IDnsResolver;
+ using aidl::android::net::IDnsResolver;
std::vector<int> params_offsets = {
IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY,
IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD,
@@ -424,9 +432,9 @@
}
TEST_F(ResolverTest, GetHostByName_Binder) {
- using android::net::IDnsResolver;
+ using aidl::android::net::IDnsResolver;
- std::vector<std::string> domains = { "example.com" };
+ std::vector<std::string> domains = {"example.com"};
std::vector<std::unique_ptr<test::DNSResponder>> dns;
std::vector<std::string> servers;
std::vector<DnsResponderClient::Mapping> mappings;
@@ -456,9 +464,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
- &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
+ &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(servers.size(), res_servers.size());
EXPECT_EQ(domains.size(), res_domains.size());
EXPECT_EQ(0U, res_tls_servers.size());
@@ -502,7 +510,7 @@
// Could be A or AAAA
std::string result_str = ToString(result);
EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
- << ", result_str='" << result_str << "'";
+ << ", result_str='" << result_str << "'";
// Verify that the name is cached.
size_t old_found = found;
@@ -512,8 +520,7 @@
EXPECT_LE(1U, found);
EXPECT_EQ(old_found, found);
result_str = ToString(result);
- EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
- << result_str;
+ EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4") << result_str;
// Change the DNS resolver, ensure that queries are still cached.
ASSERT_TRUE(mDnsClient.SetResolversForNetwork({listen_addr2}));
@@ -530,7 +537,7 @@
// Could be A or AAAA
result_str = ToString(result);
EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
- << ", result_str='" << result_str << "'";
+ << ", result_str='" << result_str << "'";
}
TEST_F(ResolverTest, GetAddrInfoV4) {
@@ -647,9 +654,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers,
- &res_domains, &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
+ &res_tls_servers, &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(0, wait_for_pending_req_timeout_count);
});
@@ -739,7 +746,7 @@
TEST_F(ResolverTest, MultidomainResolution) {
constexpr char host_name[] = "nihao.example2.com.";
- std::vector<std::string> searchDomains = { "example1.com", "example2.com", "example3.com" };
+ std::vector<std::string> searchDomains = {"example1.com", "example2.com", "example3.com"};
test::DNSResponder dns("127.0.0.6");
StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
@@ -789,10 +796,10 @@
StartDns(dns0, {{host_name, ns_type::ns_t_aaaa, "2001:db8::5"}});
StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
- std::vector<std::string> servers = { listen_addr0, listen_addr1 };
+ std::vector<std::string> servers = {listen_addr0, listen_addr1};
// <sample validity in s> <success threshold in percent> <min samples> <max samples>
int sample_count = 8;
- const std::vector<int> params = { 300, 25, sample_count, sample_count };
+ const std::vector<int> params = {300, 25, sample_count, sample_count};
ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, kDefaultSearchDomains, params));
// Repeatedly perform resolutions for non-existing domains until MAXNSSAMPLES resolutions have
@@ -882,11 +889,11 @@
StartDns(dns1, {{host_name, ns_type::ns_t_aaaa, "2001:db8::6"}});
StartDns(dns2, {{host_name, ns_type::ns_t_aaaa, "2001:db8::7"}});
- const std::vector<std::string> servers = { listen_addr0, listen_addr1, listen_addr2 };
+ const std::vector<std::string> servers = {listen_addr0, listen_addr1, listen_addr2};
std::vector<std::thread> threads(10);
for (std::thread& thread : threads) {
- thread = std::thread([this, &servers]() {
- unsigned delay = arc4random_uniform(1*1000*1000); // <= 1s
+ thread = std::thread([this, &servers]() {
+ unsigned delay = arc4random_uniform(1 * 1000 * 1000); // <= 1s
usleep(delay);
std::vector<std::string> serverSubset;
for (const auto& server : servers) {
@@ -916,14 +923,14 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
- &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
+ &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(0, wait_for_pending_req_timeout_count);
}
TEST_F(ResolverTest, EmptySetup) {
- using android::net::IDnsResolver;
+ using aidl::android::net::IDnsResolver;
std::vector<std::string> servers;
std::vector<std::string> domains;
ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
@@ -933,9 +940,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
- &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
+ &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(0U, res_servers.size());
EXPECT_EQ(0U, res_domains.size());
EXPECT_EQ(0U, res_tls_servers.size());
@@ -955,8 +962,8 @@
constexpr char listen_addr[] = "127.0.0.13";
constexpr char host_name1[] = "test13.domain1.org.";
constexpr char host_name2[] = "test13.domain2.org.";
- std::vector<std::string> servers = { listen_addr };
- std::vector<std::string> domains = { "domain1.org" };
+ std::vector<std::string> servers = {listen_addr};
+ std::vector<std::string> domains = {"domain1.org"};
const std::vector<DnsRecord> records = {
{host_name1, ns_type::ns_t_aaaa, "2001:db8::13"},
@@ -974,7 +981,7 @@
EXPECT_EQ("2001:db8::13", ToString(result));
// Test that changing the domain search path on its own works.
- domains = { "domain2.org" };
+ domains = {"domain2.org"};
ASSERT_TRUE(mDnsClient.SetResolversForNetwork(servers, domains));
dns.clearQueries();
@@ -987,7 +994,7 @@
namespace {
-std::vector<std::string> getResolverDomains(android::net::IDnsResolver* dnsResolverService,
+std::vector<std::string> getResolverDomains(aidl::android::net::IDnsResolver* dnsResolverService,
unsigned netId) {
std::vector<std::string> res_servers;
std::vector<std::string> res_domains;
@@ -995,8 +1002,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- GetResolverInfo(dnsResolverService, netId, &res_servers, &res_domains, &res_tls_servers,
- &res_params, &res_stats, &wait_for_pending_req_timeout_count);
+ DnsResponderClient::GetResolverInfo(dnsResolverService, netId, &res_servers, &res_domains,
+ &res_tls_servers, &res_params, &res_stats,
+ &wait_for_pending_req_timeout_count);
return res_domains;
}
@@ -1119,9 +1127,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
- &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
+ &res_params, &res_stats, &wait_for_pending_req_timeout_count));
// Check the size of the stats and its contents.
EXPECT_EQ(static_cast<size_t>(MAXNS), res_servers.size());
@@ -1169,9 +1177,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
- &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains, &res_tls_servers,
+ &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(1, res_stats[0].timeouts);
EXPECT_EQ(1, res_stats[1].errors);
@@ -1185,7 +1193,7 @@
test::DNSResponder dns;
StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.3"}});
- std::vector<std::string> servers = { listen_addr };
+ std::vector<std::string> servers = {listen_addr};
// There's nothing listening on this address, so validation will either fail or
/// hang. Either way, queries will continue to flow to the DNSResponder.
@@ -1213,14 +1221,14 @@
test::DNSResponder dns;
StartDns(dns, records);
- std::vector<std::string> servers = { listen_addr };
+ std::vector<std::string> servers = {listen_addr};
// Bind the specified private DNS socket but don't respond to any client sockets yet.
int s = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, IPPROTO_TCP);
ASSERT_TRUE(s >= 0);
struct sockaddr_in tlsServer = {
- .sin_family = AF_INET,
- .sin_port = htons(853),
+ .sin_family = AF_INET,
+ .sin_port = htons(853),
};
ASSERT_TRUE(inet_pton(AF_INET, listen_addr, &tlsServer.sin_addr));
ASSERT_TRUE(enableSockopt(s, SOL_SOCKET, SO_REUSEPORT).ok());
@@ -1233,7 +1241,7 @@
struct sockaddr_storage cliaddr;
socklen_t sin_size = sizeof(cliaddr);
- int new_fd = accept4(s, reinterpret_cast<struct sockaddr *>(&cliaddr), &sin_size, SOCK_CLOEXEC);
+ int new_fd = accept4(s, reinterpret_cast<struct sockaddr*>(&cliaddr), &sin_size, SOCK_CLOEXEC);
ASSERT_TRUE(new_fd > 0);
// We've received the new file descriptor but not written to it or closed, so the
@@ -1275,7 +1283,7 @@
test::DNSResponder dns;
StartDns(dns, records);
- std::vector<std::string> servers = { listen_addr };
+ std::vector<std::string> servers = {listen_addr};
test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
ASSERT_TRUE(tls.startServer());
@@ -1332,7 +1340,7 @@
StartDns(dns1, records1);
StartDns(dns2, records2);
- std::vector<std::string> servers = { listen_addr1, listen_addr2 };
+ std::vector<std::string> servers = {listen_addr1, listen_addr2};
test::DnsTlsFrontend tls1(listen_addr1, listen_tls, listen_addr1, listen_udp);
test::DnsTlsFrontend tls2(listen_addr2, listen_tls, listen_addr2, listen_udp);
@@ -1377,7 +1385,7 @@
test::DNSResponder dns;
StartDns(dns, {{host_name, ns_type::ns_t_a, "1.2.3.1"}});
- std::vector<std::string> servers = { listen_addr };
+ std::vector<std::string> servers = {listen_addr};
test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
ASSERT_TRUE(tls.startServer());
@@ -1407,7 +1415,7 @@
test::DNSResponder dns;
StartDns(dns, records);
- std::vector<std::string> servers = { listen_addr };
+ std::vector<std::string> servers = {listen_addr};
test::DnsTlsFrontend tls(listen_addr, listen_tls, listen_addr, listen_udp);
ASSERT_TRUE(tls.startServer());
@@ -1423,7 +1431,7 @@
// Could be A or AAAA
std::string result_str = ToString(result);
EXPECT_TRUE(result_str == "1.2.3.4" || result_str == "::1.2.3.4")
- << ", result_str='" << result_str << "'";
+ << ", result_str='" << result_str << "'";
// Wait for both A and AAAA queries to get counted.
EXPECT_TRUE(tls.waitForQueries(3, 5000));
@@ -1448,7 +1456,7 @@
const char cleartext_addr[] = "127.0.0.53";
const char cleartext_port[] = "53";
const char tls_port[] = "853";
- const std::vector<std::string> servers = { cleartext_addr };
+ const std::vector<std::string> servers = {cleartext_addr};
test::DNSResponder dns(cleartext_addr);
ASSERT_TRUE(dns.startServer());
@@ -1456,15 +1464,14 @@
test::DnsTlsFrontend tls(cleartext_addr, tls_port, cleartext_addr, cleartext_port);
ASSERT_TRUE(tls.startServer());
+ // clang-format off
struct TestConfig {
const std::string mode;
const bool withWorkingTLS;
const std::string method;
std::string asHostName() const {
- return StringPrintf("%s.%s.%s.",
- mode.c_str(),
- withWorkingTLS ? "tlsOn" : "tlsOff",
+ return StringPrintf("%s.%s.%s.", mode.c_str(), withWorkingTLS ? "tlsOn" : "tlsOff",
method.c_str());
}
} testConfigs[]{
@@ -1487,6 +1494,7 @@
{OPPORTUNISTIC, false, GETADDRINFOFORNET},
{STRICT, false, GETADDRINFOFORNET},
};
+ // clang-format on
for (const auto& config : testConfigs) {
const std::string testHostName = config.asHostName();
@@ -1548,7 +1556,7 @@
// Could be A or AAAA
const std::string result_str = ToString(ai_result);
EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
- << ", result_str='" << result_str << "'";
+ << ", result_str='" << result_str << "'";
} else if (config.method == GETADDRINFOFORNET) {
addrinfo* raw_ai_result = nullptr;
EXPECT_EQ(0, android_getaddrinfofornet(host_name, /*servname=*/nullptr,
@@ -1560,7 +1568,7 @@
// Could be A or AAAA
const std::string result_str = ToString(ai_result);
EXPECT_TRUE(result_str == ADDR4 || result_str == ADDR6)
- << ", result_str='" << result_str << "'";
+ << ", result_str='" << result_str << "'";
}
EXPECT_EQ(0, tls.queries());
@@ -1573,7 +1581,7 @@
TEST_F(ResolverTest, StrictMode_NoTlsServers) {
constexpr char cleartext_addr[] = "127.0.0.53";
- const std::vector<std::string> servers = { cleartext_addr };
+ const std::vector<std::string> servers = {cleartext_addr};
constexpr char host_name[] = "strictmode.notlsips.example.com.";
const std::vector<DnsRecord> records = {
{host_name, ns_type::ns_t_a, "1.2.3.4"},
@@ -1618,12 +1626,12 @@
int ancount, n = 0;
ns_rr rr;
- if (ns_initparse((const uint8_t*) buf, bufLen, &handle) >= 0) {
+ if (ns_initparse((const uint8_t*)buf, bufLen, &handle) >= 0) {
ancount = ns_msg_count(handle, ns_s_an);
if (ns_parserr(&handle, ns_s_an, n, &rr) == 0) {
const uint8_t* rdata = ns_rr_rdata(rr);
char buffer[INET6_ADDRSTRLEN];
- if (inet_ntop(ipType, (const char*) rdata, buffer, sizeof(buffer))) {
+ if (inet_ntop(ipType, (const char*)rdata, buffer, sizeof(buffer))) {
return buffer;
}
}
@@ -1644,7 +1652,7 @@
.sun_path = "/dev/socket/dnsproxyd",
};
- if (TEMP_FAILURE_RETRY(connect(s, (const struct sockaddr*) &proxy_addr, sizeof(proxy_addr))) !=
+ if (TEMP_FAILURE_RETRY(connect(s, (const struct sockaddr*)&proxy_addr, sizeof(proxy_addr))) !=
0) {
close(s);
return -1;
@@ -2160,13 +2168,14 @@
const char CLEARTEXT_ADDR[] = "127.0.0.53";
const char CLEARTEXT_PORT[] = "53";
const char TLS_PORT[] = "853";
- const std::vector<std::string> servers = { CLEARTEXT_ADDR };
+ const std::vector<std::string> servers = {CLEARTEXT_ADDR};
test::DNSResponder dns(CLEARTEXT_ADDR, CLEARTEXT_PORT, ns_rcode::ns_r_servfail);
ASSERT_TRUE(dns.startServer());
test::DnsTlsFrontend tls(CLEARTEXT_ADDR, TLS_PORT, CLEARTEXT_ADDR, CLEARTEXT_PORT);
+ // clang-format off
static const struct TestConfig {
std::string mode;
std::string method;
@@ -2222,6 +2231,7 @@
//{OPPORTUNISTIC_TLS, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
//{STRICT, GETADDRINFO, Edns::DROP, EXPECT_FAILURE},
};
+ // clang-format on
for (const auto& config : testConfigs) {
const std::string testHostName = config.asHostName();
@@ -2529,6 +2539,7 @@
EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
+ // clang-format off
static const struct TestConfig {
std::string name;
std::string addr;
@@ -2541,6 +2552,7 @@
{MULTICAST, ADDR_MULTICAST},
{LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
};
+ // clang-format on
for (const auto& config : testConfigs) {
const std::string testHostName = config.asHostName();
@@ -2633,6 +2645,7 @@
EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
+ // clang-format off
// If node is null, return address is listed by libc/getaddrinfo.c as follows.
// - passive socket -> anyaddr (0.0.0.0 or ::)
// - non-passive socket -> localhost (127.0.0.1 or ::1)
@@ -2649,6 +2662,7 @@
{0 /* non-passive */, ADDR_LOCALHOST_V4, ADDR_LOCALHOST_V6},
{AI_PASSIVE, ADDR_ANYADDR_V4, ADDR_ANYADDR_V6}
};
+ // clang-format on
for (const auto& config : testConfigs) {
SCOPED_TRACE(config.asParameters());
@@ -2813,7 +2827,7 @@
// Expect no DNS queries; localhost is resolved via /etc/hosts.
EXPECT_EQ(0U, GetNumQueries(dns, host_name));
- ASSERT_EQ(sizeof(in6_addr), (unsigned) result->h_length);
+ ASSERT_EQ(sizeof(in6_addr), (unsigned)result->h_length);
ASSERT_EQ(AF_INET6, result->h_addrtype);
std::string result_str = ToString(result);
EXPECT_EQ(result_str, host_addr);
@@ -2877,6 +2891,7 @@
EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
+ // clang-format off
static const struct TestConfig {
int flag;
int family;
@@ -2897,6 +2912,7 @@
{0, AF_INET6, "2001:db8::102:304", "v4v6.example.com"},
{0, AF_INET6, "2001:db8::506:708", "2001:db8::506:708"}, // unmapped
};
+ // clang-format on
// Reverse IPv4/IPv6 DNS query. Prefix should have no effect on it.
for (const auto& config : testConfigs) {
@@ -2910,14 +2926,14 @@
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
inet_pton(AF_INET, config.addr.c_str(), &sin.sin_addr);
- rv = getnameinfo((const struct sockaddr*) &sin, sizeof(sin), host, sizeof(host),
- nullptr, 0, config.flag);
+ rv = getnameinfo((const struct sockaddr*)&sin, sizeof(sin), host, sizeof(host), nullptr,
+ 0, config.flag);
if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v4));
} else if (config.family == AF_INET6) {
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
- rv = getnameinfo((const struct sockaddr*) &sin6, sizeof(sin6), host, sizeof(host),
+ rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nullptr, 0, config.flag);
if (config.flag == NI_NAMEREQD) EXPECT_LE(1U, GetNumQueries(dns, ptr_addr_v6));
}
@@ -2956,6 +2972,7 @@
EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
+ // clang-format off
static const struct TestConfig {
bool hasSynthesizedPtrRecord;
int flag;
@@ -2974,6 +2991,7 @@
{true, NI_NUMERICHOST, "64:ff9b::506:708", "64:ff9b::506:708"},
{true, 0, "64:ff9b::506:708", "v6synthesis.example.com"}
};
+ // clang-format on
// hasSynthesizedPtrRecord = false
// Synthesized PTR record doesn't exist on DNS server
@@ -2993,7 +3011,7 @@
memset(&sin6, 0, sizeof(sin6));
sin6.sin6_family = AF_INET6;
inet_pton(AF_INET6, config.addr.c_str(), &sin6.sin6_addr);
- int rv = getnameinfo((const struct sockaddr*) &sin6, sizeof(sin6), host, sizeof(host),
+ int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host),
nullptr, 0, config.flag);
ASSERT_EQ(0, rv);
if (config.flag == NI_NAMEREQD) {
@@ -3032,7 +3050,7 @@
char host[NI_MAXHOST];
struct sockaddr_in6 sin6 = {.sin6_family = AF_INET6};
inet_pton(AF_INET6, host_addr, &sin6.sin6_addr);
- int rv = getnameinfo((const struct sockaddr*) &sin6, sizeof(sin6), host, sizeof(host), nullptr,
+ int rv = getnameinfo((const struct sockaddr*)&sin6, sizeof(sin6), host, sizeof(host), nullptr,
0, NI_NAMEREQD);
ASSERT_EQ(0, rv);
// Expect no DNS queries; localhost is resolved via /etc/hosts.
@@ -3162,13 +3180,13 @@
EXPECT_TRUE(mDnsClient.resolvService()->startPrefix64Discovery(TEST_NETID).isOk());
EXPECT_TRUE(WaitForNat64Prefix(EXPECT_FOUND));
+ // clang-format off
static const struct TestConfig {
std::string name;
std::string addr;
std::string asHostName() const {
- return StringPrintf("%s.example.com.",
- name.c_str());
+ return StringPrintf("%s.example.com.", name.c_str());
}
} testConfigs[]{
{THIS_NETWORK, ADDR_THIS_NETWORK},
@@ -3177,6 +3195,7 @@
{MULTICAST, ADDR_MULTICAST},
{LIMITED_BROADCAST, ADDR_LIMITED_BROADCAST}
};
+ // clang-format on
for (const auto& config : testConfigs) {
const std::string testHostName = config.asHostName();
@@ -3293,8 +3312,8 @@
return true;
}
-android::net::UidRangeParcel makeUidRangeParcel(int start, int stop) {
- android::net::UidRangeParcel res;
+aidl::android::net::UidRangeParcel makeUidRangeParcel(int start, int stop) {
+ aidl::android::net::UidRangeParcel res;
res.start = start;
res.stop = stop;
@@ -3493,7 +3512,8 @@
ScopedSystemProperties scopedSystemProperties(kDotConnectTimeoutMsFlag, "100");
// Set up resolver to opportunistic mode with the default configuration.
- const ResolverParamsParcel parcel = DnsResponderClient::GetDefaultResolverParamsParcel();
+ const aidl::android::net::ResolverParamsParcel parcel =
+ DnsResponderClient::GetDefaultResolverParamsParcel();
ASSERT_TRUE(mDnsClient.SetResolversFromParcel(parcel));
EXPECT_TRUE(WaitForPrivateDnsValidation(tls.listen_address(), true));
dns.clearQueries();
diff --git a/tests/resolv_stress_test.cpp b/tests/resolv_stress_test.cpp
index 6f7ee9d..9058f17 100644
--- a/tests/resolv_stress_test.cpp
+++ b/tests/resolv_stress_test.cpp
@@ -26,7 +26,7 @@
#include <gtest/gtest.h>
#include "ResolverStats.h"
-#include "dns_responder/dns_responder_client.h"
+#include "dns_responder/dns_responder_client_ndk.h"
#include "params.h" // MAX_NS
#include "resolv_test_utils.h"
@@ -87,9 +87,9 @@
res_params res_params;
std::vector<ResolverStats> res_stats;
int wait_for_pending_req_timeout_count;
- ASSERT_TRUE(GetResolverInfo(mDnsClient.resolvService(), TEST_NETID, &res_servers,
- &res_domains, &res_tls_servers, &res_params, &res_stats,
- &wait_for_pending_req_timeout_count));
+ ASSERT_TRUE(DnsResponderClient::GetResolverInfo(
+ mDnsClient.resolvService(), TEST_NETID, &res_servers, &res_domains,
+ &res_tls_servers, &res_params, &res_stats, &wait_for_pending_req_timeout_count));
EXPECT_EQ(0, wait_for_pending_req_timeout_count);
}
diff --git a/tests/resolv_test_utils.cpp b/tests/resolv_test_utils.cpp
index 4b2a83f..e706e00 100644
--- a/tests/resolv_test_utils.cpp
+++ b/tests/resolv_test_utils.cpp
@@ -21,7 +21,6 @@
#include <netdutils/InternetAddresses.h>
-using android::net::ResolverStats;
using android::netdutils::ScopedAddrinfo;
std::string ToString(const hostent* he) {
@@ -96,33 +95,3 @@
}
return found;
}
-
-bool GetResolverInfo(android::net::IDnsResolver* dnsResolverService, unsigned netId,
- std::vector<std::string>* servers, std::vector<std::string>* domains,
- std::vector<std::string>* tlsServers, res_params* params,
- std::vector<ResolverStats>* stats, int* wait_for_pending_req_timeout_count) {
- using android::net::IDnsResolver;
- std::vector<int32_t> params32;
- std::vector<int32_t> stats32;
- std::vector<int32_t> wait_for_pending_req_timeout_count32{0};
- auto rv = dnsResolverService->getResolverInfo(netId, servers, domains, tlsServers, ¶ms32,
- &stats32, &wait_for_pending_req_timeout_count32);
-
- if (!rv.isOk() || params32.size() != static_cast<size_t>(IDnsResolver::RESOLVER_PARAMS_COUNT)) {
- return false;
- }
- *params = res_params{
- .sample_validity =
- static_cast<uint16_t>(params32[IDnsResolver::RESOLVER_PARAMS_SAMPLE_VALIDITY]),
- .success_threshold =
- static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_SUCCESS_THRESHOLD]),
- .min_samples =
- static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_MIN_SAMPLES]),
- .max_samples =
- static_cast<uint8_t>(params32[IDnsResolver::RESOLVER_PARAMS_MAX_SAMPLES]),
- .base_timeout_msec = params32[IDnsResolver::RESOLVER_PARAMS_BASE_TIMEOUT_MSEC],
- .retry_count = params32[IDnsResolver::RESOLVER_PARAMS_RETRY_COUNT],
- };
- *wait_for_pending_req_timeout_count = wait_for_pending_req_timeout_count32[0];
- return ResolverStats::decodeAll(stats32, stats);
-}
\ No newline at end of file
diff --git a/tests/resolv_test_utils.h b/tests/resolv_test_utils.h
index 954e4c9..baf4dda 100644
--- a/tests/resolv_test_utils.h
+++ b/tests/resolv_test_utils.h
@@ -25,9 +25,6 @@
#include <netdutils/InternetAddresses.h>
-#include "ResolverStats.h"
-
-#include "android/net/IDnsResolver.h"
#include "dns_responder/dns_responder.h"
#include "params.h"
@@ -110,9 +107,3 @@
std::string ToString(const android::netdutils::ScopedAddrinfo& ai);
std::vector<std::string> ToStrings(const addrinfo* ai);
std::vector<std::string> ToStrings(const android::netdutils::ScopedAddrinfo& ai);
-
-bool GetResolverInfo(android::net::IDnsResolver* dnsResolverService, unsigned netId,
- std::vector<std::string>* servers, std::vector<std::string>* domains,
- std::vector<std::string>* tlsServers, res_params* params,
- std::vector<android::net::ResolverStats>* stats,
- int* wait_for_pending_req_timeout_count);