1 /*
2 *
3 * Copyright (c) International Business Machines Corp., 2001
4 * Copyright (c) Cyril Hrubis <chrubis@suse.cz> 2012
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
14 * the GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 */
20
21 /*
22 * Test Name: sendto01
23 *
24 * Test Description:
25 * Verify that sendto() returns the proper errno for various failure cases
26 *
27 * HISTORY
28 * 07/2001 Ported by Wayne Boyer
29 */
30
31 #include <stdio.h>
32 #include <unistd.h>
33 #include <errno.h>
34 #include <fcntl.h>
35
36 #include <sys/types.h>
37 #include <sys/socket.h>
38 #include <sys/signal.h>
39 #include <sys/un.h>
40
41 #include <netinet/in.h>
42
43 #include "test.h"
44 #include "safe_macros.h"
45
46 char *TCID = "sendto01";
47 int testno;
48
49 static char buf[1024], bigbuf[128 * 1024];
50 static int s;
51 static struct sockaddr_in sin1, sin2;
52 static int sfd;
53
54 struct test_case_t { /* test case structure */
55 int domain; /* PF_INET, PF_UNIX, ... */
56 int type; /* SOCK_STREAM, SOCK_DGRAM ... */
57 int proto; /* protocol number (usually 0 = default) */
58 void *buf; /* send data buffer */
59 int buflen; /* send's 3rd argument */
60 unsigned flags; /* send's 4th argument */
61 struct sockaddr_in *to; /* destination */
62 int tolen; /* length of "to" buffer */
63 int retval;
64 int experrno;
65 void (*setup) (void);
66 void (*cleanup) (void);
67 char *desc;
68 };
69
70 static void setup(void);
71 static void setup0(void);
72 static void setup1(void);
73 static void setup2(void);
74 static void setup3(void);
75 static void cleanup(void);
76 static void cleanup0(void);
77 static void cleanup1(void);
78 static void do_child(void);
79
80 struct test_case_t tdat[] = {
81 {.domain = PF_INET,
82 .type = SOCK_STREAM,
83 .proto = 0,
84 .buf = buf,
85 .buflen = sizeof(buf),
86 .flags = 0,
87 .to = &sin1,
88 .tolen = sizeof(sin1),
89 .retval = -1,
90 .experrno = EBADF,
91 .setup = setup0,
92 .cleanup = cleanup0,
93 .desc = "bad file descriptor"}
94 ,
95 {.domain = 0,
96 .type = 0,
97 .proto = 0,
98 .buf = buf,
99 .buflen = sizeof(buf),
100 .flags = 0,
101 .to = &sin1,
102 .tolen = sizeof(sin1),
103 .retval = -1,
104 .experrno = ENOTSOCK,
105 .setup = setup0,
106 .cleanup = cleanup0,
107 .desc = "invalid socket"}
108 ,
109 #ifndef UCLINUX
110 /* Skip since uClinux does not implement memory protection */
111 {.domain = PF_INET,
112 .type = SOCK_DGRAM,
113 .proto = 0,
114 .buf = (void *)-1,
115 .buflen = sizeof(buf),
116 .flags = 0,
117 .to = &sin1,
118 .tolen = sizeof(sin1),
119 .retval = -1,
120 .experrno = EFAULT,
121 .setup = setup1,
122 .cleanup = cleanup1,
123 .desc = "invalid send buffer"}
124 ,
125 #endif
126 {.domain = PF_INET,
127 .type = SOCK_STREAM,
128 .proto = 0,
129 .buf = buf,
130 .buflen = sizeof(buf),
131 .flags = 0,
132 .to = &sin2,
133 .tolen = sizeof(sin2),
134 .retval = 0,
135 .experrno = EFAULT,
136 .setup = setup1,
137 .cleanup = cleanup1,
138 .desc = "connected TCP"}
139 ,
140 {.domain = PF_INET,
141 .type = SOCK_STREAM,
142 .proto = 0,
143 .buf = buf,
144 .buflen = sizeof(buf),
145 .flags = 0,
146 .to = &sin1,
147 .tolen = sizeof(sin1),
148 .retval = -1,
149 .experrno = EPIPE,
150 .setup = setup3,
151 .cleanup = cleanup1,
152 .desc = "not connected TCP"}
153 ,
154 {.domain = PF_INET,
155 .type = SOCK_DGRAM,
156 .proto = 0,
157 .buf = buf,
158 .buflen = sizeof(buf),
159 .flags = 0,
160 .to = &sin1,
161 .tolen = -1,
162 .retval = -1,
163 .experrno = EINVAL,
164 .setup = setup1,
165 .cleanup = cleanup1,
166 .desc = "invalid to buffer length"}
167 ,
168 #ifndef UCLINUX
169 /* Skip since uClinux does not implement memory protection */
170 {.domain = PF_INET,
171 .type = SOCK_DGRAM,
172 .proto = 0,
173 .buf = buf,
174 .buflen = sizeof(buf),
175 .flags = 0,
176 .to = (struct sockaddr_in *)-1,
177 .tolen = sizeof(sin1),
178 .retval = -1,
179 .experrno = EFAULT,
180 .setup = setup1,
181 .cleanup = cleanup1,
182 .desc = "invalid to buffer"}
183 ,
184 #endif
185 {.domain = PF_INET,
186 .type = SOCK_DGRAM,
187 .proto = 0,
188 .buf = bigbuf,
189 .buflen = sizeof(bigbuf),
190 .flags = 0,
191 .to = &sin1,
192 .tolen = sizeof(sin1),
193 .retval = -1,
194 .experrno = EMSGSIZE,
195 .setup = setup1,
196 .cleanup = cleanup1,
197 .desc = "UDP message too big"}
198 ,
199 {.domain = PF_INET,
200 .type = SOCK_STREAM,
201 .proto = 0,
202 .buf = buf,
203 .buflen = sizeof(buf),
204 .flags = 0,
205 .to = &sin1,
206 .tolen = sizeof(sin1),
207 .retval = -1,
208 .experrno = EPIPE,
209 .setup = setup2,
210 .cleanup = cleanup1,
211 .desc = "local endpoint shutdown"}
212 ,
213 {.domain = PF_INET,
214 .type = SOCK_DGRAM,
215 .proto = 0,
216 .buf = buf,
217 .buflen = sizeof(buf),
218 .flags = MSG_OOB,
219 .to = &sin1,
220 .tolen = sizeof(sin1),
221 .retval = -1,
222 .experrno = EOPNOTSUPP,
223 .setup = setup1,
224 .cleanup = cleanup1,
225 .desc = "invalid flags set"}
226 };
227
228 int TST_TOTAL = sizeof(tdat) / sizeof(tdat[0]);
229
230 #ifdef UCLINUX
231 static char *argv0;
232 #endif
233
start_server(struct sockaddr_in * sin0)234 static pid_t start_server(struct sockaddr_in *sin0)
235 {
236 pid_t pid;
237 socklen_t slen = sizeof(*sin0);
238
239 sin0->sin_family = AF_INET;
240 sin0->sin_port = 0; /* pick random free port */
241 sin0->sin_addr.s_addr = INADDR_ANY;
242
243 sfd = socket(PF_INET, SOCK_STREAM, 0);
244 if (sfd < 0) {
245 tst_brkm(TBROK | TERRNO, cleanup, "server socket failed");
246 return -1;
247 }
248 if (bind(sfd, (struct sockaddr *)sin0, sizeof(*sin0)) < 0) {
249 tst_brkm(TBROK | TERRNO, cleanup, "server bind failed");
250 return -1;
251 }
252 if (listen(sfd, 10) < 0) {
253 tst_brkm(TBROK | TERRNO, cleanup, "server listen failed");
254 return -1;
255 }
256 SAFE_GETSOCKNAME(cleanup, sfd, (struct sockaddr *)sin0, &slen);
257
258 switch ((pid = FORK_OR_VFORK())) {
259 case 0:
260 #ifdef UCLINUX
261 if (self_exec(argv0, "d", sfd) < 0)
262 tst_brkm(TBROK | TERRNO, cleanup,
263 "server self_exec failed");
264 #else
265 do_child();
266 #endif
267 break;
268 case -1:
269 tst_brkm(TBROK | TERRNO, cleanup, "server fork failed");
270 default:
271 (void)close(sfd);
272 return pid;
273 }
274
275 exit(1);
276 }
277
do_child(void)278 static void do_child(void)
279 {
280 struct sockaddr_in fsin;
281 fd_set afds, rfds;
282 int nfds, cc, fd;
283
284 FD_ZERO(&afds);
285 FD_SET(sfd, &afds);
286
287 nfds = sfd + 1;
288
289 /* accept connections until killed */
290 while (1) {
291 socklen_t fromlen;
292
293 memcpy(&rfds, &afds, sizeof(rfds));
294
295 if (select(nfds, &rfds, NULL, NULL, NULL) < 0 && errno != EINTR)
296 exit(1);
297
298 if (FD_ISSET(sfd, &rfds)) {
299 int newfd;
300
301 fromlen = sizeof(fsin);
302 newfd = accept(sfd, (struct sockaddr *)&fsin, &fromlen);
303 if (newfd >= 0) {
304 FD_SET(newfd, &afds);
305 nfds = MAX(nfds, newfd + 1);
306 }
307 }
308 for (fd = 0; fd < nfds; ++fd) {
309 if (fd != sfd && FD_ISSET(fd, &rfds)) {
310 cc = read(fd, buf, sizeof(buf));
311 if (cc == 0 || (cc < 0 && errno != EINTR)) {
312 (void)close(fd);
313 FD_CLR(fd, &afds);
314 }
315 }
316 }
317 }
318 }
319
main(int ac,char * av[])320 int main(int ac, char *av[])
321 {
322 int lc;
323
324 tst_parse_opts(ac, av, NULL, NULL);
325
326 #ifdef UCLINUX
327 argv0 = av[0];
328 maybe_run_child(&do_child, "d", &sfd);
329 #endif
330
331 setup();
332
333 for (lc = 0; TEST_LOOPING(lc); ++lc) {
334
335 tst_count = 0;
336 for (testno = 0; testno < TST_TOTAL; ++testno) {
337 tdat[testno].setup();
338
339 TEST(sendto(s, tdat[testno].buf, tdat[testno].buflen,
340 tdat[testno].flags,
341 (const struct sockaddr *)tdat[testno].to,
342 tdat[testno].tolen));
343
344 if (TEST_RETURN > 0)
345 TEST_RETURN = 0;
346
347 if (TEST_RETURN != tdat[testno].retval ||
348 (TEST_RETURN < 0 &&
349 TEST_ERRNO != tdat[testno].experrno)) {
350 tst_resm(TFAIL, "%s ; returned"
351 " %ld (expected %d), errno %d (expected"
352 " %d)", tdat[testno].desc,
353 TEST_RETURN, tdat[testno].retval,
354 TEST_ERRNO, tdat[testno].experrno);
355 } else {
356 tst_resm(TPASS, "%s successful",
357 tdat[testno].desc);
358 }
359 tdat[testno].cleanup();
360 }
361 }
362 cleanup();
363
364 tst_exit();
365 }
366
367 static pid_t server_pid;
368
setup(void)369 static void setup(void)
370 {
371 TEST_PAUSE;
372
373 server_pid = start_server(&sin1);
374
375 signal(SIGPIPE, SIG_IGN);
376 }
377
cleanup(void)378 static void cleanup(void)
379 {
380 kill(server_pid, SIGKILL);
381 }
382
setup0(void)383 static void setup0(void)
384 {
385 if (tdat[testno].experrno == EBADF)
386 s = 400;
387 else if ((s = open("/dev/null", O_WRONLY)) == -1)
388 tst_brkm(TBROK | TERRNO, cleanup, "open(/dev/null) failed");
389 }
390
cleanup0(void)391 static void cleanup0(void)
392 {
393 s = -1;
394 }
395
setup1(void)396 static void setup1(void)
397 {
398 s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
399 tdat[testno].proto);
400 SAFE_CONNECT(cleanup, s, (const struct sockaddr *)&sin1, sizeof(sin1));
401 }
402
cleanup1(void)403 static void cleanup1(void)
404 {
405 (void)close(s);
406 s = -1;
407 }
408
setup2(void)409 static void setup2(void)
410 {
411 setup1();
412 if (shutdown(s, 1) < 0)
413 tst_brkm(TBROK | TERRNO, cleanup, "socket setup failed connect "
414 "test %d", testno);
415 }
416
setup3(void)417 static void setup3(void)
418 {
419 s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
420 tdat[testno].proto);
421 }
422