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 <time.h> 23 24 #include <cutils/sockets.h> 25 #include <gtest/gtest.h> 26 27 // Makes sure the passed sockets are valid, sends data between them, and closes 28 // them. Any failures are logged with gtest. 29 // 30 // On Mac recvfrom() will not fill in the address for TCP sockets, so we need 31 // separate logic paths depending on socket type. TestConnectedSockets(cutils_socket_t server,cutils_socket_t client,int type)32 static void TestConnectedSockets(cutils_socket_t server, cutils_socket_t client, 33 int type) { 34 ASSERT_NE(INVALID_SOCKET, server); 35 ASSERT_NE(INVALID_SOCKET, client); 36 37 char buffer[128]; 38 sockaddr_storage addr; 39 socklen_t addr_size = sizeof(addr); 40 41 // Send client -> server first to get the UDP client's address. 42 ASSERT_EQ(3, send(client, "foo", 3, 0)); 43 if (type == SOCK_DGRAM) { 44 EXPECT_EQ(3, recvfrom(server, buffer, sizeof(buffer), 0, 45 reinterpret_cast<sockaddr*>(&addr), &addr_size)); 46 } else { 47 EXPECT_EQ(3, recv(server, buffer, sizeof(buffer), 0)); 48 } 49 EXPECT_EQ(0, memcmp(buffer, "foo", 3)); 50 51 // Now send server -> client. 52 if (type == SOCK_DGRAM) { 53 ASSERT_EQ(3, sendto(server, "bar", 3, 0, 54 reinterpret_cast<sockaddr*>(&addr), addr_size)); 55 } else { 56 ASSERT_EQ(3, send(server, "bar", 3, 0)); 57 } 58 EXPECT_EQ(3, recv(client, buffer, sizeof(buffer), 0)); 59 EXPECT_EQ(0, memcmp(buffer, "bar", 3)); 60 61 // Send multiple buffers using socket_send_buffers(). 62 std::string data[] = {"foo", "bar", "12345"}; 63 cutils_socket_buffer_t socket_buffers[] = { {data[0].data(), data[0].length()}, 64 {data[1].data(), data[1].length()}, 65 {data[2].data(), data[2].length()} }; 66 EXPECT_EQ(11, socket_send_buffers(client, socket_buffers, 3)); 67 EXPECT_EQ(11, recv(server, buffer, sizeof(buffer), 0)); 68 EXPECT_EQ(0, memcmp(buffer, "foobar12345", 11)); 69 70 EXPECT_EQ(0, socket_close(server)); 71 EXPECT_EQ(0, socket_close(client)); 72 } 73 74 // Tests socket_get_local_port(). TEST(SocketsTest,TestGetLocalPort)75 TEST(SocketsTest, TestGetLocalPort) { 76 cutils_socket_t server; 77 78 // Check a bunch of ports so that we can ignore any conflicts in case 79 // of ports already being taken, but if a server is able to start up we 80 // should always be able to read its port. 81 for (int port : {10000, 12345, 15999, 20202, 25000}) { 82 for (int type : {SOCK_DGRAM, SOCK_STREAM}) { 83 server = socket_inaddr_any_server(port, type); 84 if (server != INVALID_SOCKET) { 85 EXPECT_EQ(port, socket_get_local_port(server)); 86 } 87 socket_close(server); 88 } 89 } 90 91 // Check expected failure for an invalid socket. 92 EXPECT_EQ(-1, socket_get_local_port(INVALID_SOCKET)); 93 } 94 95 // Tests socket_inaddr_any_server() and socket_network_client() for IPv4 UDP. TEST(SocketsTest,TestIpv4UdpLoopback)96 TEST(SocketsTest, TestIpv4UdpLoopback) { 97 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM); 98 cutils_socket_t client = socket_network_client( 99 "127.0.0.1", socket_get_local_port(server), SOCK_DGRAM); 100 101 TestConnectedSockets(server, client, SOCK_DGRAM); 102 } 103 104 // Tests socket_inaddr_any_server() and socket_network_client() for IPv4 TCP. TEST(SocketsTest,TestIpv4TcpLoopback)105 TEST(SocketsTest, TestIpv4TcpLoopback) { 106 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM); 107 ASSERT_NE(INVALID_SOCKET, server); 108 109 cutils_socket_t client = socket_network_client( 110 "127.0.0.1", socket_get_local_port(server), SOCK_STREAM); 111 cutils_socket_t handler = accept(server, nullptr, nullptr); 112 EXPECT_EQ(0, socket_close(server)); 113 114 TestConnectedSockets(handler, client, SOCK_STREAM); 115 } 116 117 // Tests socket_inaddr_any_server() and socket_network_client() for IPv6 UDP. TEST(SocketsTest,TestIpv6UdpLoopback)118 TEST(SocketsTest, TestIpv6UdpLoopback) { 119 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_DGRAM); 120 cutils_socket_t client = socket_network_client( 121 "::1", socket_get_local_port(server), SOCK_DGRAM); 122 123 TestConnectedSockets(server, client, SOCK_DGRAM); 124 } 125 126 // Tests socket_inaddr_any_server() and socket_network_client() for IPv6 TCP. TEST(SocketsTest,TestIpv6TcpLoopback)127 TEST(SocketsTest, TestIpv6TcpLoopback) { 128 cutils_socket_t server = socket_inaddr_any_server(0, SOCK_STREAM); 129 ASSERT_NE(INVALID_SOCKET, server); 130 131 cutils_socket_t client = socket_network_client( 132 "::1", socket_get_local_port(server), SOCK_STREAM); 133 cutils_socket_t handler = accept(server, nullptr, nullptr); 134 EXPECT_EQ(0, socket_close(server)); 135 136 TestConnectedSockets(handler, client, SOCK_STREAM); 137 } 138 139 // Tests socket_send_buffers() failure. TEST(SocketsTest,TestSocketSendBuffersFailure)140 TEST(SocketsTest, TestSocketSendBuffersFailure) { 141 EXPECT_EQ(-1, socket_send_buffers(INVALID_SOCKET, nullptr, 0)); 142 } 143