1 /*
2 * Copyright (C) 2014 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 #include <gtest/gtest.h>
18
19 #include <errno.h>
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <sys/un.h>
23 #include <fcntl.h>
24
25 #if defined(__BIONIC__)
26 #define ACCEPT4_SUPPORTED 1
27 #define RECVMMSG_SUPPORTED 1
28 #define SENDMMSG_SUPPORTED 1
29 #elif defined(__GLIBC_PREREQ)
30 #if __GLIBC_PREREQ(2, 9)
31 #define ACCEPT4_SUPPORTED 1
32 #endif
33 #if __GLIBC_PREREQ(2, 12)
34 #define RECVMMSG_SUPPORTED 1
35 #endif
36 #if __GLIBC_PREREQ(2, 14)
37 #define SENDMMSG_SUPPORTED 1
38 #endif
39 #endif
40
41 #if defined(ACCEPT4_SUPPORTED) || defined(RECVMMSG_SUPPORTED) || defined(SENDMMSG_SUPPORTED)
42
43 #define SOCK_PATH "test"
44
ConnectFn(void * data)45 static void* ConnectFn(void* data) {
46 bool (*callback_fn)(int) = reinterpret_cast<bool (*)(int)>(data);
47 void* return_value = NULL;
48
49 int fd = socket(PF_UNIX, SOCK_SEQPACKET | SOCK_CLOEXEC | SOCK_NONBLOCK, 0);
50 if (fd < 0) {
51 GTEST_LOG_(ERROR) << "socket call failed: " << strerror(errno);
52 return reinterpret_cast<void*>(-1);
53 }
54
55 struct sockaddr_un addr;
56 memset(&addr, 0, sizeof(addr));
57 addr.sun_family = AF_UNIX;
58 addr.sun_path[0] = '\0';
59 strcpy(addr.sun_path + 1, SOCK_PATH);
60
61 if (connect(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr)) < 0) {
62 GTEST_LOG_(ERROR) << "connect call failed: " << strerror(errno);
63 return_value = reinterpret_cast<void*>(-1);
64 }
65 else if (callback_fn != NULL && !callback_fn(fd)) {
66 return_value = reinterpret_cast<void*>(-1);
67 }
68
69 close(fd);
70
71 return return_value;
72 }
73
RunTest(void (* test_fn)(struct sockaddr_un *,int),bool (* callback_fn)(int fd))74 static void RunTest(void (*test_fn)(struct sockaddr_un*, int),
75 bool (*callback_fn)(int fd)) {
76 int fd = socket(PF_UNIX, SOCK_SEQPACKET, 0);
77 ASSERT_NE(fd, -1) << strerror(errno);
78
79 struct sockaddr_un addr;
80 memset(&addr, 0, sizeof(addr));
81 addr.sun_family = AF_UNIX;
82 addr.sun_path[0] = '\0';
83 strcpy(addr.sun_path + 1, SOCK_PATH);
84
85 ASSERT_NE(-1, bind(fd, reinterpret_cast<struct sockaddr*>(&addr), sizeof(addr))) << strerror(errno);
86
87 ASSERT_NE(-1, listen(fd, 1)) << strerror(errno);
88
89 pthread_t thread;
90 ASSERT_EQ(0, pthread_create(&thread, NULL, ConnectFn, reinterpret_cast<void*>(callback_fn)));
91
92 fd_set read_set;
93 FD_ZERO(&read_set);
94 FD_SET(fd, &read_set);
95 timeval tv;
96 tv.tv_sec = 5;
97 tv.tv_usec = 0;
98 ASSERT_LT(0, select(fd+1, &read_set, NULL, NULL, &tv));
99
100 test_fn(&addr, fd);
101
102 void* ret_val;
103 ASSERT_EQ(0, pthread_join(thread, &ret_val));
104 ASSERT_EQ(NULL, ret_val);
105
106 close(fd);
107 }
108 #endif
109
TEST(sys_socket,accept4_error)110 TEST(sys_socket, accept4_error) {
111 #if defined(ACCEPT4_SUPPORTED)
112 ASSERT_EQ(-1, accept4(-1, NULL, NULL, 0));
113 ASSERT_EQ(EBADF, errno);
114 #else
115 GTEST_LOG_(INFO) << "This test does nothing.\n";
116 #endif
117 }
118
119 #if defined(ACCEPT4_SUPPORTED)
TestAccept4(struct sockaddr_un * addr,int fd)120 static void TestAccept4(struct sockaddr_un* addr, int fd) {
121 socklen_t len = sizeof(*addr);
122 int fd_acc = accept4(fd, reinterpret_cast<struct sockaddr*>(addr), &len, SOCK_CLOEXEC);
123 ASSERT_NE(fd_acc, -1) << strerror(errno);
124
125 // Check that the flag was set properly.
126 ASSERT_EQ(FD_CLOEXEC, fcntl(fd_acc, F_GETFD) & FD_CLOEXEC);
127
128 close(fd_acc);
129 }
130 #endif
131
TEST(sys_socket,accept4_smoke)132 TEST(sys_socket, accept4_smoke) {
133 #if defined(ACCEPT4_SUPPORTED)
134 RunTest(TestAccept4, NULL);
135 #else
136 GTEST_LOG_(INFO) << "This test does nothing.\n";
137 #endif
138 }
139
140 #if defined(RECVMMSG_SUPPORTED)
141 const char* g_RecvMsgs[] = {
142 "RECVMMSG_ONE",
143 "RECVMMSG_TWO",
144 "RECVMMSG_THREE",
145 };
146 #define NUM_RECV_MSGS (sizeof(g_RecvMsgs)/sizeof(const char*))
147
SendMultiple(int fd)148 static bool SendMultiple(int fd) {
149 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
150 if (send(fd, g_RecvMsgs[i], strlen(g_RecvMsgs[i]) + 1, 0) < 0) {
151 GTEST_LOG_(ERROR) << "send call failed: " << strerror(errno);
152 return false;
153 }
154 }
155
156 return true;
157 }
158
TestRecvMMsg(struct sockaddr_un * addr,int fd)159 static void TestRecvMMsg(struct sockaddr_un *addr, int fd) {
160 socklen_t len = sizeof(*addr);
161 int fd_acc = accept(fd, reinterpret_cast<struct sockaddr*>(addr), &len);
162 ASSERT_NE(fd_acc, -1) << strerror(errno);
163
164 struct mmsghdr msgs[NUM_RECV_MSGS];
165 memset(msgs, 0, sizeof(struct mmsghdr)*NUM_RECV_MSGS);
166
167 struct iovec io[NUM_RECV_MSGS];
168 char bufs[NUM_RECV_MSGS][100];
169 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
170 io[i].iov_base = reinterpret_cast<void*>(bufs[i]);
171 io[i].iov_len = strlen(g_RecvMsgs[i]) + 1;
172
173 msgs[i].msg_hdr.msg_iov = &io[i];
174 msgs[i].msg_hdr.msg_iovlen = 1;
175 msgs[i].msg_len = sizeof(struct msghdr);
176 }
177
178 struct timespec ts;
179 memset(&ts, 0, sizeof(ts));
180 ts.tv_sec = 5;
181 ts.tv_nsec = 0;
182 ASSERT_EQ(NUM_RECV_MSGS,
183 static_cast<size_t>(recvmmsg(fd_acc, msgs, NUM_RECV_MSGS, 0, &ts)))
184 << strerror(errno);
185 for (size_t i = 0; i < NUM_RECV_MSGS; i++) {
186 ASSERT_STREQ(g_RecvMsgs[i], bufs[i]);
187 }
188
189 close(fd_acc);
190 }
191 #endif
192
TEST(sys_socket,recvmmsg_smoke)193 TEST(sys_socket, recvmmsg_smoke) {
194 #if defined(RECVMMSG_SUPPORTED)
195 RunTest(TestRecvMMsg, SendMultiple);
196 #else
197 GTEST_LOG_(INFO) << "This test does nothing.\n";
198 #endif
199 }
200
TEST(sys_socket,recvmmsg_error)201 TEST(sys_socket, recvmmsg_error) {
202 #if defined(RECVMMSG_SUPPORTED)
203 ASSERT_EQ(-1, recvmmsg(-1, NULL, 0, 0, NULL));
204 ASSERT_EQ(EBADF, errno);
205 #else
206 GTEST_LOG_(INFO) << "This test does nothing.\n";
207 #endif
208 }
209
210 #if defined(SENDMMSG_SUPPORTED)
211 const char* g_SendMsgs[] = {
212 "MSG_ONE",
213 "MSG_TWO",
214 "MSG_THREE"
215 };
216 #define NUM_SEND_MSGS (sizeof(g_SendMsgs)/sizeof(const char*))
217
SendMMsg(int fd)218 static bool SendMMsg(int fd) {
219 struct mmsghdr msgs[NUM_SEND_MSGS];
220 memset(msgs, 0, sizeof(struct mmsghdr)*NUM_SEND_MSGS);
221 struct iovec io[NUM_SEND_MSGS];
222 for (size_t i = 0; i < NUM_SEND_MSGS; i++) {
223 io[i].iov_base = reinterpret_cast<void*>(const_cast<char*>(g_SendMsgs[i]));
224 io[i].iov_len = strlen(g_SendMsgs[i]) + 1;
225 msgs[i].msg_hdr.msg_iov = &io[i];
226 msgs[i].msg_hdr.msg_iovlen = 1;
227 msgs[i].msg_len = sizeof(struct msghdr);
228 }
229
230 if (sendmmsg(fd, msgs, NUM_SEND_MSGS, 0) < 0) {
231 GTEST_LOG_(ERROR) << "sendmmsg call failed: " << strerror(errno);
232 return false;
233 }
234 return true;
235 }
236
TestSendMMsg(struct sockaddr_un * addr,int fd)237 static void TestSendMMsg(struct sockaddr_un *addr, int fd) {
238 socklen_t len = sizeof(*addr);
239 int fd_acc = accept(fd, reinterpret_cast<struct sockaddr*>(addr), &len);
240 ASSERT_NE(fd_acc, -1) << strerror(errno);
241
242 fd_set read_set;
243 FD_ZERO(&read_set);
244 FD_SET(fd_acc, &read_set);
245
246 for (size_t i = 0; i < NUM_SEND_MSGS; i++) {
247 timeval tv;
248 tv.tv_sec = 5;
249 tv.tv_usec = 0;
250 ASSERT_LT(0, select(fd_acc+1, &read_set, NULL, NULL, &tv));
251 char buffer[100];
252 ASSERT_EQ(strlen(g_SendMsgs[i]) + 1,
253 static_cast<size_t>(recv(fd_acc, buffer, sizeof(buffer), 0)));
254 ASSERT_STREQ(g_SendMsgs[i], buffer);
255 }
256
257 close(fd_acc);
258 }
259 #endif
260
TEST(sys_socket,sendmmsg_smoke)261 TEST(sys_socket, sendmmsg_smoke) {
262 #if defined(SENDMMSG_SUPPORTED)
263 RunTest(TestSendMMsg, SendMMsg);
264 #else
265 GTEST_LOG_(INFO) << "This test does nothing.\n";
266 #endif
267 }
268
TEST(sys_socket,sendmmsg_error)269 TEST(sys_socket, sendmmsg_error) {
270 #if defined(SENDMMSG_SUPPORTED)
271 ASSERT_EQ(-1, sendmmsg(-1, NULL, 0, 0));
272 ASSERT_EQ(EBADF, errno);
273 #else
274 GTEST_LOG_(INFO) << "This test does nothing.\n";
275 #endif
276 }
277