sys_socket_test.cpp revision b760164dd67929789a4732ed3f5df56a4b66c3ae 
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
45static 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
74static 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
110TEST(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)
120static 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
132TEST(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)
141const 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
148static 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
159static 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
193TEST(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
201TEST(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)
211const 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
218static 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
237static 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
261TEST(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
269TEST(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