1/*
2 * Copyright (C) 2015 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// Tests socket functionality using loopback connections. Requires IPv4 and
18// IPv6 capabilities. These tests assume that no UDP packets are lost, which
19// should be the case for loopback communication, but is not guaranteed.
20
21#include <string.h>
22#include <sys/socket.h>
23#include <sys/types.h>
24#include <time.h>
25
26#include <cutils/sockets.h>
27#include <gtest/gtest.h>
28
29// Makes sure the passed sockets are valid, sends data between them, and closes
30// them. Any failures are logged with gtest.
31//
32// On Mac recvfrom() will not fill in the address for TCP sockets, so we need
33// separate logic paths depending on socket type.
34static void TestConnectedSockets(cutils_socket_t server, cutils_socket_t client,
35                                 int type) {
36    ASSERT_NE(INVALID_SOCKET, server);
37    ASSERT_NE(INVALID_SOCKET, client);
38
39    char buffer[128];
40    sockaddr_storage addr;
41    socklen_t addr_size = sizeof(addr);
42
43    // Send client -> server first to get the UDP client's address.
44    ASSERT_EQ(3, send(client, "foo", 3, 0));
45    if (type == SOCK_DGRAM) {
46        EXPECT_EQ(3, recvfrom(server, buffer, sizeof(buffer), 0,
47                              reinterpret_cast<sockaddr*>(&addr), &addr_size));
48    } else {
49        EXPECT_EQ(3, recv(server, buffer, sizeof(buffer), 0));
50    }
51    EXPECT_EQ(0, memcmp(buffer, "foo", 3));
52
53    // Now send server -> client.
54    if (type == SOCK_DGRAM) {
55        ASSERT_EQ(3, sendto(server, "bar", 3, 0,
56                            reinterpret_cast<sockaddr*>(&addr), addr_size));
57    } else {
58        ASSERT_EQ(3, send(server, "bar", 3, 0));
59    }
60    EXPECT_EQ(3, recv(client, buffer, sizeof(buffer), 0));
61    EXPECT_EQ(0, memcmp(buffer, "bar", 3));
62
63    // Send multiple buffers using socket_send_buffers().
64    std::string data[] = {"foo", "bar", "12345"};
65    cutils_socket_buffer_t socket_buffers[] = { {data[0].data(), data[0].length()},
66                                                {data[1].data(), data[1].length()},
67                                                {data[2].data(), data[2].length()} };
68    EXPECT_EQ(11, socket_send_buffers(client, socket_buffers, 3));
69    EXPECT_EQ(11, recv(server, buffer, sizeof(buffer), 0));
70    EXPECT_EQ(0, memcmp(buffer, "foobar12345", 11));
71
72    EXPECT_EQ(0, socket_close(server));
73    EXPECT_EQ(0, socket_close(client));
74}
75
76// Tests receive timeout. The timing verification logic must be very coarse to
77// make sure different systems can all pass these tests.
78void TestReceiveTimeout(cutils_socket_t sock) {
79    time_t start_time;
80    char buffer[32];
81
82    // Make sure a 20ms timeout completes in 1 second or less.
83    EXPECT_EQ(0, socket_set_receive_timeout(sock, 20));
84    start_time = time(nullptr);
85    EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
86    EXPECT_LE(difftime(time(nullptr), start_time), 1.0);
87
88    // Make sure a 1250ms timeout takes 1 second or more.
89    EXPECT_EQ(0, socket_set_receive_timeout(sock, 1250));
90    start_time = time(nullptr);
91    EXPECT_EQ(-1, recv(sock, buffer, sizeof(buffer), 0));
92    EXPECT_LE(1.0, difftime(time(nullptr), start_time));
93}
94
95// Tests socket_get_local_port().
96TEST(SocketsTest, TestGetLocalPort) {
97    cutils_socket_t server;
98
99    // Check a bunch of ports so that we can ignore any conflicts in case
100    // of ports already being taken, but if a server is able to start up we
101    // should always be able to read its port.
102    for (int port : {10000, 12345, 15999, 20202, 25000}) {
103        for (int type : {SOCK_DGRAM, SOCK_STREAM}) {
104            server = socket_inaddr_any_server(port, type);
105            if (server != INVALID_SOCKET) {
106                EXPECT_EQ(port, socket_get_local_port(server));
107            }
108            socket_close(server);
109        }
110    }
111
112    // Check expected failure for an invalid socket.
113    EXPECT_EQ(-1, socket_get_local_port(INVALID_SOCKET));
114}
115
116// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 UDP.
117TEST(SocketsTest, TestIpv4UdpLoopback) {
118    cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM);
119    cutils_socket_t client = socket_network_client(
120            "127.0.0.1", socket_get_local_port(server), SOCK_DGRAM);
121
122    TestConnectedSockets(server, client, SOCK_DGRAM);
123}
124
125// Tests socket_inaddr_any_server() and socket_network_client() for IPv4 TCP.
126TEST(SocketsTest, TestIpv4TcpLoopback) {
127    cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM);
128    ASSERT_NE(INVALID_SOCKET, server);
129
130    cutils_socket_t client = socket_network_client(
131            "127.0.0.1", socket_get_local_port(server), SOCK_STREAM);
132    cutils_socket_t handler = accept(server, nullptr, nullptr);
133    EXPECT_EQ(0, socket_close(server));
134
135    TestConnectedSockets(handler, client, SOCK_STREAM);
136}
137
138// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 UDP.
139TEST(SocketsTest, TestIpv6UdpLoopback) {
140    cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM);
141    cutils_socket_t client = socket_network_client(
142            "::1", socket_get_local_port(server), SOCK_DGRAM);
143
144    TestConnectedSockets(server, client, SOCK_DGRAM);
145}
146
147// Tests socket_inaddr_any_server() and socket_network_client() for IPv6 TCP.
148TEST(SocketsTest, TestIpv6TcpLoopback) {
149    cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM);
150    ASSERT_NE(INVALID_SOCKET, server);
151
152    cutils_socket_t client = socket_network_client(
153            "::1", socket_get_local_port(server), SOCK_STREAM);
154    cutils_socket_t handler = accept(server, nullptr, nullptr);
155    EXPECT_EQ(0, socket_close(server));
156
157    TestConnectedSockets(handler, client, SOCK_STREAM);
158}
159
160// Tests setting a receive timeout for UDP sockets.
161TEST(SocketsTest, TestUdpReceiveTimeout) {
162    cutils_socket_t sock = socket_inaddr_any_server(0, SOCK_DGRAM);
163    ASSERT_NE(INVALID_SOCKET, sock);
164
165    TestReceiveTimeout(sock);
166
167    EXPECT_EQ(0, socket_close(sock));
168}
169
170// Tests setting a receive timeout for TCP sockets.
171TEST(SocketsTest, TestTcpReceiveTimeout) {
172    cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM);
173    ASSERT_NE(INVALID_SOCKET, server);
174
175    cutils_socket_t client = socket_network_client(
176            "localhost", socket_get_local_port(server), SOCK_STREAM);
177    cutils_socket_t handler = accept(server, nullptr, nullptr);
178    EXPECT_EQ(0, socket_close(server));
179
180    TestReceiveTimeout(handler);
181
182    EXPECT_EQ(0, socket_close(client));
183    EXPECT_EQ(0, socket_close(handler));
184}
185
186// Tests socket_send_buffers() failure.
187TEST(SocketsTest, TestSocketSendBuffersFailure) {
188    EXPECT_EQ(-1, socket_send_buffers(INVALID_SOCKET, nullptr, 0));
189}
190