tetheroffload/control/1.0/vts/functional/VtsHalTetheroffloadControlV1_0TargetTest.cpp

   1 /*
   2  * Copyright (C) 2017 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #define LOG_TAG "VtsOffloadControlV1_0TargetTest"
  18
  19 #include <VtsHalHidlTargetCallbackBase.h>
  20 #include <VtsHalHidlTargetTestBase.h>
  21 #include <android-base/stringprintf.h>
  22 #include <android-base/unique_fd.h>
  23 #include <android/hardware/tetheroffload/config/1.0/IOffloadConfig.h>
  24 #include <android/hardware/tetheroffload/control/1.0/IOffloadControl.h>
  25 #include <android/hardware/tetheroffload/control/1.0/types.h>
  26 #include <linux/netfilter/nfnetlink.h>
  27 #include <linux/netlink.h>
  28 #include <log/log.h>
  29 #include <net/if.h>
  30 #include <sys/socket.h>
  31 #include <unistd.h>
  32 #include <set>
  33
  34 using android::base::StringPrintf;
  35 using android::base::unique_fd;
  36 using android::hardware::hidl_handle;
  37 using android::hardware::hidl_string;
  38 using android::hardware::hidl_vec;
  39 using android::hardware::Return;
  40 using android::hardware::tetheroffload::config::V1_0::IOffloadConfig;
  41 using android::hardware::tetheroffload::control::V1_0::IOffloadControl;
  42 using android::hardware::tetheroffload::control::V1_0::IPv4AddrPortPair;
  43 using android::hardware::tetheroffload::control::V1_0::ITetheringOffloadCallback;
  44 using android::hardware::tetheroffload::control::V1_0::OffloadCallbackEvent;
  45 using android::hardware::tetheroffload::control::V1_0::NatTimeoutUpdate;
  46 using android::hardware::tetheroffload::control::V1_0::NetworkProtocol;
  47 using android::hardware::Void;
  48 using android::sp;
  49
  50 enum class ExpectBoolean {
  51     Ignored = -1,
  52     False = 0,
  53     True = 1,
  54 };
  55
  56 constexpr const char* TEST_IFACE = "rmnet_data0";
  57
  58 // We use #defines here so as to get local lamba captures and error message line numbers
  59 #define ASSERT_TRUE_CALLBACK                            \
  60     [&](bool success, std::string errMsg) {             \
  61         if (!success) {                                 \
  62             ALOGI("Error message: %s", errMsg.c_str()); \
  63         }                                               \
  64         ASSERT_TRUE(success);                           \
  65     }
  66
  67 #define ASSERT_FALSE_CALLBACK                           \
  68     [&](bool success, std::string errMsg) {             \
  69         if (!success) {                                 \
  70             ALOGI("Error message: %s", errMsg.c_str()); \
  71         }                                               \
  72         ASSERT_FALSE(success);                          \
  73     }
  74
  75 #define ASSERT_ZERO_BYTES_CALLBACK            \
  76     [&](uint64_t rxBytes, uint64_t txBytes) { \
  77         EXPECT_EQ(0ULL, rxBytes);             \
  78         EXPECT_EQ(0ULL, txBytes);             \
  79     }
  80
  81 inline const sockaddr* asSockaddr(const sockaddr_nl* nladdr) {
  82     return reinterpret_cast<const sockaddr*>(nladdr);
  83 }
  84
  85 int conntrackSocket(unsigned groups) {
  86     unique_fd s(socket(AF_NETLINK, SOCK_DGRAM, NETLINK_NETFILTER));
  87     if (s.get() < 0) {
  88         return -errno;
  89     }
  90
  91     const struct sockaddr_nl bind_addr = {
  92         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
  93     };
  94     if (::bind(s.get(), asSockaddr(&bind_addr), sizeof(bind_addr)) < 0) {
  95         return -errno;
  96     }
  97
  98     const struct sockaddr_nl kernel_addr = {
  99         .nl_family = AF_NETLINK, .nl_pad = 0, .nl_pid = 0, .nl_groups = groups,
 100     };
 101     if (connect(s.get(), asSockaddr(&kernel_addr), sizeof(kernel_addr)) != 0) {
 102         return -errno;
 103     }
 104
 105     return s.release();
 106 }
 107
 108 constexpr char kCallbackOnEvent[] = "onEvent";
 109 constexpr char kCallbackUpdateTimeout[] = "updateTimeout";
 110
 111 class TetheringOffloadCallbackArgs {
 112    public:
 113     OffloadCallbackEvent last_event;
 114     NatTimeoutUpdate last_params;
 115 };
 116
 117 class OffloadControlHidlTestBase : public testing::VtsHalHidlTargetTestBase {
 118    public:
 119     virtual void SetUp() override {
 120         setupConfigHal();
 121         prepareControlHal();
 122     }
 123
 124     virtual void TearDown() override {
 125         // For good measure, we should try stopOffload() once more. Since we
 126         // don't know where we are in HAL call test cycle we don't know what
 127         // return code to actually expect, so we just ignore it.
 128         stopOffload(ExpectBoolean::Ignored);
 129     }
 130
 131     // The IOffloadConfig HAL is tested more thoroughly elsewhere. He we just
 132     // setup everything correctly and verify basic readiness.
 133     void setupConfigHal() {
 134         config = testing::VtsHalHidlTargetTestBase::getService<IOffloadConfig>();
 135         ASSERT_NE(nullptr, config.get()) << "Could not get HIDL instance";
 136
 137         unique_fd fd1(conntrackSocket(NF_NETLINK_CONNTRACK_NEW | NF_NETLINK_CONNTRACK_DESTROY));
 138         if (fd1.get() < 0) {
 139             ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
 140             FAIL();
 141         }
 142         native_handle_t* const nativeHandle1 = native_handle_create(1, 0);
 143         nativeHandle1->data[0] = fd1.release();
 144         hidl_handle h1;
 145         h1.setTo(nativeHandle1, true);
 146
 147         unique_fd fd2(conntrackSocket(NF_NETLINK_CONNTRACK_UPDATE | NF_NETLINK_CONNTRACK_DESTROY));
 148         if (fd2.get() < 0) {
 149             ALOGE("Unable to create conntrack handles: %d/%s", errno, strerror(errno));
 150             FAIL();
 151         }
 152         native_handle_t* const nativeHandle2 = native_handle_create(1, 0);
 153         nativeHandle2->data[0] = fd2.release();
 154         hidl_handle h2;
 155         h2.setTo(nativeHandle2, true);
 156
 157         const Return<void> ret = config->setHandles(h1, h2, ASSERT_TRUE_CALLBACK);
 158         ASSERT_TRUE(ret.isOk());
 159     }
 160
 161     void prepareControlHal() {
 162         control = testing::VtsHalHidlTargetTestBase::getService<IOffloadControl>();
 163         ASSERT_NE(nullptr, control.get()) << "Could not get HIDL instance";
 164
 165         control_cb = new TetheringOffloadCallback();
 166         ASSERT_NE(nullptr, control_cb.get()) << "Could not get get offload callback";
 167     }
 168
 169     void initOffload(const bool expected_result) {
 170         auto init_cb = [&](bool success, std::string errMsg) {
 171             if (!success) {
 172                 ALOGI("Error message: %s", errMsg.c_str());
 173             }
 174             ASSERT_EQ(expected_result, success);
 175         };
 176         const Return<void> ret = control->initOffload(control_cb, init_cb);
 177         ASSERT_TRUE(ret.isOk());
 178     }
 179
 180     void setupControlHal() {
 181         prepareControlHal();
 182         initOffload(true);
 183     }
 184
 185     void stopOffload(const ExpectBoolean value) {
 186         auto cb = [&](bool success, const hidl_string& errMsg) {
 187             if (!success) {
 188                 ALOGI("Error message: %s", errMsg.c_str());
 189             }
 190             switch (value) {
 191                 case ExpectBoolean::False:
 192                     ASSERT_EQ(false, success);
 193                     break;
 194                 case ExpectBoolean::True:
 195                     ASSERT_EQ(true, success);
 196                     break;
 197                 case ExpectBoolean::Ignored:
 198                     break;
 199             }
 200         };
 201         const Return<void> ret = control->stopOffload(cb);
 202         ASSERT_TRUE(ret.isOk());
 203     }
 204
 205     // Callback class for both events and NAT timeout updates.
 206     class TetheringOffloadCallback
 207         : public testing::VtsHalHidlTargetCallbackBase<TetheringOffloadCallbackArgs>,
 208           public ITetheringOffloadCallback {
 209        public:
 210         TetheringOffloadCallback() = default;
 211         virtual ~TetheringOffloadCallback() = default;
 212
 213         Return<void> onEvent(OffloadCallbackEvent event) override {
 214             const TetheringOffloadCallbackArgs args{.last_event = event};
 215             NotifyFromCallback(kCallbackOnEvent, args);
 216             return Void();
 217         };
 218
 219         Return<void> updateTimeout(const NatTimeoutUpdate& params) override {
 220             const TetheringOffloadCallbackArgs args{.last_params = params};
 221             NotifyFromCallback(kCallbackUpdateTimeout, args);
 222             return Void();
 223         };
 224     };
 225
 226     sp<IOffloadConfig> config;
 227     sp<IOffloadControl> control;
 228     sp<TetheringOffloadCallback> control_cb;
 229 };
 230
 231 // Call initOffload() multiple times. Check that non-first initOffload() calls return false.
 232 TEST_F(OffloadControlHidlTestBase, AdditionalInitsWithoutStopReturnFalse) {
 233     initOffload(true);
 234     initOffload(false);
 235     initOffload(false);
 236     initOffload(false);
 237 }
 238
 239 // Check that calling stopOffload() without first having called initOffload() returns false.
 240 TEST_F(OffloadControlHidlTestBase, MultipleStopsWithoutInitReturnFalse) {
 241     stopOffload(ExpectBoolean::False);
 242     stopOffload(ExpectBoolean::False);
 243     stopOffload(ExpectBoolean::False);
 244 }
 245
 246 // Check whether the specified interface is up.
 247 bool interfaceIsUp(const char* name) {
 248     if (name == nullptr) return false;
 249     struct ifreq ifr = {};
 250     strlcpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 251     int sock = socket(AF_INET6, SOCK_DGRAM, 0);
 252     if (sock == -1) return false;
 253     int ret = ioctl(sock, SIOCGIFFLAGS, &ifr, sizeof(ifr));
 254     close(sock);
 255     return (ret == 0) && (ifr.ifr_flags & IFF_UP);
 256 }
 257
 258 // Check that calling stopOffload() after a complete init/stop cycle returns false.
 259 TEST_F(OffloadControlHidlTestBase, AdditionalStopsWithInitReturnFalse) {
 260     initOffload(true);
 261     // Call setUpstreamParameters() so that "offload" can be reasonably said
 262     // to be both requested and operational.
 263     const hidl_string v4Addr("192.0.0.2");
 264     const hidl_string v4Gw("192.0.0.1");
 265     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
 266     const Return<void> upstream =
 267         control->setUpstreamParameters(TEST_IFACE, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 268     EXPECT_TRUE(upstream.isOk());
 269     if (!interfaceIsUp(TEST_IFACE)) {
 270         return;
 271     }
 272     stopOffload(ExpectBoolean::True);  // balance out initOffload(true)
 273     stopOffload(ExpectBoolean::False);
 274     stopOffload(ExpectBoolean::False);
 275 }
 276
 277 // Check that calling setLocalPrefixes() without first having called initOffload() returns false.
 278 TEST_F(OffloadControlHidlTestBase, SetLocalPrefixesWithoutInitReturnsFalse) {
 279     const vector<hidl_string> prefixes{hidl_string("2001:db8::/64")};
 280     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 281     EXPECT_TRUE(ret.isOk());
 282 }
 283
 284 // Check that calling getForwardedStats() without first having called initOffload()
 285 // returns zero bytes statistics.
 286 TEST_F(OffloadControlHidlTestBase, GetForwardedStatsWithoutInitReturnsZeroValues) {
 287     const hidl_string upstream(TEST_IFACE);
 288     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 289     EXPECT_TRUE(ret.isOk());
 290 }
 291
 292 // Check that calling setDataLimit() without first having called initOffload() returns false.
 293 TEST_F(OffloadControlHidlTestBase, SetDataLimitWithoutInitReturnsFalse) {
 294     const hidl_string upstream(TEST_IFACE);
 295     const uint64_t limit = 5000ULL;
 296     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
 297     EXPECT_TRUE(ret.isOk());
 298 }
 299
 300 // Check that calling setUpstreamParameters() without first having called initOffload()
 301 // returns false.
 302 TEST_F(OffloadControlHidlTestBase, SetUpstreamParametersWithoutInitReturnsFalse) {
 303     const hidl_string iface(TEST_IFACE);
 304     const hidl_string v4Addr("192.0.2.0/24");
 305     const hidl_string v4Gw("192.0.2.1");
 306     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 307     const Return<void> ret =
 308         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 309     EXPECT_TRUE(ret.isOk());
 310 }
 311
 312 // Check that calling addDownstream() with an IPv4 prefix without first having called
 313 // initOffload() returns false.
 314 TEST_F(OffloadControlHidlTestBase, AddIPv4DownstreamWithoutInitReturnsFalse) {
 315     const hidl_string iface(TEST_IFACE);
 316     const hidl_string prefix("192.0.2.0/24");
 317     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 318     EXPECT_TRUE(ret.isOk());
 319 }
 320
 321 // Check that calling addDownstream() with an IPv6 prefix without first having called
 322 // initOffload() returns false.
 323 TEST_F(OffloadControlHidlTestBase, AddIPv6DownstreamWithoutInitReturnsFalse) {
 324     const hidl_string iface(TEST_IFACE);
 325     const hidl_string prefix("2001:db8::/64");
 326     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 327     EXPECT_TRUE(ret.isOk());
 328 }
 329
 330 // Check that calling removeDownstream() with an IPv4 prefix without first having called
 331 // initOffload() returns false.
 332 TEST_F(OffloadControlHidlTestBase, RemoveIPv4DownstreamWithoutInitReturnsFalse) {
 333     const hidl_string iface(TEST_IFACE);
 334     const hidl_string prefix("192.0.2.0/24");
 335     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 336     EXPECT_TRUE(ret.isOk());
 337 }
 338
 339 // Check that calling removeDownstream() with an IPv6 prefix without first having called
 340 // initOffload() returns false.
 341 TEST_F(OffloadControlHidlTestBase, RemoveIPv6DownstreamWithoutInitReturnsFalse) {
 342     const hidl_string iface(TEST_IFACE);
 343     const hidl_string prefix("2001:db8::/64");
 344     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 345     EXPECT_TRUE(ret.isOk());
 346 }
 347
 348 class OffloadControlHidlTest : public OffloadControlHidlTestBase {
 349    public:
 350     virtual void SetUp() override {
 351         setupConfigHal();
 352         setupControlHal();
 353     }
 354
 355     virtual void TearDown() override {
 356         // For good measure, we should try stopOffload() once more. Since we
 357         // don't know where we are in HAL call test cycle we don't know what
 358         // return code to actually expect, so we just ignore it.
 359         stopOffload(ExpectBoolean::Ignored);
 360     }
 361 };
 362
 363 /*
 364  * Tests for IOffloadControl::setLocalPrefixes().
 365  */
 366
 367 // Test setLocalPrefixes() accepts an IPv4 address.
 368 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4AddressOk) {
 369     const vector<hidl_string> prefixes{hidl_string("192.0.2.1")};
 370     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 371     EXPECT_TRUE(ret.isOk());
 372 }
 373
 374 // Test setLocalPrefixes() accepts an IPv6 address.
 375 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv6AddressOk) {
 376     const vector<hidl_string> prefixes{hidl_string("fe80::1")};
 377     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 378     EXPECT_TRUE(ret.isOk());
 379 }
 380
 381 // Test setLocalPrefixes() accepts both IPv4 and IPv6 prefixes.
 382 TEST_F(OffloadControlHidlTest, SetLocalPrefixesIPv4v6PrefixesOk) {
 383     const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("fe80::/64")};
 384     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_TRUE_CALLBACK);
 385     EXPECT_TRUE(ret.isOk());
 386 }
 387
 388 // Test that setLocalPrefixes() fails given empty input. There is always
 389 // a non-empty set of local prefixes; when all networking interfaces are down
 390 // we still apply {127.0.0.0/8, ::1/128, fe80::/64} here.
 391 TEST_F(OffloadControlHidlTest, SetLocalPrefixesEmptyFails) {
 392     const vector<hidl_string> prefixes{};
 393     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 394     EXPECT_TRUE(ret.isOk());
 395 }
 396
 397 // Test setLocalPrefixes() fails on incorrectly formed input strings.
 398 TEST_F(OffloadControlHidlTest, SetLocalPrefixesInvalidFails) {
 399     const vector<hidl_string> prefixes{hidl_string("192.0.2.0/24"), hidl_string("invalid")};
 400     const Return<void> ret = control->setLocalPrefixes(prefixes, ASSERT_FALSE_CALLBACK);
 401     EXPECT_TRUE(ret.isOk());
 402 }
 403
 404 /*
 405  * Tests for IOffloadControl::getForwardedStats().
 406  */
 407
 408 // Test that getForwardedStats() for a non-existent upstream yields zero bytes statistics.
 409 TEST_F(OffloadControlHidlTest, GetForwardedStatsInvalidUpstreamIface) {
 410     const hidl_string upstream("invalid");
 411     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 412     EXPECT_TRUE(ret.isOk());
 413 }
 414
 415 // TEST_IFACE is presumed to exist on the device and be up. No packets
 416 // are ever actually caused to be forwarded.
 417 TEST_F(OffloadControlHidlTest, GetForwardedStatsDummyIface) {
 418     const hidl_string upstream(TEST_IFACE);
 419     const Return<void> ret = control->getForwardedStats(upstream, ASSERT_ZERO_BYTES_CALLBACK);
 420     EXPECT_TRUE(ret.isOk());
 421 }
 422
 423 /*
 424  * Tests for IOffloadControl::setDataLimit().
 425  */
 426
 427 // Test that setDataLimit() for an empty interface name fails.
 428 TEST_F(OffloadControlHidlTest, SetDataLimitEmptyUpstreamIfaceFails) {
 429     const hidl_string upstream("");
 430     const uint64_t limit = 5000ULL;
 431     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_FALSE_CALLBACK);
 432     EXPECT_TRUE(ret.isOk());
 433 }
 434
 435 // TEST_IFACE is presumed to exist on the device and be up. No packets
 436 // are ever actually caused to be forwarded.
 437 TEST_F(OffloadControlHidlTest, SetDataLimitNonZeroOk) {
 438     const hidl_string upstream(TEST_IFACE);
 439     const uint64_t limit = 5000ULL;
 440     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
 441     EXPECT_TRUE(ret.isOk());
 442 }
 443
 444 // TEST_IFACE is presumed to exist on the device and be up. No packets
 445 // are ever actually caused to be forwarded.
 446 TEST_F(OffloadControlHidlTest, SetDataLimitZeroOk) {
 447     const hidl_string upstream(TEST_IFACE);
 448     const uint64_t limit = 0ULL;
 449     const Return<void> ret = control->setDataLimit(upstream, limit, ASSERT_TRUE_CALLBACK);
 450     EXPECT_TRUE(ret.isOk());
 451 }
 452
 453 /*
 454  * Tests for IOffloadControl::setUpstreamParameters().
 455  */
 456
 457 // TEST_IFACE is presumed to exist on the device and be up. No packets
 458 // are ever actually caused to be forwarded.
 459 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv6OnlyOk) {
 460     const hidl_string iface(TEST_IFACE);
 461     const hidl_string v4Addr("");
 462     const hidl_string v4Gw("");
 463     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
 464     const Return<void> ret =
 465         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 466     EXPECT_TRUE(ret.isOk());
 467 }
 468
 469 // TEST_IFACE is presumed to exist on the device and be up. No packets
 470 // are ever actually caused to be forwarded.
 471 TEST_F(OffloadControlHidlTest, SetUpstreamParametersAlternateIPv6OnlyOk) {
 472     const hidl_string iface(TEST_IFACE);
 473     const hidl_string v4Addr;
 474     const hidl_string v4Gw;
 475     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:3")};
 476     const Return<void> ret =
 477         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 478     EXPECT_TRUE(ret.isOk());
 479 }
 480
 481 // TEST_IFACE is presumed to exist on the device and be up. No packets
 482 // are ever actually caused to be forwarded.
 483 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4OnlyOk) {
 484     const hidl_string iface(TEST_IFACE);
 485     const hidl_string v4Addr("192.0.2.2");
 486     const hidl_string v4Gw("192.0.2.1");
 487     const vector<hidl_string> v6Gws{};
 488     const Return<void> ret =
 489         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 490     EXPECT_TRUE(ret.isOk());
 491 }
 492
 493 // TEST_IFACE is presumed to exist on the device and be up. No packets
 494 // are ever actually caused to be forwarded.
 495 TEST_F(OffloadControlHidlTest, SetUpstreamParametersIPv4v6Ok) {
 496     const hidl_string iface(TEST_IFACE);
 497     const hidl_string v4Addr("192.0.2.2");
 498     const hidl_string v4Gw("192.0.2.1");
 499     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1"), hidl_string("fe80::db8:2")};
 500     const Return<void> ret =
 501         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_TRUE_CALLBACK);
 502     EXPECT_TRUE(ret.isOk());
 503 }
 504
 505 // Test that setUpstreamParameters() fails when all parameters are empty.
 506 TEST_F(OffloadControlHidlTest, SetUpstreamParametersEmptyFails) {
 507     const hidl_string iface("");
 508     const hidl_string v4Addr("");
 509     const hidl_string v4Gw("");
 510     const vector<hidl_string> v6Gws{};
 511     const Return<void> ret =
 512         control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 513     EXPECT_TRUE(ret.isOk());
 514 }
 515
 516 // Test that setUpstreamParameters() fails when given empty or non-existent interface names.
 517 TEST_F(OffloadControlHidlTest, SetUpstreamParametersBogusIfaceFails) {
 518     const hidl_string v4Addr("192.0.2.2");
 519     const hidl_string v4Gw("192.0.2.1");
 520     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 521     for (const auto& bogus : {"", "invalid"}) {
 522         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 523         const hidl_string iface(bogus);
 524         const Return<void> ret =
 525             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 526         EXPECT_TRUE(ret.isOk());
 527     }
 528 }
 529
 530 // Test that setUpstreamParameters() fails when given unparseable IPv4 addresses.
 531 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4AddrFails) {
 532     const hidl_string iface(TEST_IFACE);
 533     const hidl_string v4Gw("192.0.2.1");
 534     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 535     for (const auto& bogus : {"invalid", "192.0.2"}) {
 536         SCOPED_TRACE(StringPrintf("v4addr='%s'", bogus));
 537         const hidl_string v4Addr(bogus);
 538         const Return<void> ret =
 539             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 540         EXPECT_TRUE(ret.isOk());
 541     }
 542 }
 543
 544 // Test that setUpstreamParameters() fails when given unparseable IPv4 gateways.
 545 TEST_F(OffloadControlHidlTest, SetUpstreamParametersInvalidIPv4GatewayFails) {
 546     const hidl_string iface(TEST_IFACE);
 547     const hidl_string v4Addr("192.0.2.2");
 548     const vector<hidl_string> v6Gws{hidl_string("fe80::db8:1")};
 549     for (const auto& bogus : {"invalid", "192.0.2"}) {
 550         SCOPED_TRACE(StringPrintf("v4gateway='%s'", bogus));
 551         const hidl_string v4Gw(bogus);
 552         const Return<void> ret =
 553             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 554         EXPECT_TRUE(ret.isOk());
 555     }
 556 }
 557
 558 // Test that setUpstreamParameters() fails when given unparseable IPv6 gateways.
 559 TEST_F(OffloadControlHidlTest, SetUpstreamParametersBadIPv6GatewaysFail) {
 560     const hidl_string iface(TEST_IFACE);
 561     const hidl_string v4Addr("192.0.2.2");
 562     const hidl_string v4Gw("192.0.2.1");
 563     for (const auto& bogus : {"", "invalid", "fe80::bogus", "192.0.2.66"}) {
 564         SCOPED_TRACE(StringPrintf("v6gateway='%s'", bogus));
 565         const vector<hidl_string> v6Gws{hidl_string("fe80::1"), hidl_string(bogus)};
 566         const Return<void> ret =
 567             control->setUpstreamParameters(iface, v4Addr, v4Gw, v6Gws, ASSERT_FALSE_CALLBACK);
 568         EXPECT_TRUE(ret.isOk());
 569     }
 570 }
 571
 572 /*
 573  * Tests for IOffloadControl::addDownstream().
 574  */
 575
 576 // Test addDownstream() works given an IPv4 prefix.
 577 TEST_F(OffloadControlHidlTest, AddDownstreamIPv4) {
 578     const hidl_string iface("dummy0");
 579     const hidl_string prefix("192.0.2.0/24");
 580     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 581     EXPECT_TRUE(ret.isOk());
 582 }
 583
 584 // Test addDownstream() works given an IPv6 prefix.
 585 TEST_F(OffloadControlHidlTest, AddDownstreamIPv6) {
 586     const hidl_string iface("dummy0");
 587     const hidl_string prefix("2001:db8::/64");
 588     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 589     EXPECT_TRUE(ret.isOk());
 590 }
 591
 592 // Test addDownstream() fails given all empty parameters.
 593 TEST_F(OffloadControlHidlTest, AddDownstreamEmptyFails) {
 594     const hidl_string iface("");
 595     const hidl_string prefix("");
 596     const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 597     EXPECT_TRUE(ret.isOk());
 598 }
 599
 600 // Test addDownstream() fails given empty or non-existent interface names.
 601 TEST_F(OffloadControlHidlTest, AddDownstreamInvalidIfaceFails) {
 602     const hidl_string prefix("192.0.2.0/24");
 603     for (const auto& bogus : {"", "invalid"}) {
 604         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 605         const hidl_string iface(bogus);
 606         const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 607         EXPECT_TRUE(ret.isOk());
 608     }
 609 }
 610
 611 // Test addDownstream() fails given unparseable prefix arguments.
 612 TEST_F(OffloadControlHidlTest, AddDownstreamBogusPrefixFails) {
 613     const hidl_string iface("dummy0");
 614     for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
 615         SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
 616         const hidl_string prefix(bogus);
 617         const Return<void> ret = control->addDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 618         EXPECT_TRUE(ret.isOk());
 619     }
 620 }
 621
 622 /*
 623  * Tests for IOffloadControl::removeDownstream().
 624  */
 625
 626 // Test removeDownstream() works given an IPv4 prefix.
 627 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv4) {
 628     const hidl_string iface("dummy0");
 629     const hidl_string prefix("192.0.2.0/24");
 630     // First add the downstream, otherwise removeDownstream logic can reasonably
 631     // return false for downstreams not previously added.
 632     const Return<void> add = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 633     EXPECT_TRUE(add.isOk());
 634     const Return<void> del = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 635     EXPECT_TRUE(del.isOk());
 636 }
 637
 638 // Test removeDownstream() works given an IPv6 prefix.
 639 TEST_F(OffloadControlHidlTest, RemoveDownstreamIPv6) {
 640     const hidl_string iface("dummy0");
 641     const hidl_string prefix("2001:db8::/64");
 642     // First add the downstream, otherwise removeDownstream logic can reasonably
 643     // return false for downstreams not previously added.
 644     const Return<void> add = control->addDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 645     EXPECT_TRUE(add.isOk());
 646     const Return<void> del = control->removeDownstream(iface, prefix, ASSERT_TRUE_CALLBACK);
 647     EXPECT_TRUE(del.isOk());
 648 }
 649
 650 // Test removeDownstream() fails given all empty parameters.
 651 TEST_F(OffloadControlHidlTest, RemoveDownstreamEmptyFails) {
 652     const hidl_string iface("");
 653     const hidl_string prefix("");
 654     const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 655     EXPECT_TRUE(ret.isOk());
 656 }
 657
 658 // Test removeDownstream() fails given empty or non-existent interface names.
 659 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusIfaceFails) {
 660     const hidl_string prefix("192.0.2.0/24");
 661     for (const auto& bogus : {"", "invalid"}) {
 662         SCOPED_TRACE(StringPrintf("iface='%s'", bogus));
 663         const hidl_string iface(bogus);
 664         const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 665         EXPECT_TRUE(ret.isOk());
 666     }
 667 }
 668
 669 // Test removeDownstream() fails given unparseable prefix arguments.
 670 TEST_F(OffloadControlHidlTest, RemoveDownstreamBogusPrefixFails) {
 671     const hidl_string iface("dummy0");
 672     for (const auto& bogus : {"", "192.0.2/24", "2001:db8/64"}) {
 673         SCOPED_TRACE(StringPrintf("prefix='%s'", bogus));
 674         const hidl_string prefix(bogus);
 675         const Return<void> ret = control->removeDownstream(iface, prefix, ASSERT_FALSE_CALLBACK);
 676         EXPECT_TRUE(ret.isOk());
 677     }
 678 }
 679
 680 int main(int argc, char** argv) {
 681     testing::InitGoogleTest(&argc, argv);
 682     int status = RUN_ALL_TESTS();
 683     ALOGE("Test result with status=%d", status);
 684     return status;
 685 }