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