libcutils/tests/sockets_test.cpp

/*
 * 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. Requires IPv4 and
// IPv6 capabilities, and that kTestPort is available for loopback
// communication. These tests also assume that no UDP packets are lost,
// which should be the case for loopback communication, but is not guaranteed.

#include <cutils/sockets.h>

#include <time.h>

#include <gtest/gtest.h>

enum {
    // This port must be available for loopback communication.
    kTestPort = 54321
};

// Makes sure the passed sockets are valid, sends data between them, and closes
// them. Any failures are logged with gtest.
//
// On Mac recvfrom() will not fill in the address for TCP sockets, so we need
// separate logic paths depending on socket type.
static void TestConnectedSockets(cutils_socket_t server, cutils_socket_t client,
                                 int type) {
    ASSERT_NE(INVALID_SOCKET, server);
    ASSERT_NE(INVALID_SOCKET, client);

    char buffer[3];
    sockaddr_storage addr;
    socklen_t addr_size = sizeof(addr);

    // Send client -> server first to get the UDP client's address.
    ASSERT_EQ(3, send(client, "foo", 3, 0));
    if (type == SOCK_DGRAM) {
      EXPECT_EQ(3, recvfrom(server, buffer, 3, 0,
                            reinterpret_cast<sockaddr*>(&addr), &addr_size));
    } else {
      EXPECT_EQ(3, recv(server, buffer, 3, 0));
    }
    EXPECT_EQ(0, memcmp(buffer, "foo", 3));

    // Now send server -> client.
    if (type == SOCK_DGRAM) {
      ASSERT_EQ(3, sendto(server, "bar", 3, 0,
                          reinterpret_cast<sockaddr*>(&addr), addr_size));
    } else {
      ASSERT_EQ(3, send(server, "bar", 3, 0));
    }
    EXPECT_EQ(3, recv(client, buffer, 3, 0));
    EXPECT_EQ(0, memcmp(buffer, "bar", 3));

    EXPECT_EQ(0, socket_close(server));
    EXPECT_EQ(0, socket_close(client));
}

// Tests receive timeout. The timing verification logic must be very coarse to
// make sure different systems can all pass these tests.
void TestReceiveTimeout(cutils_socket_t sock) {
    time_t start_time;
    char buffer[32];

    // Make sure a 20ms timeout completes in 1 second or less.
    EXPECT_EQ(0, socket_set_receive_timeout(sock, 20));
    start_time = time(nullptr);
    EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
    EXPECT_LE(difftime(time(nullptr), start_time), 1.0);

    // Make sure a 1250ms timeout takes 1 second or more.
    EXPECT_EQ(0, socket_set_receive_timeout(sock, 1250));
    start_time = time(nullptr);
    EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
    EXPECT_LE(1.0, difftime(time(nullptr), start_time));
}

// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 UDP.
TEST(SocketsTest, TestIpv4UdpLoopback) {
    cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
    cutils_socket_t client = socket_network_client("127.0.0.1", kTestPort,
                                                   SOCK_DGRAM);

    TestConnectedSockets(server, client, SOCK_DGRAM);
}

// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 TCP.
TEST(SocketsTest, TestIpv4TcpLoopback) {
    cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
    ASSERT_NE(INVALID_SOCKET, server);

    cutils_socket_t client = socket_network_client("127.0.0.1", kTestPort,
                                                   SOCK_STREAM);
    cutils_socket_t handler = accept(server, nullptr, nullptr);
    EXPECT_EQ(0, socket_close(server));

    TestConnectedSockets(handler, client, SOCK_STREAM);
}

// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 UDP.
TEST(SocketsTest, TestIpv6UdpLoopback) {
    cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
    cutils_socket_t client = socket_network_client("::1", kTestPort,
                                                   SOCK_DGRAM);

    TestConnectedSockets(server, client, SOCK_DGRAM);
}

// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 TCP.
TEST(SocketsTest, TestIpv6TcpLoopback) {
    cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
    ASSERT_NE(INVALID_SOCKET, server);

    cutils_socket_t client = socket_network_client("::1", kTestPort,
                                                   SOCK_STREAM);
    cutils_socket_t handler = accept(server, nullptr, nullptr);
    EXPECT_EQ(0, socket_close(server));

    TestConnectedSockets(handler, client, SOCK_STREAM);
}

// Tests setting a receive timeout for UDP sockets.
TEST(SocketsTest, TestUdpReceiveTimeout) {
    cutils_socket_t sock = socket_inaddr_any_server(kTestPort, SOCK_DGRAM);
    ASSERT_NE(INVALID_SOCKET, sock);

    TestReceiveTimeout(sock);

    EXPECT_EQ(0, socket_close(sock));
}

// Tests setting a receive timeout for TCP sockets.
TEST(SocketsTest, TestTcpReceiveTimeout) {
    cutils_socket_t server = socket_inaddr_any_server(kTestPort, SOCK_STREAM);
    ASSERT_NE(INVALID_SOCKET, server);

    cutils_socket_t client = socket_network_client("localhost", kTestPort,
                                                   SOCK_STREAM);
    cutils_socket_t handler = accept(server, nullptr, nullptr);
    EXPECT_EQ(0, socket_close(server));

    TestReceiveTimeout(handler);

    EXPECT_EQ(0, socket_close(client));
    EXPECT_EQ(0, socket_close(handler));
}