1/*
2 *
3 *   Copyright (c) International Business Machines  Corp., 2001
4 *
5 *   This program is free software;  you can redistribute it and/or modify
6 *   it under the terms of the GNU General Public License as published by
7 *   the Free Software Foundation; either version 2 of the License, or
8 *   (at your option) any later version.
9 *
10 *   This program is distributed in the hope that it will be useful,
11 *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
12 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
13 *   the GNU General Public License for more details.
14 *
15 *   You should have received a copy of the GNU General Public License
16 *   along with this program;  if not, write to the Free Software
17 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
18 */
19
20/*
21 * Test Name: recvmsg01
22 *
23 * Test Description:
24 *  Verify that recvmsg() returns the proper errno for various failure cases
25 *
26 * Usage:  <for command-line>
27 *  recvmsg01 [-c n] [-e] [-i n] [-I x] [-P x] [-t]
28 *     where,  -c n : Run n copies concurrently.
29 *             -e   : Turn on errno logging.
30 *	       -i n : Execute test n times.
31 *	       -I x : Execute test for x seconds.
32 *	       -P x : Pause for x seconds between iterations.
33 *	       -t   : Turn on syscall timing.
34 *
35 * HISTORY
36 *	07/2001 Ported by Wayne Boyer
37 *
38 * RESTRICTIONS:
39 *  None.
40 *
41 */
42
43#include <stdio.h>
44#include <unistd.h>
45#include <string.h>
46#include <errno.h>
47#include <fcntl.h>
48
49#include <sys/types.h>
50#include <sys/socket.h>
51#include <sys/signal.h>
52#include <sys/uio.h>
53#include <sys/un.h>
54#include <sys/file.h>
55
56#include <netinet/in.h>
57
58#include "test.h"
59#include "safe_macros.h"
60
61char *TCID = "recvmsg01";
62int testno;
63
64char buf[1024], cbuf[1024];
65int s;				/* socket descriptor */
66int passed_fd = -1;		/* rights-passing test descriptor */
67struct sockaddr_in sin1, from;
68struct sockaddr_un sun1;
69struct msghdr msgdat;
70struct cmsghdr *control = 0;
71int controllen = 0;
72struct iovec iov[1];
73static int sfd;			/* shared between do_child and start_server */
74static int ufd;			/* shared between do_child and start_server */
75
76void setup(void);
77void setup0(void);
78void setup1(void);
79void setup2(void);
80void setup3(void);
81void setup4(void);
82void cleanup(void);
83void cleanup0(void);
84void cleanup1(void);
85void cleanup2(void);
86void do_child(void);
87
88void sender(int);
89pid_t start_server(struct sockaddr_in *, struct sockaddr_un *);
90
91struct test_case_t {		/* test case structure */
92	int domain;		/* PF_INET, PF_UNIX, ... */
93	int type;		/* SOCK_STREAM, SOCK_DGRAM ... */
94	int proto;		/* protocol number (usually 0 = default) */
95	struct iovec *iov;
96	int iovcnt;
97	void *buf;		/* recv data buffer */
98	int buflen;		/* recv buffer length */
99	struct msghdr *msg;
100	unsigned flags;
101	struct sockaddr *from;	/* from address */
102	int fromlen;		/* from address value/result buffer length */
103	int retval;		/* syscall return value */
104	int experrno;		/* expected errno */
105	void (*setup) (void);
106	void (*cleanup) (void);
107	char *desc;
108} tdat[] = {
109/* 1 */
110	{
111	PF_INET, SOCK_STREAM, 0, iov, 1, buf, sizeof(buf), &msgdat, 0,
112		    (struct sockaddr *)&from, sizeof(from),
113		    -1, EBADF, setup0, cleanup0, "bad file descriptor"}
114	,
115/* 2 */
116	{
117	0, 0, 0, iov, 1, (void *)buf, sizeof(buf), &msgdat, 0,
118		    (struct sockaddr *)&from, sizeof(from),
119		    -1, ENOTSOCK, setup0, cleanup0, "invalid socket"}
120	,
121/* 3 */
122	{
123	PF_INET, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
124		    &msgdat, 0, (struct sockaddr *)-1, sizeof(from), 0,
125		    ENOTSOCK, setup1, cleanup1, "invalid socket buffer"}
126	,
127/* 4 */
128	{
129	PF_INET, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
130		    &msgdat, -1, (struct sockaddr *)&from, -1, -1,
131		    EINVAL, setup1, cleanup1, "invalid socket length"},
132/* 5 */
133	{
134	PF_INET, SOCK_STREAM, 0, iov, 1, (void *)-1, sizeof(buf),
135		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
136		    -1, EFAULT, setup1, cleanup1, "invalid recv buffer"}
137	,
138/* 6 */
139	{
140	PF_INET, SOCK_STREAM, 0, 0, 1, (void *)buf, sizeof(buf),
141		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
142		    -1, EFAULT, setup1, cleanup1, "invalid iovec buffer"}
143	,
144/* 7 */
145	{
146	PF_INET, SOCK_STREAM, 0, iov, -1, (void *)buf, sizeof(buf),
147		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
148		    -1, EMSGSIZE, setup1, cleanup1, "invalid iovec count"}
149	,
150/* 8 */
151	{
152	PF_UNIX, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
153		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
154		    0, 0, setup2, cleanup2, "rights reception"}
155	,
156/* 9 */
157	{
158	PF_INET, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
159		    &msgdat, MSG_OOB, (struct sockaddr *)&from,
160		    sizeof(from), -1, EINVAL, setup1, cleanup1,
161		    "invalid MSG_OOB flag set"}
162	,
163/* 10 */
164	{
165	PF_INET, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
166		    &msgdat, MSG_ERRQUEUE, (struct sockaddr *)&from,
167		    sizeof(from), -1, EAGAIN, setup1, cleanup1,
168		    "invalid MSG_ERRQUEUE flag set"}
169	,
170/* 11 */
171	{
172	PF_UNIX, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
173		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
174		    0, EINVAL, setup3, cleanup2, "invalid cmsg length"}
175	,
176/* 12 */
177	{
178	PF_UNIX, SOCK_STREAM, 0, iov, 1, (void *)buf, sizeof(buf),
179		    &msgdat, 0, (struct sockaddr *)&from, sizeof(from),
180		    0, 0, setup4, cleanup2, "large cmesg length"}
181,};
182
183int TST_TOTAL = sizeof(tdat) / sizeof(tdat[0]);
184
185#ifdef UCLINUX
186static char *argv0;
187#endif
188
189int main(int argc, char *argv[])
190{
191	int lc;
192
193	tst_parse_opts(argc, argv, NULL, NULL);
194#ifdef UCLINUX
195	argv0 = argv[0];
196	maybe_run_child(&do_child, "dd", &sfd, &ufd);
197#endif
198
199	setup();
200
201	for (lc = 0; TEST_LOOPING(lc); ++lc) {
202		tst_count = 0;
203		for (testno = 0; testno < TST_TOTAL; ++testno) {
204			if ((tst_kvercmp(3, 17, 0) < 0)
205			    && (tdat[testno].flags & MSG_ERRQUEUE)
206			    && (tdat[testno].type & SOCK_STREAM)) {
207				tst_resm(TCONF, "skip MSG_ERRQUEUE test, "
208						"it's supported from 3.17");
209				continue;
210			}
211
212			tdat[testno].setup();
213
214			/* setup common to all tests */
215			iov[0].iov_base = tdat[testno].buf;
216			iov[0].iov_len = tdat[testno].buflen;
217			msgdat.msg_name = tdat[testno].from;
218			msgdat.msg_namelen = tdat[testno].fromlen;
219			msgdat.msg_iov = tdat[testno].iov;
220			msgdat.msg_iovlen = tdat[testno].iovcnt;
221			msgdat.msg_control = control;
222			msgdat.msg_controllen = controllen;
223			msgdat.msg_flags = 0;
224
225			TEST(recvmsg(s, tdat[testno].msg, tdat[testno].flags));
226			if (TEST_RETURN >= 0)
227				TEST_RETURN = 0;	/* all nonzero equal here */
228			if (TEST_RETURN != tdat[testno].retval ||
229			    (TEST_RETURN < 0 &&
230			     TEST_ERRNO != tdat[testno].experrno)) {
231				tst_resm(TFAIL, "%s ; returned"
232					 " %ld (expected %d), errno %d (expected"
233					 " %d)", tdat[testno].desc,
234					 TEST_RETURN, tdat[testno].retval,
235					 TEST_ERRNO, tdat[testno].experrno);
236			} else {
237				tst_resm(TPASS, "%s successful",
238					 tdat[testno].desc);
239			}
240			tdat[testno].cleanup();
241		}
242	}
243	cleanup();
244
245	tst_exit();
246}
247
248pid_t pid;
249char tmpsunpath[1024];
250
251void setup(void)
252{
253	int tfd;
254	TEST_PAUSE;
255
256	tst_tmpdir();
257	(void)strcpy(tmpsunpath, "udsockXXXXXX");
258	tfd = mkstemp(tmpsunpath);
259	close(tfd);
260	unlink(tmpsunpath);
261	sun1.sun_family = AF_UNIX;
262	(void)strcpy(sun1.sun_path, tmpsunpath);
263
264	signal(SIGPIPE, SIG_IGN);
265
266	pid = start_server(&sin1, &sun1);
267}
268
269void cleanup(void)
270{
271	if (pid > 0)
272		(void)kill(pid, SIGKILL);	/* kill server */
273	if (tmpsunpath[0] != '\0')
274		(void)unlink(tmpsunpath);
275	tst_rmdir();
276
277}
278
279void setup0(void)
280{
281	if (tdat[testno].experrno == EBADF)
282		s = 400;	/* anything not an open file */
283	else if ((s = open("/dev/null", O_WRONLY)) == -1)
284		tst_brkm(TBROK | TERRNO, cleanup, "open(/dev/null) failed");
285}
286
287void cleanup0(void)
288{
289	s = -1;
290}
291
292void setup1(void)
293{
294	fd_set rdfds;
295	struct timeval timeout;
296	int n;
297
298	s = SAFE_SOCKET(cleanup, tdat[testno].domain, tdat[testno].type,
299			tdat[testno].proto);
300	if (tdat[testno].type == SOCK_STREAM) {
301		if (tdat[testno].domain == PF_INET) {
302			SAFE_CONNECT(cleanup, s, (struct sockaddr *)&sin1,
303				     sizeof(sin1));
304			/* Wait for something to be readable, else we won't detect EFAULT on recv */
305			FD_ZERO(&rdfds);
306			FD_SET(s, &rdfds);
307			timeout.tv_sec = 2;
308			timeout.tv_usec = 0;
309			n = select(s + 1, &rdfds, 0, 0, &timeout);
310			if (n != 1 || !FD_ISSET(s, &rdfds))
311				tst_brkm(TBROK, cleanup,
312					 "client setup1 failed - no message ready in 2 sec");
313		} else if (tdat[testno].domain == PF_UNIX) {
314			SAFE_CONNECT(cleanup, s, (struct sockaddr *)&sun1,
315				     sizeof(sun1));
316		}
317	}
318}
319
320void setup2(void)
321{
322	setup1();
323	if (write(s, "R", 1) < 0)
324		tst_brkm(TBROK | TERRNO, cleanup, "test setup failed: write:");
325	control = (struct cmsghdr *)cbuf;
326	controllen = control->cmsg_len = sizeof(cbuf);
327}
328
329void setup3(void)
330{
331	setup2();
332	controllen = sizeof(struct cmsghdr) - 1;
333}
334
335void setup4(void)
336{
337	setup2();
338	controllen = 128 * 1024;
339}
340
341void cleanup1(void)
342{
343	(void)close(s);
344	close(ufd);
345	close(sfd);
346	s = -1;
347}
348
349void cleanup2(void)
350{
351	close(ufd);
352	close(sfd);
353	(void)close(s);
354	s = -1;
355
356	if (passed_fd >= 0)
357		(void)close(passed_fd);
358	passed_fd = -1;
359	control = 0;
360	controllen = 0;
361}
362
363pid_t start_server(struct sockaddr_in *ssin, struct sockaddr_un *ssun)
364{
365	pid_t pid;
366	socklen_t slen = sizeof(*ssin);
367
368	ssin->sin_family = AF_INET;
369	ssin->sin_port = 0; /* pick random free port */
370	ssin->sin_addr.s_addr = INADDR_ANY;
371
372	/* set up inet socket */
373	sfd = socket(PF_INET, SOCK_STREAM, 0);
374	if (sfd < 0) {
375		tst_brkm(TBROK | TERRNO, cleanup, "server socket failed");
376		return -1;
377	}
378	if (bind(sfd, (struct sockaddr *)ssin, sizeof(*ssin)) < 0) {
379		tst_brkm(TBROK | TERRNO, cleanup, "server bind failed");
380		return -1;
381	}
382	if (listen(sfd, 10) < 0) {
383		tst_brkm(TBROK | TERRNO, cleanup, "server listen failed");
384		return -1;
385	}
386	SAFE_GETSOCKNAME(cleanup, sfd, (struct sockaddr *)ssin, &slen);
387
388	/* set up UNIX-domain socket */
389	ufd = socket(PF_UNIX, SOCK_STREAM, 0);
390	if (ufd < 0) {
391		tst_brkm(TBROK | TERRNO, cleanup, "server UD socket failed");
392		return -1;
393	}
394	if (bind(ufd, (struct sockaddr *)ssun, sizeof(*ssun))) {
395		tst_brkm(TBROK | TERRNO, cleanup, "server UD bind failed");
396		return -1;
397	}
398	if (listen(ufd, 10) < 0) {
399		tst_brkm(TBROK | TERRNO, cleanup, "server UD listen failed");
400		return -1;
401	}
402
403	switch ((pid = FORK_OR_VFORK())) {
404	case 0:		/* child */
405#ifdef UCLINUX
406		if (self_exec(argv0, "dd", sfd, ufd) < 0)
407			tst_brkm(TBROK | TERRNO, cleanup,
408				 "server self_exec failed");
409#else
410		do_child();
411#endif
412		break;
413	case -1:
414		tst_brkm(TBROK | TERRNO, cleanup, "server fork failed");
415		/* fall through */
416	default:		/* parent */
417		(void)close(sfd);
418		(void)close(ufd);
419		return pid;
420	}
421	exit(1);
422}
423
424void do_child(void)
425{
426	struct sockaddr_in fsin;
427	struct sockaddr_un fsun;
428	fd_set afds, rfds;
429	int nfds, cc, fd;
430
431	FD_ZERO(&afds);
432	FD_SET(sfd, &afds);
433	FD_SET(ufd, &afds);
434
435	nfds = MAX(sfd + 1, ufd + 1);
436
437	/* accept connections until killed */
438	while (1) {
439		socklen_t fromlen;
440
441		memcpy(&rfds, &afds, sizeof(rfds));
442
443		if (select(nfds, &rfds, NULL, NULL,
444			   NULL) < 0) {
445			if (errno != EINTR) {
446				perror("server select");
447				exit(1);
448			}
449			continue;
450		}
451		if (FD_ISSET(sfd, &rfds)) {
452			int newfd;
453
454			fromlen = sizeof(fsin);
455			newfd = accept(sfd, (struct sockaddr *)&fsin, &fromlen);
456			if (newfd >= 0) {
457				FD_SET(newfd, &afds);
458				nfds = MAX(nfds, newfd + 1);
459				/* send something back */
460				(void)write(newfd, "hoser\n", 6);
461			}
462		}
463		if (FD_ISSET(ufd, &rfds)) {
464			int newfd;
465
466			fromlen = sizeof(fsun);
467			newfd = accept(ufd, (struct sockaddr *)&fsun, &fromlen);
468			if (newfd >= 0) {
469				FD_SET(newfd, &afds);
470				nfds = MAX(nfds, newfd + 1);
471			}
472		}
473		for (fd = 0; fd < nfds; ++fd)
474			if (fd != sfd && fd != ufd && FD_ISSET(fd, &rfds)) {
475				char rbuf[1024];
476
477				cc = read(fd, rbuf, sizeof(rbuf));
478				if (cc && rbuf[0] == 'R')
479					sender(fd);
480				if (cc == 0 || (cc < 0 && errno != EINTR)) {
481					(void)close(fd);
482					FD_CLR(fd, &afds);
483				}
484			}
485	}
486}
487
488#define TM	"from recvmsg01 server"
489
490/* special for rights-passing test */
491void sender(int fd)
492{
493	struct msghdr mh;
494	struct cmsghdr *control;
495	char tmpfn[1024], snd_cbuf[1024];
496	int tfd;
497
498	(void)strcpy(tmpfn, "smtXXXXXX");
499	tfd = mkstemp(tmpfn);
500	if (tfd < 0)
501		return;
502
503	memset(&mh, 0x00, sizeof(mh));
504
505	/* set up cmsghdr */
506	control = (struct cmsghdr *)snd_cbuf;
507	memset(control, 0x00, sizeof(struct cmsghdr));
508	control->cmsg_len = sizeof(struct cmsghdr) + 4;
509	control->cmsg_level = SOL_SOCKET;
510	control->cmsg_type = SCM_RIGHTS;
511	*(int *)CMSG_DATA(control) = tfd;
512
513	/* set up msghdr */
514	iov[0].iov_base = TM;
515	iov[0].iov_len = sizeof(TM);
516	mh.msg_iov = iov;
517	mh.msg_iovlen = 1;
518	mh.msg_flags = 0;
519	mh.msg_control = control;
520	mh.msg_controllen = control->cmsg_len;
521
522	/* do it */
523	(void)sendmsg(fd, &mh, 0);
524	(void)close(tfd);
525	(void)unlink(tmpfn);
526}
527