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.
TestConnectedSockets(cutils_socket_t server,cutils_socket_t client,int type)34 static 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 socket_get_local_port().
TEST(SocketsTest,TestGetLocalPort)77 TEST(SocketsTest, TestGetLocalPort) {
78 cutils_socket_t server;
79
80 // Check a bunch of ports so that we can ignore any conflicts in case
81 // of ports already being taken, but if a server is able to start up we
82 // should always be able to read its port.
83 for (int port : {10000, 12345, 15999, 20202, 25000}) {
84 for (int type : {SOCK_DGRAM, SOCK_STREAM}) {
85 server = socket_inaddr_any_server(port, type);
86 if (server != INVALID_SOCKET) {
87 EXPECT_EQ(port, socket_get_local_port(server));
88 }
89 socket_close(server);
90 }
91 }
92
93 // Check expected failure for an invalid socket.
94 EXPECT_EQ(-1, socket_get_local_port(INVALID_SOCKET));
95 }
96
97 // Tests socket_inaddr_any_server() and socket_network_client() for IPv4 UDP.
TEST(SocketsTest,TestIpv4UdpLoopback)98 TEST(SocketsTest, TestIpv4UdpLoopback) {
99 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM);
100 cutils_socket_t client = socket_network_client(
101 "127.0.0.1", socket_get_local_port(server), SOCK_DGRAM);
102
103 TestConnectedSockets(server, client, SOCK_DGRAM);
104 }
105
106 // Tests socket_inaddr_any_server() and socket_network_client() for IPv4 TCP.
TEST(SocketsTest,TestIpv4TcpLoopback)107 TEST(SocketsTest, TestIpv4TcpLoopback) {
108 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM);
109 ASSERT_NE(INVALID_SOCKET, server);
110
111 cutils_socket_t client = socket_network_client(
112 "127.0.0.1", socket_get_local_port(server), SOCK_STREAM);
113 cutils_socket_t handler = accept(server, nullptr, nullptr);
114 EXPECT_EQ(0, socket_close(server));
115
116 TestConnectedSockets(handler, client, SOCK_STREAM);
117 }
118
119 // Tests socket_inaddr_any_server() and socket_network_client() for IPv6 UDP.
TEST(SocketsTest,TestIpv6UdpLoopback)120 TEST(SocketsTest, TestIpv6UdpLoopback) {
121 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM);
122 cutils_socket_t client = socket_network_client(
123 "::1", socket_get_local_port(server), SOCK_DGRAM);
124
125 TestConnectedSockets(server, client, SOCK_DGRAM);
126 }
127
128 // Tests socket_inaddr_any_server() and socket_network_client() for IPv6 TCP.
TEST(SocketsTest,TestIpv6TcpLoopback)129 TEST(SocketsTest, TestIpv6TcpLoopback) {
130 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM);
131 ASSERT_NE(INVALID_SOCKET, server);
132
133 cutils_socket_t client = socket_network_client(
134 "::1", socket_get_local_port(server), SOCK_STREAM);
135 cutils_socket_t handler = accept(server, nullptr, nullptr);
136 EXPECT_EQ(0, socket_close(server));
137
138 TestConnectedSockets(handler, client, SOCK_STREAM);
139 }
140
141 // Tests socket_send_buffers() failure.
TEST(SocketsTest,TestSocketSendBuffersFailure)142 TEST(SocketsTest, TestSocketSendBuffersFailure) {
143 EXPECT_EQ(-1, socket_send_buffers(INVALID_SOCKET, nullptr, 0));
144 }
145