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

Commit 6bac1a61 authored by Ken Chen's avatar Ken Chen Committed by Automerger Merge Worker
Browse files

Migrate to networkCreate RPC am: b637e9d5 

Original change: https://android-review.googlesource.com/c/platform/packages/modules/DnsResolver/+/1714188

Change-Id: I7fd87ec66bffeff158e2df997159a71da02ed877
parents e02c1e89 b637e9d5

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 {};