1 /*
2 *
3 * Copyright (c) International Business Machines Corp., 2001
4 * Copyright (c) Cyril Hrubis <[email protected]> 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 /*
23 * Test Name: sendmsg01
24 *
25 * Test Description:
26 * Verify that sendmsg() returns the proper errno for various failure cases
27 *
28 * HISTORY
29 * 07/2001 Ported by Wayne Boyer
30 * 05/2003 Modified by Manoj Iyer - Make setup function set up lo device.
31 */
32
33 #include <stdio.h>
34 #include <unistd.h>
35 #include <errno.h>
36 #include <string.h>
37 #include <fcntl.h>
38 #include <time.h>
39 #include <stdlib.h>
40 #include <sys/types.h>
41 #include <sys/socket.h>
42 #include <sys/signal.h>
43 #include <sys/uio.h>
44 #include <sys/un.h>
45 #include <sys/file.h>
46 #include <sys/wait.h>
47
48 #include <netinet/in.h>
49
50 #include "test.h"
51 #include "safe_macros.h"
52
53 char *TCID = "sendmsg01";
54 int testno;
55
56 static char buf[1024], bigbuf[128 * 1024];
57 static int s;
58 static struct sockaddr_in sin1, sin2;
59 static struct sockaddr_un sun1;
60 static struct msghdr msgdat;
61 static char cbuf[4096];
62 static struct cmsghdr *control;
63 static int controllen;
64 static struct iovec iov[1];
65 static int sfd; /* shared between do_child and start_server */
66 static int ufd; /* shared between do_child and start_server */
67
68 static void setup(void);
69 static void setup0(void);
70 static void setup1(void);
71 static void setup2(void);
72 static void setup3(void);
73 static void setup4(void);
74 static void setup5(void);
75 static void setup6(void);
76 static void setup8(void);
77
78 static void cleanup(void);
79 static void cleanup0(void);
80 static void cleanup1(void);
81 static void cleanup4(void);
82
83 static void do_child(void);
84
85 struct test_case_t { /* test case structure */
86 int domain; /* PF_INET, PF_UNIX, ... */
87 int type; /* SOCK_STREAM, SOCK_DGRAM ... */
88 int proto; /* protocol number (usually 0 = default) */
89 struct iovec *iov;
90 int iovcnt; /* # elements in iovec */
91 void *buf; /* send data buffer */
92 int buflen; /* send buffer length */
93 struct msghdr *msg;
94 unsigned flags;
95 struct sockaddr *to; /* destination */
96 int tolen; /* length of "to" buffer */
97 int retval; /* syscall return value */
98 int experrno; /* expected errno */
99 void (*setup) (void);
100 void (*cleanup) (void);
101 char *desc;
102 };
103
104 struct test_case_t tdat[] = {
105 {.domain = PF_INET,
106 .type = SOCK_STREAM,
107 .proto = 0,
108 .iov = iov,
109 .iovcnt = 1,
110 .buf = buf,
111 .buflen = sizeof(buf),
112 .msg = &msgdat,
113 .flags = 0,
114 .to = (struct sockaddr *)&sin1,
115 .tolen = sizeof(sin1),
116 .retval = -1,
117 .experrno = EBADF,
118 .setup = setup0,
119 .cleanup = cleanup0,
120 .desc = "bad file descriptor"}
121 ,
122 {.domain = 0,
123 .type = 0,
124 .proto = 0,
125 .iov = iov,
126 .iovcnt = 1,
127 .buf = buf,
128 .buflen = sizeof(buf),
129 .msg = &msgdat,
130 .flags = 0,
131 .to = (struct sockaddr *)&sin1,
132 .tolen = sizeof(sin1),
133 .retval = -1,
134 .experrno = ENOTSOCK,
135 .setup = setup0,
136 .cleanup = cleanup0,
137 .desc = "invalid socket"}
138 ,
139 {.domain = PF_INET,
140 .type = SOCK_DGRAM,
141 .proto = 0,
142 .iov = iov,
143 .iovcnt = 1,
144 .buf = (void *)-1,
145 .buflen = sizeof(buf),
146 .msg = &msgdat,
147 .flags = 0,
148 .to = (struct sockaddr *)&sin1,
149 .tolen = sizeof(sin1),
150 .retval = -1,
151 .experrno = EFAULT,
152 .setup = setup1,
153 .cleanup = cleanup1,
154 .desc = "invalid send buffer"}
155 ,
156 {.domain = PF_INET,
157 .type = SOCK_STREAM,
158 .proto = 0,
159 .iov = iov,
160 .iovcnt = 1,
161 .buf = buf,
162 .buflen = sizeof(buf),
163 .msg = &msgdat,
164 .flags = 0,
165 .to = (struct sockaddr *)&sin2,
166 .tolen = sizeof(sin2),
167 .retval = 0,
168 .experrno = EFAULT,
169 .setup = setup5,
170 .cleanup = cleanup1,
171 .desc = "connected TCP"}
172 ,
173 {.domain = PF_INET,
174 .type = SOCK_STREAM,
175 .proto = 0,
176 .iov = iov,
177 .iovcnt = 1,
178 .buf = buf,
179 .buflen = sizeof(buf),
180 .msg = &msgdat,
181 .flags = 0,
182 .to = (struct sockaddr *)&sin1,
183 .tolen = sizeof(sin1),
184 .retval = -1,
185 .experrno = EPIPE,
186 .setup = setup3,
187 .cleanup = cleanup1,
188 .desc = "not connected TCP"}
189 ,
190 {.domain = PF_INET,
191 .type = SOCK_DGRAM,
192 .proto = 0,
193 .iov = iov,
194 .iovcnt = 1,
195 .buf = buf,
196 .buflen = sizeof(buf),
197 .msg = &msgdat,
198 .flags = 0,
199 .to = (struct sockaddr *)&sin1,
200 .tolen = 1,
201 .retval = -1,
202 .experrno = EINVAL,
203 .setup = setup1,
204 .cleanup = cleanup1,
205 .desc = "invalid to buffer length"},
206 {.domain = PF_INET,
207 .type = SOCK_DGRAM,
208 .proto = 0,
209 .iov = iov,
210 .iovcnt = 1,
211 .buf = buf,
212 .buflen = sizeof(buf),
213 .msg = &msgdat,
214 .flags = 0,
215 .to = (struct sockaddr *)-1,
216 .tolen = sizeof(struct sockaddr),
217 .retval = -1,
218 .experrno = EFAULT,
219 .setup = setup1,
220 .cleanup = cleanup1,
221 .desc = "invalid to buffer"},
222 {.domain = PF_INET,
223 .type = SOCK_DGRAM,
224 .proto = 0,
225 .iov = iov,
226 .iovcnt = 1,
227 .buf = bigbuf,
228 .buflen = sizeof(bigbuf),
229 .msg = &msgdat,
230 .flags = 0,
231 .to = (struct sockaddr *)&sin1,
232 .tolen = sizeof(sin1),
233 .retval = -1,
234 .experrno = EMSGSIZE,
235 .setup = setup1,
236 .cleanup = cleanup1,
237 .desc = "UDP message too big"}
238 ,
239 {.domain = PF_INET,
240 .type = SOCK_STREAM,
241 .proto = 0,
242 .iov = iov,
243 .iovcnt = 1,
244 .buf = buf,
245 .buflen = sizeof(buf),
246 .msg = &msgdat,
247 .flags = 0,
248 .to = (struct sockaddr *)&sin1,
249 .tolen = sizeof(sin1),
250 .retval = -1,
251 .experrno = EPIPE,
252 .setup = setup2,
253 .cleanup = cleanup1,
254 .desc = "local endpoint shutdown"}
255 ,
256 {.domain = PF_INET,
257 .type = SOCK_STREAM,
258 .proto = 0,
259 .iov = NULL,
260 .iovcnt = 1,
261 .buf = buf,
262 .buflen = sizeof(buf),
263 .msg = &msgdat,
264 .flags = 0,
265 .to = (struct sockaddr *)&sin1,
266 .tolen = sizeof(sin1),
267 .retval = -1,
268 .experrno = EFAULT,
269 .setup = setup1,
270 .cleanup = cleanup1,
271 .desc = "invalid iovec pointer"}
272 ,
273 {.domain = PF_INET,
274 .type = SOCK_STREAM,
275 .proto = 0,
276 .iov = iov,
277 .iovcnt = 1,
278 .buf = buf,
279 .buflen = sizeof(buf),
280 .msg = NULL,
281 .flags = 0,
282 .to = (struct sockaddr *)&sin1,
283 .tolen = sizeof(sin1),
284 .retval = -1,
285 .experrno = EFAULT,
286 .setup = setup1,
287 .cleanup = cleanup1,
288 .desc = "invalid msghdr pointer"}
289 ,
290 {.domain = PF_UNIX,
291 .type = SOCK_DGRAM,
292 .proto = 0,
293 .iov = iov,
294 .iovcnt = 1,
295 .buf = buf,
296 .buflen = sizeof(buf),
297 .msg = &msgdat,
298 .flags = 0,
299 .to = (struct sockaddr *)&sun1,
300 .tolen = sizeof(sun1),
301 .retval = 0,
302 .experrno = 0,
303 .setup = setup4,
304 .cleanup = cleanup4,
305 .desc = "rights passing"}
306 ,
307 {.domain = PF_INET,
308 .type = SOCK_DGRAM,
309 .proto = 0,
310 .iov = iov,
311 .iovcnt = 1,
312 .buf = buf,
313 .buflen = sizeof(buf),
314 .msg = &msgdat,
315 .flags = MSG_OOB,
316 .to = (struct sockaddr *)&sin1,
317 .tolen = sizeof(sin1),
318 .retval = -1,
319 .experrno = EOPNOTSUPP,
320 .setup = setup1,
321 .cleanup = cleanup1,
322 .desc = "invalid flags set"}
323 ,
324 {.domain = PF_UNIX,
325 .type = SOCK_DGRAM,
326 .proto = 0,
327 .iov = iov,
328 .iovcnt = 1,
329 .buf = buf,
330 .buflen = sizeof(buf),
331 .msg = &msgdat,
332 .flags = 0,
333 .to = (struct sockaddr *)&sun1,
334 .tolen = sizeof(sun1),
335 .retval = 0,
336 .experrno = EOPNOTSUPP,
337 .setup = setup6,
338 .cleanup = cleanup4,
339 .desc = "invalid cmsg length"}
340 ,
341 {.domain = PF_UNIX,
342 .type = SOCK_DGRAM,
343 .proto = 0,
344 .iov = iov,
345 .iovcnt = 1,
346 .buf = buf,
347 .buflen = sizeof(buf),
348 .msg = &msgdat,
349 .flags = 0,
350 .to = (struct sockaddr *)&sun1,
351 .tolen = sizeof(sun1),
352 .retval = -1,
353 .experrno = EFAULT,
354 .setup = setup8,
355 .cleanup = cleanup4,
356 .desc = "invalid cmsg pointer"}
357 };
358
359 int TST_TOTAL = sizeof(tdat) / sizeof(tdat[0]);
360
main(int argc,char * argv[])361 int main(int argc, char *argv[])
362 {
363 int lc;
364
365 tst_parse_opts(argc, argv, NULL, NULL);
366
367 setup();
368
369 for (lc = 0; TEST_LOOPING(lc); ++lc) {
370 tst_count = 0;
371 for (testno = 0; testno < TST_TOTAL; ++testno) {
372 tdat[testno].setup();
373
374 iov[0].iov_base = tdat[testno].buf;
375 iov[0].iov_len = tdat[testno].buflen;
376 if (tdat[testno].type != SOCK_STREAM) {
377 msgdat.msg_name = tdat[testno].to;
378 msgdat.msg_namelen = tdat[testno].tolen;
379 }
380 msgdat.msg_iov = tdat[testno].iov;
381 msgdat.msg_iovlen = tdat[testno].iovcnt;
382 msgdat.msg_control = control;
383 msgdat.msg_controllen = controllen;
384 msgdat.msg_flags = 0;
385
386 TEST(sendmsg(s, tdat[testno].msg, tdat[testno].flags));
387
388 if (TEST_RETURN > 0)
389 TEST_RETURN = 0;
390
391 if (TEST_RETURN != tdat[testno].retval ||
392 (TEST_RETURN < 0 &&
393 TEST_ERRNO != tdat[testno].experrno)) {
394 tst_resm(TFAIL, "%s ; returned"
395 " %ld (expected %d), errno %d (expected"
396 " %d)", tdat[testno].desc,
397 TEST_RETURN, tdat[testno].retval,
398 TEST_ERRNO, tdat[testno].experrno);
399 } else {
400 tst_resm(TPASS, "%s successful",
401 tdat[testno].desc);
402 }
403 tdat[testno].cleanup();
404 }
405 }
406 cleanup();
407 tst_exit();
408 }
409
start_server(struct sockaddr_in * sin0,struct sockaddr_un * sun0)410 static pid_t start_server(struct sockaddr_in *sin0, struct sockaddr_un *sun0)
411 {
412 pid_t pid;
413 socklen_t slen = sizeof(*sin0);
414
415 sin0->sin_family = AF_INET;
416 sin0->sin_port = 0; /* pick random free port */
417 sin0->sin_addr.s_addr = INADDR_ANY;
418
419 /* set up inet socket */
420 sfd = socket(PF_INET, SOCK_STREAM, 0);
421 if (sfd < 0) {
422 tst_brkm(TBROK, cleanup, "server socket failed: %s",
423 strerror(errno));
424 return -1;
425 }
426 if (bind(sfd, (struct sockaddr *)sin0, sizeof(*sin0)) < 0) {
427 tst_brkm(TBROK, cleanup, "server bind failed: %s",
428 strerror(errno));
429 return -1;
430 }
431 if (listen(sfd, 10) < 0) {
432 tst_brkm(TBROK, cleanup, "server listen failed: %s",
433 strerror(errno));
434 return -1;
435 }
436 SAFE_GETSOCKNAME(cleanup, sfd, (struct sockaddr *)sin0, &slen);
437
438 /* set up UNIX-domain socket */
439 ufd = socket(PF_UNIX, SOCK_DGRAM, 0);
440 if (ufd < 0) {
441 tst_brkm(TBROK, cleanup, "server UD socket failed: %s",
442 strerror(errno));
443 return -1;
444 }
445 if (bind(ufd, (struct sockaddr *)sun0, sizeof(*sun0))) {
446 tst_brkm(TBROK, cleanup, "server UD bind failed: %s",
447 strerror(errno));
448 return -1;
449 }
450
451 switch ((pid = tst_fork())) {
452 case 0:
453 do_child();
454 break;
455 case -1:
456 tst_brkm(TBROK, cleanup, "server fork failed: %s",
457 strerror(errno));
458 default:
459 close(sfd);
460 close(ufd);
461 return pid;
462 }
463
464 exit(1);
465 }
466
do_child(void)467 static void do_child(void)
468 {
469 struct sockaddr_in fsin;
470 struct sockaddr_un fsun;
471 fd_set afds, rfds;
472 int nfds, cc, fd;
473
474 FD_ZERO(&afds);
475 FD_SET(sfd, &afds);
476 FD_SET(ufd, &afds);
477
478 nfds = MAX(sfd + 1, ufd + 1);
479
480 /* accept connections until killed */
481 while (1) {
482 socklen_t fromlen;
483
484 memcpy(&rfds, &afds, sizeof(rfds));
485
486 if (select(nfds, &rfds, NULL, NULL, NULL) < 0)
487 if (errno != EINTR)
488 exit(1);
489 if (FD_ISSET(sfd, &rfds)) {
490 int newfd;
491
492 fromlen = sizeof(fsin);
493 newfd = accept(sfd, (struct sockaddr *)&fsin, &fromlen);
494 if (newfd >= 0) {
495 FD_SET(newfd, &afds);
496 nfds = MAX(nfds, newfd + 1);
497 }
498 }
499 if (FD_ISSET(ufd, &rfds)) {
500 int newfd;
501
502 fromlen = sizeof(fsun);
503 newfd = accept(ufd, (struct sockaddr *)&fsun, &fromlen);
504 if (newfd >= 0)
505 FD_SET(newfd, &afds);
506 }
507 for (fd = 0; fd < nfds; ++fd) {
508 if (fd != sfd && fd != ufd && FD_ISSET(fd, &rfds)) {
509 cc = read(fd, buf, sizeof(buf));
510 if (cc == 0 || (cc < 0 && errno != EINTR)) {
511 close(fd);
512 FD_CLR(fd, &afds);
513 }
514 }
515 }
516 }
517 }
518
519 static pid_t pid;
520 static char tmpsunpath[1024];
521
setup(void)522 static void setup(void)
523 {
524
525 int ret = 0;
526
527 tst_require_root();
528 tst_sig(FORK, DEF_HANDLER, cleanup);
529 TEST_PAUSE;
530
531
532 tst_tmpdir();
533 snprintf(tmpsunpath, 1024, "udsock%ld", (long)time(NULL));
534 sun1.sun_family = AF_UNIX;
535 strcpy(sun1.sun_path, tmpsunpath);
536
537 /* this test will fail or in some cases hang if no eth or lo is
538 * configured, so making sure in setup that at least lo is up
539 */
540 ret = system("ip link set lo up");
541 if (WEXITSTATUS(ret) != 0) {
542 ret = system("ifconfig lo up 127.0.0.1");
543 if (WEXITSTATUS(ret) != 0) {
544 tst_brkm(TBROK, cleanup,
545 "ip/ifconfig failed to bring up loop back device");
546 }
547 }
548
549 pid = start_server(&sin1, &sun1);
550
551 signal(SIGPIPE, SIG_IGN);
552 }
553
cleanup(void)554 static void cleanup(void)
555 {
556 if (pid > 0)
557 kill(pid, SIGKILL); /* kill server, if server exists */
558 unlink(tmpsunpath);
559 tst_rmdir();
560 }
561
setup0(void)562 static void setup0(void)
563 {
564 if (tdat[testno].experrno == EBADF)
565 s = 400; /* anything not an open file */
566 else if ((s = open("/dev/null", O_WRONLY)) == -1)
567 tst_brkm(TBROK, cleanup, "error opening /dev/null - "
568 "errno: %s", strerror(errno));
569 }
570
cleanup0(void)571 static void cleanup0(void)
572 {
573 s = -1;
574 }
575
setup1(void)576 static void setup1(void)
577 {
578 s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
579 tdat[testno].proto);
580 if (tdat[testno].type == SOCK_STREAM &&
581 connect(s, (struct sockaddr *)tdat[testno].to,
582 tdat[testno].tolen) < 0) {
583 tst_brkm(TBROK, cleanup, "connect failed: %s", strerror(errno));
584 }
585 }
586
cleanup1(void)587 static void cleanup1(void)
588 {
589 close(s);
590 s = -1;
591 }
592
setup2(void)593 static void setup2(void)
594 {
595 setup1(); /* get a socket in s */
596 if (shutdown(s, 1) < 0) {
597 tst_brkm(TBROK, cleanup, "socket setup failed connect "
598 "test %d: %s", testno, strerror(errno));
599 }
600 }
601
setup3(void)602 static void setup3(void)
603 {
604 s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
605 tdat[testno].proto);
606 }
607
608 static char tmpfilename[1024];
609 static int tfd;
610
setup4(void)611 static void setup4(void)
612 {
613
614 setup1(); /* get a socket in s */
615
616 strcpy(tmpfilename, "sockXXXXXX");
617 tfd = mkstemp(tmpfilename);
618 if (tfd < 0) {
619 tst_brkm(TBROK, cleanup4, "socket setup failed: %s",
620 strerror(errno));
621 }
622 control = (struct cmsghdr *)cbuf;
623 memset(cbuf, 0x00, sizeof(cbuf));
624 control->cmsg_len = sizeof(struct cmsghdr) + 4;
625 control->cmsg_level = SOL_SOCKET;
626 control->cmsg_type = SCM_RIGHTS;
627 *(int *)CMSG_DATA(control) = tfd;
628 controllen = control->cmsg_len;
629 }
630
cleanup4(void)631 static void cleanup4(void)
632 {
633 cleanup1();
634 close(tfd);
635 tfd = -1;
636 control = 0;
637 controllen = 0;
638 }
639
setup5(void)640 static void setup5(void)
641 {
642 s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
643 tdat[testno].proto);
644
645 SAFE_CONNECT(cleanup, s, (struct sockaddr *)&sin1, sizeof(sin1));
646
647 /* slight change destination (port) so connect() is to different
648 * 5-tuple than already connected
649 */
650 sin2 = sin1;
651 sin2.sin_port = TST_GET_UNUSED_PORT(cleanup, AF_INET, SOCK_STREAM);
652 }
653
setup6(void)654 static void setup6(void)
655 {
656 setup4();
657 /*
658 controllen = control->cmsg_len = sizeof(struct cmsghdr) - 4;
659 */
660 controllen = control->cmsg_len = 0;
661 }
662
setup8(void)663 static void setup8(void)
664 {
665 setup4();
666 control = (struct cmsghdr *)-1;
667 }
668