android-9.0.0_r3/s

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

// Tests socket functionality using loopback connections. The UDP tests assume that no packets are
// lost, which should be the case for loopback communication, but is not guaranteed.
//
// Also tests our SocketMock class to make sure it works as expected and reports errors properly
// if the mock expectations aren't met during a test.

#include "socket.h"
#include "socket_mock.h"

#include <list>

#include <gtest/gtest-spi.h>
#include <gtest/gtest.h>

static constexpr int kShortTimeoutMs = 10;
static constexpr int kTestTimeoutMs = 3000;

// Creates connected sockets |server| and |client|. Returns true on success.
bool MakeConnectedSockets(Socket::Protocol protocol, std::unique_ptr<Socket>* server,
                          std::unique_ptr<Socket>* client,
                          const std::string& hostname = "localhost") {
    *server = Socket::NewServer(protocol, 0);
    if (*server == nullptr) {
        ADD_FAILURE() << "Failed to create server.";
        return false;
    }

    *client = Socket::NewClient(protocol, hostname, (*server)->GetLocalPort(), nullptr);
    if (*client == nullptr) {
        ADD_FAILURE() << "Failed to create client.";
        return false;
    }

    // TCP passes the client off to a new socket.
    if (protocol == Socket::Protocol::kTcp) {
        *server = (*server)->Accept();
        if (*server == nullptr) {
            ADD_FAILURE() << "Failed to accept client connection.";
            return false;
        }
    }

    return true;
}

// Sends a string over a Socket. Returns true if the full string (without terminating char)
// was sent.
static bool SendString(Socket* sock, const std::string& message) {
    return sock->Send(message.c_str(), message.length());
}

// Receives a string from a Socket. Returns true if the full string (without terminating char)
// was received.
static bool ReceiveString(Socket* sock, const std::string& message) {
    std::string received(message.length(), '\0');
    ssize_t bytes = sock->ReceiveAll(&received[0], received.length(), kTestTimeoutMs);
    return static_cast<size_t>(bytes) == received.length() && received == message;
}

// Tests sending packets client -> server, then server -> client.
TEST(SocketTest, TestSendAndReceive) {
    std::unique_ptr<Socket> server, client;

    for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
        ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));

        EXPECT_TRUE(SendString(client.get(), "foo"));
        EXPECT_TRUE(ReceiveString(server.get(), "foo"));

        EXPECT_TRUE(SendString(server.get(), "bar baz"));
        EXPECT_TRUE(ReceiveString(client.get(), "bar baz"));
    }
}

TEST(SocketTest, TestReceiveTimeout) {
    std::unique_ptr<Socket> server, client;
    char buffer[16];

    for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
        ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));

        EXPECT_EQ(-1, server->Receive(buffer, sizeof(buffer), kShortTimeoutMs));
        EXPECT_TRUE(server->ReceiveTimedOut());

        EXPECT_EQ(-1, client->Receive(buffer, sizeof(buffer), kShortTimeoutMs));
        EXPECT_TRUE(client->ReceiveTimedOut());
    }

    // UDP will wait for timeout if the other side closes.
    ASSERT_TRUE(MakeConnectedSockets(Socket::Protocol::kUdp, &server, &client));
    EXPECT_EQ(0, server->Close());
    EXPECT_EQ(-1, client->Receive(buffer, sizeof(buffer), kShortTimeoutMs));
    EXPECT_TRUE(client->ReceiveTimedOut());
}

TEST(SocketTest, TestReceiveFailure) {
    std::unique_ptr<Socket> server, client;
    char buffer[16];

    for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
        ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));

        EXPECT_EQ(0, server->Close());
        EXPECT_EQ(-1, server->Receive(buffer, sizeof(buffer), kTestTimeoutMs));
        EXPECT_FALSE(server->ReceiveTimedOut());

        EXPECT_EQ(0, client->Close());
        EXPECT_EQ(-1, client->Receive(buffer, sizeof(buffer), kTestTimeoutMs));
        EXPECT_FALSE(client->ReceiveTimedOut());
    }

    // TCP knows right away when the other side closes and returns 0 to indicate EOF.
    ASSERT_TRUE(MakeConnectedSockets(Socket::Protocol::kTcp, &server, &client));
    EXPECT_EQ(0, server->Close());
    EXPECT_EQ(0, client->Receive(buffer, sizeof(buffer), kTestTimeoutMs));
    EXPECT_FALSE(client->ReceiveTimedOut());
}

// Tests sending and receiving large packets.
TEST(SocketTest, TestLargePackets) {
    std::string message(1024, '\0');
    std::unique_ptr<Socket> server, client;

    for (Socket::Protocol protocol : {Socket::Protocol::kUdp, Socket::Protocol::kTcp}) {
        ASSERT_TRUE(MakeConnectedSockets(protocol, &server, &client));

        // Run through the test a few times.
        for (int i = 0; i < 10; ++i) {
            // Use a different message each iteration to prevent false positives.
            for (size_t j = 0; j < message.length(); ++j) {
                message[j] = static_cast<char>(i + j);
            }

            EXPECT_TRUE(SendString(client.get(), message));
            EXPECT_TRUE(ReceiveString(server.get(), message));
        }
    }
}

// Tests UDP receive overflow when the UDP packet is larger than the receive buffer.
TEST(SocketTest, TestUdpReceiveOverflow) {
    std::unique_ptr<Socket> server, client;
    ASSERT_TRUE(MakeConnectedSockets(Socket::Protocol::kUdp, &server, &client));

    EXPECT_TRUE(SendString(client.get(), "1234567890"));

    // This behaves differently on different systems, either truncating the packet or returning -1.
    char buffer[5];
    ssize_t bytes = server->Receive(buffer, 5, kTestTimeoutMs);
    if (bytes == 5) {
        EXPECT_EQ(0, memcmp(buffer, "12345", 5));
    } else {
        EXPECT_EQ(-1, bytes);
    }
}

// Tests UDP multi-buffer send.
TEST(SocketTest, TestUdpSendBuffers) {
    std::unique_ptr<Socket> sock = Socket::NewServer(Socket::Protocol::kUdp, 0);
    std::vector<std::string> data{"foo", "bar", "12345"};
    std::vector<cutils_socket_buffer_t> buffers{{data[0].data(), data[0].length()},
                                                {data[1].data(), data[1].length()},
                                                {data[2].data(), data[2].length()}};
    ssize_t mock_return_value = 0;

    // Mock out socket_send_buffers() to verify we're sending in the correct buffers and
    // return |mock_return_value|.
    sock->socket_send_buffers_function_ = [&buffers, &mock_return_value](
            cutils_socket_t /*cutils_sock*/, cutils_socket_buffer_t* sent_buffers,
            size_t num_sent_buffers) -> ssize_t {
        EXPECT_EQ(buffers.size(), num_sent_buffers);
        for (size_t i = 0; i < num_sent_buffers; ++i) {
            EXPECT_EQ(buffers[i].data, sent_buffers[i].data);
            EXPECT_EQ(buffers[i].length, sent_buffers[i].length);
        }
        return mock_return_value;
    };

    mock_return_value = strlen("foobar12345");
    EXPECT_TRUE(sock->Send(buffers));

    mock_return_value -= 1;
    EXPECT_FALSE(sock->Send(buffers));

    mock_return_value = 0;
    EXPECT_FALSE(sock->Send(buffers));

    mock_return_value = -1;
    EXPECT_FALSE(sock->Send(buffers));
}

// Tests TCP re-sending until socket_send_buffers() sends all data. This is a little complicated,
// but the general idea is that we intercept calls to socket_send_buffers() using a lambda mock
// function that simulates partial writes.
TEST(SocketTest, TestTcpSendBuffers) {
    std::unique_ptr<Socket> sock = Socket::NewServer(Socket::Protocol::kTcp, 0);
    std::vector<std::string> data{"foo", "bar", "12345"};
    std::vector<cutils_socket_buffer_t> buffers{{data[0].data(), data[0].length()},
                                                {data[1].data(), data[1].length()},
                                                {data[2].data(), data[2].length()}};

    // Test breaking up the buffered send at various points.
    std::list<std::string> test_sends[] = {
            // Successes.
            {"foobar12345"},
            {"f", "oob", "ar12345"},
            {"fo", "obar12", "345"},
            {"foo", "bar12345"},
            {"foob", "ar123", "45"},
            {"f", "o", "o", "b", "a", "r", "1", "2", "3", "4", "5"},

            // Failures.
            {},
            {"f"},
            {"foo", "bar"},
            {"fo", "obar12"},
            {"foobar1234"}
    };

    for (auto& test : test_sends) {
        ssize_t bytes_sent = 0;
        bool expect_success = true;

        // Create a mock function for custom socket_send_buffers() behavior. This function will
        // check to make sure the input buffers start at the next unsent byte, then return the
        // number of bytes indicated by the next entry in |test|.
        sock->socket_send_buffers_function_ = [&bytes_sent, &data, &expect_success, &test](
                cutils_socket_t /*cutils_sock*/, cutils_socket_buffer_t* buffers,
                size_t num_buffers) -> ssize_t {
            EXPECT_TRUE(num_buffers > 0);

            // Failure case - pretend we errored out before sending all the buffers.
            if (test.empty()) {
                expect_success = false;
                return -1;
            }

            // Count the bytes we've sent to find where the next buffer should start and how many
            // bytes should be left in it.
            size_t byte_count = bytes_sent, data_index = 0;
            while (data_index < data.size()) {
                if (byte_count >= data[data_index].length()) {
                    byte_count -= data[data_index].length();
                    ++data_index;
                } else {
                    break;
                }
            }
            void* expected_next_byte = &data[data_index][byte_count];
            size_t expected_next_size = data[data_index].length() - byte_count;

            EXPECT_EQ(data.size() - data_index, num_buffers);
            EXPECT_EQ(expected_next_byte, buffers[0].data);
            EXPECT_EQ(expected_next_size, buffers[0].length);

            std::string to_send = std::move(test.front());
            test.pop_front();
            bytes_sent += to_send.length();
            return to_send.length();
        };

        EXPECT_EQ(expect_success, sock->Send(buffers));
        EXPECT_TRUE(test.empty());
    }
}

TEST(SocketMockTest, TestSendSuccess) {
    SocketMock mock;

    mock.ExpectSend("foo");
    EXPECT_TRUE(SendString(&mock, "foo"));

    mock.ExpectSend("abc");
    mock.ExpectSend("123");
    EXPECT_TRUE(SendString(&mock, "abc"));
    EXPECT_TRUE(SendString(&mock, "123"));
}

TEST(SocketMockTest, TestSendFailure) {
    SocketMock* mock = new SocketMock;

    mock->ExpectSendFailure("foo");
    EXPECT_FALSE(SendString(mock, "foo"));

    EXPECT_NONFATAL_FAILURE(SendString(mock, "foo"), "no message was expected");

    mock->ExpectSend("foo");
    EXPECT_NONFATAL_FAILURE(SendString(mock, "bar"), "expected foo, but got bar");
    EXPECT_TRUE(SendString(mock, "foo"));

    mock->AddReceive("foo");
    EXPECT_NONFATAL_FAILURE(SendString(mock, "foo"), "called out-of-order");
    EXPECT_TRUE(ReceiveString(mock, "foo"));

    mock->ExpectSend("foo");
    EXPECT_NONFATAL_FAILURE(delete mock, "1 event(s) were not handled");
}

TEST(SocketMockTest, TestReceiveSuccess) {
    SocketMock mock;

    mock.AddReceive("foo");
    EXPECT_TRUE(ReceiveString(&mock, "foo"));

    mock.AddReceive("abc");
    mock.AddReceive("123");
    EXPECT_TRUE(ReceiveString(&mock, "abc"));
    EXPECT_TRUE(ReceiveString(&mock, "123"));

    // Make sure ReceiveAll() can piece together multiple receives.
    mock.AddReceive("foo");
    mock.AddReceive("bar");
    mock.AddReceive("123");
    EXPECT_TRUE(ReceiveString(&mock, "foobar123"));
}

TEST(SocketMockTest, TestReceiveFailure) {
    SocketMock* mock = new SocketMock;

    mock->AddReceiveFailure();
    EXPECT_FALSE(ReceiveString(mock, "foo"));
    EXPECT_FALSE(mock->ReceiveTimedOut());

    mock->AddReceiveTimeout();
    EXPECT_FALSE(ReceiveString(mock, "foo"));
    EXPECT_TRUE(mock->ReceiveTimedOut());

    mock->AddReceive("foo");
    mock->AddReceiveFailure();
    EXPECT_FALSE(ReceiveString(mock, "foobar"));

    EXPECT_NONFATAL_FAILURE(ReceiveString(mock, "foo"), "no message was ready");

    mock->ExpectSend("foo");
    EXPECT_NONFATAL_FAILURE(ReceiveString(mock, "foo"), "called out-of-order");
    EXPECT_TRUE(SendString(mock, "foo"));

    char c;
    mock->AddReceive("foo");
    EXPECT_NONFATAL_FAILURE(mock->Receive(&c, 1, 0), "not enough bytes (1) for foo");
    EXPECT_TRUE(ReceiveString(mock, "foo"));

    mock->AddReceive("foo");
    EXPECT_NONFATAL_FAILURE(delete mock, "1 event(s) were not handled");
}

TEST(SocketMockTest, TestAcceptSuccess) {
    SocketMock mock;

    SocketMock* mock_handler = new SocketMock;
    mock.AddAccept(std::unique_ptr<SocketMock>(mock_handler));
    EXPECT_EQ(mock_handler, mock.Accept().get());

    mock.AddAccept(nullptr);
    EXPECT_EQ(nullptr, mock.Accept().get());
}

TEST(SocketMockTest, TestAcceptFailure) {
    SocketMock* mock = new SocketMock;

    EXPECT_NONFATAL_FAILURE(mock->Accept(), "no socket was ready");

    mock->ExpectSend("foo");
    EXPECT_NONFATAL_FAILURE(mock->Accept(), "called out-of-order");
    EXPECT_TRUE(SendString(mock, "foo"));

    mock->AddAccept(nullptr);
    EXPECT_NONFATAL_FAILURE(delete mock, "1 event(s) were not handled");
}