Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit b637e9d5 authored by Ken Chen's avatar Ken Chen
Browse files

Migrate to networkCreate RPC 

1. networkCreatePhysical and networkCreateVpn were deprecated. Use
networkCreate RPC when it is supported by platform.

2. The deprecated RPCs are still referenced in backward compatibility
tests (on Android R image). In that case, use deprecated RPCs and
temporarily ignore -Wdeprecated-declarations.

3. Generalize helper function isRemoteVersionSupported() so that it can
take arbitrary AIDL services.

Bug: 171872481
Test: atest
Change-Id: I68ceab87ab1a95b47b3fb58988cff1f961d18c1a
parent 48cbd1b0

tests/dns_responder/dns_responder_client_ndk.cpp

+26 −19
Original line number Diff line number Diff line
@@ -18,9 +18,6 @@ 


#include "dns_responder_client_ndk.h"



#include <android-base/logging.h>

#include <android-base/stringprintf.h>



#include <android/binder_manager.h>

#include "NetdClient.h"
@@ -34,7 +31,6 @@ 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;



void DnsResponderClient::SetupMappings(unsigned numHosts, const std::vector<std::string>& domains,
@@ -122,20 +118,6 @@ bool DnsResponderClient::GetResolverInfo(aidl::android::net::IDnsResolver* dnsRe 
    return ResolverStats::decodeAll(stats32, stats);

}



bool DnsResponderClient::isRemoteVersionSupported(

        aidl::android::net::IDnsResolver* dnsResolverService, int requiredVersion) {

    int remoteVersion = 0;

    if (!dnsResolverService->getInterfaceVersion(&remoteVersion).isOk()) {

        LOG(FATAL) << "Can't get 'dnsresolver' remote version";

    }

    if (remoteVersion < requiredVersion) {

        LOG(WARNING) << StringPrintf("Remote version: %d < Required version: %d", remoteVersion,

                                     requiredVersion);

        return false;

    }

    return true;

}



bool DnsResponderClient::SetResolversForNetwork(const std::vector<std::string>& servers,

                                                const std::vector<std::string>& domains,

                                                const std::vector<int>& params) {
@@ -191,7 +173,19 @@ void DnsResponderClient::SetupDNSServers(unsigned numServers, const std::vector< 
int DnsResponderClient::SetupOemNetwork() {

    mNetdSrv->networkDestroy(TEST_NETID);

    mDnsResolvSrv->destroyNetworkCache(TEST_NETID);

    auto ret = mNetdSrv->networkCreatePhysical(TEST_NETID, INetd::PERMISSION_NONE);



    ::ndk::ScopedAStatus ret;

    if (DnsResponderClient::isRemoteVersionSupported(mNetdSrv, 6)) {

        const auto& config = DnsResponderClient::makeNativeNetworkConfig(

                TEST_NETID, NativeNetworkType::PHYSICAL, INetd::PERMISSION_NONE, /*secure=*/false);

        ret = mNetdSrv->networkCreate(config);

    } else {

        // Only for presubmit tests that run mainline module (and its tests) on R or earlier images.

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

        ret = mNetdSrv->networkCreatePhysical(TEST_NETID, INetd::PERMISSION_NONE);

#pragma clang diagnostic pop

    }

    if (!ret.isOk()) {

        fprintf(stderr, "Creating physical network %d failed, %s\n", TEST_NETID, ret.getMessage());

        return -1;
@@ -238,3 +232,16 @@ void DnsResponderClient::SetUp() { 
void DnsResponderClient::TearDown() {

    TearDownOemNetwork(mOemNetId);

}



NativeNetworkConfig DnsResponderClient::makeNativeNetworkConfig(int netId,

                                                                NativeNetworkType networkType,

                                                                int permission, bool secure) {

    NativeNetworkConfig config = {};

    config.netId = netId;

    config.networkType = networkType;

    config.permission = permission;

    config.secure = secure;

    // The vpnType doesn't matter in AOSP. Just pick a well defined one from INetd.

    config.vpnType = NativeVpnType::PLATFORM;

    return config;

}

tests/dns_responder/dns_responder_client_ndk.h

+24 −2
Original line number Diff line number Diff line
@@ -21,6 +21,9 @@ 
#include <string>

#include <vector>



#include <android-base/logging.h>

#include <android-base/stringprintf.h>



#include <aidl/android/net/IDnsResolver.h>

#include <aidl/android/net/INetd.h>

#include "ResolverStats.h"  // TODO: stop depending on this internal header
@@ -28,6 +31,11 @@ 
#include "dns_tls_certificate.h"

#include "params.h"



using aidl::android::net::NativeNetworkConfig;

using aidl::android::net::NativeNetworkType;

using aidl::android::net::NativeVpnType;

using android::base::StringPrintf;



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 = {
@@ -85,8 +93,22 @@ class DnsResponderClient { 


    bool SetResolversFromParcel(const aidl::android::net::ResolverParamsParcel& resolverParams);



    static bool isRemoteVersionSupported(aidl::android::net::IDnsResolver* dnsResolverService,

                                         int enabledVersion);

    template <class T>

    static bool isRemoteVersionSupported(T remoteService, int requiredVersion) {

        int remoteVersion = 0;

        if (!remoteService->getInterfaceVersion(&remoteVersion).isOk()) {

            LOG(FATAL) << "Can't get remote version";

        }

        if (remoteVersion < requiredVersion) {

            LOG(WARNING) << StringPrintf("Remote version: %d < Required version: %d", remoteVersion,

                                         requiredVersion);

            return false;

        }

        return true;

    };



    static NativeNetworkConfig makeNativeNetworkConfig(int netId, NativeNetworkType networkType,

                                                       int permission, bool secure);



    static bool GetResolverInfo(aidl::android::net::IDnsResolver* dnsResolverService,

                                unsigned netId, std::vector<std::string>* servers,

tests/resolv_integration_test.cpp

+38 −4
Original line number Diff line number Diff line
@@ -4145,7 +4145,17 @@ void expectDnsNetIdIsDefaultNetwork(INetd* netdService) { 
}



void expectDnsNetIdWithVpn(INetd* netdService, unsigned vpnNetId, unsigned expectedNetId) {

    if (DnsResponderClient::isRemoteVersionSupported(netdService, 6)) {

        const auto& config = DnsResponderClient::makeNativeNetworkConfig(

                vpnNetId, NativeNetworkType::VIRTUAL, INetd::PERMISSION_NONE, /*secure=*/false);

        EXPECT_TRUE(netdService->networkCreate(config).isOk());

    } else {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

        EXPECT_TRUE(netdService->networkCreateVpn(vpnNetId, false /* secure */).isOk());

#pragma clang diagnostic pop

    }



    uid_t uid = getuid();

    // Add uid to VPN

    EXPECT_TRUE(netdService->networkAddUidRanges(vpnNetId, {makeUidRangeParcel(uid, uid)}).isOk());
@@ -6033,8 +6043,20 @@ class ResolverMultinetworkTest : public ResolverTest { 


      protected:

        Result<void> createNetwork() const override {

            if (auto r = mNetdSrv->networkCreatePhysical(mNetId, INetd::PERMISSION_NONE);

                !r.isOk()) {

            ::ndk::ScopedAStatus r;

            if (DnsResponderClient::isRemoteVersionSupported(mNetdSrv, 6)) {

                const auto& config = DnsResponderClient::makeNativeNetworkConfig(

                        mNetId, NativeNetworkType::PHYSICAL, INetd::PERMISSION_NONE,

                        /*secure=*/false);

                r = mNetdSrv->networkCreate(config);

            } else {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

                r = mNetdSrv->networkCreatePhysical(mNetId, INetd::PERMISSION_NONE);

#pragma clang diagnostic pop

            }



            if (!r.isOk()) {

                return Error() << r.getMessage();

            }

            return {};
@@ -6079,7 +6101,19 @@ class ResolverMultinetworkTest : public ResolverTest { 


      protected:

        Result<void> createNetwork() const override {

            if (auto r = mNetdSrv->networkCreateVpn(mNetId, mIsSecure); !r.isOk()) {

            ::ndk::ScopedAStatus r;

            if (DnsResponderClient::isRemoteVersionSupported(mNetdSrv, 6)) {

                const auto& config = DnsResponderClient::makeNativeNetworkConfig(

                        mNetId, NativeNetworkType::VIRTUAL, INetd::PERMISSION_NONE, mIsSecure);

                r = mNetdSrv->networkCreate(config);

            } else {

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wdeprecated-declarations"

                r = mNetdSrv->networkCreateVpn(mNetId, mIsSecure);

#pragma clang diagnostic pop

            }



            if (!r.isOk()) {

                return Error() << r.getMessage();

            }

            return {};