1/*
2 * Copyright 2016 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 * IptablesBaseTest.cpp - utility class for tests that use iptables
17 */
18
19#include <deque>
20#include <string>
21#include <vector>
22
23#include <gtest/gtest.h>
24
25#include <android-base/stringprintf.h>
26
27#include "IptablesBaseTest.h"
28#include "NetdConstants.h"
29
30#define LOG_TAG "IptablesBaseTest"
31#include <cutils/log.h>
32
33using android::base::StringPrintf;
34
35IptablesBaseTest::IptablesBaseTest() {
36    sCmds.clear();
37    sRestoreCmds.clear();
38    sReturnValues.clear();
39}
40
41int IptablesBaseTest::fake_android_fork_exec(int argc, char* argv[], int *status, bool, bool) {
42    std::string cmd = argv[0];
43    for (int i = 1; i < argc; i++) {
44        if (argv[i] == NULL) break;  // NatController likes to pass in invalid argc values.
45        cmd += " ";
46        cmd += argv[i];
47    }
48    sCmds.push_back(cmd);
49
50    int ret;
51    if (sReturnValues.size()) {
52        ret = sReturnValues.front();
53        sReturnValues.pop_front();
54    } else {
55        ret = 0;
56    }
57
58    if (status) {
59        *status = ret;
60    }
61    return ret;
62}
63
64FILE *IptablesBaseTest::fake_popen(const char * /* cmd */, const char *type) {
65    if (sPopenContents.empty() || strcmp(type, "r") != 0) {
66        return NULL;
67    }
68
69    std::string realCmd = StringPrintf("echo '%s'", sPopenContents.front().c_str());
70    sPopenContents.pop_front();
71    return popen(realCmd.c_str(), "r");
72}
73
74int IptablesBaseTest::fakeExecIptablesRestoreWithOutput(IptablesTarget target,
75                                                        const std::string& commands,
76                                                        std::string *output) {
77    sRestoreCmds.push_back({ target, commands });
78    if (output != nullptr) {
79        *output = sIptablesRestoreOutput.size() ? sIptablesRestoreOutput.front().c_str() : "";
80    }
81    if (sIptablesRestoreOutput.size()) {
82        sIptablesRestoreOutput.pop_front();
83    }
84    return 0;
85}
86
87int IptablesBaseTest::fakeExecIptablesRestore(IptablesTarget target, const std::string& commands) {
88    return fakeExecIptablesRestoreWithOutput(target, commands, nullptr);
89}
90
91int IptablesBaseTest::fakeExecIptablesRestoreCommand(IptablesTarget target,
92                                                     const std::string& table,
93                                                     const std::string& command,
94                                                     std::string *output) {
95    std::string fullCmd = StringPrintf("-t %s %s", table.c_str(), command.c_str());
96    return fakeExecIptablesRestoreWithOutput(target, fullCmd, output);
97}
98
99void IptablesBaseTest::expectIptablesRestoreCommands(const std::vector<std::string>& expectedCmds) {
100    ExpectedIptablesCommands expected;
101    for (const auto& cmd : expectedCmds) {
102        expected.push_back({ V4V6, cmd });
103    }
104    expectIptablesRestoreCommands(expected);
105}
106
107void IptablesBaseTest::expectIptablesRestoreCommands(const ExpectedIptablesCommands& expectedCmds) {
108    EXPECT_EQ(expectedCmds.size(), sRestoreCmds.size());
109    for (size_t i = 0; i < expectedCmds.size(); i++) {
110        EXPECT_EQ(expectedCmds[i], sRestoreCmds[i]) <<
111            "iptables-restore command " << i << " differs";
112    }
113    sRestoreCmds.clear();
114}
115
116void IptablesBaseTest::setReturnValues(const std::deque<int>& returnValues) {
117    sReturnValues = returnValues;
118}
119
120std::vector<std::string> IptablesBaseTest::sCmds = {};
121IptablesBaseTest::ExpectedIptablesCommands IptablesBaseTest::sRestoreCmds = {};
122std::deque<std::string> IptablesBaseTest::sPopenContents = {};
123std::deque<std::string> IptablesBaseTest::sIptablesRestoreOutput = {};
124std::deque<int> IptablesBaseTest::sReturnValues = {};
125