summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/regress/lib/libc/sys/Makefile104
-rw-r--r--src/regress/lib/libc/sys/README68
-rw-r--r--src/regress/lib/libc/sys/atf-c.c113
-rw-r--r--src/regress/lib/libc/sys/atf-c.h100
-rw-r--r--src/regress/lib/libc/sys/h_macros.h87
-rw-r--r--src/regress/lib/libc/sys/macros.h55
-rw-r--r--src/regress/lib/libc/sys/t_access.c216
-rw-r--r--src/regress/lib/libc/sys/t_bind.c81
-rw-r--r--src/regress/lib/libc/sys/t_chroot.c321
-rw-r--r--src/regress/lib/libc/sys/t_clock_gettime.c215
-rw-r--r--src/regress/lib/libc/sys/t_dup.c395
-rw-r--r--src/regress/lib/libc/sys/t_fsync.c125
-rw-r--r--src/regress/lib/libc/sys/t_getgroups.c175
-rw-r--r--src/regress/lib/libc/sys/t_getitimer.c215
-rw-r--r--src/regress/lib/libc/sys/t_getlogin.c241
-rw-r--r--src/regress/lib/libc/sys/t_getpid.c138
-rw-r--r--src/regress/lib/libc/sys/t_getrusage.c269
-rw-r--r--src/regress/lib/libc/sys/t_getsid.c123
-rw-r--r--src/regress/lib/libc/sys/t_getsockname.c85
-rw-r--r--src/regress/lib/libc/sys/t_gettimeofday.c90
-rw-r--r--src/regress/lib/libc/sys/t_kill.c316
-rw-r--r--src/regress/lib/libc/sys/t_link.c234
-rw-r--r--src/regress/lib/libc/sys/t_listen.c139
-rw-r--r--src/regress/lib/libc/sys/t_mkdir.c213
-rw-r--r--src/regress/lib/libc/sys/t_mkfifo.c309
-rw-r--r--src/regress/lib/libc/sys/t_mknod.c199
-rw-r--r--src/regress/lib/libc/sys/t_mlock.c325
-rw-r--r--src/regress/lib/libc/sys/t_mmap.c584
-rw-r--r--src/regress/lib/libc/sys/t_msgctl.c405
-rw-r--r--src/regress/lib/libc/sys/t_msgget.c339
-rw-r--r--src/regress/lib/libc/sys/t_msgrcv.c388
-rw-r--r--src/regress/lib/libc/sys/t_msgsnd.c384
-rw-r--r--src/regress/lib/libc/sys/t_msync.c228
-rw-r--r--src/regress/lib/libc/sys/t_pipe.c168
-rw-r--r--src/regress/lib/libc/sys/t_pipe2.c203
-rw-r--r--src/regress/lib/libc/sys/t_poll.c398
-rw-r--r--src/regress/lib/libc/sys/t_ptrace.c231
-rw-r--r--src/regress/lib/libc/sys/t_revoke.c198
-rw-r--r--src/regress/lib/libc/sys/t_select.c219
-rw-r--r--src/regress/lib/libc/sys/t_sendrecv.c186
-rw-r--r--src/regress/lib/libc/sys/t_setuid.c126
-rw-r--r--src/regress/lib/libc/sys/t_sigaction.c156
-rw-r--r--src/regress/lib/libc/sys/t_socketpair.c141
-rw-r--r--src/regress/lib/libc/sys/t_stat.c423
-rw-r--r--src/regress/lib/libc/sys/t_syscall.c122
-rw-r--r--src/regress/lib/libc/sys/t_truncate.c183
-rw-r--r--src/regress/lib/libc/sys/t_umask.c210
-rw-r--r--src/regress/lib/libc/sys/t_unlink.c162
-rw-r--r--src/regress/lib/libc/sys/t_write.c287
49 files changed, 10692 insertions, 0 deletions
diff --git a/src/regress/lib/libc/sys/Makefile b/src/regress/lib/libc/sys/Makefile
new file mode 100644
index 0000000000..e8c06d0fb2
--- /dev/null
+++ b/src/regress/lib/libc/sys/Makefile
@@ -0,0 +1,104 @@
1# $OpenBSD: Makefile,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $
2
3# Copyright (c) 2019 Moritz Buhl <openbsd@moritzbuhl.de>
4# Copyright (c) 2019 Alexander Bluhm <bluhm@openbsd.org>
5#
6# Permission to use, copy, modify, and distribute this software for any
7# purpose with or without fee is hereby granted, provided that the above
8# copyright notice and this permission notice appear in all copies.
9#
10# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17
18# Each test program in PROGS may define several numbered subtests.
19# In a first step compile all programs and extract their parameters.
20# For each PROG define new regression subtests based on the test number.
21
22.if defined(NUMBERS)
23REGRESS_TARGETS = ${NUMBERS:S/^/run-${PROG}-/}
24.else
25REGRESS_TARGETS = ${PROGS:S/^/run-/}
26.endif
27
28PROGS =
29PROGS += t_access t_bind t_chroot t_clock_gettime t_dup t_fsync
30PROGS += t_getgroups t_getitimer t_getlogin t_getpid t_getrusage
31PROGS += t_getsid t_getsockname t_gettimeofday t_kill t_link t_listen
32PROGS += t_mkdir t_mknod t_msgctl t_msgget t_msgsnd t_msync t_pipe
33PROGS += t_poll t_revoke t_select t_sendrecv t_setuid t_socketpair
34PROGS += t_sigaction t_truncate t_umask t_write
35
36# failing tests
37.if 0
38PROGS += t_mkfifo
39PROGS += t_mlock
40PROGS += t_mmap
41PROGS += t_msgrcv
42PROGS += t_pipe2
43PROGS += t_ptrace
44PROGS += t_stat
45PROGS += t_syscall
46PROGS += t_unlink
47.endif
48
49. for p in ${PROGS}
50SRCS_$p = $p.c atf-c.c
51. endfor
52
53LDADD_t_getpid = -lpthread
54
55run-t_truncate: setup-t_truncate
56setup-t_truncate:
57 ${SUDO} touch truncate_test.root_owned
58 ${SUDO} chown root:wheel truncate_test.root_owned
59
60run-t_chroot: cleanup-t_chroot
61cleanup-t_chroot:
62 ${SUDO} rm -rf dir
63
64CLEANFILES = access dummy mmap truncate_test.root_owned
65
66.for p in ${PROGS}
67run-$p: $p
68 @echo "\n======== $@ ========"
69 ntests="`./$p -n`" && \
70 echo "1..$$ntests" && \
71 tnumbers="`jot -ns' ' - 1 $$ntests`" && \
72 ${.MAKE} -C ${.CURDIR} PROG=$p NUMBERS="$$tnumbers" regress
73.endfor
74
75.if defined(NUMBERS)
76CUR_USER != id -g
77
78. for n in ${NUMBERS}
79DESCR_$n != eval `./${PROG} -i $n` && echo $$DESCR
80REQ_USER_$n != eval `./${PROG} -i $n` && echo $$REQ_USER
81
82. if ${REQ_USER_$n} == "root"
83REGRESS_ROOT_TARGETS += run-${PROG}-$n
84. endif
85
86run-${PROG}-$n:
87 @echo "$n ${DESCR_$n}"
88. if ${REQ_USER_$n} == "root"
89 ${SUDO} ./${PROG} -r $n
90. elif ${REQ_USER_$n} == "unprivileged" && ${CUR_USER} == 0
91 ${SUDO} su ${BUILDUSER} -c exec ./${PROG} -r $n
92. elif ${REQ_USER_$n} == "unprivileged" || ${REQ_USER_$n} == ""
93 ./${PROG} -r $n
94. else
95 # bad REQ_USER: ${REQ_USER_$n}
96 false
97. endif
98
99. endfor
100.endif
101
102.include <bsd.regress.mk>
103
104clean: cleanup-t_chroot
diff --git a/src/regress/lib/libc/sys/README b/src/regress/lib/libc/sys/README
new file mode 100644
index 0000000000..979f3bde4a
--- /dev/null
+++ b/src/regress/lib/libc/sys/README
@@ -0,0 +1,68 @@
1Regression tests for system calls ported from NetBSD.
2
3Reimplement ATF with many hacks to adjust the tests as little as possible.
4
5Tests passing without source file adjustments:
6t_access t_getpid t_kill t_msgsnd t_sigaction
7t_bind t_link t_msync t_socketpair t_getgroups
8t_getsid t_listen t_pipe t_truncate t_getitimer
9t_getsockname t_mkdir t_sendrecv t_umask t_getlogin
10t_gettimeofday t_msgctl t_setuid t_write
11
12Tests passing after adjustments:
13t_chroot - fchroot is not implemented
14t_clock_gettime - requires sysctlbyname
15t_dup - OpenBSD dup3 is similar to Linux dup3
16t_fsync - replace mkstemp
17t_getrusage - no expected fail, PR kern/30115 is NetBSD, work more
18t_mknod - remove tests for unsupported file types
19t_msgget - remove msgget_limit test
20t_poll - remove pollts_* tests
21t_revoke - remove basic tests, revoke only on ttys supported
22t_select - remove sigset_t struct as it is int on OpenBSD
23
24Failing tests:
25t_mkfifo - every test case fails now
26t_mlock - wrong errno, succeeds where not expected, POSIX imprecise
27t_mmap - ENOTBLK on test NetBSD is skipping, remove mmap_va0 test
28t_msgrcv - msgrcv(id, &r, 3 - 1, 0x41, 004000) != -1
29t_pipe2 - closefrom(4) == -1, remove F_GETNOSIGPIPE and nosigpipe test
30t_ptrace - ptrace(0, 0, ((void *)0), 0) != -1
31t_stat - invalid GID with doas
32t_syscall - SIGSEGV
33t_unlink - wrong errno according to POSIX
34
35Excluded tests:
36t_clock_nanosleep - not available
37t_clone - not available
38t_connect -
39t_fork -
40t_getcontext -
41t_issetugid -
42t_kevent -
43t_lwp_create - not available
44t_lwp_ctl - not available
45t_mincore - removed
46t_minherit -
47t_mprotect -
48t_nanosleep - not available
49t_posix_fadvise -
50t_posix_fallocate -
51t_ptrace_wait -
52t_ptrace_wait3 -
53t_ptrace_wait4 -
54t_ptrace_wait6 - not implemented
55t_ptrace_waitid -
56t_ptrace_waitpid -
57t_recvmmsg -
58t_sendmmsg -
59t_setrlimit -
60t_sigqueue -
61t_sigtimedwait -
62t_swapcontext -
63t_timer_create -
64t_ucontext -
65t_vfork -
66t_wait -
67t_wait_noproc -
68t_wait_noproc_wnohang -
diff --git a/src/regress/lib/libc/sys/atf-c.c b/src/regress/lib/libc/sys/atf-c.c
new file mode 100644
index 0000000000..45181c7353
--- /dev/null
+++ b/src/regress/lib/libc/sys/atf-c.c
@@ -0,0 +1,113 @@
1/* $OpenBSD: atf-c.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2
3#include <sys/wait.h>
4
5#include <err.h>
6#include <errno.h>
7#include <limits.h>
8#include <stdarg.h>
9#include <stdio.h>
10#include <stdlib.h>
11#include <pwd.h>
12#include <unistd.h>
13
14#include "atf-c.h"
15
16void usage(void);
17
18int cleanup;
19int count;
20int inspect;
21int run;
22int test;
23
24int
25main(int argc, char *argv[])
26{
27 int ch, test;
28 const char *errstr, *num;
29
30 while ((ch = getopt(argc, argv, "c:i:nr:")) != -1) {
31 switch(ch) {
32 case 'c':
33 cleanup = 1;
34 num = optarg;
35 break;
36 case 'i':
37 inspect = 1;
38 num = optarg;
39 break;
40 case 'n':
41 count = 1;
42 break;
43 case 'r':
44 run = 1;
45 num = optarg;
46 break;
47 default:
48 usage();
49 }
50 }
51 argc -= optind;
52 argv += optind;
53
54 if (cleanup + count + inspect + run > 1)
55 usage();
56
57 if (cleanup || inspect || run) {
58 test = strtonum(num, 1, INT_MAX, &errstr);
59 if (errstr != NULL)
60 errx(1, "test # is %s: %s", errstr, argv[1]);
61 }
62 if (count)
63 printf("%d\n", atf_test(0, 0));
64 else if (cleanup)
65 ATF_CLEANUP(test);
66 else if (run)
67 ATF_RUN(test);
68 else if (inspect)
69 ATF_INSPECT(test);
70 else
71 usage();
72
73 return 0;
74}
75
76void
77usage(void)
78{
79 fprintf(stderr, "usage: %s [-n] [-c|i|r test#]\n", getprogname());
80 exit(1);
81}
82
83void
84atf_require(int exp, int expected_errno, const char *expstr, const char *src,
85 const int lineno, char *fmt, ...)
86{
87 va_list args;
88 if (!(exp)) {
89 fprintf(stderr, "\n%s:%d: ", src, lineno);
90 if (fmt != NULL) {
91 va_start(args, fmt);
92 vfprintf(stderr, fmt, args);
93 va_end(args);
94 } else {
95 fprintf(stderr, "'%s' evaluated to false\n", expstr);
96 }
97 exit(1);
98 } else if (expected_errno >= 0 && errno != expected_errno) {
99 fprintf(stderr, "\n%s:%d: ", src, lineno);
100 fprintf(stderr, "expected errno %d but got %d instead\n",
101 expected_errno, errno);
102 exit(1);
103 }
104 return;
105}
106
107void
108atf_tc_fail(char *fmt, ...)
109{
110 va_list args;
111 va_start(args, fmt);
112 verrx(1, fmt, args);
113}
diff --git a/src/regress/lib/libc/sys/atf-c.h b/src/regress/lib/libc/sys/atf-c.h
new file mode 100644
index 0000000000..740881485d
--- /dev/null
+++ b/src/regress/lib/libc/sys/atf-c.h
@@ -0,0 +1,100 @@
1/* $OpenBSD: atf-c.h,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/*
3 * Copyright (c) 2019 Moritz Buhl <openbsd@moritzbuhl.de>
4 *
5 * Permission to use, copy, modify, and distribute this software for any
6 * purpose with or without fee is hereby granted, provided that the above
7 * copyright notice and this permission notice appear in all copies.
8 *
9 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16 */
17
18#if !defined(ATF_C_H)
19#define ATF_C_H
20
21#include <pwd.h>
22#include <stdio.h>
23#include <string.h>
24#include <unistd.h>
25
26
27int atf_test(int, int);
28void atf_require(int, int, const char *, const char *, const int, char *, ...);
29void atf_tc_fail(char *, ...)
30 __attribute__((__noreturn__, __format__ (printf, 1, 2)));
31
32#define ATF_INSPECT_TEST 1
33#define ATF_RUN_TEST 2
34#define ATF_CLEANUP_TEST 3
35
36#define ATF_TC_FUNCTIONS(fn) \
37void atf_head_##fn(void); \
38void atf_body_##fn(void); \
39void atf_cleanup_##fn(void);
40
41#define ATF_TC(fn) \
42ATF_TC_FUNCTIONS(fn) \
43void atf_cleanup_##fn(void) { return; }
44
45#define ATF_TC_WITH_CLEANUP(fn) \
46ATF_TC_FUNCTIONS(fn)
47
48#define ATF_TC_HEAD(fn, tc) void atf_head_##fn(void)
49#define ATF_TC_BODY(fn, tc) void atf_body_##fn(void)
50#define ATF_TC_CLEANUP(fn, tc) void atf_cleanup_##fn(void)
51
52#define ATF_TP_ADD_TCS(tp) int atf_test(int tst, int what)
53#define ATF_TP_ADD_TC(tp, fn) tst--; \
54 if (tst == 0) { \
55 if (what == ATF_INSPECT_TEST) \
56 atf_head_##fn(); \
57 else if (what == ATF_RUN_TEST) \
58 atf_body_##fn(); \
59 else if (what == ATF_CLEANUP_TEST) \
60 atf_cleanup_##fn(); \
61 return 0; \
62 }
63
64#define atf_no_error() (-tst)
65
66#define ATF_INSPECT(i) atf_test(i, ATF_INSPECT_TEST)
67#define ATF_RUN(i) atf_test(i, ATF_RUN_TEST)
68#define ATF_CLEANUP(i) atf_test(i, ATF_CLEANUP_TEST)
69
70#define atf_tc_set_md_var(tc, attr, fmt, ...) \
71 if (strcmp(attr, "descr") == 0) \
72 printf("DESCR=\"" fmt "\"\n", ##__VA_ARGS__); \
73 else if (strcmp(attr, "require.user") == 0) \
74 printf("REQ_USER=" fmt "\n", ##__VA_ARGS__);
75
76#define ATF_CHECK ATF_REQUIRE
77#define ATF_CHECK_MSG ATF_REQUIRE_MSG
78#define ATF_CHECK_EQ ATF_REQUIRE_EQ
79
80#define atf_req(exp, err, msg, ...) \
81 atf_require(exp, err, #exp, __FILE__, __LINE__, NULL)
82#define ATF_REQUIRE(exp) atf_req(exp, -1, NULL)
83#define ATF_REQUIRE_ERRNO(no, exp) atf_req(exp, no, NULL)
84#define ATF_REQUIRE_MSG(exp, fmt, ...) atf_req(exp, -1, fmt, ##__VA_ARGS__)
85#define ATF_REQUIRE_EQ(a, b) atf_req((a) == (b), -1, NULL)
86#define ATF_REQUIRE_EQ_MSG(a, b, fmt, ...) \
87 atf_req((a) == (b), -1, fmt, ##__VA_ARGS__)
88
89#define atf_tc_fail_nonfatal(fmt, ...) atf_tc_fail(fmt, ##__VA_ARGS__)
90#define atf_tc_expect_fail(fmt, ...) \
91 atf_tc_fail(fmt "\nEXPECTED_FAIL", ##__VA_ARGS__)
92#define atf_tc_skip(fmt, ...) \
93 atf_tc_fail(fmt "\nSKIPPING", ##__VA_ARGS__)
94#define atf_tc_pass() exit(0)
95
96#define atf_tc_get_config_var(a, b) "."
97
98#define atf_utils_fork() fork()
99
100#endif /* !defined(ATF_C_H) */
diff --git a/src/regress/lib/libc/sys/h_macros.h b/src/regress/lib/libc/sys/h_macros.h
new file mode 100644
index 0000000000..227db0f31b
--- /dev/null
+++ b/src/regress/lib/libc/sys/h_macros.h
@@ -0,0 +1,87 @@
1/* $NetBSD: h_macros.h,v 1.13 2016/08/20 15:49:08 christos Exp $ */
2
3/*-
4 * Copyright (c) 2008, 2009 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
17 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
18 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
19 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
20 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
21 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
22 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
23 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
24 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
25 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
26 * POSSIBILITY OF SUCH DAMAGE.
27 */
28
29#ifndef SRC_TESTS_H_MACROS_H_
30#define SRC_TESTS_H_MACROS_H_
31
32#include <sys/types.h>
33#include <errno.h>
34#include <stdarg.h>
35#include <stdio.h>
36#include <stdlib.h>
37#include <string.h>
38
39#include "atf-c.h"
40
41#define REQUIRE_LIBC(x, v) \
42 ATF_REQUIRE_MSG((x) != (v), "%s: %s", #x, strerror(errno))
43
44#define CHECK_LIBC(x, v) \
45 ATF_CHECK_MSG((x) != (v), "%s: %s", #x, strerror(errno))
46
47#define RL(x) REQUIRE_LIBC(x, -1)
48#define RLF(x, fmt, arg) \
49 ATF_CHECK_MSG((x) != -1, "%s [" fmt "]: %s", #x, arg, strerror(errno))
50#define RZ(x) \
51do { \
52 int RZ_rv = x; \
53 ATF_REQUIRE_MSG(RZ_rv == 0, "%s: %s", #x, strerror(RZ_rv)); \
54} while (/*CONSTCOND*/0)
55
56__dead static __inline __attribute__((__format__(__printf__,1,2))) void
57atf_tc_fail_errno(const char *fmt, ...)
58{
59 va_list ap;
60 char buf[1024];
61 int sverrno = errno;
62
63 va_start(ap, fmt);
64 vsnprintf(buf, sizeof(buf), fmt, ap);
65 va_end(ap);
66
67 strlcat(buf, ": ", sizeof(buf));
68 strlcat(buf, strerror(sverrno), sizeof(buf));
69
70 atf_tc_fail("%s", buf);
71}
72
73static __inline void
74tests_makegarbage(void *space, size_t len)
75{
76 uint16_t *sb = space;
77 uint16_t randval;
78
79 while (len >= sizeof(randval)) {
80 *sb++ = (uint16_t)random();
81 len -= sizeof(*sb);
82 }
83 randval = (uint16_t)random();
84 memcpy(sb, &randval, len);
85}
86
87#endif
diff --git a/src/regress/lib/libc/sys/macros.h b/src/regress/lib/libc/sys/macros.h
new file mode 100644
index 0000000000..932f230c03
--- /dev/null
+++ b/src/regress/lib/libc/sys/macros.h
@@ -0,0 +1,55 @@
1/* $OpenBSD: macros.h,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* Public domain - Moritz Buhl */
3
4#include <sys/param.h>
5#include <sys/socket.h>
6#include <sys/stdint.h>
7#include <sys/sysctl.h>
8#include <sys/types.h>
9
10#include <stdbool.h>
11#include <string.h>
12
13#define __RCSID(str)
14#define __COPYRIGHT(str)
15
16#define __arraycount(_a) nitems(_a)
17#define __unreachable() atf_tc_fail("unreachable")
18#define __UNCONST(a) (a)
19
20/* t_chroot.c */
21#define fchroot(fd) 0
22
23/* t_clock_gettime.c */
24int sysctlbyname(char *, void *, size_t *, void *, size_t);
25
26int
27sysctlbyname(char* s, void *oldp, size_t *oldlenp, void *newp, size_t newlen)
28{
29 int ktc;
30 if (strcmp(s, "kern.timecounter.hardware") == 0)
31 ktc = KERN_TIMECOUNTER_HARDWARE;
32 else if (strcmp(s, "kern.timecounter.choice") == 0)
33 ktc = KERN_TIMECOUNTER_CHOICE;
34
35 int mib[3];
36 mib[0] = CTL_KERN;
37 mib[1] = KERN_TIMECOUNTER;
38 mib[2] = ktc;
39 return sysctl(mib, 3, oldp, oldlenp, newp, newlen);
40}
41
42/* t_mlock.c */
43#define MAP_WIRED __MAP_NOREPLACE
44
45/* t_pipe2.c */
46#define O_NOSIGPIPE 0
47
48/* t_poll.c */
49#define pollts(a, b, c, e) 0
50
51/* t_sendrecv.c */
52#define SO_RERROR SO_DEBUG
53
54/* t_write.c */
55#define _PATH_DEVZERO "/dev/zero"
diff --git a/src/regress/lib/libc/sys/t_access.c b/src/regress/lib/libc/sys/t_access.c
new file mode 100644
index 0000000000..33888c7039
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_access.c
@@ -0,0 +1,216 @@
1/* $OpenBSD: t_access.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_access.c,v 1.2 2017/01/10 22:36:29 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_access.c,v 1.2 2017/01/10 22:36:29 christos Exp $");
37
38#include "atf-c.h"
39
40#include <sys/stat.h>
41
42#include <errno.h>
43#include <fcntl.h>
44#include <limits.h>
45#include <stdint.h>
46#include <stdlib.h>
47#include <unistd.h>
48
49static const char path[] = "access";
50static const int mode[4] = { R_OK, W_OK, X_OK, F_OK };
51
52ATF_TC_WITH_CLEANUP(access_access);
53ATF_TC_HEAD(access_access, tc)
54{
55 atf_tc_set_md_var(tc, "descr", "Test access(2) for EACCES");
56 atf_tc_set_md_var(tc, "require.user", "unprivileged");
57}
58
59ATF_TC_BODY(access_access, tc)
60{
61 const int perm[3] = { 0200, 0400, 0000 };
62 size_t i;
63 int fd;
64
65 fd = open(path, O_RDONLY | O_CREAT);
66
67 if (fd < 0)
68 return;
69
70 for (i = 0; i < __arraycount(mode) - 1; i++) {
71
72 ATF_REQUIRE(fchmod(fd, perm[i]) == 0);
73
74 errno = 0;
75
76 ATF_REQUIRE(access(path, mode[i]) != 0);
77 ATF_REQUIRE(errno == EACCES);
78 }
79
80 ATF_REQUIRE(close(fd) == 0);
81}
82
83ATF_TC_CLEANUP(access_access, tc)
84{
85 (void)unlink(path);
86}
87
88ATF_TC(access_fault);
89ATF_TC_HEAD(access_fault, tc)
90{
91 atf_tc_set_md_var(tc, "descr", "Test access(2) for EFAULT");
92}
93
94ATF_TC_BODY(access_fault, tc)
95{
96 size_t i;
97
98 for (i = 0; i < __arraycount(mode); i++) {
99
100 errno = 0;
101
102 ATF_REQUIRE(access(NULL, mode[i]) != 0);
103 ATF_REQUIRE(errno == EFAULT);
104
105 errno = 0;
106
107 ATF_REQUIRE(access((char *)-1, mode[i]) != 0);
108 ATF_REQUIRE(errno == EFAULT);
109 }
110}
111
112ATF_TC(access_inval);
113ATF_TC_HEAD(access_inval, tc)
114{
115 atf_tc_set_md_var(tc, "descr", "Test access(2) for EINVAL");
116}
117
118ATF_TC_BODY(access_inval, tc)
119{
120
121 errno = 0;
122
123 ATF_REQUIRE(access("/usr", -1) != 0);
124 ATF_REQUIRE(errno == EINVAL);
125}
126
127ATF_TC(access_notdir);
128ATF_TC_HEAD(access_notdir, tc)
129{
130 atf_tc_set_md_var(tc, "descr", "Test access(2) for ENOTDIR");
131}
132
133ATF_TC_BODY(access_notdir, tc)
134{
135 size_t i;
136
137 for (i = 0; i < __arraycount(mode); i++) {
138
139 errno = 0;
140
141 /*
142 * IEEE Std 1003.1-2008 about ENOTDIR:
143 *
144 * "A component of the path prefix is not a directory,
145 * or the path argument contains at least one non-<slash>
146 * character and ends with one or more trailing <slash>
147 * characters and the last pathname component names an
148 * existing file that is neither a directory nor a symbolic
149 * link to a directory."
150 */
151 ATF_REQUIRE(access("/etc/passwd//", mode[i]) != 0);
152 ATF_REQUIRE(errno == ENOTDIR);
153 }
154}
155
156ATF_TC(access_notexist);
157ATF_TC_HEAD(access_notexist, tc)
158{
159 atf_tc_set_md_var(tc, "descr", "Test access(2) for ENOENT");
160}
161
162ATF_TC_BODY(access_notexist, tc)
163{
164 size_t i;
165
166 for (i = 0; i < __arraycount(mode); i++) {
167
168 errno = 0;
169
170 ATF_REQUIRE(access("", mode[i]) != 0);
171 ATF_REQUIRE(errno == ENOENT);
172 }
173}
174
175ATF_TC(access_toolong);
176ATF_TC_HEAD(access_toolong, tc)
177{
178 atf_tc_set_md_var(tc, "descr", "Test access(2) for ENAMETOOLONG");
179}
180
181ATF_TC_BODY(access_toolong, tc)
182{
183 char *buf;
184 size_t i;
185
186 buf = malloc(PATH_MAX);
187
188 if (buf == NULL)
189 return;
190
191 for (i = 0; i < PATH_MAX; i++)
192 buf[i] = 'x';
193
194 for (i = 0; i < __arraycount(mode); i++) {
195
196 errno = 0;
197
198 ATF_REQUIRE(access(buf, mode[i]) != 0);
199 ATF_REQUIRE(errno == ENAMETOOLONG);
200 }
201
202 free(buf);
203}
204
205ATF_TP_ADD_TCS(tp)
206{
207
208 ATF_TP_ADD_TC(tp, access_access);
209 ATF_TP_ADD_TC(tp, access_fault);
210 ATF_TP_ADD_TC(tp, access_inval);
211 ATF_TP_ADD_TC(tp, access_notdir);
212 ATF_TP_ADD_TC(tp, access_notexist);
213 ATF_TP_ADD_TC(tp, access_toolong);
214
215 return atf_no_error();
216}
diff --git a/src/regress/lib/libc/sys/t_bind.c b/src/regress/lib/libc/sys/t_bind.c
new file mode 100644
index 0000000000..7989c7c229
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_bind.c
@@ -0,0 +1,81 @@
1/* $OpenBSD: t_bind.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_bind.c,v 1.3 2015/04/05 23:28:10 rtr Exp $ */
3/*
4 * Copyright (c) 2015 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <errno.h>
33#include <stdlib.h>
34#include <string.h>
35
36#include <unistd.h>
37
38#include <sys/socket.h>
39#include <arpa/inet.h>
40#include <netinet/in.h>
41
42#include "atf-c.h"
43
44ATF_TC(bind_foreign_family);
45
46ATF_TC_HEAD(bind_foreign_family, tc)
47{
48 atf_tc_set_md_var(tc, "descr", "Checks that binding a socket "
49 "with a different address family fails");
50}
51
52ATF_TC_BODY(bind_foreign_family, tc)
53{
54 struct sockaddr_in addr;
55
56 /* addr.sin_family = AF_UNSPEC = 0 */
57 memset(&addr, 0, sizeof(addr));
58
59 /*
60 * it is not necessary to initialize sin_{addr,port} since
61 * those structure members shall not be accessed if bind
62 * fails correctly.
63 */
64
65 int sock = socket(AF_LOCAL, SOCK_STREAM, 0);
66 ATF_REQUIRE(sock != -1);
67
68 /* should fail but currently doesn't */
69 ATF_REQUIRE(-1 == bind(sock, (struct sockaddr *)&addr, sizeof(addr)));
70 ATF_REQUIRE(EAFNOSUPPORT == errno);
71
72 close(sock);
73}
74
75ATF_TP_ADD_TCS(tp)
76{
77
78 ATF_TP_ADD_TC(tp, bind_foreign_family);
79
80 return atf_no_error();
81}
diff --git a/src/regress/lib/libc/sys/t_chroot.c b/src/regress/lib/libc/sys/t_chroot.c
new file mode 100644
index 0000000000..1fbe392a88
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_chroot.c
@@ -0,0 +1,321 @@
1/* $OpenBSD: t_chroot.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_chroot.c,v 1.2 2017/01/10 22:36:29 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_chroot.c,v 1.2 2017/01/10 22:36:29 christos Exp $");
37
38#include <sys/wait.h>
39#include <sys/stat.h>
40
41#include "atf-c.h"
42#include <errno.h>
43#include <fcntl.h>
44#include <limits.h>
45#include <pwd.h>
46#include <stdlib.h>
47#include <string.h>
48#include <unistd.h>
49
50ATF_TC(chroot_basic);
51ATF_TC_HEAD(chroot_basic, tc)
52{
53 atf_tc_set_md_var(tc, "descr", "A basic test of chroot(2)");
54 atf_tc_set_md_var(tc, "require.user", "root");
55}
56
57ATF_TC_BODY(chroot_basic, tc)
58{
59 char buf[PATH_MAX];
60 int fd, sta;
61 pid_t pid;
62
63 (void)memset(buf, '\0', sizeof(buf));
64 (void)getcwd(buf, sizeof(buf));
65 (void)strlcat(buf, "/dir", sizeof(buf));
66
67 ATF_REQUIRE(mkdir(buf, 0500) == 0);
68 ATF_REQUIRE(chdir(buf) == 0);
69
70 pid = fork();
71 ATF_REQUIRE(pid >= 0);
72
73 if (pid == 0) {
74
75 if (chroot(buf) != 0)
76 _exit(EXIT_FAILURE);
77
78 errno = 0;
79
80 if (chroot("/root") != -1)
81 _exit(EXIT_FAILURE);
82
83 if (errno != ENOENT)
84 _exit(EXIT_FAILURE);
85
86 fd = open("file", O_RDONLY | O_CREAT, 0600);
87
88 if (fd < 0)
89 _exit(EXIT_FAILURE);
90
91 if (close(fd) != 0)
92 _exit(EXIT_FAILURE);
93
94 _exit(EXIT_SUCCESS);
95 }
96
97 (void)wait(&sta);
98
99 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
100 atf_tc_fail("chroot(2) failed");
101
102 (void)chdir("/");
103 (void)strlcat(buf, "/file", sizeof(buf));
104
105 fd = open(buf, O_RDONLY);
106
107 if (fd < 0)
108 atf_tc_fail("chroot(2) did not change the root directory");
109
110 ATF_REQUIRE(close(fd) == 0);
111 ATF_REQUIRE(unlink(buf) == 0);
112}
113
114ATF_TC(chroot_err);
115ATF_TC_HEAD(chroot_err, tc)
116{
117 atf_tc_set_md_var(tc, "descr", "Test error conditions of chroot(2)");
118 atf_tc_set_md_var(tc, "require.user", "root");
119}
120
121ATF_TC_BODY(chroot_err, tc)
122{
123 char buf[PATH_MAX + 1];
124
125 (void)memset(buf, 'x', sizeof(buf));
126
127 errno = 0;
128 ATF_REQUIRE_ERRNO(ENAMETOOLONG, chroot(buf) == -1);
129
130 errno = 0;
131 ATF_REQUIRE_ERRNO(EFAULT, chroot((void *)-1) == -1);
132
133 errno = 0;
134 ATF_REQUIRE_ERRNO(ENOENT, chroot("/a/b/c/d/e/f/g/h/i/j") == -1);
135}
136
137ATF_TC(chroot_perm);
138ATF_TC_HEAD(chroot_perm, tc)
139{
140 atf_tc_set_md_var(tc, "descr", "Test permissions with chroot(2)");
141 atf_tc_set_md_var(tc, "require.user", "unprivileged");
142}
143
144ATF_TC_BODY(chroot_perm, tc)
145{
146 static char buf[LINE_MAX];
147 pid_t pid;
148 int sta;
149
150 (void)memset(buf, '\0', sizeof(buf));
151 ATF_REQUIRE(getcwd(buf, sizeof(buf)) != NULL);
152
153 pid = fork();
154 ATF_REQUIRE(pid >= 0);
155
156 if (pid == 0) {
157
158 errno = 0;
159
160 if (chroot(buf) != -1)
161 _exit(EXIT_FAILURE);
162
163 if (errno != EPERM)
164 _exit(EXIT_FAILURE);
165
166 _exit(EXIT_SUCCESS);
167 }
168
169 (void)wait(&sta);
170
171 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
172 atf_tc_fail("chroot(2) succeeded as unprivileged user");
173}
174
175ATF_TC(fchroot_basic);
176ATF_TC_HEAD(fchroot_basic, tc)
177{
178 atf_tc_set_md_var(tc, "descr", "A basic test of fchroot(2)");
179 atf_tc_set_md_var(tc, "require.user", "root");
180}
181
182ATF_TC_BODY(fchroot_basic, tc)
183{
184 char buf[PATH_MAX];
185 int fd, sta;
186 pid_t pid;
187
188 (void)memset(buf, '\0', sizeof(buf));
189 (void)getcwd(buf, sizeof(buf));
190 (void)strlcat(buf, "/dir", sizeof(buf));
191
192 ATF_REQUIRE(mkdir(buf, 0500) == 0);
193 ATF_REQUIRE(chdir(buf) == 0);
194
195 fd = open(buf, O_RDONLY);
196 ATF_REQUIRE(fd >= 0);
197
198 pid = fork();
199 ATF_REQUIRE(pid >= 0);
200
201 if (pid == 0) {
202
203 if (fchroot(fd) != 0)
204 _exit(EXIT_FAILURE);
205
206 if (close(fd) != 0)
207 _exit(EXIT_FAILURE);
208
209 fd = open("file", O_RDONLY | O_CREAT, 0600);
210
211 if (fd < 0)
212 _exit(EXIT_FAILURE);
213
214 if (close(fd) != 0)
215 _exit(EXIT_FAILURE);
216
217 _exit(EXIT_SUCCESS);
218 }
219
220 (void)wait(&sta);
221
222 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
223 atf_tc_fail("fchroot(2) failed");
224
225 (void)chdir("/");
226 (void)strlcat(buf, "/file", sizeof(buf));
227
228 fd = open(buf, O_RDONLY);
229
230 if (fd < 0)
231 atf_tc_fail("fchroot(2) did not change the root directory");
232
233 ATF_REQUIRE(close(fd) == 0);
234 ATF_REQUIRE(unlink(buf) == 0);
235}
236
237ATF_TC(fchroot_err);
238ATF_TC_HEAD(fchroot_err, tc)
239{
240 atf_tc_set_md_var(tc, "descr", "Test error conditions of fchroot(2)");
241 atf_tc_set_md_var(tc, "require.user", "root");
242}
243
244ATF_TC_BODY(fchroot_err, tc)
245{
246 int fd;
247
248 fd = open("/etc/passwd", O_RDONLY);
249 ATF_REQUIRE(fd >= 0);
250
251 errno = 0;
252 ATF_REQUIRE_ERRNO(EBADF, fchroot(-1) == -1);
253
254 errno = 0;
255 ATF_REQUIRE_ERRNO(ENOTDIR, fchroot(fd) == -1);
256
257 ATF_REQUIRE(close(fd) == 0);
258}
259
260ATF_TC(fchroot_perm);
261ATF_TC_HEAD(fchroot_perm, tc)
262{
263 atf_tc_set_md_var(tc, "descr", "Test permissions with fchroot(2)");
264 atf_tc_set_md_var(tc, "require.user", "root");
265}
266
267ATF_TC_BODY(fchroot_perm, tc)
268{
269 static char buf[LINE_MAX];
270 struct passwd *pw;
271 int fd, sta;
272 pid_t pid;
273
274 (void)memset(buf, '\0', sizeof(buf));
275 ATF_REQUIRE(getcwd(buf, sizeof(buf)) != NULL);
276
277 pw = getpwnam("nobody");
278 fd = open(buf, O_RDONLY);
279
280 ATF_REQUIRE(fd >= 0);
281 ATF_REQUIRE(pw != NULL);
282
283 pid = fork();
284 ATF_REQUIRE(pid >= 0);
285
286 if (pid == 0) {
287
288 (void)setuid(pw->pw_uid);
289
290 errno = 0;
291
292 if (fchroot(fd) != -1)
293 _exit(EXIT_FAILURE);
294
295 if (errno != EPERM)
296 _exit(EXIT_FAILURE);
297
298 _exit(EXIT_SUCCESS);
299 }
300
301 (void)wait(&sta);
302
303 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
304 atf_tc_fail("fchroot(2) succeeded as unprivileged user");
305}
306
307ATF_TP_ADD_TCS(tp)
308{
309
310 ATF_TP_ADD_TC(tp, chroot_basic);
311 ATF_TP_ADD_TC(tp, chroot_err);
312 ATF_TP_ADD_TC(tp, chroot_perm);
313/*
314 * Not available on OpenBSD
315 * ATF_TP_ADD_TC(tp, fchroot_basic);
316 * ATF_TP_ADD_TC(tp, fchroot_err);
317 * ATF_TP_ADD_TC(tp, fchroot_perm);
318 */
319
320 return atf_no_error();
321}
diff --git a/src/regress/lib/libc/sys/t_clock_gettime.c b/src/regress/lib/libc/sys/t_clock_gettime.c
new file mode 100644
index 0000000000..206710799e
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_clock_gettime.c
@@ -0,0 +1,215 @@
1/* $NetBSD: t_clock_gettime.c,v 1.3 2017/01/13 21:30:41 christos Exp $ */
2
3/*-
4 * Copyright (c) 2008 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * This code is derived from software contributed to The NetBSD Foundation
8 * by Frank Kardel.
9 *
10 * Redistribution and use in source and binary forms, with or without
11 * modification, are permitted provided that the following conditions
12 * are met:
13 * 1. Redistributions of source code must retain the above copyright
14 * notice, this list of conditions and the following disclaimer.
15 * 2. Redistributions in binary form must reproduce the above copyright
16 * notice, this list of conditions and the following disclaimer in the
17 * documentation and/or other materials provided with the distribution.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
20 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
21 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
23 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
24 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
25 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
26 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
27 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
28 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
29 * POSSIBILITY OF SUCH DAMAGE.
30 */
31
32/*-
33 * Copyright (c) 2006 Frank Kardel
34 * All rights reserved.
35 *
36 * Redistribution and use in source and binary forms, with or without
37 * modification, are permitted provided that the following conditions
38 * are met:
39 * 1. Redistributions of source code must retain the above copyright
40 * notice, this list of conditions and the following disclaimer.
41 * 2. Redistributions in binary form must reproduce the above copyright
42 * notice, this list of conditions and the following disclaimer in the
43 * documentation and/or other materials provided with the distribution.
44 *
45 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
46 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
47 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
48 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
49 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
50 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
51 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
52 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
53 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
54 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
55 * POSSIBILITY OF SUCH DAMAGE.
56 */
57
58#include "macros.h"
59
60#include <sys/cdefs.h>
61__COPYRIGHT("@(#) Copyright (c) 2008\
62 The NetBSD Foundation, inc. All rights reserved.");
63__RCSID("$NetBSD: t_clock_gettime.c,v 1.3 2017/01/13 21:30:41 christos Exp $");
64
65#include <sys/param.h>
66#include <sys/sysctl.h>
67
68
69#include "atf-c.h"
70#include <errno.h>
71#include <limits.h>
72#include <stdio.h>
73#include <stdint.h>
74#include <stdlib.h>
75#include <string.h>
76#include <time.h>
77#include <unistd.h>
78
79#include "h_macros.h"
80
81#define MINPOSDIFF 15000000 /* 15 ms for now */
82#define TIMEOUT 5
83
84#define TC_HARDWARE "kern.timecounter.hardware"
85#define TC_CHOICE "kern.timecounter.choice"
86
87static void
88check_timecounter(void)
89{
90 struct timespec tsa, tsb, tsl, res;
91 long long mindiff = INTMAX_MAX;
92 time_t endlimit;
93
94#define CL(x) \
95 do { \
96 if ((x) != -1) \
97 break; \
98 atf_tc_fail_nonfatal("%s: %s", #x, strerror(errno)); \
99 return; \
100 } while (0)
101
102 CL(clock_gettime(CLOCK_REALTIME, &tsa));
103 tsl = tsa;
104
105 CL(time(&endlimit));
106 endlimit += TIMEOUT + 1;
107
108 while ((time_t)tsa.tv_sec < endlimit) {
109 long long diff;
110
111 CL(clock_gettime(CLOCK_REALTIME, &tsb));
112 diff = 1000000000LL * (tsb.tv_sec - tsa.tv_sec)
113 + tsb.tv_nsec - tsa.tv_nsec;
114
115 if (diff > 0 && mindiff > diff)
116 mindiff = diff;
117
118 if (diff < 0 || diff > MINPOSDIFF) {
119 long long elapsed;
120 (void)printf("%stime TSA: 0x%jx.%08jx, TSB: 0x%jx.%08jx, "
121 "diff = %lld nsec, ", (diff < 0) ? "BAD " : "",
122 (uintmax_t)tsa.tv_sec, (uintmax_t)tsa.tv_nsec,
123 (uintmax_t)tsb.tv_sec, (uintmax_t)tsb.tv_nsec, diff);
124
125 elapsed = 1000000000LL * (tsb.tv_sec - tsl.tv_sec)
126 + tsb.tv_nsec - tsl.tv_nsec;
127
128
129 (void)printf("%lld nsec\n", elapsed);
130 tsl = tsb;
131
132 ATF_CHECK(diff >= 0);
133 if (diff < 0)
134 return;
135 }
136
137 tsa.tv_sec = tsb.tv_sec;
138 tsa.tv_nsec = tsb.tv_nsec;
139 }
140
141 if (clock_getres(CLOCK_REALTIME, &res) == 0) {
142 long long r = res.tv_sec * 1000000000 + res.tv_nsec;
143
144 (void)printf("Claimed resolution: %lld nsec (%f Hz) or "
145 "better\n", r, 1.0 / r * 1e9);
146 (void)printf("Observed minimum non zero delta: %lld "
147 "nsec\n", mindiff);
148 }
149
150#undef CL
151}
152
153ATF_TC(clock_gettime_real);
154ATF_TC_HEAD(clock_gettime_real, tc)
155{
156 atf_tc_set_md_var(tc, "require.user", "root");
157 atf_tc_set_md_var(tc, "descr",
158 "Checks the monotonicity of the CLOCK_REALTIME implementation");
159 atf_tc_set_md_var(tc, "timeout", "300");
160}
161
162ATF_TC_BODY(clock_gettime_real, tc)
163{
164 char name[128], cbuf[512], ctrbuf[10240];
165 size_t cbufsiz = sizeof(cbuf);
166 size_t ctrbufsiz = sizeof(ctrbuf);
167 const char *p;
168 char *save;
169 int quality, n;
170
171 if (sysctlbyname(TC_HARDWARE, cbuf, &cbufsiz, NULL, 0) != 0) {
172 (void)printf("\nChecking legacy time implementation "
173 "for %d seconds\n", TIMEOUT);
174 check_timecounter();
175 return;
176 /* NOTREACHED */
177 }
178 (void)printf("%s = %s\n", TC_HARDWARE, cbuf);
179 REQUIRE_LIBC(save = strdup(cbuf), NULL);
180
181 RL(sysctlbyname(TC_CHOICE, ctrbuf, &ctrbufsiz, NULL, 0));
182 (void)printf("%s = %s\n", TC_CHOICE, ctrbuf);
183
184 for (p = ctrbuf, n = 0; sscanf(p, "%127[^(](q=%d, f=%*u Hz)%*[ ]%n",
185 name, &quality, &n) == 2; p += n) {
186 struct timespec ts;
187 int ret;
188
189 if (quality < 0)
190 continue;
191
192 (void)printf("\nChecking %s for %d seconds\n", name, TIMEOUT);
193 CHECK_LIBC(ret = sysctlbyname(TC_HARDWARE, NULL, 0,
194 name, strlen(name)), -1);
195 if (ret == -1)
196 continue;
197
198 /* wait a bit to select new counter in clockinterrupt */
199 ts.tv_sec = 0;
200 ts.tv_nsec = 100000000;
201 (void)nanosleep(&ts, NULL);
202
203 check_timecounter();
204 }
205
206 RL(sysctlbyname(TC_HARDWARE, NULL, 0, save, strlen(save)));
207}
208
209ATF_TP_ADD_TCS(tp)
210{
211
212 ATF_TP_ADD_TC(tp, clock_gettime_real);
213
214 return atf_no_error();
215}
diff --git a/src/regress/lib/libc/sys/t_dup.c b/src/regress/lib/libc/sys/t_dup.c
new file mode 100644
index 0000000000..4021a4f6e4
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_dup.c
@@ -0,0 +1,395 @@
1/* $OpenBSD: t_dup.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_dup.c,v 1.9 2017/01/13 20:31:53 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_dup.c,v 1.9 2017/01/13 20:31:53 christos Exp $");
37
38#include <sys/resource.h>
39#include <sys/stat.h>
40#include <sys/wait.h>
41
42#include "atf-c.h"
43#include <errno.h>
44#include <fcntl.h>
45#include <limits.h>
46#include <stdbool.h>
47#include <stdio.h>
48#include <stdlib.h>
49#include <string.h>
50#include <unistd.h>
51#include <sysexits.h>
52
53static char path[] = "dup";
54static void check_mode(bool, bool, bool);
55
56static void
57check_mode(bool _dup, bool _dup2, bool _dup3)
58{
59 int mode[3] = { O_RDONLY, O_WRONLY, O_RDWR };
60 int perm[5] = { 0700, 0400, 0600, 0444, 0666 };
61 struct stat st, st1;
62 int fd, fd1, fd2;
63 size_t i, j;
64
65 /*
66 * Check that a duplicated descriptor
67 * retains the mode of the original file.
68 */
69 for (i = 0; i < __arraycount(mode); i++) {
70
71 for (j = 0; j < __arraycount(perm); j++) {
72
73 fd1 = open(path, mode[i] | O_CREAT, perm[j]);
74 fd2 = open("/etc/passwd", O_RDONLY);
75
76 ATF_REQUIRE(fd1 >= 0);
77 ATF_REQUIRE(fd2 >= 0);
78
79 if (_dup != false)
80 fd = dup(fd1);
81 else if (_dup2 != false)
82 fd = dup2(fd1, fd2);
83 else if (_dup3 != false)
84 fd = dup3(fd1, fd2, O_CLOEXEC);
85 else {
86 fd = -1;
87 }
88
89 ATF_REQUIRE(fd >= 0);
90
91 (void)memset(&st, 0, sizeof(struct stat));
92 (void)memset(&st1, 0, sizeof(struct stat));
93
94 ATF_REQUIRE(fstat(fd, &st) == 0);
95 ATF_REQUIRE(fstat(fd1, &st1) == 0);
96
97 if (st.st_mode != st1.st_mode)
98 atf_tc_fail("invalid mode");
99
100 (void)close(fd);
101 (void)close(fd1);
102 (void)close(fd2);
103 (void)unlink(path);
104 }
105 }
106}
107
108ATF_TC(dup2_basic);
109ATF_TC_HEAD(dup2_basic, tc)
110{
111 atf_tc_set_md_var(tc, "descr", "A basic test of dup2(2)");
112}
113
114ATF_TC_BODY(dup2_basic, tc)
115{
116 int fd, fd1, fd2;
117
118 fd1 = open("/etc/passwd", O_RDONLY);
119 fd2 = open("/etc/passwd", O_RDONLY);
120
121 ATF_REQUIRE(fd1 >= 0);
122 ATF_REQUIRE(fd2 >= 0);
123
124 fd = dup2(fd1, fd2);
125 ATF_REQUIRE(fd >= 0);
126
127 if (fd != fd2)
128 atf_tc_fail("invalid descriptor");
129
130 (void)close(fd);
131 (void)close(fd1);
132
133 ATF_REQUIRE(close(fd2) != 0);
134}
135
136ATF_TC(dup2_err);
137ATF_TC_HEAD(dup2_err, tc)
138{
139 atf_tc_set_md_var(tc, "descr", "Test error conditions of dup2(2)");
140}
141
142ATF_TC_BODY(dup2_err, tc)
143{
144 int fd;
145
146 fd = open("/etc/passwd", O_RDONLY);
147 ATF_REQUIRE(fd >= 0);
148
149 errno = 0;
150 ATF_REQUIRE_ERRNO(EBADF, dup2(-1, -1) == -1);
151
152 errno = 0;
153 ATF_REQUIRE_ERRNO(EBADF, dup2(fd, -1) == -1);
154
155 errno = 0;
156 ATF_REQUIRE_ERRNO(EBADF, dup2(-1, fd) == -1);
157
158 /*
159 * Note that this should not fail with EINVAL.
160 */
161 ATF_REQUIRE(dup2(fd, fd) != -1);
162
163 (void)close(fd);
164}
165
166ATF_TC(dup2_max);
167ATF_TC_HEAD(dup2_max, tc)
168{
169 atf_tc_set_md_var(tc, "descr", "Test dup2(2) against limits");
170}
171
172ATF_TC_BODY(dup2_max, tc)
173{
174 struct rlimit res;
175
176 (void)memset(&res, 0, sizeof(struct rlimit));
177 (void)getrlimit(RLIMIT_NOFILE, &res);
178
179 errno = 0;
180 ATF_REQUIRE_ERRNO(EBADF, dup2(STDERR_FILENO, res.rlim_cur + 1) == -1);
181}
182
183ATF_TC_WITH_CLEANUP(dup2_mode);
184ATF_TC_HEAD(dup2_mode, tc)
185{
186 atf_tc_set_md_var(tc, "descr", "A basic test of dup2(2)");
187}
188
189ATF_TC_BODY(dup2_mode, tc)
190{
191 check_mode(false, true, false);
192}
193
194ATF_TC_CLEANUP(dup2_mode, tc)
195{
196 (void)unlink(path);
197}
198
199
200ATF_TC(dup3_err);
201ATF_TC_HEAD(dup3_err, tc)
202{
203 atf_tc_set_md_var(tc, "descr",
204 "Test error conditions of dup3(2) (PR lib/45148)");
205}
206
207ATF_TC_BODY(dup3_err, tc)
208{
209 int fd;
210
211 fd = open("/etc/passwd", O_RDONLY);
212 ATF_REQUIRE(fd >= 0);
213
214 errno = 0;
215 /* Adjusted for OpenBSD, initially != -1 */
216 ATF_REQUIRE(dup3(fd, fd, O_CLOEXEC) == -1);
217
218 errno = 0;
219 /* Adjusted for OpenBSD, initially EBADF */
220 ATF_REQUIRE_ERRNO(EINVAL, dup3(-1, -1, O_CLOEXEC) == -1);
221
222 errno = 0;
223 ATF_REQUIRE_ERRNO(EBADF, dup3(fd, -1, O_CLOEXEC) == -1);
224
225 errno = 0;
226 ATF_REQUIRE_ERRNO(EBADF, dup3(-1, fd, O_CLOEXEC) == -1);
227
228 errno = 0;
229 ATF_REQUIRE_ERRNO(EINVAL, dup3(fd, 1, O_NOFOLLOW) == -1);
230
231 (void)close(fd);
232}
233
234ATF_TC(dup3_max);
235ATF_TC_HEAD(dup3_max, tc)
236{
237 atf_tc_set_md_var(tc, "descr", "Test dup3(2) against limits");
238}
239
240ATF_TC_BODY(dup3_max, tc)
241{
242 struct rlimit res;
243
244 (void)memset(&res, 0, sizeof(struct rlimit));
245 (void)getrlimit(RLIMIT_NOFILE, &res);
246
247 errno = 0;
248 ATF_REQUIRE_ERRNO(EBADF, dup3(STDERR_FILENO,
249 res.rlim_cur + 1, O_CLOEXEC) == -1);
250}
251
252ATF_TC_WITH_CLEANUP(dup3_mode);
253ATF_TC_HEAD(dup3_mode, tc)
254{
255 atf_tc_set_md_var(tc, "descr", "A basic test of dup3(2)");
256}
257
258ATF_TC_BODY(dup3_mode, tc)
259{
260 check_mode(false, false, true);
261}
262
263ATF_TC_CLEANUP(dup3_mode, tc)
264{
265 (void)unlink(path);
266}
267
268ATF_TC(dup_err);
269ATF_TC_HEAD(dup_err, tc)
270{
271 atf_tc_set_md_var(tc, "descr", "Test error conditions of dup(2)");
272}
273
274ATF_TC_BODY(dup_err, tc)
275{
276
277 errno = 0;
278 ATF_REQUIRE_ERRNO(EBADF, dup(-1) == -1);
279}
280
281ATF_TC_WITH_CLEANUP(dup_max);
282ATF_TC_HEAD(dup_max, tc)
283{
284 atf_tc_set_md_var(tc, "descr", "Test dup(2) against limits");
285}
286
287ATF_TC_BODY(dup_max, tc)
288{
289 struct rlimit res;
290 int *buf, fd, sta;
291 size_t i, n;
292 pid_t pid;
293
294 pid = fork();
295 ATF_REQUIRE(pid >= 0);
296
297 if (pid == 0) {
298
299 /*
300 * Open a temporary file until the
301 * maximum number of open files is
302 * reached. Ater that dup(2) family
303 * should fail with EMFILE.
304 */
305 /* Adjusted for OpenBSD, initially 0 */
306 (void)closefrom(STDERR_FILENO + 1);
307 (void)memset(&res, 0, sizeof(struct rlimit));
308
309 n = 10;
310 res.rlim_cur = res.rlim_max = n;
311 if (setrlimit(RLIMIT_NOFILE, &res) != 0)
312 _exit(EX_OSERR);
313
314 buf = calloc(n, sizeof(int));
315
316 if (buf == NULL)
317 _exit(EX_OSERR);
318
319 /* Adjusted for OpenBSD, initially mkstemp(path) */
320 buf[0] = open(path, O_CREAT|O_EXCL|O_RDWR, S_IRUSR|S_IWUSR);
321
322 if (buf[0] < 0)
323 _exit(EX_OSERR);
324
325 /* Adjusted for OpenBSD, initially i < n */
326 for (i = 1; i < n - (STDERR_FILENO + 1); i++) {
327
328 buf[i] = open(path, O_RDONLY);
329
330 if (buf[i] < 0)
331 _exit(EX_OSERR);
332 }
333
334 errno = 0;
335 fd = dup(buf[0]);
336
337 if (fd != -1 || errno != EMFILE)
338 _exit(EX_DATAERR);
339
340 _exit(EXIT_SUCCESS);
341 }
342
343 (void)wait(&sta);
344
345 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) {
346
347 if (WEXITSTATUS(sta) == EX_OSERR)
348 atf_tc_fail("system call error");
349
350 if (WEXITSTATUS(sta) == EX_DATAERR)
351 atf_tc_fail("dup(2) dupped more than RLIMIT_NOFILE");
352
353 atf_tc_fail("unknown error");
354 }
355
356 (void)unlink(path);
357}
358
359ATF_TC_CLEANUP(dup_max, tc)
360{
361 (void)unlink(path);
362}
363
364ATF_TC_WITH_CLEANUP(dup_mode);
365ATF_TC_HEAD(dup_mode, tc)
366{
367 atf_tc_set_md_var(tc, "descr", "A basic test of dup(2)");
368}
369
370ATF_TC_BODY(dup_mode, tc)
371{
372 check_mode(true, false, false);
373}
374
375ATF_TC_CLEANUP(dup_mode, tc)
376{
377 (void)unlink(path);
378}
379
380ATF_TP_ADD_TCS(tp)
381{
382
383 ATF_TP_ADD_TC(tp, dup2_basic);
384 ATF_TP_ADD_TC(tp, dup2_err);
385 ATF_TP_ADD_TC(tp, dup2_max);
386 ATF_TP_ADD_TC(tp, dup2_mode);
387 ATF_TP_ADD_TC(tp, dup3_err);
388 ATF_TP_ADD_TC(tp, dup3_max);
389 ATF_TP_ADD_TC(tp, dup3_mode);
390 ATF_TP_ADD_TC(tp, dup_err);
391 ATF_TP_ADD_TC(tp, dup_max);
392 ATF_TP_ADD_TC(tp, dup_mode);
393
394 return atf_no_error();
395}
diff --git a/src/regress/lib/libc/sys/t_fsync.c b/src/regress/lib/libc/sys/t_fsync.c
new file mode 100644
index 0000000000..c6f24c0e85
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_fsync.c
@@ -0,0 +1,125 @@
1/* $OpenBSD: t_fsync.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_fsync.c,v 1.2 2012/03/18 07:00:52 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_fsync.c,v 1.2 2012/03/18 07:00:52 jruoho Exp $");
37
38#include <errno.h>
39#include <fcntl.h>
40#include <stdio.h>
41#include <stdlib.h>
42#include <string.h>
43#include <unistd.h>
44
45#include "atf-c.h"
46
47ATF_TC(fsync_err);
48ATF_TC_HEAD(fsync_err, tc)
49{
50 atf_tc_set_md_var(tc, "descr",
51 "Test error conditions of fsync(2) (PR kern/30)");
52}
53
54ATF_TC_BODY(fsync_err, tc)
55{
56 int i, fd[2];
57
58 /*
59 * The fsync(2) call should fail with EBADF
60 * when the 'fd' is not a valid descriptor.
61 */
62 for (i = 1; i < 1024; i = i + 128) {
63
64 errno = 0;
65
66 ATF_REQUIRE(fsync(-i) == -1);
67 ATF_REQUIRE(errno == EBADF);
68 }
69
70 /*
71 * On the other hand, EINVAL should follow
72 * if the operation is not possible with
73 * the file descriptor.
74 */
75 ATF_REQUIRE(pipe(fd) == 0);
76
77 errno = 0;
78
79 ATF_REQUIRE(fsync(fd[0]) == -1);
80 ATF_REQUIRE(errno == EINVAL);
81
82 errno = 0;
83
84 ATF_REQUIRE(fsync(fd[1]) == -1);
85 ATF_REQUIRE(errno == EINVAL);
86
87 ATF_REQUIRE(close(fd[0]) == 0);
88 ATF_REQUIRE(close(fd[1]) == 0);
89}
90
91ATF_TC(fsync_sync);
92ATF_TC_HEAD(fsync_sync, tc)
93{
94 atf_tc_set_md_var(tc, "descr", "A basic test of fsync(2)");
95}
96
97ATF_TC_BODY(fsync_sync, tc)
98{
99 char buf[128];
100 int fd, i;
101
102 for (i = 0; i < 10; i++) {
103
104 (void)snprintf(buf, sizeof(buf), "t_fsync-%d", i);
105
106 /* Adjusted for OpenBSD, initially mkstemp(buf) */
107 fd = open(buf, O_CREAT|O_EXCL|O_RDWR, 0600);
108
109 ATF_REQUIRE(fd != -1);
110 ATF_REQUIRE(write(fd, "0", 1) == 1);
111 ATF_REQUIRE(fsync(fd) == 0);
112
113 ATF_REQUIRE(unlink(buf) == 0);
114 ATF_REQUIRE(close(fd) == 0);
115 }
116}
117
118ATF_TP_ADD_TCS(tp)
119{
120
121 ATF_TP_ADD_TC(tp, fsync_err);
122 ATF_TP_ADD_TC(tp, fsync_sync);
123
124 return atf_no_error();
125}
diff --git a/src/regress/lib/libc/sys/t_getgroups.c b/src/regress/lib/libc/sys/t_getgroups.c
new file mode 100644
index 0000000000..dcef3c16f5
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getgroups.c
@@ -0,0 +1,175 @@
1/* $OpenBSD: t_getgroups.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getgroups.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getgroups.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/wait.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <limits.h>
43#include <stdlib.h>
44#include <string.h>
45#include <unistd.h>
46
47ATF_TC(getgroups_err);
48ATF_TC_HEAD(getgroups_err, tc)
49{
50 atf_tc_set_md_var(tc, "descr", "Test errors in getgroups(2)");
51}
52
53ATF_TC_BODY(getgroups_err, tc)
54{
55 gid_t gidset[NGROUPS_MAX];
56
57 errno = 0;
58
59 ATF_REQUIRE(getgroups(NGROUPS_MAX, (gid_t *)-1) == -1);
60 ATF_REQUIRE(errno == EFAULT);
61
62 errno = 0;
63
64 ATF_REQUIRE(getgroups(-1, gidset) == -1);
65 ATF_REQUIRE(errno == EINVAL);
66}
67
68ATF_TC(getgroups_getgid);
69ATF_TC_HEAD(getgroups_getgid, tc)
70{
71 atf_tc_set_md_var(tc, "descr", "Test getgid(2) from getgroups(2)");
72}
73
74ATF_TC_BODY(getgroups_getgid, tc)
75{
76 gid_t gidset[NGROUPS_MAX];
77 gid_t gid = getgid();
78 int i, n;
79
80 /*
81 * Check that getgid(2) is found from
82 * the GIDs returned by getgroups(2).
83 */
84 n = getgroups(NGROUPS_MAX, gidset);
85
86 for (i = 0; i < n; i++) {
87
88 if (gidset[i] == gid)
89 return;
90 }
91
92 atf_tc_fail("getgid(2) not found from getgroups(2)");
93}
94
95ATF_TC(getgroups_setgid);
96ATF_TC_HEAD(getgroups_setgid, tc)
97{
98 atf_tc_set_md_var(tc, "descr", "Test setgid(2) from getgroups(2)");
99 atf_tc_set_md_var(tc, "require.user", "root");
100}
101
102ATF_TC_BODY(getgroups_setgid, tc)
103{
104 gid_t gidset[NGROUPS_MAX];
105 int i, n, rv, sta;
106 pid_t pid;
107
108 /*
109 * Check that we can setgid(2)
110 * to the returned group IDs.
111 */
112 n = getgroups(NGROUPS_MAX, gidset);
113 ATF_REQUIRE(n >= 0);
114
115 for (i = 0; i < n; i++) {
116
117 pid = fork();
118 ATF_REQUIRE(pid >= 0);
119
120 if (pid == 0) {
121
122 rv = setgid(gidset[i]);
123
124 if (rv != 0)
125 _exit(EXIT_FAILURE);
126
127 _exit(EXIT_SUCCESS);
128 }
129
130 (void)wait(&sta);
131
132 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
133 atf_tc_fail("getgroups(2) is inconsistent");
134 }
135}
136
137ATF_TC(getgroups_zero);
138ATF_TC_HEAD(getgroups_zero, tc)
139{
140 atf_tc_set_md_var(tc, "descr", "Test getgroups(2) with zero param");
141}
142
143ATF_TC_BODY(getgroups_zero, tc)
144{
145 const gid_t val = 123456789;
146 gid_t gidset[NGROUPS_MAX];
147 size_t i;
148
149 /*
150 * If the first parameter is zero, the number
151 * of groups should be returned but the supplied
152 * buffer should remain intact.
153 */
154 for (i = 0; i < __arraycount(gidset); i++)
155 gidset[i] = val;
156
157 ATF_REQUIRE(getgroups(0, gidset) >= 0);
158
159 for (i = 0; i < __arraycount(gidset); i++) {
160
161 if (gidset[i] != val)
162 atf_tc_fail("getgroups(2) modified the buffer");
163 }
164}
165
166ATF_TP_ADD_TCS(tp)
167{
168
169 ATF_TP_ADD_TC(tp, getgroups_err);
170 ATF_TP_ADD_TC(tp, getgroups_getgid);
171 ATF_TP_ADD_TC(tp, getgroups_setgid);
172 ATF_TP_ADD_TC(tp, getgroups_zero);
173
174 return atf_no_error();
175}
diff --git a/src/regress/lib/libc/sys/t_getitimer.c b/src/regress/lib/libc/sys/t_getitimer.c
new file mode 100644
index 0000000000..b6cc4102bb
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getitimer.c
@@ -0,0 +1,215 @@
1/* $OpenBSD: t_getitimer.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getitimer.c,v 1.2 2012/03/22 18:20:46 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getitimer.c,v 1.2 2012/03/22 18:20:46 christos Exp $");
37
38#include <sys/time.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <limits.h>
43#include <signal.h>
44#include <string.h>
45#include <unistd.h>
46
47static bool fail;
48static void sighandler(int);
49
50static void
51sighandler(int signo)
52{
53
54 if (signo == SIGALRM || signo == SIGVTALRM)
55 fail = false;
56}
57
58ATF_TC(getitimer_empty);
59ATF_TC_HEAD(getitimer_empty, tc)
60{
61 atf_tc_set_md_var(tc, "descr", "getitimer(2) before setitimer(2)");
62}
63
64ATF_TC_BODY(getitimer_empty, tc)
65{
66 struct itimerval it;
67
68 /*
69 * Verify that the passed structure remains
70 * empty after calling getitimer(2) but before
71 * actually arming the timer with setitimer(2).
72 */
73 (void)memset(&it, 0, sizeof(struct itimerval));
74
75 ATF_REQUIRE(getitimer(ITIMER_REAL, &it) == 0);
76
77 if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0)
78 goto fail;
79
80 ATF_REQUIRE(getitimer(ITIMER_VIRTUAL, &it) == 0);
81
82 if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0)
83 goto fail;
84
85 ATF_REQUIRE(getitimer(ITIMER_PROF, &it) == 0);
86
87 if (it.it_value.tv_sec != 0 || it.it_value.tv_usec != 0)
88 goto fail;
89
90 return;
91
92fail:
93 atf_tc_fail("getitimer(2) modfied the timer before it was armed");
94}
95
96ATF_TC(getitimer_err);
97ATF_TC_HEAD(getitimer_err, tc)
98{
99 atf_tc_set_md_var(tc, "descr", "Test errors from getitimer(2)");
100}
101
102ATF_TC_BODY(getitimer_err, tc)
103{
104 struct itimerval it;
105
106 errno = 0;
107 ATF_REQUIRE_ERRNO(EINVAL, getitimer(-1, &it) == -1);
108
109 errno = 0;
110 ATF_REQUIRE_ERRNO(EINVAL, getitimer(INT_MAX, &it) == -1);
111
112 errno = 0;
113 ATF_REQUIRE_ERRNO(EFAULT, getitimer(ITIMER_REAL, (void *)-1) == -1);
114}
115
116ATF_TC(setitimer_basic);
117ATF_TC_HEAD(setitimer_basic, tc)
118{
119 atf_tc_set_md_var(tc, "descr", "A basic test of setitimer(2)");
120}
121
122ATF_TC_BODY(setitimer_basic, tc)
123{
124 struct itimerval it;
125
126 it.it_value.tv_sec = 0;
127 it.it_value.tv_usec = 100;
128
129 it.it_interval.tv_sec = 0;
130 it.it_interval.tv_usec = 0;
131
132 fail = true;
133
134 ATF_REQUIRE(signal(SIGALRM, sighandler) != SIG_ERR);
135 ATF_REQUIRE(setitimer(ITIMER_REAL, &it, NULL) == 0);
136
137 /*
138 * Although the interaction between
139 * setitimer(2) and sleep(3) can be
140 * unspecified, it is assumed that one
141 * second suspension will be enough for
142 * the timer to fire.
143 */
144 (void)sleep(1);
145
146 if (fail != false)
147 atf_tc_fail("timer did not fire");
148}
149
150ATF_TC(setitimer_err);
151ATF_TC_HEAD(setitimer_err, tc)
152{
153 atf_tc_set_md_var(tc, "descr", "Test errors from setitimer(2)"
154 " (PR standards/44927)");
155}
156
157ATF_TC_BODY(setitimer_err, tc)
158{
159 struct itimerval it, ot;
160
161 errno = 0;
162 ATF_REQUIRE_ERRNO(EINVAL, setitimer(-1, &it, &ot) == -1);
163
164 errno = 0;
165 ATF_REQUIRE_ERRNO(EINVAL, setitimer(INT_MAX, &it, &ot) == -1);
166
167 errno = 0;
168 ATF_REQUIRE_ERRNO(EFAULT, setitimer(ITIMER_REAL,(void*)-1, &ot) == -1);
169}
170
171ATF_TC(setitimer_old);
172ATF_TC_HEAD(setitimer_old, tc)
173{
174 atf_tc_set_md_var(tc, "descr", "Test old values from setitimer(2)");
175}
176
177ATF_TC_BODY(setitimer_old, tc)
178{
179 struct itimerval it, ot;
180
181 /*
182 * Make two calls; the second one
183 * should store the old values.
184 */
185 it.it_value.tv_sec = 4;
186 it.it_value.tv_usec = 3;
187
188 it.it_interval.tv_sec = 0;
189 it.it_interval.tv_usec = 0;
190
191 ATF_REQUIRE(setitimer(ITIMER_REAL, &it, &ot) == 0);
192
193 it.it_value.tv_sec = 2;
194 it.it_value.tv_usec = 1;
195
196 it.it_interval.tv_sec = 0;
197 it.it_interval.tv_usec = 0;
198
199 ATF_REQUIRE(setitimer(ITIMER_REAL, &it, &ot) == 0);
200
201 if (ot.it_value.tv_sec != 4 || ot.it_value.tv_usec != 3)
202 atf_tc_fail("setitimer(2) did not store old values");
203}
204
205ATF_TP_ADD_TCS(tp)
206{
207
208 ATF_TP_ADD_TC(tp, getitimer_empty);
209 ATF_TP_ADD_TC(tp, getitimer_err);
210 ATF_TP_ADD_TC(tp, setitimer_basic);
211 ATF_TP_ADD_TC(tp, setitimer_err);
212 ATF_TP_ADD_TC(tp, setitimer_old);
213
214 return atf_no_error();
215}
diff --git a/src/regress/lib/libc/sys/t_getlogin.c b/src/regress/lib/libc/sys/t_getlogin.c
new file mode 100644
index 0000000000..3c98cd7de8
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getlogin.c
@@ -0,0 +1,241 @@
1/* $OpenBSD: t_getlogin.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getlogin.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getlogin.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/param.h>
39#include <sys/wait.h>
40
41#include "atf-c.h"
42#include <errno.h>
43#include <stdlib.h>
44#include <string.h>
45#include <unistd.h>
46
47ATF_TC(getlogin_r_err);
48ATF_TC_HEAD(getlogin_r_err, tc)
49{
50 atf_tc_set_md_var(tc, "descr", "Test errors from getlogin_r(2)");
51}
52
53ATF_TC_BODY(getlogin_r_err, tc)
54{
55 char small[0];
56
57 ATF_REQUIRE(getlogin_r(small, sizeof(small)) == ERANGE);
58}
59
60ATF_TC(getlogin_same);
61ATF_TC_HEAD(getlogin_same, tc)
62{
63 atf_tc_set_md_var(tc, "descr", "getlogin(2) vs. getlogin_r(2)");
64}
65
66ATF_TC_BODY(getlogin_same, tc)
67{
68 char buf[MAXLOGNAME];
69 char *str;
70
71 str = getlogin();
72
73 if (str == NULL)
74 return;
75
76 ATF_REQUIRE(getlogin_r(buf, sizeof(buf)) == 0);
77
78 if (strcmp(str, buf) != 0)
79 atf_tc_fail("getlogin(2) and getlogin_r(2) differ");
80}
81
82ATF_TC(setlogin_basic);
83ATF_TC_HEAD(setlogin_basic, tc)
84{
85 atf_tc_set_md_var(tc, "descr", "Test that setlogin(2) works");
86 atf_tc_set_md_var(tc, "require.user", "root");
87}
88
89ATF_TC_BODY(setlogin_basic, tc)
90{
91 char *name;
92 pid_t pid;
93 int sta;
94
95 pid = fork();
96 ATF_REQUIRE(pid >= 0);
97
98 if (pid == 0) {
99
100 (void)setsid();
101
102 if (setlogin("foobar") != 0)
103 _exit(EXIT_FAILURE);
104
105 name = getlogin();
106
107 if (name == NULL)
108 _exit(EXIT_FAILURE);
109
110 if (strcmp(name, "foobar") != 0)
111 _exit(EXIT_FAILURE);
112
113 _exit(EXIT_SUCCESS);
114 }
115
116 (void)wait(&sta);
117
118 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
119 atf_tc_fail("setlogin(2) failed to set login name");
120}
121
122ATF_TC(setlogin_err);
123ATF_TC_HEAD(setlogin_err, tc)
124{
125 atf_tc_set_md_var(tc, "descr", "Test errors from setlogin(2)");
126 atf_tc_set_md_var(tc, "require.user", "root");
127}
128
129ATF_TC_BODY(setlogin_err, tc)
130{
131 char buf[MAXLOGNAME + 1];
132 char *name;
133 pid_t pid;
134 int sta;
135
136 pid = fork();
137 ATF_REQUIRE(pid >= 0);
138
139 (void)memset(buf, 'x', sizeof(buf));
140
141 if (pid == 0) {
142
143 (void)setsid();
144
145 errno = 0;
146
147 if (setlogin(buf) != -1)
148 _exit(EINVAL);
149
150 if (errno != EINVAL)
151 _exit(EINVAL);
152
153 errno = 0;
154
155 if (setlogin((void *)-1) != -1)
156 _exit(EFAULT);
157
158 if (errno != EFAULT)
159 _exit(EFAULT);
160
161 name = getlogin();
162
163 if (name == NULL)
164 _exit(EXIT_FAILURE);
165
166 if (strcmp(name, "foobar") == 0)
167 _exit(EXIT_FAILURE);
168
169 _exit(EXIT_SUCCESS);
170 }
171
172 (void)wait(&sta);
173
174 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) {
175
176 if (WEXITSTATUS(sta) == EFAULT)
177 atf_tc_fail("expected EFAULT, but the call succeeded");
178
179 if (WEXITSTATUS(sta) == EINVAL)
180 atf_tc_fail("expected EINVAL, but the call succeeded");
181
182 atf_tc_fail("setlogin(2) failed, but login name was set");
183 }
184}
185
186ATF_TC(setlogin_perm);
187ATF_TC_HEAD(setlogin_perm, tc)
188{
189 atf_tc_set_md_var(tc, "descr", "Test setlogin(2) as normal user");
190 atf_tc_set_md_var(tc, "require.user", "unprivileged");
191}
192
193ATF_TC_BODY(setlogin_perm, tc)
194{
195 char *name;
196 pid_t pid;
197 int sta;
198
199 pid = fork();
200 ATF_REQUIRE(pid >= 0);
201
202 if (pid == 0) {
203
204 (void)setsid();
205
206 errno = 0;
207
208 if (setlogin("foobar") != -1)
209 _exit(EXIT_FAILURE);
210
211 if (errno != EPERM)
212 _exit(EXIT_FAILURE);
213
214 name = getlogin();
215
216 if (name == NULL)
217 _exit(EXIT_FAILURE);
218
219 if (strcmp(name, "foobar") == 0)
220 _exit(EXIT_FAILURE);
221
222 _exit(EXIT_SUCCESS);
223 }
224
225 (void)wait(&sta);
226
227 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
228 atf_tc_fail("login name was set as an unprivileged user");
229}
230
231ATF_TP_ADD_TCS(tp)
232{
233
234 ATF_TP_ADD_TC(tp, getlogin_r_err);
235 ATF_TP_ADD_TC(tp, getlogin_same);
236 ATF_TP_ADD_TC(tp, setlogin_basic);
237 ATF_TP_ADD_TC(tp, setlogin_err);
238 ATF_TP_ADD_TC(tp, setlogin_perm);
239
240 return atf_no_error();
241}
diff --git a/src/regress/lib/libc/sys/t_getpid.c b/src/regress/lib/libc/sys/t_getpid.c
new file mode 100644
index 0000000000..0dbf7f43fe
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getpid.c
@@ -0,0 +1,138 @@
1/* $OpenBSD: t_getpid.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getpid.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getpid.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/wait.h>
39
40#include <stdlib.h>
41#include <pthread.h>
42#include <unistd.h>
43
44#include "atf-c.h"
45
46static int maxiter = 10;
47static void *threadfunc(void *);
48
49static void *
50threadfunc(void *arg)
51{
52 *(pid_t *)arg = getpid();
53
54 return NULL;
55}
56
57ATF_TC(getpid_process);
58ATF_TC_HEAD(getpid_process, tc)
59{
60 atf_tc_set_md_var(tc, "descr", "Test getpid(2) with processes");
61}
62
63ATF_TC_BODY(getpid_process, tc)
64{
65 pid_t ppid, fpid, cpid, tpid, wpid;
66 int i, sta;
67
68 for (i = 0; i < maxiter; i++) {
69
70 tpid = getpid();
71 fpid = fork();
72
73 ATF_REQUIRE(fpid >= 0);
74
75 if (fpid == 0) {
76
77 cpid = getpid();
78 ppid = getppid();
79
80 if (tpid != ppid)
81 _exit(EXIT_FAILURE);
82
83 if (cpid == ppid)
84 _exit(EXIT_FAILURE);
85
86 if (tpid == fpid)
87 _exit(EXIT_FAILURE);
88
89 _exit(EXIT_SUCCESS);
90 }
91
92 wpid = wait(&sta);
93
94 if (wpid != fpid)
95 atf_tc_fail("PID mismatch");
96
97 ATF_REQUIRE(WIFEXITED(sta) != 0);
98
99 if (WEXITSTATUS(sta) != EXIT_SUCCESS)
100 atf_tc_fail("PID mismatch");
101 }
102}
103
104ATF_TC(getpid_thread);
105ATF_TC_HEAD(getpid_thread, tc)
106{
107 atf_tc_set_md_var(tc, "descr", "Test getpid(2) with threads");
108}
109
110ATF_TC_BODY(getpid_thread, tc)
111{
112 pid_t pid, tpid;
113 pthread_t tid;
114 int i, rv;
115
116 for (i = 0; i < maxiter; i++) {
117
118 pid = getpid();
119
120 rv = pthread_create(&tid, NULL, threadfunc, &tpid);
121 ATF_REQUIRE(rv == 0);
122
123 rv = pthread_join(tid, NULL);
124 ATF_REQUIRE(rv == 0);
125
126 if (pid != tpid)
127 atf_tc_fail("Unequal PIDs");
128 }
129}
130
131ATF_TP_ADD_TCS(tp)
132{
133
134 ATF_TP_ADD_TC(tp, getpid_process);
135 ATF_TP_ADD_TC(tp, getpid_thread);
136
137 return atf_no_error();
138}
diff --git a/src/regress/lib/libc/sys/t_getrusage.c b/src/regress/lib/libc/sys/t_getrusage.c
new file mode 100644
index 0000000000..481d73431b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getrusage.c
@@ -0,0 +1,269 @@
1/* $OpenBSD: t_getrusage.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getrusage.c,v 1.8 2018/05/09 08:45:03 mrg Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getrusage.c,v 1.8 2018/05/09 08:45:03 mrg Exp $");
37
38#include <sys/resource.h>
39#include <sys/time.h>
40
41#include "atf-c.h"
42#include <stdio.h>
43#include <errno.h>
44#include <limits.h>
45#include <signal.h>
46#include <stdint.h>
47#include <stdlib.h>
48#include <string.h>
49#include <fcntl.h>
50#include <sys/socket.h>
51#include <netinet/in.h>
52
53static void work(void);
54static void sighandler(int);
55
56static const size_t maxiter = 2000;
57
58static void
59sighandler(int signo __unused)
60{
61 /* Nothing. */
62}
63
64static void
65work(void)
66{
67 size_t n = UINT16_MAX * 10;
68
69 while (n > 0) {
70#ifdef __or1k__
71 asm volatile("l.nop"); /* Do something. */
72#elif defined(__ia64__)
73 asm volatile("nop 0"); /* Do something. */
74#else
75 asm volatile("nop"); /* Do something. */
76#endif
77 n--;
78 }
79}
80
81ATF_TC(getrusage_err);
82ATF_TC_HEAD(getrusage_err, tc)
83{
84 atf_tc_set_md_var(tc, "descr", "Test error conditions");
85}
86
87ATF_TC_BODY(getrusage_err, tc)
88{
89 struct rusage ru;
90
91 errno = 0;
92
93 ATF_REQUIRE(getrusage(INT_MAX, &ru) != 0);
94 ATF_REQUIRE(errno == EINVAL);
95
96 errno = 0;
97
98 ATF_REQUIRE(getrusage(RUSAGE_SELF, (void *)0) != 0);
99 ATF_REQUIRE(errno == EFAULT);
100}
101
102ATF_TC(getrusage_sig);
103ATF_TC_HEAD(getrusage_sig, tc)
104{
105 atf_tc_set_md_var(tc, "descr", "Test signal count with getrusage(2)");
106}
107
108ATF_TC_BODY(getrusage_sig, tc)
109{
110 struct rusage ru;
111 const long n = 5;
112 int i;
113
114 /*
115 * Test that signals are recorded.
116 */
117 ATF_REQUIRE(signal(SIGUSR1, sighandler) != SIG_ERR);
118
119 for (i = 0; i < n; i++)
120 ATF_REQUIRE(raise(SIGUSR1) == 0);
121
122 (void)memset(&ru, 0, sizeof(struct rusage));
123 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
124
125 if (n != ru.ru_nsignals)
126 atf_tc_fail("getrusage(2) did not record signals");
127}
128
129ATF_TC(getrusage_maxrss);
130ATF_TC_HEAD(getrusage_maxrss, tc)
131{
132 atf_tc_set_md_var(tc, "descr", "Test maxrss growing with getrusage(2)");
133}
134
135ATF_TC_BODY(getrusage_maxrss, tc)
136{
137 struct rusage ru;
138 long maxrss;
139 int i, fd;
140
141#define DUMP_FILE "dump"
142
143 fd = open(DUMP_FILE, O_WRONLY|O_CREAT|O_TRUNC, 0222);
144 ATF_REQUIRE(fd != -1);
145
146 (void)memset(&ru, 0, sizeof(struct rusage));
147 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
148 maxrss = ru.ru_maxrss;
149
150#define CHUNK (1024 * 1024)
151 for (i = 0; i < 40; i++) {
152 void *p = malloc(CHUNK);
153 memset(p, 0, CHUNK);
154 write(fd, p, CHUNK);
155 }
156 close(fd);
157 unlink(DUMP_FILE);
158
159 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
160 ATF_REQUIRE_MSG(maxrss < ru.ru_maxrss,
161 "maxrss: %ld, ru.ru_maxrss: %ld", maxrss, ru.ru_maxrss);
162}
163
164ATF_TC(getrusage_msgsnd);
165ATF_TC_HEAD(getrusage_msgsnd, tc)
166{
167 atf_tc_set_md_var(tc, "descr", "Test send growing with getrusage(2)");
168}
169
170ATF_TC_BODY(getrusage_msgsnd, tc)
171{
172 struct rusage ru;
173 long msgsnd;
174 int s, i;
175 struct sockaddr_in sin;
176
177 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
178 msgsnd = ru.ru_msgsnd;
179
180 s = socket(AF_INET, SOCK_DGRAM, 0);
181 ATF_REQUIRE(s >= 0);
182 memset(&sin, 0, sizeof(sin));
183 sin.sin_family = AF_INET;
184 sin.sin_len = sizeof(sin);
185 sin.sin_addr.s_addr = ntohl(INADDR_LOOPBACK);
186 sin.sin_port = htons(3333);
187
188 for (i = 0; i < 10; i++)
189 ATF_REQUIRE(sendto(s, &sin, sizeof(sin), 0, (void *)&sin,
190 (socklen_t)sizeof(sin)) != -1);
191
192 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
193 ATF_REQUIRE(msgsnd + 10 == ru.ru_msgsnd);
194 close(s);
195}
196
197ATF_TC(getrusage_utime_back);
198ATF_TC_HEAD(getrusage_utime_back, tc)
199{
200 atf_tc_set_md_var(tc, "descr", "Test bogus values from getrusage(2)");
201}
202
203ATF_TC_BODY(getrusage_utime_back, tc)
204{
205 struct rusage ru1, ru2;
206 size_t i;
207
208 /*
209 * Test that two consecutive calls are sane.
210 */
211
212 for (i = 0; i < maxiter; i++) {
213
214 (void)memset(&ru1, 0, sizeof(struct rusage));
215 (void)memset(&ru2, 0, sizeof(struct rusage));
216
217 work();
218
219 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru1) == 0);
220
221 work();
222
223 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru2) == 0);
224
225 if (timercmp(&ru2.ru_utime, &ru1.ru_utime, <) != 0)
226 atf_tc_fail("user time went backwards");
227 }
228}
229
230ATF_TC(getrusage_utime_zero);
231ATF_TC_HEAD(getrusage_utime_zero, tc)
232{
233 atf_tc_set_md_var(tc, "descr", "Test zero utime from getrusage(2)");
234}
235
236ATF_TC_BODY(getrusage_utime_zero, tc)
237{
238 struct rusage ru;
239 size_t i;
240
241 /*
242 * Test that getrusage(2) does not return
243 * zero user time for the calling process.
244 */
245
246 for (i = 0; i < maxiter; i++) {
247 work();
248 }
249
250 (void)memset(&ru, 0, sizeof(struct rusage));
251
252 ATF_REQUIRE(getrusage(RUSAGE_SELF, &ru) == 0);
253
254 if (ru.ru_utime.tv_sec == 0 && ru.ru_utime.tv_usec == 0)
255 atf_tc_fail("zero user time from getrusage(2)");
256}
257
258ATF_TP_ADD_TCS(tp)
259{
260
261 ATF_TP_ADD_TC(tp, getrusage_err);
262 ATF_TP_ADD_TC(tp, getrusage_sig);
263 ATF_TP_ADD_TC(tp, getrusage_maxrss);
264 ATF_TP_ADD_TC(tp, getrusage_msgsnd);
265 ATF_TP_ADD_TC(tp, getrusage_utime_back);
266 ATF_TP_ADD_TC(tp, getrusage_utime_zero);
267
268 return atf_no_error();
269}
diff --git a/src/regress/lib/libc/sys/t_getsid.c b/src/regress/lib/libc/sys/t_getsid.c
new file mode 100644
index 0000000000..5ccc2ca1a1
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getsid.c
@@ -0,0 +1,123 @@
1/* $OpenBSD: t_getsid.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getsid.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_getsid.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/wait.h>
39
40#include <errno.h>
41#include <stdlib.h>
42#include <unistd.h>
43
44#include "atf-c.h"
45
46ATF_TC(getsid_current);
47ATF_TC_HEAD(getsid_current, tc)
48{
49 atf_tc_set_md_var(tc, "descr", "Test getsid(0)");
50}
51
52ATF_TC_BODY(getsid_current, tc)
53{
54 pid_t sid;
55
56 sid = getsid(0);
57 ATF_REQUIRE(sid != -1);
58
59 if (sid != getsid(getpid()))
60 atf_tc_fail("getsid(0) did not match the calling process");
61}
62
63ATF_TC(getsid_err);
64ATF_TC_HEAD(getsid_err, tc)
65{
66 atf_tc_set_md_var(tc, "descr", "Test error conditions in getsid(2)");
67}
68
69ATF_TC_BODY(getsid_err, tc)
70{
71
72 errno = 0;
73
74 ATF_REQUIRE(getsid(-1) == -1);
75 ATF_REQUIRE(errno == ESRCH);
76}
77
78ATF_TC(getsid_process);
79ATF_TC_HEAD(getsid_process, tc)
80{
81 atf_tc_set_md_var(tc, "descr", "Test getsid(2) with processes");
82}
83
84ATF_TC_BODY(getsid_process, tc)
85{
86 pid_t csid, pid, ppid, sid;
87 int sta;
88
89 sid = getsid(0);
90 pid = fork();
91
92 ATF_REQUIRE(pid >= 0);
93 ATF_REQUIRE(sid != -1);
94
95 if (pid == 0) {
96
97 csid = getsid(0);
98 ppid = getppid();
99
100 if (sid != csid)
101 _exit(EXIT_FAILURE);
102
103 if (getsid(ppid) != csid)
104 _exit(EXIT_FAILURE);
105
106 _exit(EXIT_SUCCESS);
107 }
108
109 (void)wait(&sta);
110
111 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
112 atf_tc_fail("invalid session ID");
113}
114
115ATF_TP_ADD_TCS(tp)
116{
117
118 ATF_TP_ADD_TC(tp, getsid_current);
119 ATF_TP_ADD_TC(tp, getsid_err);
120 ATF_TP_ADD_TC(tp, getsid_process);
121
122 return atf_no_error();
123}
diff --git a/src/regress/lib/libc/sys/t_getsockname.c b/src/regress/lib/libc/sys/t_getsockname.c
new file mode 100644
index 0000000000..8b0accd7a0
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_getsockname.c
@@ -0,0 +1,85 @@
1/* $OpenBSD: t_getsockname.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_getsockname.c,v 1.1 2016/07/30 11:03:54 njoly Exp $ */
3/*
4 * Copyright (c) 2016 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/socket.h>
33#include <sys/un.h>
34
35#include <string.h>
36#include <unistd.h>
37
38#include "atf-c.h"
39
40ATF_TC(getsockname_unix);
41
42ATF_TC_HEAD(getsockname_unix, tc)
43{
44 atf_tc_set_md_var(tc, "descr", "Checks getsockname with UNIX domain");
45}
46
47ATF_TC_BODY(getsockname_unix, tc)
48{
49 const char *path = "sock.unix";
50 int sd;
51 socklen_t len;
52 struct sockaddr_un sun;
53
54 sd = socket(AF_UNIX, SOCK_STREAM, 0);
55 ATF_REQUIRE(sd != -1);
56
57 len = sizeof(sun);
58 memset(&sun, 0, sizeof(sun));
59 ATF_REQUIRE(getsockname(sd, (struct sockaddr *)&sun, &len) != -1);
60 ATF_CHECK(sun.sun_family == AF_UNIX);
61 ATF_CHECK(strcmp(sun.sun_path, "") == 0);
62
63 len = sizeof(sun);
64 memset(&sun, 0, sizeof(sun));
65 sun.sun_family = AF_UNIX;
66 strcpy(sun.sun_path, path);
67 ATF_REQUIRE(bind(sd, (struct sockaddr *)&sun, len) != -1);
68
69 len = sizeof(sun);
70 memset(&sun, 0, sizeof(sun));
71 ATF_REQUIRE(getsockname(sd, (struct sockaddr *)&sun, &len) != -1);
72 ATF_CHECK(sun.sun_family == AF_UNIX);
73 ATF_CHECK(strcmp(sun.sun_path, path) == 0);
74
75 ATF_REQUIRE(close(sd) != -1);
76 ATF_REQUIRE(unlink(path) != -1);
77}
78
79ATF_TP_ADD_TCS(tp)
80{
81
82 ATF_TP_ADD_TC(tp, getsockname_unix);
83
84 return atf_no_error();
85}
diff --git a/src/regress/lib/libc/sys/t_gettimeofday.c b/src/regress/lib/libc/sys/t_gettimeofday.c
new file mode 100644
index 0000000000..de768b023a
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_gettimeofday.c
@@ -0,0 +1,90 @@
1/* $OpenBSD: t_gettimeofday.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_gettimeofday.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_gettimeofday.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/time.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <string.h>
43
44ATF_TC(gettimeofday_err);
45ATF_TC_HEAD(gettimeofday_err, tc)
46{
47 atf_tc_set_md_var(tc, "descr", "Test errors from gettimeofday(2)");
48}
49
50ATF_TC_BODY(gettimeofday_err, tc)
51{
52
53 errno = 0;
54
55 ATF_REQUIRE_ERRNO(EFAULT, gettimeofday((void *)-1, NULL) != 0);
56}
57
58ATF_TC(gettimeofday_mono);
59ATF_TC_HEAD(gettimeofday_mono, tc)
60{
61 atf_tc_set_md_var(tc, "descr", "Test monotonicity of gettimeofday(2)");
62}
63
64ATF_TC_BODY(gettimeofday_mono, tc)
65{
66 static const size_t maxiter = 100;
67 struct timeval tv1, tv2;
68 size_t i;
69
70 for (i = 0; i < maxiter; i++) {
71
72 (void)memset(&tv1, 0, sizeof(struct timeval));
73 (void)memset(&tv2, 0, sizeof(struct timeval));
74
75 ATF_REQUIRE(gettimeofday(&tv1, NULL) == 0);
76 ATF_REQUIRE(gettimeofday(&tv2, NULL) == 0);
77
78 if (timercmp(&tv2, &tv1, <) != 0)
79 atf_tc_fail("time went backwards");
80 }
81}
82
83ATF_TP_ADD_TCS(tp)
84{
85
86 ATF_TP_ADD_TC(tp, gettimeofday_err);
87 ATF_TP_ADD_TC(tp, gettimeofday_mono);
88
89 return atf_no_error();
90}
diff --git a/src/regress/lib/libc/sys/t_kill.c b/src/regress/lib/libc/sys/t_kill.c
new file mode 100644
index 0000000000..c92bbdd18b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_kill.c
@@ -0,0 +1,316 @@
1/* $OpenBSD: t_kill.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_kill.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_kill.c,v 1.1 2011/07/07 06:57:53 jruoho Exp $");
37
38#include <sys/wait.h>
39
40#include <errno.h>
41#include <limits.h>
42#include <pwd.h>
43#include <signal.h>
44#include <stdlib.h>
45#include <unistd.h>
46
47#include "atf-c.h"
48
49ATF_TC(kill_basic);
50ATF_TC_HEAD(kill_basic, tc)
51{
52 atf_tc_set_md_var(tc, "descr", "Test that kill(2) works");
53}
54
55ATF_TC_BODY(kill_basic, tc)
56{
57 const int sig[] = { SIGHUP, SIGINT, SIGKILL, SIGTERM };
58 pid_t pid;
59 size_t i;
60 int sta;
61
62 for (i = 0; i < __arraycount(sig); i++) {
63
64 pid = fork();
65 ATF_REQUIRE(pid >= 0);
66
67 switch (pid) {
68
69 case 0:
70 pause();
71 break;
72
73 default:
74 ATF_REQUIRE(kill(pid, sig[i]) == 0);
75 }
76
77 (void)wait(&sta);
78
79 if (WIFSIGNALED(sta) == 0 || WTERMSIG(sta) != sig[i])
80 atf_tc_fail("kill(2) failed to kill child");
81 }
82}
83
84ATF_TC(kill_err);
85ATF_TC_HEAD(kill_err, tc)
86{
87 atf_tc_set_md_var(tc, "descr", "Test error conditions of kill(2)");
88}
89
90ATF_TC_BODY(kill_err, tc)
91{
92 int rv, sta;
93 pid_t pid;
94
95 pid = fork();
96 ATF_REQUIRE(pid >= 0);
97
98 if (pid == 0) {
99
100 errno = 0;
101 rv = kill(getpid(), -1);
102
103 if (rv == 0 || errno != EINVAL)
104 _exit(EINVAL);
105
106 errno = 0;
107 rv = kill(INT_MAX, SIGUSR1);
108
109 if (rv == 0 || errno != ESRCH)
110 _exit(ESRCH);
111
112 _exit(EXIT_SUCCESS);
113 }
114
115 (void)wait(&sta);
116
117 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) {
118
119 if (WEXITSTATUS(sta) == EINVAL)
120 atf_tc_fail("expected EINVAL, but kill(2) succeeded");
121
122 if (WEXITSTATUS(sta) == ESRCH)
123 atf_tc_fail("expected ESRCH, but kill(2) succeeded");
124
125 atf_tc_fail("unknown error from kill(2)");
126 }
127}
128
129ATF_TC(kill_perm);
130ATF_TC_HEAD(kill_perm, tc)
131{
132 atf_tc_set_md_var(tc, "descr", "Test kill(2) permissions");
133 atf_tc_set_md_var(tc, "require.user", "root");
134}
135
136ATF_TC_BODY(kill_perm, tc)
137{
138 struct passwd *pw;
139 pid_t cpid, ppid;
140 uid_t cuid = 0;
141 uid_t puid = 0;
142 int sta;
143
144 /*
145 * Test that kill(2) fails when called
146 * for a PID owned by another user.
147 */
148 pw = getpwnam("operator");
149
150 if (pw != NULL)
151 cuid = pw->pw_uid;
152
153 pw = getpwnam("nobody");
154
155 if (pw != NULL)
156 puid = pw->pw_uid;
157
158 if (cuid == 0 || puid == 0 || cuid == puid)
159 atf_tc_fail("getpwnam(3) failed");
160
161 ppid = fork();
162
163 if (ppid < 0)
164 _exit(EXIT_FAILURE);
165
166 if (ppid == 0) {
167
168 cpid = fork();
169
170 if (cpid < 0)
171 _exit(EXIT_FAILURE);
172
173 if (cpid == 0) {
174
175 if (setuid(cuid) < 0)
176 _exit(EXIT_FAILURE);
177 else {
178 (void)sleep(1);
179 }
180
181 _exit(EXIT_SUCCESS);
182 }
183
184 /*
185 * Try to kill the child after having
186 * set the real and effective UID.
187 */
188 if (setuid(puid) != 0)
189 _exit(EXIT_FAILURE);
190
191 errno = 0;
192
193 if (kill(cpid, SIGKILL) == 0)
194 _exit(EPERM);
195
196 if (errno != EPERM)
197 _exit(EPERM);
198
199 (void)waitpid(cpid, &sta, 0);
200
201 _exit(EXIT_SUCCESS);
202 }
203
204 (void)waitpid(ppid, &sta, 0);
205
206 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) == EPERM)
207 atf_tc_fail("killed a process of another user");
208
209 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
210 atf_tc_fail("unknown error from kill(2)");
211}
212
213ATF_TC(kill_pgrp_neg);
214ATF_TC_HEAD(kill_pgrp_neg, tc)
215{
216 atf_tc_set_md_var(tc, "descr", "Test kill(2) with process group, #2");
217}
218
219ATF_TC_BODY(kill_pgrp_neg, tc)
220{
221 const int maxiter = 3;
222 pid_t cpid, ppid;
223 int i, sta;
224
225 ppid = fork();
226 ATF_REQUIRE(ppid >= 0);
227
228 if (ppid == 0) {
229
230 ATF_REQUIRE(setpgid(0, 0) == 0);
231
232 for (i = 0; i < maxiter; i++) {
233
234 cpid = fork();
235 ATF_REQUIRE(cpid >= 0);
236
237 if (cpid == 0)
238 pause();
239 }
240
241 /*
242 * Test the variant of killpg(3); if the process number
243 * is negative but not -1, the signal should be sent to
244 * all processes whose process group ID is equal to the
245 * absolute value of the process number.
246 */
247 ATF_REQUIRE(kill(-getpgrp(), SIGKILL) == 0);
248
249 (void)sleep(1);
250
251 _exit(EXIT_SUCCESS);
252 }
253
254 (void)waitpid(ppid, &sta, 0);
255
256 if (WIFSIGNALED(sta) == 0 || WTERMSIG(sta) != SIGKILL)
257 atf_tc_fail("failed to kill(2) a process group");
258}
259
260ATF_TC(kill_pgrp_zero);
261ATF_TC_HEAD(kill_pgrp_zero, tc)
262{
263 atf_tc_set_md_var(tc, "descr", "Test kill(2) with process group, #1");
264}
265
266ATF_TC_BODY(kill_pgrp_zero, tc)
267{
268 const int maxiter = 3;
269 pid_t cpid, ppid;
270 int i, sta;
271
272 ppid = fork();
273 ATF_REQUIRE(ppid >= 0);
274
275 if (ppid == 0) {
276
277 ATF_REQUIRE(setpgid(0, 0) == 0);
278
279 for (i = 0; i < maxiter; i++) {
280
281 cpid = fork();
282 ATF_REQUIRE(cpid >= 0);
283
284 if (cpid == 0)
285 pause();
286 }
287
288 /*
289 * If the supplied process number is zero,
290 * the signal should be sent to all processes
291 * under the current process group.
292 */
293 ATF_REQUIRE(kill(0, SIGKILL) == 0);
294
295 (void)sleep(1);
296
297 _exit(EXIT_SUCCESS);
298 }
299
300 (void)waitpid(ppid, &sta, 0);
301
302 if (WIFSIGNALED(sta) == 0 || WTERMSIG(sta) != SIGKILL)
303 atf_tc_fail("failed to kill(2) a process group");
304}
305
306ATF_TP_ADD_TCS(tp)
307{
308
309 ATF_TP_ADD_TC(tp, kill_basic);
310 ATF_TP_ADD_TC(tp, kill_err);
311 ATF_TP_ADD_TC(tp, kill_perm);
312 ATF_TP_ADD_TC(tp, kill_pgrp_neg);
313 ATF_TP_ADD_TC(tp, kill_pgrp_zero);
314
315 return atf_no_error();
316}
diff --git a/src/regress/lib/libc/sys/t_link.c b/src/regress/lib/libc/sys/t_link.c
new file mode 100644
index 0000000000..291fd9cda4
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_link.c
@@ -0,0 +1,234 @@
1/* $OpenBSD: t_link.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_link.c,v 1.3 2017/01/13 20:42:36 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_link.c,v 1.3 2017/01/13 20:42:36 christos Exp $");
37
38#include <sys/param.h>
39#include <sys/stat.h>
40
41#include "atf-c.h"
42#include <errno.h>
43#include <fcntl.h>
44#include <limits.h>
45#include <stdio.h>
46#include <string.h>
47#include <unistd.h>
48
49static const char *getpath(void);
50static char path[] = "link";
51static const char *pathl;
52
53static const char *
54getpath(void)
55{
56 static char buf[LINE_MAX];
57
58 (void)memset(buf, '\0', sizeof(buf));
59
60 if (getcwd(buf, sizeof(buf)) == NULL)
61 return NULL;
62
63 (void)strlcat(buf, path, sizeof(buf));
64 (void)strlcat(buf, ".link", sizeof(buf));
65
66 return buf;
67}
68
69ATF_TC_WITH_CLEANUP(link_count);
70ATF_TC_HEAD(link_count, tc)
71{
72 atf_tc_set_md_var(tc, "descr", "link(2) counts are incremented?");
73}
74
75ATF_TC_BODY(link_count, tc)
76{
77 struct stat sa, sb;
78 int fd;
79
80 (void)memset(&sa, 0, sizeof(struct stat));
81 (void)memset(&sb, 0, sizeof(struct stat));
82
83 pathl = getpath();
84 fd = open(path, O_RDWR | O_CREAT, 0600);
85
86 ATF_REQUIRE(fd >= 0);
87 ATF_REQUIRE(pathl != NULL);
88
89 ATF_REQUIRE(stat(path, &sa) == 0);
90 ATF_REQUIRE(link(path, pathl) == 0);
91 ATF_REQUIRE(stat(path, &sb) == 0);
92
93 if (sa.st_nlink != sb.st_nlink - 1)
94 atf_tc_fail("incorrect link(2) count");
95
96 ATF_REQUIRE(close(fd) == 0);
97 ATF_REQUIRE(unlink(path) == 0);
98 ATF_REQUIRE(unlink(pathl) == 0);
99}
100
101ATF_TC_CLEANUP(link_count, tc)
102{
103 (void)unlink(path);
104 (void)unlink(pathl);
105}
106
107ATF_TC_WITH_CLEANUP(link_err);
108ATF_TC_HEAD(link_err, tc)
109{
110 atf_tc_set_md_var(tc, "descr", "Test error conditions of link(2)");
111}
112
113ATF_TC_BODY(link_err, tc)
114{
115 char buf[MAXPATHLEN + 1];
116 int fd;
117
118 (void)memset(buf, 'x', sizeof(buf));
119
120 pathl = getpath();
121 fd = open(path, O_RDWR | O_CREAT, 0600);
122
123 ATF_REQUIRE(fd >= 0);
124 ATF_REQUIRE(pathl != NULL);
125
126 errno = 0;
127 ATF_REQUIRE(link(path, pathl) == 0);
128 ATF_REQUIRE_ERRNO(EEXIST, link(path, pathl) == -1);
129
130 errno = 0;
131 ATF_REQUIRE_ERRNO(ENAMETOOLONG, link(buf, "xxx") == -1);
132
133 errno = 0;
134 ATF_REQUIRE_ERRNO(ENOENT, link(path, "/d/c/b/a") == -1);
135
136 errno = 0;
137 ATF_REQUIRE_ERRNO(ENOENT, link("/a/b/c/d", path) == -1);
138
139 errno = 0;
140 ATF_REQUIRE_ERRNO(ENOENT, link("/a/b/c/d", "/d/c/b/a") == -1);
141
142 errno = 0;
143 ATF_REQUIRE_ERRNO(EFAULT, link(path, (const char *)-1) == -1);
144
145 errno = 0;
146 ATF_REQUIRE_ERRNO(EFAULT, link((const char *)-1, "xxx") == -1);
147
148 ATF_REQUIRE(close(fd) == 0);
149 ATF_REQUIRE(unlink(path) == 0);
150 ATF_REQUIRE(unlink(pathl) == 0);
151}
152
153ATF_TC_CLEANUP(link_err, tc)
154{
155 (void)unlink(path);
156 (void)unlink(pathl);
157}
158
159ATF_TC(link_perm);
160ATF_TC_HEAD(link_perm, tc)
161{
162 atf_tc_set_md_var(tc, "descr", "Test permissions with link(2)");
163 atf_tc_set_md_var(tc, "require.user", "unprivileged");
164}
165
166ATF_TC_BODY(link_perm, tc)
167{
168 int rv;
169
170 errno = 0;
171 rv = link("/root", "/root.link");
172 ATF_REQUIRE_MSG(rv == -1 && (errno == EACCES || errno == EPERM),
173 "link to a directory did not fail with EPERM or EACCESS; link() "
174 "returned %d, errno %d", rv, errno);
175
176 errno = 0;
177 ATF_REQUIRE_ERRNO(EACCES,
178 link("/root/.profile", "/root/.profile.link") == -1);
179}
180
181ATF_TC_WITH_CLEANUP(link_stat);
182ATF_TC_HEAD(link_stat, tc)
183{
184 atf_tc_set_md_var(tc, "descr", "Check stat(2) of a linked file");
185}
186
187ATF_TC_BODY(link_stat, tc)
188{
189 struct stat sa, sb;
190 int fd;
191
192 (void)memset(&sa, 0, sizeof(struct stat));
193 (void)memset(&sb, 0, sizeof(struct stat));
194
195 pathl = getpath();
196 fd = open(path, O_RDWR | O_CREAT, 0600);
197
198 ATF_REQUIRE(fd >= 0);
199 ATF_REQUIRE(pathl != NULL);
200
201 ATF_REQUIRE(link(path, pathl) == 0);
202 ATF_REQUIRE(stat(path, &sa) == 0);
203 ATF_REQUIRE(lstat(pathl, &sb) == 0);
204
205 if (sa.st_uid != sb.st_uid)
206 atf_tc_fail("unequal UIDs");
207
208 if (sa.st_mode != sb.st_mode)
209 atf_tc_fail("unequal modes");
210
211 if (sa.st_ino != sb.st_ino)
212 atf_tc_fail("unequal inodes");
213
214 ATF_REQUIRE(close(fd) == 0);
215 ATF_REQUIRE(unlink(path) == 0);
216 ATF_REQUIRE(unlink(pathl) == 0);
217}
218
219ATF_TC_CLEANUP(link_stat, tc)
220{
221 (void)unlink(path);
222 (void)unlink(pathl);
223}
224
225ATF_TP_ADD_TCS(tp)
226{
227
228 ATF_TP_ADD_TC(tp, link_count);
229 ATF_TP_ADD_TC(tp, link_err);
230 ATF_TP_ADD_TC(tp, link_perm);
231 ATF_TP_ADD_TC(tp, link_stat);
232
233 return atf_no_error();
234}
diff --git a/src/regress/lib/libc/sys/t_listen.c b/src/regress/lib/libc/sys/t_listen.c
new file mode 100644
index 0000000000..da5b287cdf
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_listen.c
@@ -0,0 +1,139 @@
1/* $OpenBSD: t_listen.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_listen.c,v 1.6 2019/07/09 16:24:01 maya Exp $ */
3/*
4 * Copyright (c) 2007 The NetBSD Foundation, Inc.
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND
17 * CONTRIBUTORS ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
18 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
19 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20 * IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS BE LIABLE FOR ANY
21 * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
23 * GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER
25 * IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
26 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
27 * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/socket.h>
33#include "atf-c.h"
34#include <err.h>
35#include <errno.h>
36#include <fcntl.h>
37#include <string.h>
38#include <unistd.h>
39
40#include <arpa/inet.h>
41#include <netinet/in.h>
42
43static const char *path = "listen";
44
45ATF_TC_WITH_CLEANUP(listen_err);
46ATF_TC_HEAD(listen_err, tc)
47{
48 atf_tc_set_md_var(tc, "descr",
49 "Checks errors from listen(2) (PR standards/46150)");
50}
51
52ATF_TC_BODY(listen_err, tc)
53{
54 static const size_t siz = sizeof(struct sockaddr_in);
55 struct sockaddr_in sina, sinb;
56 int fda, fdb, fdc;
57
58 (void)memset(&sina, 0, sizeof(struct sockaddr_in));
59 (void)memset(&sinb, 0, sizeof(struct sockaddr_in));
60
61 sina.sin_family = AF_INET;
62 sina.sin_port = htons(31522);
63 sina.sin_addr.s_addr = inet_addr("127.0.0.1");
64
65 sinb.sin_family = AF_INET;
66 sinb.sin_port = htons(31522);
67 sinb.sin_addr.s_addr = inet_addr("127.0.0.1");
68
69 fda = socket(AF_INET, SOCK_STREAM, 0);
70 fdb = socket(AF_INET, SOCK_STREAM, 0);
71 fdc = open("listen", O_RDWR | O_CREAT, 0600);
72
73 ATF_REQUIRE(fda >= 0 && fdb >= 0 && fdc >= 0);
74 ATF_REQUIRE_ERRNO(ENOTSOCK, listen(fdc, 1) == -1);
75
76 (void)close(fdc);
77 (void)unlink(path);
78
79 ATF_REQUIRE(bind(fda, (struct sockaddr *)&sina, siz) == 0);
80 ATF_REQUIRE(listen(fda, 1) == 0);
81
82 /*
83 * According to IEEE Std 1003.1-2008: if the socket is
84 * already connected, the call should fail with EINVAL.
85 */
86 ATF_REQUIRE(connect(fdb, (struct sockaddr *)&sinb, siz) == 0);
87 ATF_REQUIRE_ERRNO(EINVAL, listen(fdb, 1) == -1);
88
89 (void)close(fda);
90 (void)close(fdb);
91
92 ATF_REQUIRE_ERRNO(EBADF, connect(fdb,
93 (struct sockaddr *)&sinb, siz) == -1);
94}
95
96ATF_TC_CLEANUP(listen_err, tc)
97{
98 (void)unlink(path);
99}
100
101ATF_TC(listen_low_port);
102ATF_TC_HEAD(listen_low_port, tc)
103{
104 atf_tc_set_md_var(tc, "descr", "Does low-port allocation work?");
105 atf_tc_set_md_var(tc, "require.user", "root");
106}
107
108ATF_TC_BODY(listen_low_port, tc)
109{
110 int sd, val;
111
112 sd = socket(AF_INET, SOCK_STREAM, 0);
113 ATF_REQUIRE_MSG(sd != -1, "socket failed: %s", strerror(errno));
114
115 val = IP_PORTRANGE_LOW;
116 if (setsockopt(sd, IPPROTO_IP, IP_PORTRANGE, &val,
117 sizeof(val)) == -1)
118 atf_tc_fail("setsockopt failed: %s", strerror(errno));
119
120 if (listen(sd, 5) == -1) {
121 int serrno = errno;
122 atf_tc_fail("listen failed: %s%s",
123 strerror(serrno),
124 serrno != EACCES ? "" :
125 " (see http://mail-index.netbsd.org/"
126 "source-changes/2007/12/16/0011.html)");
127 }
128
129 close(sd);
130}
131
132ATF_TP_ADD_TCS(tp)
133{
134
135 ATF_TP_ADD_TC(tp, listen_err);
136 ATF_TP_ADD_TC(tp, listen_low_port);
137
138 return atf_no_error();
139}
diff --git a/src/regress/lib/libc/sys/t_mkdir.c b/src/regress/lib/libc/sys/t_mkdir.c
new file mode 100644
index 0000000000..41df34ace9
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_mkdir.c
@@ -0,0 +1,213 @@
1/* $OpenBSD: t_mkdir.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_mkdir.c,v 1.2 2011/10/15 07:38:31 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2008, 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jason R. Thorpe and Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__COPYRIGHT("@(#) Copyright (c) 2008\
37 The NetBSD Foundation, inc. All rights reserved.");
38__RCSID("$NetBSD: t_mkdir.c,v 1.2 2011/10/15 07:38:31 jruoho Exp $");
39
40#include <sys/stat.h>
41#include <sys/wait.h>
42
43#include "atf-c.h"
44#include <errno.h>
45#include <fcntl.h>
46#include <limits.h>
47#include <pwd.h>
48#include <stdio.h>
49#include <stdlib.h>
50#include <string.h>
51#include <unistd.h>
52
53ATF_TC(mkdir_err);
54ATF_TC_HEAD(mkdir_err, tc)
55{
56 atf_tc_set_md_var(tc, "descr", "Checks errors from mkdir(2)");
57}
58
59ATF_TC_BODY(mkdir_err, tc)
60{
61 char buf[PATH_MAX + 1];
62 int fd;
63
64 (void)memset(buf, 'x', sizeof(buf));
65
66 fd = open("/etc", O_RDONLY);
67
68 if (fd >= 0) {
69
70 (void)close(fd);
71
72 errno = 0;
73 ATF_REQUIRE_ERRNO(EEXIST, mkdir("/etc", 0500) == -1);
74 }
75
76 errno = 0;
77 ATF_REQUIRE_ERRNO(EFAULT, mkdir((void *)-1, 0500) == -1);
78
79 errno = 0;
80 ATF_REQUIRE_ERRNO(ENAMETOOLONG, mkdir(buf, 0500) == -1);
81
82 errno = 0;
83 ATF_REQUIRE_ERRNO(ENOENT, mkdir("/a/b/c/d/e/f/g/h/i/j/k", 0500) == -1);
84}
85
86ATF_TC_WITH_CLEANUP(mkdir_perm);
87ATF_TC_HEAD(mkdir_perm, tc)
88{
89 atf_tc_set_md_var(tc, "descr", "Checks permissions with mkdir(2)");
90 atf_tc_set_md_var(tc, "require.user", "unprivileged");
91}
92
93ATF_TC_BODY(mkdir_perm, tc)
94{
95 errno = 0;
96 ATF_REQUIRE_ERRNO(EACCES, mkdir("/usr/__nonexistent__", 0500) == -1);
97}
98
99ATF_TC_CLEANUP(mkdir_perm, tc)
100{
101 (void)rmdir("/usr/__nonexistent__");
102}
103
104ATF_TC_WITH_CLEANUP(mkdir_mode);
105ATF_TC_HEAD(mkdir_mode, tc)
106{
107 atf_tc_set_md_var(tc, "descr", "Test that UIDs and GIDs are right "
108 "for a directory created with mkdir(2)");
109 atf_tc_set_md_var(tc, "require.user", "root");
110}
111
112ATF_TC_BODY(mkdir_mode, tc)
113{
114 static const char *path = "/tmp/mkdir";
115 struct stat st_a, st_b;
116 struct passwd *pw;
117 pid_t pid;
118 int sta;
119
120 (void)memset(&st_a, 0, sizeof(struct stat));
121 (void)memset(&st_b, 0, sizeof(struct stat));
122
123 pw = getpwnam("nobody");
124
125 ATF_REQUIRE(pw != NULL);
126 ATF_REQUIRE(stat("/tmp", &st_a) == 0);
127
128 pid = fork();
129 ATF_REQUIRE(pid >= 0);
130
131 if (pid == 0) {
132
133 if (setuid(pw->pw_uid) != 0)
134 _exit(EXIT_FAILURE);
135
136 if (mkdir(path, 0500) != 0)
137 _exit(EXIT_FAILURE);
138
139 _exit(EXIT_SUCCESS);
140 }
141
142 (void)sleep(1);
143 (void)wait(&sta);
144
145 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
146 atf_tc_fail("failed to create '%s'", path);
147
148 ATF_REQUIRE(stat(path, &st_b) == 0);
149 ATF_REQUIRE(rmdir(path) == 0);
150
151 /*
152 * The directory's owner ID should be set to the
153 * effective UID, whereas the group ID should be
154 * set to that of the parent directory.
155 */
156 if (st_b.st_uid != pw->pw_uid)
157 atf_tc_fail("invalid UID for '%s'", path);
158
159 if (st_b.st_gid != st_a.st_gid)
160 atf_tc_fail("GID did not follow the parent directory");
161}
162
163ATF_TC_CLEANUP(mkdir_mode, tc)
164{
165 (void)rmdir("/tmp/mkdir");
166}
167
168ATF_TC(mkdir_trail);
169ATF_TC_HEAD(mkdir_trail, tc)
170{
171 atf_tc_set_md_var(tc, "descr", "Checks mkdir(2) for trailing slashes");
172}
173
174ATF_TC_BODY(mkdir_trail, tc)
175{
176 const char *tests[] = {
177 /*
178 * IEEE 1003.1 second ed. 2.2.2.78:
179 *
180 * If the pathname refers to a directory, it may also have
181 * one or more trailing slashes. Multiple successive slashes
182 * are considered to be the same as one slash.
183 */
184 "dir1/",
185 "dir2//",
186
187 NULL,
188 };
189
190 const char **test;
191
192 for (test = &tests[0]; *test != NULL; ++test) {
193
194 (void)printf("Checking \"%s\"\n", *test);
195 (void)rmdir(*test);
196
197 ATF_REQUIRE(mkdir(*test, 0777) == 0);
198 ATF_REQUIRE(rename(*test, "foo") == 0);
199 ATF_REQUIRE(rename("foo/", *test) == 0);
200 ATF_REQUIRE(rmdir(*test) == 0);
201 }
202}
203
204ATF_TP_ADD_TCS(tp)
205{
206
207 ATF_TP_ADD_TC(tp, mkdir_err);
208 ATF_TP_ADD_TC(tp, mkdir_perm);
209 ATF_TP_ADD_TC(tp, mkdir_mode);
210 ATF_TP_ADD_TC(tp, mkdir_trail);
211
212 return atf_no_error();
213}
diff --git a/src/regress/lib/libc/sys/t_mkfifo.c b/src/regress/lib/libc/sys/t_mkfifo.c
new file mode 100644
index 0000000000..1c2fe60e3a
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_mkfifo.c
@@ -0,0 +1,309 @@
1/* $OpenBSD: t_mkfifo.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_mkfifo.c,v 1.3 2019/06/20 03:31:54 kamil Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_mkfifo.c,v 1.3 2019/06/20 03:31:54 kamil Exp $");
37
38#include <sys/stat.h>
39#include <sys/wait.h>
40
41#include "atf-c.h"
42#include <errno.h>
43#include <fcntl.h>
44#include <limits.h>
45#include <stdlib.h>
46#include <signal.h>
47#include <string.h>
48#include <unistd.h>
49
50static const char path[] = "fifo";
51static void support(void);
52
53static void
54support(void)
55{
56
57 errno = 0;
58
59 if (mkfifo(path, 0600) == 0) {
60 ATF_REQUIRE(unlink(path) == 0);
61 return;
62 }
63
64 if (errno == EOPNOTSUPP)
65 atf_tc_skip("the kernel does not support FIFOs");
66 else {
67 atf_tc_fail("mkfifo(2) failed");
68 }
69}
70
71ATF_TC_WITH_CLEANUP(mkfifo_block);
72ATF_TC_HEAD(mkfifo_block, tc)
73{
74 atf_tc_set_md_var(tc, "descr", "Test that FIFOs block");
75}
76
77ATF_TC_BODY(mkfifo_block, tc)
78{
79 int sta, fd = -1;
80 pid_t pid;
81
82 support();
83
84 ATF_REQUIRE(mkfifo(path, 0600) == 0);
85
86 pid = fork();
87 ATF_REQUIRE(pid >= 0);
88
89 if (pid == 0) {
90
91 /*
92 * If we open the FIFO as read-only (write-only),
93 * the call should block until another process
94 * opens the FIFO for writing (reading).
95 */
96 fd = open(path, O_RDONLY);
97
98 _exit(EXIT_FAILURE); /* NOTREACHED */
99 }
100
101 (void)sleep(1);
102
103 ATF_REQUIRE(kill(pid, SIGKILL) == 0);
104
105 (void)wait(&sta);
106
107 if (WIFSIGNALED(sta) == 0 || WTERMSIG(sta) != SIGKILL)
108 atf_tc_fail("FIFO did not block");
109
110 (void)close(fd);
111 (void)unlink(path);
112}
113
114ATF_TC_CLEANUP(mkfifo_block, tc)
115{
116 (void)unlink(path);
117}
118
119ATF_TC_WITH_CLEANUP(mkfifo_err);
120ATF_TC_HEAD(mkfifo_err, tc)
121{
122 atf_tc_set_md_var(tc, "descr", "Test erros from mkfifo(2)");
123}
124
125ATF_TC_BODY(mkfifo_err, tc)
126{
127 char buf[PATH_MAX + 1];
128
129 support();
130
131 (void)memset(buf, 'x', sizeof(buf));
132 ATF_REQUIRE(mkfifo(path, 0600) == 0);
133
134 errno = 0;
135 ATF_REQUIRE_ERRNO(EFAULT, mkfifo((char *)-1, 0600) == -1);
136
137 errno = 0;
138 ATF_REQUIRE_ERRNO(EEXIST, mkfifo("/etc/passwd", 0600) == -1);
139
140 errno = 0;
141 ATF_REQUIRE_ERRNO(EEXIST, mkfifo(path, 0600) == -1);
142
143 errno = 0;
144 ATF_REQUIRE_ERRNO(ENAMETOOLONG, mkfifo(buf, 0600) == -1);
145
146 errno = 0;
147 ATF_REQUIRE_ERRNO(ENOENT, mkfifo("/a/b/c/d/e/f/g", 0600) == -1);
148
149 ATF_REQUIRE(unlink(path) == 0);
150}
151
152ATF_TC_CLEANUP(mkfifo_err, tc)
153{
154 (void)unlink(path);
155}
156
157ATF_TC_WITH_CLEANUP(mkfifo_nonblock);
158ATF_TC_HEAD(mkfifo_nonblock, tc)
159{
160 atf_tc_set_md_var(tc, "descr", "Test O_NONBLOCK with FIFOs");
161}
162
163ATF_TC_BODY(mkfifo_nonblock, tc)
164{
165 int fd, sta;
166 pid_t pid;
167
168 support();
169
170 fd = -1;
171 ATF_REQUIRE(mkfifo(path, 0600) == 0);
172
173 pid = fork();
174 ATF_REQUIRE(pid >= 0);
175
176 if (pid == 0) {
177
178 /*
179 * If we open the FIFO as O_NONBLOCK, the O_RDONLY
180 * call should return immediately, whereas the call
181 * for write-only should fail with ENXIO.
182 */
183 fd = open(path, O_RDONLY | O_NONBLOCK);
184
185 if (fd >= 0)
186 _exit(EXIT_SUCCESS);
187
188 (void)pause(); /* NOTREACHED */
189 }
190
191 (void)sleep(1);
192
193 errno = 0;
194 ATF_REQUIRE_ERRNO(ENXIO, open(path, O_WRONLY | O_NONBLOCK) == -1);
195
196 (void)kill(pid, SIGKILL);
197 (void)wait(&sta);
198
199 if (WIFSIGNALED(sta) != 0 || WTERMSIG(sta) == SIGKILL)
200 atf_tc_fail("FIFO blocked for O_NONBLOCK open(2)");
201
202 (void)close(fd);
203 (void)unlink(path);
204}
205
206ATF_TC_CLEANUP(mkfifo_nonblock, tc)
207{
208 (void)unlink(path);
209}
210
211ATF_TC_WITH_CLEANUP(mkfifo_perm);
212ATF_TC_HEAD(mkfifo_perm, tc)
213{
214 atf_tc_set_md_var(tc, "descr", "Test permissions with mkfifo(2)");
215 atf_tc_set_md_var(tc, "require.user", "unprivileged");
216}
217
218ATF_TC_BODY(mkfifo_perm, tc)
219{
220
221 support();
222
223 errno = 0;
224 ATF_REQUIRE_ERRNO(EACCES, mkfifo("/root/fifo", 0600) == -1);
225
226 ATF_REQUIRE(mkfifo(path, 0600) == 0);
227
228 /*
229 * For some reason this fails with EFTYPE...
230 */
231 errno = 0;
232 ATF_REQUIRE_ERRNO(EFTYPE, chmod(path, 1777) == -1);
233
234 ATF_REQUIRE(unlink(path) == 0);
235}
236
237ATF_TC_CLEANUP(mkfifo_perm, tc)
238{
239 (void)unlink(path);
240}
241
242ATF_TC_WITH_CLEANUP(mkfifo_stat);
243ATF_TC_HEAD(mkfifo_stat, tc)
244{
245 atf_tc_set_md_var(tc, "descr", "Test mkfifo(2) with stat");
246}
247
248ATF_TC_BODY(mkfifo_stat, tc)
249{
250 struct stat st;
251
252 support();
253
254 (void)memset(&st, 0, sizeof(struct stat));
255
256 ATF_REQUIRE(mkfifo(path, 0600) == 0);
257 ATF_REQUIRE(stat(path, &st) == 0);
258
259 if (S_ISFIFO(st.st_mode) == 0)
260 atf_tc_fail("invalid mode from mkfifo(2)");
261
262 ATF_REQUIRE(unlink(path) == 0);
263}
264
265ATF_TC_CLEANUP(mkfifo_stat, tc)
266{
267 (void)unlink(path);
268}
269
270ATF_TC_WITH_CLEANUP(mknod_s_ififo);
271ATF_TC_HEAD(mknod_s_ififo, tc)
272{
273 atf_tc_set_md_var(tc, "descr", "Test mknod(2) with S_IFIFO");
274}
275
276ATF_TC_BODY(mknod_s_ififo, tc)
277{
278 struct stat st;
279
280 support();
281
282 (void)memset(&st, 0, sizeof(struct stat));
283
284 ATF_REQUIRE(mknod(path, S_IFIFO | 0600, 0) == 0);
285 ATF_REQUIRE(stat(path, &st) == 0);
286
287 if (S_ISFIFO(st.st_mode) == 0)
288 atf_tc_fail("invalid mode from mknod(2) with S_IFIFO");
289
290 ATF_REQUIRE(unlink(path) == 0);
291}
292
293ATF_TC_CLEANUP(mknod_s_ififo, tc)
294{
295 (void)unlink(path);
296}
297
298ATF_TP_ADD_TCS(tp)
299{
300
301 ATF_TP_ADD_TC(tp, mkfifo_block);
302 ATF_TP_ADD_TC(tp, mkfifo_err);
303 ATF_TP_ADD_TC(tp, mkfifo_nonblock);
304 ATF_TP_ADD_TC(tp, mkfifo_perm);
305 ATF_TP_ADD_TC(tp, mkfifo_stat);
306 ATF_TP_ADD_TC(tp, mknod_s_ififo);
307
308 return atf_no_error();
309}
diff --git a/src/regress/lib/libc/sys/t_mknod.c b/src/regress/lib/libc/sys/t_mknod.c
new file mode 100644
index 0000000000..0a16124859
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_mknod.c
@@ -0,0 +1,199 @@
1/* $OpenBSD: t_mknod.c,v 1.1.1.1 2019/11/19 19:57:03 bluhm Exp $ */
2/* $NetBSD: t_mknod.c,v 1.2 2012/03/18 07:00:52 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_mknod.c,v 1.2 2012/03/18 07:00:52 jruoho Exp $");
37
38#include <sys/stat.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <fcntl.h>
43#include <limits.h>
44#include <paths.h>
45#include <stdio.h>
46#include <string.h>
47#include <unistd.h>
48
49static char path[] = "node";
50
51ATF_TC_WITH_CLEANUP(mknod_err);
52ATF_TC_HEAD(mknod_err, tc)
53{
54 atf_tc_set_md_var(tc, "descr",
55 "Test error conditions of mknod(2) (PR kern/45111)");
56 atf_tc_set_md_var(tc, "require.user", "root");
57}
58
59ATF_TC_BODY(mknod_err, tc)
60{
61 char buf[PATH_MAX + 1];
62
63 (void)memset(buf, 'x', sizeof(buf));
64
65 errno = 0;
66 ATF_REQUIRE_ERRNO(EINVAL, mknod(path, S_IFCHR, -1) == -1);
67
68 errno = 0;
69 ATF_REQUIRE_ERRNO(ENAMETOOLONG, mknod(buf, S_IFCHR, 0) == -1);
70
71 errno = 0;
72 ATF_REQUIRE_ERRNO(EFAULT, mknod((char *)-1, S_IFCHR, 0) == -1);
73
74 errno = 0;
75 ATF_REQUIRE_ERRNO(ENOENT, mknod("/a/b/c/d/e/f/g", S_IFCHR, 0) == -1);
76}
77
78ATF_TC_CLEANUP(mknod_err, tc)
79{
80 (void)unlink(path);
81}
82
83ATF_TC_WITH_CLEANUP(mknod_exist);
84ATF_TC_HEAD(mknod_exist, tc)
85{
86 atf_tc_set_md_var(tc, "descr", "Test EEXIST from mknod(2)");
87 atf_tc_set_md_var(tc, "require.user", "root");
88}
89
90ATF_TC_BODY(mknod_exist, tc)
91{
92 int fd;
93
94 fd = open("/etc/passwd", O_RDONLY);
95
96 if (fd >= 0) {
97
98 (void)close(fd);
99
100 errno = 0;
101 ATF_REQUIRE_ERRNO(EEXIST,
102 mknod("/etc/passwd", S_IFCHR, 0) == -1);
103 }
104
105 ATF_REQUIRE(mknod(path, S_IFCHR, 0) == 0);
106
107 errno = 0;
108 ATF_REQUIRE_ERRNO(EEXIST, mknod(path, S_IFCHR, 0) == -1);
109
110 ATF_REQUIRE(unlink(path) == 0);
111}
112
113ATF_TC_CLEANUP(mknod_exist, tc)
114{
115 (void)unlink(path);
116}
117
118ATF_TC_WITH_CLEANUP(mknod_perm);
119ATF_TC_HEAD(mknod_perm, tc)
120{
121 atf_tc_set_md_var(tc, "descr", "Test permissions of mknod(2)");
122 atf_tc_set_md_var(tc, "require.user", "unprivileged");
123}
124
125ATF_TC_BODY(mknod_perm, tc)
126{
127
128 errno = 0;
129 ATF_REQUIRE_ERRNO(EPERM, mknod(path, S_IFCHR, 0) == -1);
130
131 errno = 0;
132 ATF_REQUIRE_ERRNO(EPERM, mknod(path, S_IFBLK, 0) == -1);
133}
134
135ATF_TC_CLEANUP(mknod_perm, tc)
136{
137 (void)unlink(path);
138}
139
140ATF_TC_WITH_CLEANUP(mknod_stat);
141ATF_TC_HEAD(mknod_stat, tc)
142{
143 atf_tc_set_md_var(tc, "descr", "A basic test of mknod(2)");
144 atf_tc_set_md_var(tc, "require.user", "root");
145}
146
147ATF_TC_BODY(mknod_stat, tc)
148{
149 struct stat st;
150
151 (void)memset(&st, 0, sizeof(struct stat));
152
153 ATF_REQUIRE(mknod(path, S_IFCHR, 0) == 0);
154 ATF_REQUIRE(stat(path, &st) == 0);
155
156 if (S_ISCHR(st.st_mode) == 0)
157 atf_tc_fail_nonfatal("invalid mode from mknod(2) (S_IFCHR)");
158
159 ATF_REQUIRE(unlink(path) == 0);
160
161 (void)memset(&st, 0, sizeof(struct stat));
162
163 ATF_REQUIRE(mknod(path, S_IFBLK, 0) == 0);
164 ATF_REQUIRE(stat(path, &st) == 0);
165
166 if (S_ISBLK(st.st_mode) == 0)
167 atf_tc_fail_nonfatal("invalid mode from mknod(2) (S_IFBLK)");
168
169 ATF_REQUIRE(unlink(path) == 0);
170
171 (void)memset(&st, 0, sizeof(struct stat));
172
173 /*
174 * Adjusted for OpenBSD, only supports FIFO and device special files
175 * ATF_REQUIRE(mknod(path, S_IFREG, 0) == 0);
176 * ATF_REQUIRE(stat(path, &st) == 0);
177 *
178 * if (S_ISREG(st.st_mode) == 0)
179 * atf_tc_fail_nonfatal("invalid mode from mknod(2) (S_IFREG)");
180 *
181 * ATF_REQUIRE(unlink(path) == 0);
182 */
183}
184
185ATF_TC_CLEANUP(mknod_stat, tc)
186{
187 (void)unlink(path);
188}
189
190ATF_TP_ADD_TCS(tp)
191{
192
193 ATF_TP_ADD_TC(tp, mknod_err);
194 ATF_TP_ADD_TC(tp, mknod_exist);
195 ATF_TP_ADD_TC(tp, mknod_perm);
196 ATF_TP_ADD_TC(tp, mknod_stat);
197
198 return atf_no_error();
199}
diff --git a/src/regress/lib/libc/sys/t_mlock.c b/src/regress/lib/libc/sys/t_mlock.c
new file mode 100644
index 0000000000..1fd986383d
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_mlock.c
@@ -0,0 +1,325 @@
1/* $OpenBSD: t_mlock.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_mlock.c,v 1.7 2019/03/13 08:50:12 kre Exp $ */
3
4/*-
5 * Copyright (c) 2012 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_mlock.c,v 1.7 2019/03/13 08:50:12 kre Exp $");
37
38#include <sys/mman.h>
39#include <sys/resource.h>
40#include <sys/sysctl.h>
41#include <sys/wait.h>
42
43#include <errno.h>
44#include "atf-c.h"
45#include <stdint.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <unistd.h>
50
51static long page = 0;
52
53ATF_TC(mlock_clip);
54ATF_TC_HEAD(mlock_clip, tc)
55{
56 atf_tc_set_md_var(tc, "descr", "Test with mlock(2) that UVM only "
57 "clips if the clip address is within the entry (PR kern/44788)");
58}
59
60ATF_TC_BODY(mlock_clip, tc)
61{
62 void *buf;
63 int err1, err2;
64
65 buf = malloc(page);
66 ATF_REQUIRE(buf != NULL);
67 fprintf(stderr, "mlock_clip: buf = %p (page=%ld)\n", buf, page);
68
69 if (page < 1024)
70 atf_tc_skip("page size too small");
71
72 for (size_t i = page; i >= 1; i = i - 1024) {
73 err1 = mlock(buf, page - i);
74 if (err1 != 0)
75 fprintf(stderr, "mlock_clip: page=%ld i=%zu,"
76 " mlock(%p, %ld): %s\n", page, i, buf, page - i,
77 strerror(errno));
78 err2 = munlock(buf, page - i);
79 if (err2 != 0)
80 fprintf(stderr, "mlock_clip: page=%ld i=%zu,"
81 " munlock(%p, %ld): %s (mlock %s)\n", page, i,
82 buf, page - i, strerror(errno), err1?"failed":"ok");
83 }
84
85 free(buf);
86}
87
88ATF_TC(mlock_err);
89ATF_TC_HEAD(mlock_err, tc)
90{
91 atf_tc_set_md_var(tc, "descr",
92 "Test error conditions in mlock(2) and munlock(2)");
93}
94
95ATF_TC_BODY(mlock_err, tc)
96{
97 void *invalid_ptr;
98 void *buf;
99 int mlock_err, munlock_err;
100
101 /*
102 * Any bad address must return ENOMEM (for lock & unlock)
103 */
104 errno = 0;
105 ATF_REQUIRE_ERRNO(ENOMEM, mlock(NULL, page) == -1);
106
107 errno = 0;
108 ATF_REQUIRE_ERRNO(ENOMEM, mlock((char *)0, page) == -1);
109
110 errno = 0;
111 /* Adjusted for OpenBSD, initially ENOMEM */
112 ATF_REQUIRE_ERRNO(EINVAL, mlock((char *)-1, page) == -1);
113
114 errno = 0;
115 ATF_REQUIRE_ERRNO(ENOMEM, munlock(NULL, page) == -1);
116
117 errno = 0;
118 ATF_REQUIRE_ERRNO(ENOMEM, munlock((char *)0, page) == -1);
119
120 errno = 0;
121 /* Adjusted for OpenBSD, initially ENOMEM */
122 ATF_REQUIRE_ERRNO(EINVAL, munlock((char *)-1, page) == -1);
123
124 buf = malloc(page);
125 ATF_REQUIRE(buf != NULL);
126 fprintf(stderr, "mlock_err: buf = %p (page=%ld)\n", buf, page);
127
128 /*
129 * unlocking memory that is not locked is an error...
130 */
131
132 /*
133 * Adjusted for OpenBSD
134 * errno = 0;
135 * ATF_REQUIRE_ERRNO(ENOMEM, munlock(buf, page) == -1);
136 */
137
138 /*
139 * These are permitted to fail (EINVAL) but do not on NetBSD
140 */
141 mlock_err = mlock((void *)(((uintptr_t)buf) + page/3), page/5);
142 if (mlock_err != 0)
143 fprintf(stderr, "mlock_err: mlock(%p, %ld): %d [%d] %s\n",
144 (void *)(((uintptr_t)buf) + page/3), page/5, mlock_err,
145 errno, strerror(errno));
146 ATF_REQUIRE(mlock_err == 0);
147 munlock_err= munlock((void *)(((uintptr_t)buf) + page/3), page/5);
148 if (munlock_err != 0)
149 fprintf(stderr, "mlock_err: munlock(%p, %ld): %d [%d] %s\n",
150 (void *)(((uintptr_t)buf) + page/3), page/5, munlock_err,
151 errno, strerror(errno));
152 ATF_REQUIRE(munlock_err == 0);
153
154 (void)free(buf);
155
156 /*
157 * Try to create a pointer to an unmapped page - first after current
158 * brk will likely do.
159 */
160 invalid_ptr = (void*)(((uintptr_t)sbrk(0)+page) & ~(page-1));
161 printf("testing with (hopefully) invalid pointer %p\n", invalid_ptr);
162
163 errno = 0;
164 ATF_REQUIRE_ERRNO(ENOMEM, mlock(invalid_ptr, page) == -1);
165
166 errno = 0;
167 ATF_REQUIRE_ERRNO(ENOMEM, munlock(invalid_ptr, page) == -1);
168}
169
170ATF_TC(mlock_limits);
171ATF_TC_HEAD(mlock_limits, tc)
172{
173 atf_tc_set_md_var(tc, "descr", "Test system limits with mlock(2)");
174}
175
176ATF_TC_BODY(mlock_limits, tc)
177{
178 struct rlimit res;
179 void *buf;
180 pid_t pid;
181 int sta;
182
183 buf = malloc(page);
184 ATF_REQUIRE(buf != NULL);
185 fprintf(stderr, "mlock_limits: buf = %p (page=%ld)\n", buf, page);
186
187 pid = fork();
188 ATF_REQUIRE(pid >= 0);
189
190 if (pid == 0) {
191
192 for (ssize_t i = page; i >= 2; i -= 100) {
193
194 res.rlim_cur = i - 1;
195 res.rlim_max = i - 1;
196
197 (void)fprintf(stderr, "trying to lock %zu bytes "
198 "with %zu byte limit\n", i, (size_t)res.rlim_cur);
199
200 if (setrlimit(RLIMIT_MEMLOCK, &res) != 0)
201 _exit(EXIT_FAILURE);
202
203 errno = 0;
204
205 if ((sta = mlock(buf, i)) != -1 || errno != EAGAIN) {
206 fprintf(stderr, "mlock(%p, %zu): %d [%d] %s\n",
207 buf, i, sta, errno, strerror(errno));
208 (void)munlock(buf, i);
209 _exit(EXIT_FAILURE);
210 }
211 }
212
213 _exit(EXIT_SUCCESS);
214 }
215
216 (void)wait(&sta);
217
218 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
219 atf_tc_fail("mlock(2) locked beyond system limits");
220
221 free(buf);
222}
223
224ATF_TC(mlock_mmap);
225ATF_TC_HEAD(mlock_mmap, tc)
226{
227 atf_tc_set_md_var(tc, "descr", "Test mlock(2)-mmap(2) interaction");
228}
229
230ATF_TC_BODY(mlock_mmap, tc)
231{
232 /* Adjusted for OpenBSD, initially ... | MAP_WIRED */
233 static const int flags = MAP_ANON | MAP_PRIVATE;
234 void *buf;
235
236 /*
237 * Make a wired RW mapping and check that mlock(2)
238 * does not fail for the (already locked) mapping.
239 */
240 buf = mmap(NULL, page, PROT_READ | PROT_WRITE, flags, -1, 0);
241
242 if (buf == MAP_FAILED)
243 fprintf(stderr,
244 "mlock_mmap: mmap(NULL, %ld, %#x, %#x, -1, 0): MAP_FAILED"
245 " [%d] %s\n", page, PROT_READ | PROT_WRITE, flags, errno,
246 strerror(errno));
247
248 ATF_REQUIRE(buf != MAP_FAILED);
249
250 fprintf(stderr, "mlock_mmap: buf=%p, page=%ld\n", buf, page);
251
252 ATF_REQUIRE(mlock(buf, page) == 0);
253 ATF_REQUIRE(munlock(buf, page) == 0);
254 ATF_REQUIRE(munmap(buf, page) == 0);
255 ATF_REQUIRE(munlock(buf, page) != 0);
256
257 fprintf(stderr, "mlock_mmap: first test succeeded\n");
258
259 /*
260 * But it should be impossible to mlock(2) a PROT_NONE mapping.
261 */
262 buf = mmap(NULL, page, PROT_NONE, flags, -1, 0);
263
264 if (buf == MAP_FAILED)
265 fprintf(stderr,
266 "mlock_mmap: mmap(NULL, %ld, %#x, %#x, -1, 0): MAP_FAILED"
267 " [%d] %s\n", page, PROT_NONE, flags, errno,
268 strerror(errno));
269
270 ATF_REQUIRE(buf != MAP_FAILED);
271 ATF_REQUIRE(mlock(buf, page) != 0);
272 ATF_REQUIRE(munmap(buf, page) == 0);
273
274 fprintf(stderr, "mlock_mmap: second test succeeded\n");
275}
276
277ATF_TC(mlock_nested);
278ATF_TC_HEAD(mlock_nested, tc)
279{
280 atf_tc_set_md_var(tc, "descr",
281 "Test that consecutive mlock(2) calls succeed");
282}
283
284ATF_TC_BODY(mlock_nested, tc)
285{
286 const size_t maxiter = 100;
287 void *buf;
288 int err;
289
290 buf = malloc(page);
291 ATF_REQUIRE(buf != NULL);
292 fprintf(stderr, "mlock_nested: buf = %p (page=%ld)\n", buf, page);
293
294 for (size_t i = 0; i < maxiter; i++) {
295 err = mlock(buf, page);
296 if (err != 0)
297 fprintf(stderr,
298 "mlock_nested: i=%zu (of %zu) mlock(%p, %ld): %d [%d] %s\n",
299 i, maxiter, buf, page, err, errno, strerror(errno));
300 ATF_REQUIRE(err == 0);
301 }
302
303 err = munlock(buf, page);
304 if (err != 0)
305 fprintf(stderr, "mlock_nested: munlock(%p, %ld): %d [%d] %s\n",
306 buf, page, err, errno, strerror(errno));
307 ATF_REQUIRE(err == 0);
308 free(buf);
309}
310
311ATF_TP_ADD_TCS(tp)
312{
313
314 page = sysconf(_SC_PAGESIZE);
315 fprintf(stderr, "t_mlock: pagesize %ld\n", page);
316 ATF_REQUIRE(page >= 0);
317
318 ATF_TP_ADD_TC(tp, mlock_clip);
319 ATF_TP_ADD_TC(tp, mlock_err);
320 ATF_TP_ADD_TC(tp, mlock_limits);
321 ATF_TP_ADD_TC(tp, mlock_mmap);
322 ATF_TP_ADD_TC(tp, mlock_nested);
323
324 return atf_no_error();
325}
diff --git a/src/regress/lib/libc/sys/t_mmap.c b/src/regress/lib/libc/sys/t_mmap.c
new file mode 100644
index 0000000000..6dbfae5bb1
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_mmap.c
@@ -0,0 +1,584 @@
1/* $OpenBSD: t_mmap.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_mmap.c,v 1.13 2017/05/23 13:04:29 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33/*-
34 * Copyright (c)2004 YAMAMOTO Takashi,
35 * All rights reserved.
36 *
37 * Redistribution and use in source and binary forms, with or without
38 * modification, are permitted provided that the following conditions
39 * are met:
40 * 1. Redistributions of source code must retain the above copyright
41 * notice, this list of conditions and the following disclaimer.
42 * 2. Redistributions in binary form must reproduce the above copyright
43 * notice, this list of conditions and the following disclaimer in the
44 * documentation and/or other materials provided with the distribution.
45 *
46 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
47 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
48 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
49 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
50 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
51 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
52 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
53 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
54 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
55 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
56 * SUCH DAMAGE.
57 */
58
59#include "macros.h"
60
61#include <sys/cdefs.h>
62__RCSID("$NetBSD: t_mmap.c,v 1.13 2017/05/23 13:04:29 christos Exp $");
63
64#include <sys/param.h>
65#include <sys/disklabel.h>
66#include <sys/mman.h>
67#include <sys/stat.h>
68#include <sys/socket.h>
69#include <sys/sysctl.h>
70#include <sys/wait.h>
71
72#include "atf-c.h"
73#include <errno.h>
74#include <fcntl.h>
75#include <signal.h>
76#include <stdio.h>
77#include <stdlib.h>
78#include <string.h>
79#include <unistd.h>
80#include <paths.h>
81
82static long page = 0;
83static char path[] = "mmap";
84static void map_check(void *, int);
85static void map_sighandler(int);
86static void testloan(void *, void *, char, int);
87
88#define BUFSIZE (32 * 1024) /* enough size to trigger sosend_loan */
89
90static void
91map_check(void *map, int flag)
92{
93
94 if (flag != 0) {
95 ATF_REQUIRE(map == MAP_FAILED);
96 return;
97 }
98
99 ATF_REQUIRE(map != MAP_FAILED);
100 ATF_REQUIRE(munmap(map, page) == 0);
101}
102
103void
104testloan(void *vp, void *vp2, char pat, int docheck)
105{
106 char buf[BUFSIZE];
107 char backup[BUFSIZE];
108 ssize_t nwritten;
109 ssize_t nread;
110 int fds[2];
111 int val;
112
113 val = BUFSIZE;
114
115 if (docheck != 0)
116 (void)memcpy(backup, vp, BUFSIZE);
117
118 if (socketpair(AF_LOCAL, SOCK_STREAM, PF_UNSPEC, fds) != 0)
119 atf_tc_fail("socketpair() failed");
120
121 val = BUFSIZE;
122
123 if (setsockopt(fds[1], SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)) != 0)
124 atf_tc_fail("setsockopt() failed, SO_RCVBUF");
125
126 val = BUFSIZE;
127
128 if (setsockopt(fds[0], SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)) != 0)
129 atf_tc_fail("setsockopt() failed, SO_SNDBUF");
130
131 if (fcntl(fds[0], F_SETFL, O_NONBLOCK) != 0)
132 atf_tc_fail("fcntl() failed");
133
134 nwritten = write(fds[0], (char *)vp + page, BUFSIZE - page);
135
136 if (nwritten == -1)
137 atf_tc_fail("write() failed");
138
139 /* Break loan. */
140 (void)memset(vp2, pat, BUFSIZE);
141
142 nread = read(fds[1], buf + page, BUFSIZE - page);
143
144 if (nread == -1)
145 atf_tc_fail("read() failed");
146
147 if (nread != nwritten)
148 atf_tc_fail("too short read");
149
150 if (docheck != 0 && memcmp(backup, buf + page, nread) != 0)
151 atf_tc_fail("data mismatch");
152
153 ATF_REQUIRE(close(fds[0]) == 0);
154 ATF_REQUIRE(close(fds[1]) == 0);
155}
156
157static void
158map_sighandler(int signo)
159{
160 _exit(signo);
161}
162
163ATF_TC(mmap_block);
164ATF_TC_HEAD(mmap_block, tc)
165{
166 atf_tc_set_md_var(tc, "descr", "Test mmap(2) with a block device");
167 atf_tc_set_md_var(tc, "require.user", "root");
168}
169
170ATF_TC_BODY(mmap_block, tc)
171{
172 static const int mib[] = { CTL_HW, HW_DISKNAMES };
173 static const unsigned int miblen = __arraycount(mib);
174 char *map, *dk, *drives, dev[PATH_MAX];
175 size_t len;
176 int fd = -1;
177
178 atf_tc_skip("The test case causes a panic (PR kern/38889, kern/46592)");
179
180 ATF_REQUIRE(sysctl(mib, miblen, NULL, &len, NULL, 0) == 0);
181 drives = malloc(len);
182 ATF_REQUIRE(drives != NULL);
183 ATF_REQUIRE(sysctl(mib, miblen, drives, &len, NULL, 0) == 0);
184 for (dk = strtok(drives, " "); dk != NULL; dk = strtok(NULL, " ")) {
185 if (strncmp(dk, "dk", 2) == 0)
186 snprintf(dev, sizeof(dev), _PATH_DEV "%s", dk);
187 else
188 snprintf(dev, sizeof(dev), _PATH_DEV "%s%c", dk,
189 'a' + RAW_PART);
190 fprintf(stderr, "trying: %s\n", dev);
191
192 if ((fd = open(dev, O_RDONLY)) >= 0) {
193 (void)fprintf(stderr, "using %s\n", dev);
194 break;
195 } else
196 (void)fprintf(stderr, "%s: %s\n", dev, strerror(errno));
197 }
198 free(drives);
199
200 if (fd < 0)
201 atf_tc_skip("failed to find suitable block device");
202
203 map = mmap(NULL, 4096, PROT_READ, MAP_FILE, fd, 0);
204 ATF_REQUIRE_MSG(map != MAP_FAILED, "mmap: %s", strerror(errno));
205
206 (void)fprintf(stderr, "first byte %x\n", *map);
207 ATF_REQUIRE(close(fd) == 0);
208 (void)fprintf(stderr, "first byte %x\n", *map);
209
210 ATF_REQUIRE(munmap(map, 4096) == 0);
211}
212
213ATF_TC(mmap_err);
214ATF_TC_HEAD(mmap_err, tc)
215{
216 atf_tc_set_md_var(tc, "descr", "Test error conditions of mmap(2)");
217}
218
219ATF_TC_BODY(mmap_err, tc)
220{
221 size_t addr = SIZE_MAX;
222 void *map;
223
224 errno = 0;
225 map = mmap(NULL, 3, PROT_READ, MAP_FILE|MAP_PRIVATE, -1, 0);
226
227 ATF_REQUIRE(map == MAP_FAILED);
228 ATF_REQUIRE(errno == EBADF);
229
230 errno = 0;
231 map = mmap(&addr, page, PROT_READ, MAP_FIXED|MAP_PRIVATE, -1, 0);
232
233 ATF_REQUIRE(map == MAP_FAILED);
234 ATF_REQUIRE(errno == EINVAL);
235
236 errno = 0;
237 map = mmap(NULL, page, PROT_READ, MAP_ANON|MAP_PRIVATE, INT_MAX, 0);
238
239 ATF_REQUIRE(map == MAP_FAILED);
240 ATF_REQUIRE(errno == EINVAL);
241}
242
243ATF_TC_WITH_CLEANUP(mmap_loan);
244ATF_TC_HEAD(mmap_loan, tc)
245{
246 atf_tc_set_md_var(tc, "descr", "Test uvm page loanout with mmap(2)");
247}
248
249ATF_TC_BODY(mmap_loan, tc)
250{
251 char buf[BUFSIZE];
252 char *vp, *vp2;
253 int fd;
254
255 fd = open(path, O_RDWR | O_CREAT, 0600);
256 ATF_REQUIRE(fd >= 0);
257
258 (void)memset(buf, 'x', sizeof(buf));
259 (void)write(fd, buf, sizeof(buf));
260
261 vp = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE,
262 MAP_FILE | MAP_PRIVATE, fd, 0);
263
264 ATF_REQUIRE(vp != MAP_FAILED);
265
266 vp2 = vp;
267
268 testloan(vp, vp2, 'A', 0);
269 testloan(vp, vp2, 'B', 1);
270
271 ATF_REQUIRE(munmap(vp, BUFSIZE) == 0);
272
273 vp = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE,
274 MAP_FILE | MAP_SHARED, fd, 0);
275
276 vp2 = mmap(NULL, BUFSIZE, PROT_READ | PROT_WRITE,
277 MAP_FILE | MAP_SHARED, fd, 0);
278
279 ATF_REQUIRE(vp != MAP_FAILED);
280 ATF_REQUIRE(vp2 != MAP_FAILED);
281
282 testloan(vp, vp2, 'E', 1);
283
284 ATF_REQUIRE(munmap(vp, BUFSIZE) == 0);
285 ATF_REQUIRE(munmap(vp2, BUFSIZE) == 0);
286}
287
288ATF_TC_CLEANUP(mmap_loan, tc)
289{
290 (void)unlink(path);
291}
292
293ATF_TC_WITH_CLEANUP(mmap_prot_1);
294ATF_TC_HEAD(mmap_prot_1, tc)
295{
296 atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #1");
297}
298
299ATF_TC_BODY(mmap_prot_1, tc)
300{
301 void *map;
302 int fd;
303
304 /*
305 * Open a file write-only and try to
306 * map it read-only. This should fail.
307 */
308 fd = open(path, O_WRONLY | O_CREAT, 0700);
309
310 if (fd < 0)
311 return;
312
313 ATF_REQUIRE(write(fd, "XXX", 3) == 3);
314
315 map = mmap(NULL, 3, PROT_READ, MAP_FILE|MAP_PRIVATE, fd, 0);
316 map_check(map, 1);
317
318 map = mmap(NULL, 3, PROT_WRITE, MAP_FILE|MAP_PRIVATE, fd, 0);
319 map_check(map, 0);
320
321 ATF_REQUIRE(close(fd) == 0);
322}
323
324ATF_TC_CLEANUP(mmap_prot_1, tc)
325{
326 (void)unlink(path);
327}
328
329ATF_TC(mmap_prot_2);
330ATF_TC_HEAD(mmap_prot_2, tc)
331{
332 atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #2");
333}
334
335ATF_TC_BODY(mmap_prot_2, tc)
336{
337 char buf[2];
338 void *map;
339 pid_t pid;
340 int sta;
341
342 /*
343 * Make a PROT_NONE mapping and try to access it.
344 * If we catch a SIGSEGV, all works as expected.
345 */
346 map = mmap(NULL, page, PROT_NONE, MAP_ANON|MAP_PRIVATE, -1, 0);
347 ATF_REQUIRE(map != MAP_FAILED);
348
349 pid = fork();
350 ATF_REQUIRE(pid >= 0);
351
352 if (pid == 0) {
353 ATF_REQUIRE(signal(SIGSEGV, map_sighandler) != SIG_ERR);
354 ATF_REQUIRE(strlcpy(buf, map, sizeof(buf)) != 0);
355 }
356
357 (void)wait(&sta);
358
359 ATF_REQUIRE(WIFEXITED(sta) != 0);
360 ATF_REQUIRE(WEXITSTATUS(sta) == SIGSEGV);
361 ATF_REQUIRE(munmap(map, page) == 0);
362}
363
364ATF_TC_WITH_CLEANUP(mmap_prot_3);
365ATF_TC_HEAD(mmap_prot_3, tc)
366{
367 atf_tc_set_md_var(tc, "descr", "Test mmap(2) protections, #3");
368}
369
370ATF_TC_BODY(mmap_prot_3, tc)
371{
372 char buf[2];
373 int fd, sta;
374 void *map;
375 pid_t pid;
376
377 /*
378 * Open a file, change the permissions
379 * to read-only, and try to map it as
380 * PROT_NONE. This should succeed, but
381 * the access should generate SIGSEGV.
382 */
383 fd = open(path, O_RDWR | O_CREAT, 0700);
384
385 if (fd < 0)
386 return;
387
388 ATF_REQUIRE(write(fd, "XXX", 3) == 3);
389 ATF_REQUIRE(close(fd) == 0);
390 ATF_REQUIRE(chmod(path, 0444) == 0);
391
392 fd = open(path, O_RDONLY);
393 ATF_REQUIRE(fd != -1);
394
395 map = mmap(NULL, 3, PROT_NONE, MAP_FILE | MAP_SHARED, fd, 0);
396 ATF_REQUIRE(map != MAP_FAILED);
397
398 pid = fork();
399
400 ATF_REQUIRE(pid >= 0);
401
402 if (pid == 0) {
403 ATF_REQUIRE(signal(SIGSEGV, map_sighandler) != SIG_ERR);
404 ATF_REQUIRE(strlcpy(buf, map, sizeof(buf)) != 0);
405 }
406
407 (void)wait(&sta);
408
409 ATF_REQUIRE(WIFEXITED(sta) != 0);
410 ATF_REQUIRE(WEXITSTATUS(sta) == SIGSEGV);
411 ATF_REQUIRE(munmap(map, 3) == 0);
412}
413
414ATF_TC_CLEANUP(mmap_prot_3, tc)
415{
416 (void)unlink(path);
417}
418
419ATF_TC_WITH_CLEANUP(mmap_truncate);
420ATF_TC_HEAD(mmap_truncate, tc)
421{
422 atf_tc_set_md_var(tc, "descr", "Test mmap(2) and ftruncate(2)");
423}
424
425ATF_TC_BODY(mmap_truncate, tc)
426{
427 char *map;
428 long i;
429 int fd;
430
431 fd = open(path, O_RDWR | O_CREAT, 0700);
432
433 if (fd < 0)
434 return;
435
436 /*
437 * See that ftruncate(2) works
438 * while the file is mapped.
439 */
440 ATF_REQUIRE(ftruncate(fd, page) == 0);
441
442 map = mmap(NULL, page, PROT_READ | PROT_WRITE, MAP_FILE|MAP_PRIVATE,
443 fd, 0);
444 ATF_REQUIRE(map != MAP_FAILED);
445
446 for (i = 0; i < page; i++)
447 map[i] = 'x';
448
449 ATF_REQUIRE(ftruncate(fd, 0) == 0);
450 ATF_REQUIRE(ftruncate(fd, page / 8) == 0);
451 ATF_REQUIRE(ftruncate(fd, page / 4) == 0);
452 ATF_REQUIRE(ftruncate(fd, page / 2) == 0);
453 ATF_REQUIRE(ftruncate(fd, page / 12) == 0);
454 ATF_REQUIRE(ftruncate(fd, page / 64) == 0);
455
456 (void)munmap(map, page);
457 ATF_REQUIRE(close(fd) == 0);
458}
459
460ATF_TC_CLEANUP(mmap_truncate, tc)
461{
462 (void)unlink(path);
463}
464
465ATF_TC_WITH_CLEANUP(mmap_truncate_signal);
466ATF_TC_HEAD(mmap_truncate_signal, tc)
467{
468 atf_tc_set_md_var(tc, "descr",
469 "Test mmap(2) ftruncate(2) causing signal");
470}
471
472ATF_TC_BODY(mmap_truncate_signal, tc)
473{
474 char *map;
475 long i;
476 int fd, sta;
477 pid_t pid;
478
479 fd = open(path, O_RDWR | O_CREAT, 0700);
480
481 if (fd < 0)
482 return;
483
484 ATF_REQUIRE(write(fd, "foo\n", 5) == 5);
485
486 map = mmap(NULL, page, PROT_READ, MAP_FILE|MAP_PRIVATE, fd, 0);
487 ATF_REQUIRE(map != MAP_FAILED);
488
489 sta = 0;
490 for (i = 0; i < 5; i++)
491 sta += map[i];
492 ATF_REQUIRE(sta == 334);
493
494 ATF_REQUIRE(ftruncate(fd, 0) == 0);
495 pid = fork();
496 ATF_REQUIRE(pid >= 0);
497
498 if (pid == 0) {
499 ATF_REQUIRE(signal(SIGBUS, map_sighandler) != SIG_ERR);
500 ATF_REQUIRE(signal(SIGSEGV, map_sighandler) != SIG_ERR);
501 sta = 0;
502 for (i = 0; i < page; i++)
503 sta += map[i];
504 /* child never will get this far, but the compiler will
505 not know, so better use the values calculated to
506 prevent the access to be optimized out */
507 ATF_REQUIRE(i == 0);
508 ATF_REQUIRE(sta == 0);
509 (void)munmap(map, page);
510 (void)close(fd);
511 return;
512 }
513
514 (void)wait(&sta);
515
516 ATF_REQUIRE(WIFEXITED(sta) != 0);
517 if (WEXITSTATUS(sta) == SIGSEGV)
518 atf_tc_fail("child process got SIGSEGV instead of SIGBUS");
519 ATF_REQUIRE(WEXITSTATUS(sta) == SIGBUS);
520 ATF_REQUIRE(munmap(map, page) == 0);
521 ATF_REQUIRE(close(fd) == 0);
522}
523
524ATF_TC_CLEANUP(mmap_truncate_signal, tc)
525{
526 (void)unlink(path);
527}
528
529ATF_TC(mmap_va0);
530ATF_TC_HEAD(mmap_va0, tc)
531{
532 atf_tc_set_md_var(tc, "descr", "Test mmap(2) and vm.user_va0_disable");
533}
534
535ATF_TC_BODY(mmap_va0, tc)
536{
537 int flags = MAP_ANON | MAP_FIXED | MAP_PRIVATE;
538 size_t len = sizeof(int);
539 void *map;
540 int val;
541
542 /*
543 * Make an anonymous fixed mapping at zero address. If the address
544 * is restricted as noted in security(7), the syscall should fail.
545 */
546 if (sysctlbyname("vm.user_va0_disable", &val, &len, NULL, 0) != 0)
547 atf_tc_fail("failed to read vm.user_va0_disable");
548
549 map = mmap(NULL, page, PROT_EXEC, flags, -1, 0);
550 map_check(map, val);
551
552 map = mmap(NULL, page, PROT_READ, flags, -1, 0);
553 map_check(map, val);
554
555 map = mmap(NULL, page, PROT_WRITE, flags, -1, 0);
556 map_check(map, val);
557
558 map = mmap(NULL, page, PROT_READ|PROT_WRITE, flags, -1, 0);
559 map_check(map, val);
560
561 map = mmap(NULL, page, PROT_EXEC|PROT_READ|PROT_WRITE, flags, -1, 0);
562 map_check(map, val);
563}
564
565ATF_TP_ADD_TCS(tp)
566{
567 page = sysconf(_SC_PAGESIZE);
568 ATF_REQUIRE(page >= 0);
569
570 ATF_TP_ADD_TC(tp, mmap_block);
571 ATF_TP_ADD_TC(tp, mmap_err);
572 ATF_TP_ADD_TC(tp, mmap_loan);
573 ATF_TP_ADD_TC(tp, mmap_prot_1);
574 ATF_TP_ADD_TC(tp, mmap_prot_2);
575 ATF_TP_ADD_TC(tp, mmap_prot_3);
576 ATF_TP_ADD_TC(tp, mmap_truncate);
577 ATF_TP_ADD_TC(tp, mmap_truncate_signal);
578 /*
579 * Adjusted for OpenBSD, not available
580 * ATF_TP_ADD_TC(tp, mmap_va0);
581 */
582
583 return atf_no_error();
584}
diff --git a/src/regress/lib/libc/sys/t_msgctl.c b/src/regress/lib/libc/sys/t_msgctl.c
new file mode 100644
index 0000000000..980f11ee0b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_msgctl.c
@@ -0,0 +1,405 @@
1/* $OpenBSD: t_msgctl.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_msgctl.c,v 1.7 2017/10/07 17:15:44 kre Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_msgctl.c,v 1.7 2017/10/07 17:15:44 kre Exp $");
37
38#include <sys/msg.h>
39#include <sys/stat.h>
40#include <sys/sysctl.h>
41#include <sys/wait.h>
42
43#include "atf-c.h"
44#include <errno.h>
45#include <limits.h>
46#include <pwd.h>
47#include <signal.h>
48#include <stdio.h>
49#include <stdlib.h>
50#include <string.h>
51#include <sysexits.h>
52#include <time.h>
53#include <unistd.h>
54
55#define MSG_KEY 12345689
56#define MSG_MTYPE_1 0x41
57
58struct msg {
59 long mtype;
60 char buf[3];
61};
62
63static void clean(void);
64
65static void
66clean(void)
67{
68 int id;
69
70 if ((id = msgget(MSG_KEY, 0)) != -1)
71 (void)msgctl(id, IPC_RMID, 0);
72}
73
74ATF_TC_WITH_CLEANUP(msgctl_err);
75ATF_TC_HEAD(msgctl_err, tc)
76{
77 atf_tc_set_md_var(tc, "descr", "Test errors from msgctl(2)");
78}
79
80ATF_TC_BODY(msgctl_err, tc)
81{
82 const int cmd[] = { IPC_STAT, IPC_SET, IPC_RMID };
83 struct msqid_ds msgds;
84 size_t i;
85 int id;
86
87 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
88
89 id = msgget(MSG_KEY, IPC_CREAT | 0600);
90 ATF_REQUIRE(id != -1);
91
92 errno = 0;
93 ATF_REQUIRE_ERRNO(EINVAL, msgctl(id, INT_MAX, &msgds) == -1);
94
95 errno = 0;
96 ATF_REQUIRE_ERRNO(EFAULT, msgctl(id, IPC_STAT, (void *)-1) == -1);
97
98 for (i = 0; i < __arraycount(cmd); i++) {
99 errno = 0;
100 ATF_REQUIRE_ERRNO(EINVAL, msgctl(-1, cmd[i], &msgds) == -1);
101 }
102
103 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
104}
105
106ATF_TC_CLEANUP(msgctl_err, tc)
107{
108 clean();
109}
110
111ATF_TC_WITH_CLEANUP(msgctl_perm);
112ATF_TC_HEAD(msgctl_perm, tc)
113{
114 atf_tc_set_md_var(tc, "descr", "Test permissions with msgctl(2)");
115 atf_tc_set_md_var(tc, "require.user", "root");
116}
117
118ATF_TC_BODY(msgctl_perm, tc)
119{
120 struct msqid_ds msgds;
121 struct passwd *pw;
122 pid_t pid;
123 int sta;
124 int id;
125
126 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
127
128 pw = getpwnam("nobody");
129 id = msgget(MSG_KEY, IPC_CREAT | 0600);
130
131 ATF_REQUIRE(id != -1);
132 ATF_REQUIRE(pw != NULL);
133 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
134
135 pid = fork();
136 ATF_REQUIRE(pid >= 0);
137
138 if (pid == 0) {
139
140 if (setuid(pw->pw_uid) != 0)
141 _exit(EX_OSERR);
142
143 msgds.msg_perm.uid = getuid();
144 msgds.msg_perm.gid = getgid();
145
146 errno = 0;
147
148 if (msgctl(id, IPC_SET, &msgds) == 0)
149 _exit(EXIT_FAILURE);
150
151 if (errno != EPERM)
152 _exit(EXIT_FAILURE);
153
154 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
155
156 if (msgctl(id, IPC_STAT, &msgds) != 0)
157 _exit(EX_OSERR);
158
159 msgds.msg_qbytes = 1;
160
161 if (msgctl(id, IPC_SET, &msgds) == 0)
162 _exit(EXIT_FAILURE);
163
164 if (errno != EPERM)
165 _exit(EXIT_FAILURE);
166
167 _exit(EXIT_SUCCESS);
168 }
169
170 (void)wait(&sta);
171
172 if (WIFEXITED(sta) == 0) {
173
174 if (WEXITSTATUS(sta) == EX_OSERR)
175 atf_tc_fail("system call failed");
176
177 if (WEXITSTATUS(sta) == EXIT_FAILURE)
178 atf_tc_fail("UID %u manipulated root's "
179 "message queue", pw->pw_uid);
180 }
181
182 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
183}
184
185ATF_TC_CLEANUP(msgctl_perm, tc)
186{
187 clean();
188}
189
190ATF_TC_WITH_CLEANUP(msgctl_pid);
191ATF_TC_HEAD(msgctl_pid, tc)
192{
193 atf_tc_set_md_var(tc, "descr", "Test that PIDs are updated");
194}
195
196ATF_TC_BODY(msgctl_pid, tc)
197{
198 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
199 struct msqid_ds msgds;
200 int id, sta;
201 pid_t pid;
202
203 id = msgget(MSG_KEY, IPC_CREAT | 0600);
204 ATF_REQUIRE(id != -1);
205
206 pid = fork();
207 ATF_REQUIRE(pid >= 0);
208
209 if (pid == 0) {
210
211 (void)msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT);
212
213 _exit(EXIT_SUCCESS);
214 }
215
216 (void)sleep(1);
217 (void)wait(&sta);
218 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
219
220 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
221
222 if (pid != msgds.msg_lspid)
223 atf_tc_fail("the PID of last msgsnd(2) was not updated");
224
225 pid = fork();
226 ATF_REQUIRE(pid >= 0);
227
228 if (pid == 0) {
229
230 (void)msgrcv(id, &msg,
231 sizeof(struct msg), MSG_MTYPE_1, IPC_NOWAIT);
232
233 _exit(EXIT_SUCCESS);
234 }
235
236 (void)sleep(1);
237 (void)wait(&sta);
238 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
239
240 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
241
242 if (pid != msgds.msg_lrpid)
243 atf_tc_fail("the PID of last msgrcv(2) was not updated");
244
245 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
246}
247
248ATF_TC_CLEANUP(msgctl_pid, tc)
249{
250 clean();
251}
252
253ATF_TC_WITH_CLEANUP(msgctl_set);
254ATF_TC_HEAD(msgctl_set, tc)
255{
256 atf_tc_set_md_var(tc, "descr", "Test msgctl(2) with IPC_SET");
257 atf_tc_set_md_var(tc, "require.user", "root");
258}
259
260ATF_TC_BODY(msgctl_set, tc)
261{
262 struct msqid_ds msgds;
263 struct passwd *pw;
264 int id;
265
266 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
267
268 pw = getpwnam("nobody");
269 id = msgget(MSG_KEY, IPC_CREAT | 0600);
270
271 ATF_REQUIRE(id != -1);
272 ATF_REQUIRE(pw != NULL);
273 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
274
275 msgds.msg_perm.uid = pw->pw_uid;
276
277 if (msgctl(id, IPC_SET, &msgds) != 0)
278 atf_tc_fail("root failed to change the UID of message queue");
279
280 msgds.msg_perm.uid = getuid();
281 msgds.msg_perm.gid = pw->pw_gid;
282
283 if (msgctl(id, IPC_SET, &msgds) != 0)
284 atf_tc_fail("root failed to change the GID of message queue");
285
286 /*
287 * Note: setting the qbytes to zero fails even as root.
288 */
289 msgds.msg_qbytes = 1;
290 msgds.msg_perm.gid = getgid();
291
292 if (msgctl(id, IPC_SET, &msgds) != 0)
293 atf_tc_fail("root failed to change qbytes of message queue");
294
295 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
296}
297
298ATF_TC_CLEANUP(msgctl_set, tc)
299{
300 clean();
301}
302
303ATF_TC_WITH_CLEANUP(msgctl_time);
304ATF_TC_HEAD(msgctl_time, tc)
305{
306 atf_tc_set_md_var(tc, "descr", "Test that access times are updated");
307}
308
309ATF_TC_BODY(msgctl_time, tc)
310{
311 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
312 struct msqid_ds msgds;
313 time_t t;
314 int id;
315
316 id = msgget(MSG_KEY, IPC_CREAT | 0600);
317 ATF_REQUIRE(id != -1);
318
319 t = time(NULL);
320
321 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
322 (void)msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT);
323 (void)msgctl(id, IPC_STAT, &msgds);
324
325 if (llabs(t - msgds.msg_stime) > 1)
326 atf_tc_fail("time of last msgsnd(2) was not updated");
327
328 if (msgds.msg_rtime != 0)
329 atf_tc_fail("time of last msgrcv(2) was updated incorrectly");
330
331 t = time(NULL);
332
333 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
334 (void)msgrcv(id, &msg, sizeof(struct msg), MSG_MTYPE_1, IPC_NOWAIT);
335 (void)msgctl(id, IPC_STAT, &msgds);
336
337 if (llabs(t - msgds.msg_rtime) > 1)
338 atf_tc_fail("time of last msgrcv(2) was not updated");
339
340 /*
341 * Note: this is non-zero even after the memset(3).
342 */
343 if (msgds.msg_stime == 0)
344 atf_tc_fail("time of last msgsnd(2) was updated incorrectly");
345
346 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
347}
348
349ATF_TC_CLEANUP(msgctl_time, tc)
350{
351 clean();
352}
353
354static volatile int sig_caught;
355
356static void
357sigsys_handler(int signum)
358{
359
360 sig_caught = signum;
361}
362
363static int
364no_kernel_sysvmsg(void)
365{
366 int id;
367 void (*osig)(int);
368
369 sig_caught = 0;
370 osig = signal(SIGSYS, sigsys_handler);
371 id = msgget(MSG_KEY, IPC_CREAT | 0600);
372 if (sig_caught || id == -1)
373 return 1;
374
375 (void)msgctl(id, IPC_RMID, 0);
376 (void)signal(SIGSYS, osig);
377
378 return 0;
379}
380
381ATF_TC(msgctl_query);
382ATF_TC_HEAD(msgctl_query, tc)
383{
384 atf_tc_set_md_var(tc, "descr", "Skip msgctl_* tests - no SYSVMSG");
385}
386ATF_TC_BODY(msgctl_query, tc)
387{
388 atf_tc_skip("No SYSVMSG in kernel");
389}
390
391ATF_TP_ADD_TCS(tp)
392{
393
394 if (no_kernel_sysvmsg()) {
395 ATF_TP_ADD_TC(tp, msgctl_query);
396 } else {
397 ATF_TP_ADD_TC(tp, msgctl_err);
398 ATF_TP_ADD_TC(tp, msgctl_perm);
399 ATF_TP_ADD_TC(tp, msgctl_pid);
400 ATF_TP_ADD_TC(tp, msgctl_set);
401 ATF_TP_ADD_TC(tp, msgctl_time);
402 }
403
404 return atf_no_error();
405}
diff --git a/src/regress/lib/libc/sys/t_msgget.c b/src/regress/lib/libc/sys/t_msgget.c
new file mode 100644
index 0000000000..2a9bb4cf3b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_msgget.c
@@ -0,0 +1,339 @@
1/* $OpenBSD: t_msgget.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_msgget.c,v 1.3 2017/10/08 08:31:05 kre Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_msgget.c,v 1.3 2017/10/08 08:31:05 kre Exp $");
37
38#include <sys/msg.h>
39#include <sys/stat.h>
40#include <sys/sysctl.h>
41#include <sys/wait.h>
42
43#include "atf-c.h"
44#include <errno.h>
45#include <pwd.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <string.h>
49#include <sysexits.h>
50#include <time.h>
51#include <unistd.h>
52
53#define MSG_KEY 12345689
54
55static void clean(void);
56
57static void
58clean(void)
59{
60 int id;
61
62 if ((id = msgget(MSG_KEY, 0)) != -1)
63 (void)msgctl(id, IPC_RMID, 0);
64}
65
66ATF_TC_WITH_CLEANUP(msgget_excl);
67ATF_TC_HEAD(msgget_excl, tc)
68{
69 atf_tc_set_md_var(tc, "descr", "Test msgget(2) with IPC_EXCL");
70}
71
72ATF_TC_BODY(msgget_excl, tc)
73{
74 int id;
75
76 /*
77 * Create a message queue and re-open it with
78 * O_CREAT and IPC_EXCL set. This should fail.
79 */
80 id = msgget(MSG_KEY, IPC_CREAT | 0600);
81
82 if (id < 0)
83 atf_tc_fail("failed to create message queue");
84
85 errno = 0;
86
87 if (msgget(MSG_KEY, IPC_CREAT | IPC_EXCL | 0600) != -1)
88 atf_tc_fail("msgget(2) failed for IPC_EXCL");
89
90 ATF_REQUIRE(errno == EEXIST);
91
92 /*
93 * However, the same call should succeed
94 * when IPC_EXCL is not set in the flags.
95 */
96 id = msgget(MSG_KEY, IPC_CREAT | 0600);
97
98 if (id < 0)
99 atf_tc_fail("msgget(2) failed to re-open");
100
101 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
102}
103
104ATF_TC_CLEANUP(msgget_excl, tc)
105{
106 clean();
107}
108
109ATF_TC_WITH_CLEANUP(msgget_exit);
110ATF_TC_HEAD(msgget_exit, tc)
111{
112 atf_tc_set_md_var(tc, "descr",
113 "Test that XSI message queues are "
114 "not removed when the process exits");
115}
116
117ATF_TC_BODY(msgget_exit, tc)
118{
119 int id, sta;
120 pid_t pid;
121
122 pid = fork();
123 ATF_REQUIRE(pid >= 0);
124
125 if (pid == 0) {
126
127 if (msgget(MSG_KEY, IPC_CREAT | IPC_EXCL | 0600) == -1)
128 _exit(EXIT_FAILURE);
129
130 _exit(EXIT_SUCCESS);
131 }
132
133 (void)wait(&sta);
134
135 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
136 atf_tc_fail("failed to create message queue");
137
138 id = msgget(MSG_KEY, 0);
139
140 if (id == -1)
141 atf_tc_fail("message queue was removed on process exit");
142
143 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
144}
145
146ATF_TC_CLEANUP(msgget_exit, tc)
147{
148 clean();
149}
150
151ATF_TC_WITH_CLEANUP(msgget_init);
152ATF_TC_HEAD(msgget_init, tc)
153{
154 atf_tc_set_md_var(tc, "descr",
155 "Test that msgget(2) initializes data structures properly");
156}
157
158ATF_TC_BODY(msgget_init, tc)
159{
160 const uid_t uid = geteuid();
161 const gid_t gid = getegid();
162 struct msqid_ds msgds;
163 time_t t;
164 int id;
165
166 (void)memset(&msgds, 0x9, sizeof(struct msqid_ds));
167
168 t = time(NULL);
169 id = msgget(MSG_KEY, IPC_CREAT | 0600);
170
171 ATF_REQUIRE(id !=-1);
172 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
173
174 ATF_CHECK(msgds.msg_qnum == 0);
175 ATF_CHECK(msgds.msg_lspid == 0);
176 ATF_CHECK(msgds.msg_lrpid == 0);
177 ATF_CHECK(msgds.msg_rtime == 0);
178 ATF_CHECK(msgds.msg_stime == 0);
179 ATF_CHECK(msgds.msg_perm.uid == uid);
180 ATF_CHECK(msgds.msg_perm.gid == gid);
181 ATF_CHECK(msgds.msg_perm.cuid == uid);
182 ATF_CHECK(msgds.msg_perm.cgid == gid);
183 ATF_CHECK(msgds.msg_perm.mode == 0600);
184
185 if (llabs(t - msgds.msg_ctime) > 5)
186 atf_tc_fail("msgget(2) initialized current time incorrectly");
187
188 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
189}
190
191ATF_TC_CLEANUP(msgget_init, tc)
192{
193 clean();
194}
195
196ATF_TC(msgget_limit);
197ATF_TC_HEAD(msgget_limit, tc)
198{
199 atf_tc_set_md_var(tc, "descr", "Test msgget(2) against system limits");
200}
201
202ATF_TC_BODY(msgget_limit, tc)
203{
204 size_t len = sizeof(int);
205 bool fail = false;
206 int i, lim = 0;
207 int *buf;
208
209 if (sysctlbyname("kern.ipc.msgmni", &lim, &len, NULL, 0) != 0)
210 atf_tc_skip("failed to read kern.ipc.msgmni sysctl");
211
212 buf = calloc(lim + 1, sizeof(*buf));
213 ATF_REQUIRE(buf != NULL);
214
215 for (i = 0; i < lim; i++) {
216
217 buf[i] = msgget(MSG_KEY + i, IPC_CREAT | IPC_EXCL | 0600);
218
219 (void)fprintf(stderr, "key[%d] = %d\n", i, buf[i]);
220
221 /*
222 * This test only works when there are zero existing
223 * message queues. Thus, bypass the unit test when
224 * this precondition is not met, for reason or another.
225 */
226 if (buf[i] == -1)
227 goto out;
228 }
229
230 i++;
231 errno = 0;
232
233 buf[i] = msgget(MSG_KEY + i, IPC_CREAT | IPC_EXCL | 0600);
234
235 if (buf[i] != -1 || errno != ENOSPC)
236 fail = true;
237
238out: /* Remember to clean-up. */
239 for (i = 0; i < lim; i++)
240 (void)msgctl(buf[i], IPC_RMID, 0);
241
242 free(buf);
243
244 if (fail != false)
245 atf_tc_fail("msgget(2) opened more than %d queues", lim);
246}
247
248ATF_TC_WITH_CLEANUP(msgget_mode);
249ATF_TC_HEAD(msgget_mode, tc)
250{
251 atf_tc_set_md_var(tc, "descr", "Test different modes with msgget(2)");
252 atf_tc_set_md_var(tc, "require.user", "root");
253}
254
255ATF_TC_BODY(msgget_mode, tc)
256{
257 static const mode_t mode[] = {
258 S_IRWXU, S_IRUSR, S_IWUSR, S_IXUSR, S_IRWXG, S_IRGRP,
259 S_IWGRP, S_IXGRP, S_IRWXO, S_IROTH, S_IWOTH, S_IXOTH
260 };
261
262 struct msqid_ds msgds;
263 size_t i;
264 int id;
265
266 for (i = 0; i < __arraycount(mode); i++) {
267
268 (void)fprintf(stderr, "testing mode %d\n", mode[i]);
269 (void)memset(&msgds, 0, sizeof(struct msqid_ds));
270
271 id = msgget(MSG_KEY, IPC_CREAT | IPC_EXCL | (int)mode[i]);
272
273 ATF_REQUIRE(id != -1);
274 ATF_REQUIRE(msgctl(id, IPC_STAT, &msgds) == 0);
275 ATF_REQUIRE(msgds.msg_perm.mode == mode[i]);
276 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
277 }
278}
279
280ATF_TC_CLEANUP(msgget_mode, tc)
281{
282 clean();
283}
284
285static volatile int sig_caught;
286
287static void
288sigsys_handler(int signum)
289{
290
291 sig_caught = signum;
292}
293
294static int
295no_kernel_sysvmsg(void)
296{
297 int id;
298 void (*osig)(int);
299
300 sig_caught = 0;
301 osig = signal(SIGSYS, sigsys_handler);
302 id = msgget(MSG_KEY, IPC_CREAT | 0600);
303 if (sig_caught || id == -1)
304 return 1;
305
306 (void)msgctl(id, IPC_RMID, 0);
307 (void)signal(SIGSYS, osig);
308
309 return 0;
310}
311
312ATF_TC(msgget_query);
313ATF_TC_HEAD(msgget_query, tc)
314{
315 atf_tc_set_md_var(tc, "descr", "Skip msgget_* tests - no SYSVMSG");
316}
317ATF_TC_BODY(msgget_query, tc)
318{
319 atf_tc_skip("No SYSVMSG in kernel");
320}
321
322ATF_TP_ADD_TCS(tp)
323{
324
325 if (no_kernel_sysvmsg()) {
326 ATF_TP_ADD_TC(tp, msgget_query);
327 } else {
328 ATF_TP_ADD_TC(tp, msgget_excl);
329 ATF_TP_ADD_TC(tp, msgget_exit);
330 ATF_TP_ADD_TC(tp, msgget_init);
331 /*
332 * Adjusted for OpenBSD, not available
333 * ATF_TP_ADD_TC(tp, msgget_limit);
334 */
335 ATF_TP_ADD_TC(tp, msgget_mode);
336 }
337
338 return atf_no_error();
339}
diff --git a/src/regress/lib/libc/sys/t_msgrcv.c b/src/regress/lib/libc/sys/t_msgrcv.c
new file mode 100644
index 0000000000..1fbcd41695
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_msgrcv.c
@@ -0,0 +1,388 @@
1/* $OpenBSD: t_msgrcv.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_msgrcv.c,v 1.5 2017/10/08 08:31:05 kre Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_msgrcv.c,v 1.5 2017/10/08 08:31:05 kre Exp $");
37
38#include <sys/msg.h>
39#include <sys/stat.h>
40#include <sys/sysctl.h>
41#include <sys/wait.h>
42
43#include "atf-c.h"
44#include <errno.h>
45#include <limits.h>
46#include <pwd.h>
47#include <signal.h>
48#include <stdio.h>
49#include <stdlib.h>
50#include <string.h>
51#include <sysexits.h>
52#include <time.h>
53#include <unistd.h>
54
55#define MSG_KEY 1234
56#define MSG_MTYPE_1 0x41
57#define MSG_MTYPE_2 0x42
58#define MSG_MTYPE_3 0x43
59#define MSG_LEN 3
60
61struct msg {
62 long mtype;
63 char buf[MSG_LEN];
64};
65
66static void clean(void);
67
68static void
69clean(void)
70{
71 int id;
72
73 if ((id = msgget(MSG_KEY, 0)) != -1)
74 (void)msgctl(id, IPC_RMID, 0);
75}
76
77ATF_TC_WITH_CLEANUP(msgrcv_basic);
78ATF_TC_HEAD(msgrcv_basic, tc)
79{
80 atf_tc_set_md_var(tc, "descr", "A basic test of msgrcv(2)");
81}
82
83ATF_TC_BODY(msgrcv_basic, tc)
84{
85 struct msg msg1 = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
86 struct msg msg2 = { MSG_MTYPE_1, { 'x', 'y', 'z' } };
87 int id;
88
89 id = msgget(MSG_KEY, IPC_CREAT | 0600);
90 ATF_REQUIRE(id != -1);
91
92 (void)msgsnd(id, &msg1, MSG_LEN, IPC_NOWAIT);
93 (void)msgrcv(id, &msg2, MSG_LEN, MSG_MTYPE_1, IPC_NOWAIT);
94
95 ATF_CHECK(msg1.buf[0] == msg2.buf[0]);
96 ATF_CHECK(msg1.buf[1] == msg2.buf[1]);
97 ATF_CHECK(msg1.buf[2] == msg2.buf[2]);
98
99 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
100}
101
102ATF_TC_CLEANUP(msgrcv_basic, tc)
103{
104 clean();
105}
106
107ATF_TC_WITH_CLEANUP(msgrcv_block);
108ATF_TC_HEAD(msgrcv_block, tc)
109{
110 atf_tc_set_md_var(tc, "descr", "Test that msgrcv(2) blocks");
111}
112
113ATF_TC_BODY(msgrcv_block, tc)
114{
115 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
116 int id, sta;
117 pid_t pid;
118
119 id = msgget(MSG_KEY, IPC_CREAT | 0600);
120 ATF_REQUIRE(id != -1);
121
122 pid = fork();
123 ATF_REQUIRE(pid >= 0);
124
125 if (pid == 0) {
126
127 if (msgrcv(id, &msg, MSG_LEN, MSG_MTYPE_1, 0) < 0)
128 _exit(EXIT_FAILURE);
129
130 _exit(EXIT_SUCCESS);
131 }
132
133 /*
134 * Below msgsnd(2) should unblock the child,
135 * and hence kill(2) should fail with ESRCH.
136 */
137 (void)sleep(1);
138 (void)msgsnd(id, &msg, MSG_LEN, IPC_NOWAIT);
139 (void)sleep(1);
140 (void)kill(pid, SIGKILL);
141 (void)wait(&sta);
142
143 if (WIFEXITED(sta) == 0 || WIFSIGNALED(sta) != 0)
144 atf_tc_fail("msgrcv(2) did not block");
145
146 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
147}
148
149ATF_TC_CLEANUP(msgrcv_block, tc)
150{
151 clean();
152}
153
154ATF_TC_WITH_CLEANUP(msgrcv_err);
155ATF_TC_HEAD(msgrcv_err, tc)
156{
157 atf_tc_set_md_var(tc, "descr", "Test errors from msgrcv(2)");
158}
159
160ATF_TC_BODY(msgrcv_err, tc)
161{
162 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
163 int id, r = 0;
164
165 id = msgget(MSG_KEY, IPC_CREAT | 0600);
166 ATF_REQUIRE(id != -1);
167
168 errno = 0;
169
170 ATF_REQUIRE_ERRNO(ENOMSG, msgrcv(id, &msg,
171 MSG_LEN, MSG_MTYPE_1, IPC_NOWAIT) == -1);
172
173 ATF_REQUIRE(msgsnd(id, &msg, MSG_LEN, IPC_NOWAIT) == 0);
174
175 errno = 0;
176
177 ATF_REQUIRE_ERRNO(EFAULT, msgrcv(id, (void *)-1,
178 MSG_LEN, MSG_MTYPE_1, IPC_NOWAIT) == -1);
179
180 errno = 0;
181
182 ATF_REQUIRE_ERRNO(EINVAL, msgrcv(-1, &msg,
183 MSG_LEN, MSG_MTYPE_1, IPC_NOWAIT) == -1);
184
185 errno = 0;
186
187 ATF_REQUIRE_ERRNO(EINVAL, msgrcv(-1, &msg,
188 SSIZE_MAX, MSG_MTYPE_1, IPC_NOWAIT) == -1);
189
190 ATF_REQUIRE(msgsnd(id, &msg, MSG_LEN, IPC_NOWAIT) == 0);
191
192 errno = 0;
193
194 ATF_REQUIRE_ERRNO(E2BIG, msgrcv(id, &r,
195 MSG_LEN - 1, MSG_MTYPE_1, IPC_NOWAIT) == -1);
196
197 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
198}
199
200ATF_TC_CLEANUP(msgrcv_err, tc)
201{
202 clean();
203}
204
205
206ATF_TC_WITH_CLEANUP(msgrcv_mtype);
207ATF_TC_HEAD(msgrcv_mtype, tc)
208{
209 atf_tc_set_md_var(tc, "descr", "Test message types with msgrcv(2)");
210}
211
212ATF_TC_BODY(msgrcv_mtype, tc)
213{
214 struct msg msg1 = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
215 struct msg msg2 = { MSG_MTYPE_3, { 'x', 'y', 'z' } };
216 int id;
217
218 id = msgget(MSG_KEY, IPC_CREAT | 0600);
219 ATF_REQUIRE(id != -1);
220
221 (void)msgsnd(id, &msg1, MSG_LEN, IPC_NOWAIT);
222 (void)msgrcv(id, &msg2, MSG_LEN, MSG_MTYPE_2, IPC_NOWAIT);
223
224 ATF_CHECK(msg1.buf[0] != msg2.buf[0]); /* Different mtype. */
225 ATF_CHECK(msg1.buf[1] != msg2.buf[1]);
226 ATF_CHECK(msg1.buf[2] != msg2.buf[2]);
227
228 (void)msgrcv(id, &msg2, MSG_LEN, MSG_MTYPE_1, IPC_NOWAIT);
229
230 ATF_CHECK(msg1.buf[0] == msg2.buf[0]); /* Same mtype. */
231 ATF_CHECK(msg1.buf[1] == msg2.buf[1]);
232 ATF_CHECK(msg1.buf[2] == msg2.buf[2]);
233
234 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
235}
236
237ATF_TC_CLEANUP(msgrcv_mtype, tc)
238{
239 clean();
240}
241
242ATF_TC_WITH_CLEANUP(msgrcv_nonblock);
243ATF_TC_HEAD(msgrcv_nonblock, tc)
244{
245 atf_tc_set_md_var(tc, "descr", "Test msgrcv(2) with IPC_NOWAIT");
246 atf_tc_set_md_var(tc, "timeout", "10");
247}
248
249ATF_TC_BODY(msgrcv_nonblock, tc)
250{
251 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
252 const ssize_t n = 10;
253 int id, sta;
254 ssize_t i;
255 pid_t pid;
256
257 id = msgget(MSG_KEY, IPC_CREAT | 0600);
258 ATF_REQUIRE(id != -1);
259
260 for (i = 0; i < n; i++) {
261
262 ATF_REQUIRE(msgsnd(id, &msg, MSG_LEN, IPC_NOWAIT) == 0);
263 }
264
265 pid = fork();
266 ATF_REQUIRE(pid >= 0);
267
268 if (pid == 0) {
269
270 while (i != 0) {
271
272 if (msgrcv(id, &msg, MSG_LEN, MSG_MTYPE_1,
273 IPC_NOWAIT) == -1)
274 _exit(EXIT_FAILURE);
275
276 i--;
277 }
278
279 _exit(EXIT_SUCCESS);
280 }
281
282 (void)sleep(2);
283 (void)kill(pid, SIGKILL);
284 (void)wait(&sta);
285
286 if (WIFSIGNALED(sta) != 0 || WTERMSIG(sta) == SIGKILL)
287 atf_tc_fail("msgrcv(2) blocked with IPC_NOWAIT");
288
289 if (WIFEXITED(sta) == 0 && WEXITSTATUS(sta) != EXIT_SUCCESS)
290 atf_tc_fail("msgrcv(2) failed");
291
292 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
293}
294
295ATF_TC_CLEANUP(msgrcv_nonblock, tc)
296{
297 clean();
298}
299
300ATF_TC_WITH_CLEANUP(msgrcv_truncate);
301ATF_TC_HEAD(msgrcv_truncate, tc)
302{
303 atf_tc_set_md_var(tc, "descr", "Test msgrcv(2) with MSG_NOERROR");
304}
305
306ATF_TC_BODY(msgrcv_truncate, tc)
307{
308#define MSG_SMALLLEN 2
309 struct msgsmall {
310 long mtype;
311 char buf[MSG_SMALLLEN];
312 };
313
314 struct msg msg1 = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
315 struct msgsmall msg2 = { MSG_MTYPE_1, { 'x', 'y' } };
316 int id;
317
318 id = msgget(MSG_KEY, IPC_CREAT | 0600);
319 ATF_REQUIRE(id != -1);
320
321 (void)msgsnd(id, &msg1, MSG_LEN, IPC_NOWAIT);
322 (void)msgrcv(id, &msg2, MSG_SMALLLEN,
323 MSG_MTYPE_1, IPC_NOWAIT | MSG_NOERROR);
324
325 ATF_CHECK(msg1.buf[0] == msg2.buf[0]);
326 ATF_CHECK(msg1.buf[1] == msg2.buf[1]);
327
328 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
329}
330
331ATF_TC_CLEANUP(msgrcv_truncate, tc)
332{
333 clean();
334}
335
336static volatile int sig_caught;
337
338static void
339sigsys_handler(int signum)
340{
341
342 sig_caught = signum;
343}
344
345static int
346no_kernel_sysvmsg(void)
347{
348 int id;
349 void (*osig)(int);
350
351 sig_caught = 0;
352 osig = signal(SIGSYS, sigsys_handler);
353 id = msgget(MSG_KEY, IPC_CREAT | 0600);
354 if (sig_caught || id == -1)
355 return 1;
356
357 (void)msgctl(id, IPC_RMID, 0);
358 (void)signal(SIGSYS, osig);
359
360 return 0;
361}
362
363ATF_TC(msgrcv_query);
364ATF_TC_HEAD(msgrcv_query, tc)
365{
366 atf_tc_set_md_var(tc, "descr", "Skip msgrcv_* tests - no SYSVMSG");
367}
368ATF_TC_BODY(msgrcv_query, tc)
369{
370 atf_tc_skip("No SYSVMSG in kernel");
371}
372
373ATF_TP_ADD_TCS(tp)
374{
375
376 if (no_kernel_sysvmsg()) {
377 ATF_TP_ADD_TC(tp, msgrcv_query);
378 } else {
379 ATF_TP_ADD_TC(tp, msgrcv_basic);
380 ATF_TP_ADD_TC(tp, msgrcv_block);
381 ATF_TP_ADD_TC(tp, msgrcv_err);
382 ATF_TP_ADD_TC(tp, msgrcv_mtype);
383 ATF_TP_ADD_TC(tp, msgrcv_nonblock);
384 ATF_TP_ADD_TC(tp, msgrcv_truncate);
385 }
386
387 return atf_no_error();
388}
diff --git a/src/regress/lib/libc/sys/t_msgsnd.c b/src/regress/lib/libc/sys/t_msgsnd.c
new file mode 100644
index 0000000000..ab0cc87e6f
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_msgsnd.c
@@ -0,0 +1,384 @@
1/* $OpenBSD: t_msgsnd.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_msgsnd.c,v 1.4 2017/10/08 08:31:05 kre Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_msgsnd.c,v 1.4 2017/10/08 08:31:05 kre Exp $");
37
38#include <sys/msg.h>
39#include <sys/stat.h>
40#include <sys/sysctl.h>
41#include <sys/wait.h>
42
43#include "atf-c.h"
44#include <errno.h>
45#include <limits.h>
46#include <pwd.h>
47#include <signal.h>
48#include <stdio.h>
49#include <stdlib.h>
50#include <string.h>
51#include <sysexits.h>
52#include <time.h>
53#include <unistd.h>
54
55#define MSG_KEY 1234
56#define MSG_MTYPE_1 0x41
57#define MSG_MTYPE_2 0x42
58#define MSG_MTYPE_3 0x43
59
60struct msg {
61 long mtype;
62 char buf[3];
63};
64
65static void clean(void);
66
67static void
68clean(void)
69{
70 int id;
71
72 if ((id = msgget(MSG_KEY, 0)) != -1)
73 (void)msgctl(id, IPC_RMID, 0);
74}
75
76ATF_TC_WITH_CLEANUP(msgsnd_block);
77ATF_TC_HEAD(msgsnd_block, tc)
78{
79 atf_tc_set_md_var(tc, "descr", "Test that msgsnd(2) blocks");
80 atf_tc_set_md_var(tc, "timeout", "10");
81}
82
83ATF_TC_BODY(msgsnd_block, tc)
84{
85 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
86 int id, sta;
87 pid_t pid;
88
89 id = msgget(MSG_KEY, IPC_CREAT | 0600);
90 ATF_REQUIRE(id != -1);
91
92 pid = fork();
93 ATF_REQUIRE(pid >= 0);
94
95 if (pid == 0) {
96
97 /*
98 * Enqueue messages until some limit (e.g. the maximum
99 * number of messages in the queue or the maximum number
100 * of bytes in the queue) is reached. After this the call
101 * should block when the IPC_NOWAIT is not set.
102 */
103 for (;;) {
104
105 if (msgsnd(id, &msg, sizeof(struct msg), 0) < 0)
106 _exit(EXIT_FAILURE);
107 }
108 }
109
110 (void)sleep(2);
111 (void)kill(pid, SIGKILL);
112 (void)wait(&sta);
113
114 if (WIFEXITED(sta) != 0 || WIFSIGNALED(sta) == 0)
115 atf_tc_fail("msgsnd(2) did not block");
116
117 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
118}
119
120ATF_TC_CLEANUP(msgsnd_block, tc)
121{
122 clean();
123}
124
125ATF_TC_WITH_CLEANUP(msgsnd_count);
126ATF_TC_HEAD(msgsnd_count, tc)
127{
128 atf_tc_set_md_var(tc, "descr",
129 "Test that msgsnd(2) increments the amount of "
130 "message in the queue, as given by msgctl(2)");
131 atf_tc_set_md_var(tc, "timeout", "10");
132}
133
134ATF_TC_BODY(msgsnd_count, tc)
135{
136 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
137 struct msqid_ds ds;
138 size_t i = 0;
139 int id, rv;
140
141 id = msgget(MSG_KEY, IPC_CREAT | 0600);
142 ATF_REQUIRE(id != -1);
143
144 for (;;) {
145
146 errno = 0;
147 rv = msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT);
148
149 if (rv == 0) {
150 i++;
151 continue;
152 }
153
154 if (rv == -1 && errno == EAGAIN)
155 break;
156
157 atf_tc_fail("failed to enqueue a message");
158 }
159
160 (void)memset(&ds, 0, sizeof(struct msqid_ds));
161 (void)msgctl(id, IPC_STAT, &ds);
162
163 if (ds.msg_qnum != i)
164 atf_tc_fail("incorrect message count");
165
166 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
167}
168
169ATF_TC_CLEANUP(msgsnd_count, tc)
170{
171 clean();
172}
173
174ATF_TC_WITH_CLEANUP(msgsnd_err);
175ATF_TC_HEAD(msgsnd_err, tc)
176{
177 atf_tc_set_md_var(tc, "descr", "Test errors from msgsnd(2)");
178}
179
180ATF_TC_BODY(msgsnd_err, tc)
181{
182 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
183 int id;
184
185 id = msgget(MSG_KEY, IPC_CREAT | 0600);
186 ATF_REQUIRE(id != -1);
187
188 errno = 0;
189
190 ATF_REQUIRE_ERRNO(EFAULT, msgsnd(id, (void *)-1,
191 sizeof(struct msg), IPC_NOWAIT) == -1);
192
193 errno = 0;
194
195 ATF_REQUIRE_ERRNO(EINVAL, msgsnd(-1, &msg,
196 sizeof(struct msg), IPC_NOWAIT) == -1);
197
198 errno = 0;
199
200 ATF_REQUIRE_ERRNO(EINVAL, msgsnd(-1, &msg,
201 SSIZE_MAX, IPC_NOWAIT) == -1);
202
203 errno = 0;
204 msg.mtype = 0;
205
206 ATF_REQUIRE_ERRNO(EINVAL, msgsnd(id, &msg,
207 sizeof(struct msg), IPC_NOWAIT) == -1);
208
209 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
210}
211
212ATF_TC_CLEANUP(msgsnd_err, tc)
213{
214 clean();
215}
216
217ATF_TC_WITH_CLEANUP(msgsnd_nonblock);
218ATF_TC_HEAD(msgsnd_nonblock, tc)
219{
220 atf_tc_set_md_var(tc, "descr", "Test msgsnd(2) with IPC_NOWAIT");
221 atf_tc_set_md_var(tc, "timeout", "10");
222}
223
224ATF_TC_BODY(msgsnd_nonblock, tc)
225{
226 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
227 int id, rv, sta;
228 pid_t pid;
229
230 id = msgget(MSG_KEY, IPC_CREAT | 0600);
231 ATF_REQUIRE(id != -1);
232
233 pid = fork();
234 ATF_REQUIRE(pid >= 0);
235
236 if (pid == 0) {
237
238 for (;;) {
239
240 errno = 0;
241 rv = msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT);
242
243 if (rv == -1 && errno == EAGAIN)
244 _exit(EXIT_SUCCESS);
245 }
246 }
247
248 (void)sleep(2);
249 (void)kill(pid, SIGKILL);
250 (void)wait(&sta);
251
252 if (WIFEXITED(sta) == 0 || WIFSIGNALED(sta) != 0)
253 atf_tc_fail("msgsnd(2) blocked with IPC_NOWAIT");
254
255 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
256}
257
258ATF_TC_CLEANUP(msgsnd_nonblock, tc)
259{
260 clean();
261}
262
263ATF_TC_WITH_CLEANUP(msgsnd_perm);
264ATF_TC_HEAD(msgsnd_perm, tc)
265{
266 atf_tc_set_md_var(tc, "descr", "Test permissions with msgsnd(2)");
267 atf_tc_set_md_var(tc, "require.user", "root");
268}
269
270ATF_TC_BODY(msgsnd_perm, tc)
271{
272 struct msg msg = { MSG_MTYPE_1, { 'a', 'b', 'c' } };
273 struct passwd *pw;
274 int id, sta;
275 pid_t pid;
276 uid_t uid;
277
278 pw = getpwnam("nobody");
279 id = msgget(MSG_KEY, IPC_CREAT | 0600);
280
281 ATF_REQUIRE(id != -1);
282 ATF_REQUIRE(pw != NULL);
283
284 uid = pw->pw_uid;
285 ATF_REQUIRE(uid != 0);
286
287 pid = fork();
288 ATF_REQUIRE(pid >= 0);
289
290 if (pid == 0) {
291
292 /*
293 * Try to enqueue a message to the queue
294 * created by root as RW for owner only.
295 */
296 if (setuid(uid) != 0)
297 _exit(EX_OSERR);
298
299 id = msgget(MSG_KEY, 0);
300
301 if (id == -1)
302 _exit(EX_OSERR);
303
304 errno = 0;
305
306 if (msgsnd(id, &msg, sizeof(struct msg), IPC_NOWAIT) == 0)
307 _exit(EXIT_FAILURE);
308
309 if (errno != EACCES)
310 _exit(EXIT_FAILURE);
311
312 _exit(EXIT_SUCCESS);
313 }
314
315 (void)wait(&sta);
316
317 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS) {
318
319 if (errno == EX_OSERR)
320 atf_tc_fail("system call failed");
321
322 atf_tc_fail("UID %u enqueued message to root's queue", uid);
323 }
324
325 ATF_REQUIRE(msgctl(id, IPC_RMID, 0) == 0);
326}
327
328ATF_TC_CLEANUP(msgsnd_perm, tc)
329{
330 clean();
331}
332
333static volatile int sig_caught;
334
335static void
336sigsys_handler(int signum)
337{
338
339 sig_caught = signum;
340}
341
342static int
343no_kernel_sysvmsg(void)
344{
345 int id;
346 void (*osig)(int);
347
348 sig_caught = 0;
349 osig = signal(SIGSYS, sigsys_handler);
350 id = msgget(MSG_KEY, IPC_CREAT | 0600);
351 if (sig_caught || id == -1)
352 return 1;
353
354 (void)msgctl(id, IPC_RMID, 0);
355 (void)signal(SIGSYS, osig);
356
357 return 0;
358}
359
360ATF_TC(msgsnd_query);
361ATF_TC_HEAD(msgsnd_query, tc)
362{
363 atf_tc_set_md_var(tc, "descr", "Skip msgsnd_* tests - no SYSVMSG");
364}
365ATF_TC_BODY(msgsnd_query, tc)
366{
367 atf_tc_skip("No SYSVMSG in kernel");
368}
369
370ATF_TP_ADD_TCS(tp)
371{
372
373 if (no_kernel_sysvmsg()) {
374 ATF_TP_ADD_TC(tp, msgsnd_query);
375 } else {
376 ATF_TP_ADD_TC(tp, msgsnd_block);
377 ATF_TP_ADD_TC(tp, msgsnd_count);
378 ATF_TP_ADD_TC(tp, msgsnd_err);
379 ATF_TP_ADD_TC(tp, msgsnd_nonblock);
380 ATF_TP_ADD_TC(tp, msgsnd_perm);
381 }
382
383 return atf_no_error();
384}
diff --git a/src/regress/lib/libc/sys/t_msync.c b/src/regress/lib/libc/sys/t_msync.c
new file mode 100644
index 0000000000..8e06d79d9a
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_msync.c
@@ -0,0 +1,228 @@
1/* $OpenBSD: t_msync.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_msync.c,v 1.3 2017/01/14 20:52:42 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_msync.c,v 1.3 2017/01/14 20:52:42 christos Exp $");
37
38#include <sys/mman.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <fcntl.h>
43#include <limits.h>
44#include <stdlib.h>
45#include <string.h>
46#include <unistd.h>
47
48static long page = 0;
49static const off_t off = 512;
50static const char path[] = "msync";
51
52static const char *msync_sync(const char *, int);
53
54static const char *
55msync_sync(const char *garbage, int flags)
56{
57 char *buf, *map = MAP_FAILED;
58 const char *str = NULL;
59 size_t len;
60 int fd, rv;
61
62 /*
63 * Create a temporary file, write
64 * one page to it, and map the file.
65 */
66 buf = malloc(page);
67
68 if (buf == NULL)
69 return NULL;
70
71 memset(buf, 'x', page);
72
73 fd = open(path, O_RDWR | O_CREAT, 0700);
74
75 if (fd < 0) {
76 free(buf);
77 return "failed to open";
78 }
79
80 ATF_REQUIRE_MSG(write(fd, buf, page) != -1, "write(2) failed: %s",
81 strerror(errno));
82
83 map = mmap(NULL, page, PROT_READ | PROT_WRITE, MAP_FILE|MAP_PRIVATE,
84 fd, 0);
85
86 if (map == MAP_FAILED) {
87 str = "failed to map";
88 goto out;
89 }
90
91 /*
92 * Seek to an arbitrary offset and
93 * write garbage to this position.
94 */
95 if (lseek(fd, off, SEEK_SET) != off) {
96 str = "failed to seek";
97 goto out;
98 }
99
100 len = strlen(garbage);
101 rv = write(fd, garbage, len);
102
103 if (rv != (ssize_t)len) {
104 str = "failed to write garbage";
105 goto out;
106 }
107
108 /*
109 * Synchronize the mapping and verify
110 * that garbage is at the given offset.
111 */
112 if (msync(map, page, flags) != 0) {
113 str = "failed to msync";
114 goto out;
115 }
116
117 if (memcmp(map + off, garbage, len) != 0) {
118 str = "msync did not synchronize";
119 goto out;
120 }
121
122out:
123 free(buf);
124
125 (void)close(fd);
126 (void)unlink(path);
127
128 if (map != MAP_FAILED)
129 (void)munmap(map, page);
130
131 return str;
132}
133
134ATF_TC(msync_async);
135ATF_TC_HEAD(msync_async, tc)
136{
137 atf_tc_set_md_var(tc, "descr", "Test of msync(2), MS_ASYNC");
138}
139
140ATF_TC_BODY(msync_async, tc)
141{
142 const char *str;
143
144 str = msync_sync("garbage", MS_ASYNC);
145
146 if (str != NULL)
147 atf_tc_fail("%s", str);
148}
149
150ATF_TC(msync_err);
151ATF_TC_HEAD(msync_err, tc)
152{
153 atf_tc_set_md_var(tc, "descr", "Test error conditions in msync(2)");
154}
155
156ATF_TC_BODY(msync_err, tc)
157{
158
159 char *map = MAP_FAILED;
160
161 /*
162 * Test that invalid flags error out.
163 */
164 ATF_REQUIRE(msync_sync("error", -1) != NULL);
165 ATF_REQUIRE(msync_sync("error", INT_MAX) != NULL);
166
167 errno = 0;
168
169 /*
170 * Map a page and then unmap to get an unmapped address.
171 */
172 map = mmap(NULL, page, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE,
173 -1, 0);
174 ATF_REQUIRE(map != MAP_FAILED);
175
176 (void)munmap(map, page);
177
178 ATF_REQUIRE(msync(map, page, MS_SYNC) != 0);
179 ATF_REQUIRE(errno == EFAULT);
180}
181
182ATF_TC(msync_invalidate);
183ATF_TC_HEAD(msync_invalidate, tc)
184{
185 atf_tc_set_md_var(tc, "descr", "Test of msync(2), MS_INVALIDATE");
186}
187
188ATF_TC_BODY(msync_invalidate, tc)
189{
190 const char *str;
191
192 str = msync_sync("garbage", MS_INVALIDATE);
193
194 if (str != NULL)
195 atf_tc_fail("%s", str);
196}
197
198ATF_TC(msync_sync);
199ATF_TC_HEAD(msync_sync, tc)
200{
201 atf_tc_set_md_var(tc, "descr", "Test of msync(2), MS_SYNC");
202}
203
204ATF_TC_BODY(msync_sync, tc)
205{
206 const char *str;
207
208 str = msync_sync("garbage", MS_SYNC);
209
210 if (str != NULL)
211 atf_tc_fail("%s", str);
212}
213
214ATF_TP_ADD_TCS(tp)
215{
216
217 page = sysconf(_SC_PAGESIZE);
218
219 ATF_REQUIRE(page >= 0);
220 ATF_REQUIRE(page > off);
221
222 ATF_TP_ADD_TC(tp, msync_async);
223 ATF_TP_ADD_TC(tp, msync_err);
224 ATF_TP_ADD_TC(tp, msync_invalidate);
225 ATF_TP_ADD_TC(tp, msync_sync);
226
227 return atf_no_error();
228}
diff --git a/src/regress/lib/libc/sys/t_pipe.c b/src/regress/lib/libc/sys/t_pipe.c
new file mode 100644
index 0000000000..bd9805a4b9
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_pipe.c
@@ -0,0 +1,168 @@
1/* $OpenBSD: t_pipe.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_pipe.c,v 1.5 2017/01/13 21:30:41 christos Exp $ */
3
4/*-
5 * Copyright (c) 2001, 2008 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/cdefs.h>
33#include <sys/cdefs.h>
34__COPYRIGHT("@(#) Copyright (c) 2008\
35 The NetBSD Foundation, inc. All rights reserved.");
36__RCSID("$NetBSD: t_pipe.c,v 1.5 2017/01/13 21:30:41 christos Exp $");
37
38#include <sys/types.h>
39#include <sys/wait.h>
40
41#include <errno.h>
42#include <fcntl.h>
43#include <poll.h>
44#include <sched.h>
45#include <signal.h>
46#include <stdio.h>
47#include <stdlib.h>
48#include <unistd.h>
49
50#include "atf-c.h"
51
52#include "h_macros.h"
53
54static pid_t pid;
55static int nsiginfo = 0;
56
57/*
58 * This is used for both parent and child. Handle parent's SIGALRM,
59 * the childs SIGINFO doesn't need anything.
60 */
61static void
62sighand(int sig)
63{
64 if (sig == SIGALRM) {
65 kill(pid, SIGINFO);
66 }
67 if (sig == SIGINFO) {
68 nsiginfo++;
69 }
70}
71
72ATF_TC(pipe_restart);
73ATF_TC_HEAD(pipe_restart, tc)
74{
75 atf_tc_set_md_var(tc, "descr", "Checks that writing to pipe "
76 "works correctly after being interrupted and restarted "
77 "(kern/14087)");
78}
79
80ATF_TC_BODY(pipe_restart, tc)
81{
82 int pp[2], st;
83 ssize_t sz, todo, done;
84 char *f;
85 sigset_t asigset, osigset, emptysigset;
86
87 /* Initialise signal masks */
88 RL(sigemptyset(&emptysigset));
89 RL(sigemptyset(&asigset));
90 RL(sigaddset(&asigset, SIGINFO));
91
92 /* Register signal handlers for both read and writer */
93 REQUIRE_LIBC(signal(SIGINFO, sighand), SIG_ERR);
94 REQUIRE_LIBC(signal(SIGALRM, sighand), SIG_ERR);
95
96 todo = 2 * 1024 * 1024;
97 REQUIRE_LIBC(f = malloc(todo), NULL);
98
99 RL(pipe(pp));
100
101 RL(pid = fork());
102 if (pid == 0) {
103 /* child */
104 RL(close(pp[1]));
105
106 /* Do inital write. This should succeed, make
107 * the other side do partial write and wait for us to pick
108 * rest up.
109 */
110 RL(done = read(pp[0], f, 128 * 1024));
111
112 /* Wait until parent is alarmed and awakens us */
113 RL(sigprocmask(SIG_BLOCK, &asigset, &osigset));
114 while (nsiginfo == 0) {
115 if (sigsuspend(&emptysigset) != -1 || errno != EINTR)
116 atf_tc_fail("sigsuspend(&emptysigset): %s",
117 strerror(errno));
118 }
119 RL(sigprocmask(SIG_SETMASK, &osigset, NULL));
120
121 /* Read all what parent wants to give us */
122 while((sz = read(pp[0], f, 1024 * 1024)) > 0)
123 done += sz;
124
125 /*
126 * Exit with 1 if number of bytes read doesn't match
127 * number of expected bytes
128 */
129 printf("Read: %#zx\n", (size_t)done);
130 printf("Expected: %#zx\n", (size_t)todo);
131
132 exit(done != todo);
133
134 /* NOTREACHED */
135 } else {
136 RL(close(pp[0]));
137
138 /*
139 * Arrange for alarm after two seconds. Since we have
140 * handler setup for SIGARLM, the write(2) call should
141 * be restarted internally by kernel.
142 */
143 (void)alarm(2);
144
145 /* We write exactly 'todo' bytes. The very first write(2)
146 * should partially succeed, block and eventually
147 * be restarted by kernel
148 */
149 while(todo > 0 && ((sz = write(pp[1], f, todo)) > 0))
150 todo -= sz;
151
152 /* Close the pipe, so that child would stop reading */
153 RL(close(pp[1]));
154
155 /* And pickup child's exit status */
156 RL(waitpid(pid, &st, 0));
157
158 ATF_REQUIRE_EQ(WEXITSTATUS(st), 0);
159 }
160 free(f);
161}
162
163ATF_TP_ADD_TCS(tp)
164{
165 ATF_TP_ADD_TC(tp, pipe_restart);
166
167 return atf_no_error();
168}
diff --git a/src/regress/lib/libc/sys/t_pipe2.c b/src/regress/lib/libc/sys/t_pipe2.c
new file mode 100644
index 0000000000..4964be14ce
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_pipe2.c
@@ -0,0 +1,203 @@
1/* $OpenBSD: t_pipe2.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_pipe2.c,v 1.9 2017/01/13 21:19:45 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Christos Zoulas.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40#include "macros.h"
41
42#include <sys/cdefs.h>
43__RCSID("$NetBSD: t_pipe2.c,v 1.9 2017/01/13 21:19:45 christos Exp $");
44
45#include "atf-c.h"
46#include <fcntl.h>
47#include <unistd.h>
48#include <stdlib.h>
49#include <errno.h>
50#include <sys/resource.h>
51
52static void
53run(int flags)
54{
55 int fd[2], i;
56
57 while ((i = open("/", O_RDONLY)) < 3)
58 ATF_REQUIRE(i != -1);
59
60 ATF_REQUIRE_MSG(closefrom(3) != -1, "closefrom failed: %s",
61 strerror(errno));
62
63 ATF_REQUIRE(pipe2(fd, flags) == 0);
64
65 ATF_REQUIRE(fd[0] == 3);
66 ATF_REQUIRE(fd[1] == 4);
67
68 if (flags & O_CLOEXEC) {
69 ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) != 0);
70 ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) != 0);
71 } else {
72 ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) == 0);
73 ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) == 0);
74 }
75
76 if (flags & O_NONBLOCK) {
77 ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) != 0);
78 ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) != 0);
79 } else {
80 ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) == 0);
81 ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) == 0);
82 }
83
84 /*
85 * Adjusted for OpenBSD, not available
86 * if (flags & O_NOSIGPIPE) {
87 * ATF_REQUIRE(fcntl(fd[0], F_GETNOSIGPIPE) != 0);
88 * ATF_REQUIRE(fcntl(fd[1], F_GETNOSIGPIPE) != 0);
89 *} else {
90 * ATF_REQUIRE(fcntl(fd[0], F_GETNOSIGPIPE) == 0);
91 * ATF_REQUIRE(fcntl(fd[1], F_GETNOSIGPIPE) == 0);
92 *}
93 */
94
95 ATF_REQUIRE(close(fd[0]) != -1);
96 ATF_REQUIRE(close(fd[1]) != -1);
97}
98
99ATF_TC(pipe2_basic);
100ATF_TC_HEAD(pipe2_basic, tc)
101{
102 atf_tc_set_md_var(tc, "descr", "A basic test of pipe2(2)");
103}
104
105ATF_TC_BODY(pipe2_basic, tc)
106{
107 run(0);
108}
109
110ATF_TC(pipe2_consume);
111ATF_TC_HEAD(pipe2_consume, tc)
112{
113 atf_tc_set_md_var(tc, "descr", "Test that consuming file descriptors "
114 "with pipe2(2) does not crash the system (PR kern/46457)");
115}
116
117ATF_TC_BODY(pipe2_consume, tc)
118{
119 struct rlimit rl;
120 int err, filedes[2];
121 int old;
122
123 ATF_REQUIRE_MSG(closefrom(4) != -1, "closefrom failed: %s",
124 strerror(errno));
125
126 err = getrlimit(RLIMIT_NOFILE, &rl);
127 ATF_REQUIRE(err == 0);
128 /*
129 * The heart of this test is to run against the number of open
130 * file descriptor limit in the middle of a pipe2() call - i.e.
131 * before the call only a single descriptor may be openend.
132 */
133 old = rl.rlim_cur;
134 rl.rlim_cur = 4;
135 err = setrlimit(RLIMIT_NOFILE, &rl);
136 ATF_REQUIRE(err == 0);
137
138 err = pipe2(filedes, O_CLOEXEC);
139 ATF_REQUIRE(err == -1);
140 rl.rlim_cur = old;
141 err = setrlimit(RLIMIT_NOFILE, &rl);
142}
143
144ATF_TC(pipe2_nonblock);
145ATF_TC_HEAD(pipe2_nonblock, tc)
146{
147 atf_tc_set_md_var(tc, "descr", "A non-blocking test of pipe2(2)");
148}
149
150ATF_TC_BODY(pipe2_nonblock, tc)
151{
152 run(O_NONBLOCK);
153}
154
155ATF_TC(pipe2_cloexec);
156ATF_TC_HEAD(pipe2_cloexec, tc)
157{
158 atf_tc_set_md_var(tc, "descr", "A close-on-exec test of pipe2(2)");
159}
160
161ATF_TC_BODY(pipe2_cloexec, tc)
162{
163 run(O_CLOEXEC);
164}
165
166ATF_TC(pipe2_nosigpipe);
167ATF_TC_HEAD(pipe2_nosigpipe, tc)
168{
169 atf_tc_set_md_var(tc, "descr", "A no sigpipe test of pipe2(2)");
170}
171
172ATF_TC_BODY(pipe2_nosigpipe, tc)
173{
174 run(O_NOSIGPIPE);
175}
176
177ATF_TC(pipe2_einval);
178ATF_TC_HEAD(pipe2_einval, tc)
179{
180 atf_tc_set_md_var(tc, "descr", "A error check of pipe2(2)");
181}
182
183ATF_TC_BODY(pipe2_einval, tc)
184{
185 int fd[2];
186 ATF_REQUIRE_ERRNO(EINVAL, pipe2(fd, O_ASYNC) == -1);
187}
188
189ATF_TP_ADD_TCS(tp)
190{
191
192 ATF_TP_ADD_TC(tp, pipe2_basic);
193 ATF_TP_ADD_TC(tp, pipe2_consume);
194 ATF_TP_ADD_TC(tp, pipe2_nonblock);
195 ATF_TP_ADD_TC(tp, pipe2_cloexec);
196 /*
197 * Adjusted for OpenBSD, not available
198 * ATF_TP_ADD_TC(tp, pipe2_nosigpipe);
199 */
200 ATF_TP_ADD_TC(tp, pipe2_einval);
201
202 return atf_no_error();
203}
diff --git a/src/regress/lib/libc/sys/t_poll.c b/src/regress/lib/libc/sys/t_poll.c
new file mode 100644
index 0000000000..bbb8dc2d14
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_poll.c
@@ -0,0 +1,398 @@
1/* $OpenBSD: t_poll.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_poll.c,v 1.3 2012/03/18 07:00:52 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Matthias Scheler.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/time.h>
36#include <sys/wait.h>
37
38#include "atf-c.h"
39#include <errno.h>
40#include <fcntl.h>
41#include <paths.h>
42#include <poll.h>
43#include <stdio.h>
44#include <signal.h>
45#include <unistd.h>
46
47static int desc;
48
49static void
50child1(void)
51{
52 struct pollfd pfd;
53
54 pfd.fd = desc;
55 pfd.events = POLLIN | POLLHUP | POLLOUT;
56
57 (void)poll(&pfd, 1, 2000);
58 (void)printf("child1 exit\n");
59}
60
61static void
62child2(void)
63{
64 struct pollfd pfd;
65
66 pfd.fd = desc;
67 pfd.events = POLLIN | POLLHUP | POLLOUT;
68
69 (void)sleep(1);
70 (void)poll(&pfd, 1, INFTIM);
71 (void)printf("child2 exit\n");
72}
73
74static void
75child3(void)
76{
77 struct pollfd pfd;
78
79 (void)sleep(5);
80
81 pfd.fd = desc;
82 pfd.events = POLLIN | POLLHUP | POLLOUT;
83
84 (void)poll(&pfd, 1, INFTIM);
85 (void)printf("child3 exit\n");
86}
87
88ATF_TC(poll_3way);
89ATF_TC_HEAD(poll_3way, tc)
90{
91 atf_tc_set_md_var(tc, "timeout", "15");
92 atf_tc_set_md_var(tc, "descr",
93 "Check for 3-way collision for descriptor. First child comes "
94 "and polls on descriptor, second child comes and polls, first "
95 "child times out and exits, third child comes and polls. When "
96 "the wakeup event happens, the two remaining children should "
97 "both be awaken. (kern/17517)");
98}
99
100ATF_TC_BODY(poll_3way, tc)
101{
102 int pf[2];
103 int status, i;
104 pid_t pid;
105
106 pipe(pf);
107 desc = pf[0];
108
109 pid = fork();
110 ATF_REQUIRE(pid >= 0);
111
112 if (pid == 0) {
113 (void)close(pf[1]);
114 child1();
115 _exit(0);
116 /* NOTREACHED */
117 }
118
119 pid = fork();
120 ATF_REQUIRE(pid >= 0);
121
122 if (pid == 0) {
123 (void)close(pf[1]);
124 child2();
125 _exit(0);
126 /* NOTREACHED */
127 }
128
129 pid = fork();
130 ATF_REQUIRE( pid >= 0);
131
132 if (pid == 0) {
133 (void)close(pf[1]);
134 child3();
135 _exit(0);
136 /* NOTREACHED */
137 }
138
139 (void)sleep(10);
140
141 (void)printf("parent write\n");
142
143 ATF_REQUIRE(write(pf[1], "konec\n", 6) == 6);
144
145 for(i = 0; i < 3; ++i)
146 (void)wait(&status);
147
148 (void)printf("parent terminated\n");
149}
150
151ATF_TC(poll_basic);
152ATF_TC_HEAD(poll_basic, tc)
153{
154 atf_tc_set_md_var(tc, "timeout", "10");
155 atf_tc_set_md_var(tc, "descr",
156 "Basis functionality test for poll(2)");
157}
158
159ATF_TC_BODY(poll_basic, tc)
160{
161 int fds[2];
162 struct pollfd pfds[2];
163 int ret;
164
165 ATF_REQUIRE_EQ(pipe(fds), 0);
166
167 pfds[0].fd = fds[0];
168 pfds[0].events = POLLIN;
169 pfds[1].fd = fds[1];
170 pfds[1].events = POLLOUT;
171
172 /*
173 * Check that we get a timeout waiting for data on the read end
174 * of our pipe.
175 */
176 pfds[0].revents = -1;
177 pfds[1].revents = -1;
178 ATF_REQUIRE_EQ_MSG(ret = poll(&pfds[0], 1, 1), 0,
179 "got: %d", ret);
180 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents);
181 ATF_REQUIRE_EQ_MSG(pfds[1].revents, -1, "got: %d", pfds[1].revents);
182
183 /* Check that the write end of the pipe as reported as ready. */
184 pfds[0].revents = -1;
185 pfds[1].revents = -1;
186 ATF_REQUIRE_EQ_MSG(ret = poll(&pfds[1], 1, 1), 1,
187 "got: %d", ret);
188 ATF_REQUIRE_EQ_MSG(pfds[0].revents, -1, "got: %d", pfds[0].revents);
189 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",\
190 pfds[1].revents);
191
192 /* Check that only the write end of the pipe as reported as ready. */
193 pfds[0].revents = -1;
194 pfds[1].revents = -1;
195 ATF_REQUIRE_EQ_MSG(ret = poll(pfds, 2, 1), 1,
196 "got: %d", ret);
197 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents);
198 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",
199 pfds[1].revents);
200
201 /* Write data to our pipe. */
202 ATF_REQUIRE_EQ(write(fds[1], "", 1), 1);
203
204 /* Check that both ends of our pipe are reported as ready. */
205 pfds[0].revents = -1;
206 pfds[1].revents = -1;
207 ATF_REQUIRE_EQ_MSG(ret = poll(pfds, 2, 1), 2,
208 "got: %d", ret);
209 ATF_REQUIRE_EQ_MSG(pfds[0].revents, POLLIN, "got: %d",
210 pfds[0].revents);
211 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",
212 pfds[1].revents);
213
214 ATF_REQUIRE_EQ(close(fds[0]), 0);
215 ATF_REQUIRE_EQ(close(fds[1]), 0);
216}
217
218ATF_TC(poll_err);
219ATF_TC_HEAD(poll_err, tc)
220{
221 atf_tc_set_md_var(tc, "descr", "Check errors from poll(2)");
222}
223
224ATF_TC_BODY(poll_err, tc)
225{
226 struct pollfd pfd;
227 int fd = 0;
228
229 pfd.fd = fd;
230 pfd.events = POLLIN;
231
232 errno = 0;
233 ATF_REQUIRE_ERRNO(EFAULT, poll((struct pollfd *)-1, 1, -1) == -1);
234
235 errno = 0;
236 ATF_REQUIRE_ERRNO(EINVAL, poll(&pfd, 1, -2) == -1);
237}
238
239ATF_TC(pollts_basic);
240ATF_TC_HEAD(pollts_basic, tc)
241{
242 atf_tc_set_md_var(tc, "timeout", "10");
243 atf_tc_set_md_var(tc, "descr",
244 "Basis functionality test for pollts(2)");
245}
246
247ATF_TC_BODY(pollts_basic, tc)
248{
249 int fds[2];
250 struct pollfd pfds[2];
251 struct timespec timeout;
252 int ret;
253
254 ATF_REQUIRE_EQ(pipe(fds), 0);
255
256 pfds[0].fd = fds[0];
257 pfds[0].events = POLLIN;
258 pfds[1].fd = fds[1];
259 pfds[1].events = POLLOUT;
260
261 /* Use a timeout of 1 second. */
262 timeout.tv_sec = 1;
263 timeout.tv_nsec = 0;
264
265 /*
266 * Check that we get a timeout waiting for data on the read end
267 * of our pipe.
268 */
269 pfds[0].revents = -1;
270 pfds[1].revents = -1;
271 ATF_REQUIRE_EQ_MSG(ret = pollts(&pfds[0], 1, &timeout, NULL), 0,
272 "got: %d", ret);
273 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents);
274 ATF_REQUIRE_EQ_MSG(pfds[1].revents, -1, "got: %d", pfds[1].revents);
275
276 /* Check that the write end of the pipe as reported as ready. */
277 pfds[0].revents = -1;
278 pfds[1].revents = -1;
279 ATF_REQUIRE_EQ_MSG(ret = pollts(&pfds[1], 1, &timeout, NULL), 1,
280 "got: %d", ret);
281 ATF_REQUIRE_EQ_MSG(pfds[0].revents, -1, "got: %d", pfds[0].revents);
282 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",\
283 pfds[1].revents);
284
285 /* Check that only the write end of the pipe as reported as ready. */
286 pfds[0].revents = -1;
287 pfds[1].revents = -1;
288 ATF_REQUIRE_EQ_MSG(ret = pollts(pfds, 2, &timeout, NULL), 1,
289 "got: %d", ret);
290 ATF_REQUIRE_EQ_MSG(pfds[0].revents, 0, "got: %d", pfds[0].revents);
291 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",
292 pfds[1].revents);
293
294 /* Write data to our pipe. */
295 ATF_REQUIRE_EQ(write(fds[1], "", 1), 1);
296
297 /* Check that both ends of our pipe are reported as ready. */
298 pfds[0].revents = -1;
299 pfds[1].revents = -1;
300 ATF_REQUIRE_EQ_MSG(ret = pollts(pfds, 2, &timeout, NULL), 2,
301 "got: %d", ret);
302 ATF_REQUIRE_EQ_MSG(pfds[0].revents, POLLIN, "got: %d",
303 pfds[0].revents);
304 ATF_REQUIRE_EQ_MSG(pfds[1].revents, POLLOUT, "got: %d",
305 pfds[1].revents);
306
307 ATF_REQUIRE_EQ(close(fds[0]), 0);
308 ATF_REQUIRE_EQ(close(fds[1]), 0);
309}
310
311ATF_TC(pollts_err);
312ATF_TC_HEAD(pollts_err, tc)
313{
314 atf_tc_set_md_var(tc, "descr", "Check errors from pollts(2)");
315}
316
317ATF_TC_BODY(pollts_err, tc)
318{
319 struct timespec timeout;
320 struct pollfd pfd;
321 int fd = 0;
322
323 pfd.fd = fd;
324 pfd.events = POLLIN;
325
326 timeout.tv_sec = 1;
327 timeout.tv_nsec = 0;
328
329 errno = 0;
330 ATF_REQUIRE_ERRNO(EFAULT, pollts((void *)-1, 1, &timeout, NULL) == -1);
331
332 timeout.tv_sec = -1;
333 timeout.tv_nsec = -1;
334
335 errno = 0;
336 ATF_REQUIRE_ERRNO(EINVAL, pollts(&pfd, 1, &timeout, NULL) == -1);
337}
338
339ATF_TC(pollts_sigmask);
340ATF_TC_HEAD(pollts_sigmask, tc)
341{
342 atf_tc_set_md_var(tc, "timeout", "10");
343 atf_tc_set_md_var(tc, "descr",
344 "Check that pollts(2) restores the signal mask (PR kern/44986)");
345}
346
347ATF_TC_BODY(pollts_sigmask, tc)
348{
349 int fd;
350 struct pollfd pfd;
351 struct timespec timeout;
352 sigset_t mask;
353 int ret;
354
355 fd = open(_PATH_DEVNULL, O_RDONLY);
356 ATF_REQUIRE(fd >= 0);
357
358 pfd.fd = fd;
359 pfd.events = POLLIN;
360
361 /* Use a timeout of 1 second. */
362 timeout.tv_sec = 1;
363 timeout.tv_nsec = 0;
364
365 /* Unblock all signals. */
366 ATF_REQUIRE_EQ(sigfillset(&mask), 0);
367 ATF_REQUIRE_EQ(sigprocmask(SIG_UNBLOCK, &mask, NULL), 0);
368
369 /*
370 * Check that pollts(2) immediately returns. We block *all*
371 * signals during pollts(2).
372 */
373 ATF_REQUIRE_EQ_MSG(ret = pollts(&pfd, 1, &timeout, &mask), 1,
374 "got: %d", ret);
375
376 /* Check that signals are now longer blocked. */
377 ATF_REQUIRE_EQ(sigprocmask(SIG_SETMASK, NULL, &mask), 0);
378 ATF_REQUIRE_EQ_MSG(sigismember(&mask, SIGUSR1), 0,
379 "signal mask was changed.");
380
381 ATF_REQUIRE_EQ(close(fd), 0);
382}
383
384ATF_TP_ADD_TCS(tp)
385{
386
387 ATF_TP_ADD_TC(tp, poll_3way);
388 ATF_TP_ADD_TC(tp, poll_basic);
389 ATF_TP_ADD_TC(tp, poll_err);
390 /*
391 * Adjusted for OpenBSD, not supported
392 * ATF_TP_ADD_TC(tp, pollts_basic);
393 * ATF_TP_ADD_TC(tp, pollts_err);
394 * ATF_TP_ADD_TC(tp, pollts_sigmask);
395 */
396
397 return atf_no_error();
398}
diff --git a/src/regress/lib/libc/sys/t_ptrace.c b/src/regress/lib/libc/sys/t_ptrace.c
new file mode 100644
index 0000000000..756c9c514e
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_ptrace.c
@@ -0,0 +1,231 @@
1/* $OpenBSD: t_ptrace.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_ptrace.c,v 1.4 2018/05/14 12:44:40 kamil Exp $ */
3
4/*-
5 * Copyright (c) 2016 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/cdefs.h>
33__RCSID("$NetBSD: t_ptrace.c,v 1.4 2018/05/14 12:44:40 kamil Exp $");
34
35#include <sys/param.h>
36#include <sys/types.h>
37#include <sys/ptrace.h>
38#include <sys/stat.h>
39#include <sys/sysctl.h>
40#include <err.h>
41#include <errno.h>
42#include <unistd.h>
43
44#include "atf-c.h"
45
46#include "h_macros.h"
47
48/*
49 * A child process cannot call atf functions and expect them to magically
50 * work like in the parent.
51 * The printf(3) messaging from a child will not work out of the box as well
52 * without estabilishing a communication protocol with its parent. To not
53 * overcomplicate the tests - do not log from a child and use err(3)/errx(3)
54 * wrapped with FORKEE_ASSERT()/FORKEE_ASSERTX() as that is guaranteed to work.
55 */
56#define FORKEE_ASSERTX(x) \
57do { \
58 int ret = (x); \
59 if (!ret) \
60 errx(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: %s", \
61 __FILE__, __LINE__, __func__, #x); \
62} while (0)
63
64#define FORKEE_ASSERT(x) \
65do { \
66 int ret = (x); \
67 if (!ret) \
68 err(EXIT_FAILURE, "%s:%d %s(): Assertion failed for: %s", \
69 __FILE__, __LINE__, __func__, #x); \
70} while (0)
71
72ATF_TC(attach_pid0);
73ATF_TC_HEAD(attach_pid0, tc)
74{
75 atf_tc_set_md_var(tc, "descr",
76 "Assert that a debugger cannot attach to PID 0");
77}
78
79ATF_TC_BODY(attach_pid0, tc)
80{
81 errno = 0;
82 ATF_REQUIRE_ERRNO(EPERM, ptrace(PT_ATTACH, 0, NULL, 0) == -1);
83}
84
85ATF_TC(attach_pid1);
86ATF_TC_HEAD(attach_pid1, tc)
87{
88 atf_tc_set_md_var(tc, "descr",
89 "Assert that a debugger cannot attach to PID 1 (as non-root)");
90
91 atf_tc_set_md_var(tc, "require.user", "unprivileged");
92}
93
94ATF_TC_BODY(attach_pid1, tc)
95{
96 ATF_REQUIRE_ERRNO(EPERM, ptrace(PT_ATTACH, 1, NULL, 0) == -1);
97}
98
99ATF_TC(attach_pid1_securelevel);
100ATF_TC_HEAD(attach_pid1_securelevel, tc)
101{
102 atf_tc_set_md_var(tc, "descr",
103 "Assert that a debugger cannot attach to PID 1 with "
104 "securelevel >= 0 (as root)");
105
106 atf_tc_set_md_var(tc, "require.user", "root");
107}
108
109ATF_TC_BODY(attach_pid1_securelevel, tc)
110{
111 int level;
112 size_t len = sizeof(level);
113
114 ATF_REQUIRE(sysctlbyname("kern.securelevel", &level, &len, NULL, 0)
115 != -1);
116
117 if (level < 0) {
118 atf_tc_skip("Test must be run with securelevel >= 0");
119 }
120
121 ATF_REQUIRE_ERRNO(EPERM, ptrace(PT_ATTACH, 1, NULL, 0) == -1);
122}
123
124ATF_TC(attach_self);
125ATF_TC_HEAD(attach_self, tc)
126{
127 atf_tc_set_md_var(tc, "descr",
128 "Assert that a debugger cannot attach to self (as it's nonsense)");
129}
130
131ATF_TC_BODY(attach_self, tc)
132{
133 ATF_REQUIRE_ERRNO(EINVAL, ptrace(PT_ATTACH, getpid(), NULL, 0) == -1);
134}
135
136ATF_TC(attach_chroot);
137ATF_TC_HEAD(attach_chroot, tc)
138{
139 atf_tc_set_md_var(tc, "descr",
140 "Assert that a debugger cannot trace another process unless the "
141 "process's root directory is at or below the tracing process's "
142 "root");
143
144 atf_tc_set_md_var(tc, "require.user", "root");
145}
146
147ATF_TC_BODY(attach_chroot, tc)
148{
149 char buf[PATH_MAX];
150 pid_t child;
151 int fds_toparent[2], fds_fromparent[2];
152 int rv;
153 uint8_t msg = 0xde; /* dummy message for IPC based on pipe(2) */
154
155 (void)memset(buf, '\0', sizeof(buf));
156 ATF_REQUIRE(getcwd(buf, sizeof(buf)) != NULL);
157 (void)strlcat(buf, "/dir", sizeof(buf));
158
159 ATF_REQUIRE(mkdir(buf, 0500) == 0);
160 ATF_REQUIRE(chdir(buf) == 0);
161
162 ATF_REQUIRE(pipe(fds_toparent) == 0);
163 ATF_REQUIRE(pipe(fds_fromparent) == 0);
164 child = atf_utils_fork();
165 if (child == 0) {
166 FORKEE_ASSERT(close(fds_toparent[0]) == 0);
167 FORKEE_ASSERT(close(fds_fromparent[1]) == 0);
168
169 FORKEE_ASSERT(chroot(buf) == 0);
170
171 rv = write(fds_toparent[1], &msg, sizeof(msg));
172 FORKEE_ASSERTX(rv == sizeof(msg));
173
174 ATF_REQUIRE_ERRNO(EPERM,
175 ptrace(PT_ATTACH, getppid(), NULL, 0) == -1);
176
177 rv = read(fds_fromparent[0], &msg, sizeof(msg));
178 FORKEE_ASSERTX(rv == sizeof(msg));
179
180 _exit(0);
181 }
182 ATF_REQUIRE(close(fds_toparent[1]) == 0);
183 ATF_REQUIRE(close(fds_fromparent[0]) == 0);
184
185 printf("Waiting for chrooting of the child PID %d", child);
186 rv = read(fds_toparent[0], &msg, sizeof(msg));
187 ATF_REQUIRE(rv == sizeof(msg));
188
189 printf("Child is ready, it will try to PT_ATTACH to parent\n");
190 rv = write(fds_fromparent[1], &msg, sizeof(msg));
191 ATF_REQUIRE(rv == sizeof(msg));
192
193 printf("fds_fromparent is no longer needed - close it\n");
194 ATF_REQUIRE(close(fds_fromparent[1]) == 0);
195
196 printf("fds_toparent is no longer needed - close it\n");
197 ATF_REQUIRE(close(fds_toparent[0]) == 0);
198}
199
200ATF_TC(traceme_twice);
201ATF_TC_HEAD(traceme_twice, tc)
202{
203 atf_tc_set_md_var(tc, "descr",
204 "Assert that a process cannot mark its parent a debugger twice");
205}
206
207ATF_TC_BODY(traceme_twice, tc)
208{
209
210 printf("Mark the parent process (PID %d) a debugger of PID %d",
211 getppid(), getpid());
212 ATF_REQUIRE(ptrace(PT_TRACE_ME, 0, NULL, 0) == 0);
213
214 printf("Mark the parent process (PID %d) a debugger of PID %d again",
215 getppid(), getpid());
216 ATF_REQUIRE_ERRNO(EBUSY, ptrace(PT_TRACE_ME, 0, NULL, 0) == -1);
217}
218
219ATF_TP_ADD_TCS(tp)
220{
221 setvbuf(stdout, NULL, _IONBF, 0);
222 setvbuf(stderr, NULL, _IONBF, 0);
223 ATF_TP_ADD_TC(tp, attach_pid0);
224 ATF_TP_ADD_TC(tp, attach_pid1);
225 ATF_TP_ADD_TC(tp, attach_pid1_securelevel);
226 ATF_TP_ADD_TC(tp, attach_self);
227 ATF_TP_ADD_TC(tp, attach_chroot);
228 ATF_TP_ADD_TC(tp, traceme_twice);
229
230 return atf_no_error();
231}
diff --git a/src/regress/lib/libc/sys/t_revoke.c b/src/regress/lib/libc/sys/t_revoke.c
new file mode 100644
index 0000000000..ad54f814d1
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_revoke.c
@@ -0,0 +1,198 @@
1/* $OpenBSD: t_revoke.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_revoke.c,v 1.2 2017/01/13 21:15:57 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_revoke.c,v 1.2 2017/01/13 21:15:57 christos Exp $");
37
38#include <sys/resource.h>
39#include <sys/wait.h>
40
41#include "atf-c.h"
42#include <fcntl.h>
43#include <errno.h>
44#include <pwd.h>
45#include <stdio.h>
46#include <stdlib.h>
47#include <string.h>
48#include <unistd.h>
49
50static const char path[] = "revoke";
51
52ATF_TC_WITH_CLEANUP(revoke_basic);
53ATF_TC_HEAD(revoke_basic, tc)
54{
55 atf_tc_set_md_var(tc, "descr", "A basic test of revoke(2)");
56}
57
58ATF_TC_BODY(revoke_basic, tc)
59{
60 struct rlimit res;
61 char tmp[10];
62 size_t i, n;
63 int *buf;
64
65 (void)memset(&res, 0, sizeof(struct rlimit));
66 (void)getrlimit(RLIMIT_NOFILE, &res);
67
68 if ((n = res.rlim_cur / 10) == 0)
69 n = 10;
70
71 buf = calloc(n, sizeof(int));
72 ATF_REQUIRE(buf != NULL);
73
74 buf[0] = open(path, O_RDWR | O_CREAT, 0600);
75 ATF_REQUIRE(buf[0] >= 0);
76
77 for (i = 1; i < n; i++) {
78 buf[i] = open(path, O_RDWR);
79 ATF_REQUIRE(buf[i] >= 0);
80 }
81
82 ATF_REQUIRE(revoke(path) == 0);
83
84 for (i = 0; i < n; i++) {
85
86 ATF_REQUIRE(read(buf[i], tmp, sizeof(tmp)) == -1);
87
88 (void)close(buf[i]);
89 }
90
91 free(buf);
92
93 (void)unlink(path);
94}
95
96ATF_TC_CLEANUP(revoke_basic, tc)
97{
98 (void)unlink(path);
99}
100
101ATF_TC(revoke_err);
102ATF_TC_HEAD(revoke_err, tc)
103{
104 atf_tc_set_md_var(tc, "descr", "Test errors from revoke(2)");
105 atf_tc_set_md_var(tc, "require.user", "unprivileged");
106}
107
108ATF_TC_BODY(revoke_err, tc)
109{
110 char buf[1024 + 1]; /* XXX: From the manual page... */
111
112 (void)memset(buf, 'x', sizeof(buf));
113
114 errno = 0;
115 ATF_REQUIRE_ERRNO(EFAULT, revoke((char *)-1) == -1);
116
117 errno = 0;
118 ATF_REQUIRE_ERRNO(ENAMETOOLONG, revoke(buf) == -1);
119
120 errno = 0;
121 /* Adjusted for OpenBSD, initially EPERM */
122 ATF_REQUIRE_ERRNO(ENOTTY, revoke("/etc/passwd") == -1);
123
124 errno = 0;
125 ATF_REQUIRE_ERRNO(ENOENT, revoke("/etc/xxx/yyy") == -1);
126}
127
128ATF_TC_WITH_CLEANUP(revoke_perm);
129ATF_TC_HEAD(revoke_perm, tc)
130{
131 atf_tc_set_md_var(tc, "descr", "Test permissions revoke(2)");
132 atf_tc_set_md_var(tc, "require.user", "root");
133}
134
135ATF_TC_BODY(revoke_perm, tc)
136{
137 struct passwd *pw;
138 int fd, sta;
139 pid_t pid;
140
141 pw = getpwnam("nobody");
142 fd = open(path, O_RDWR | O_CREAT, 0600);
143
144 ATF_REQUIRE(fd >= 0);
145 ATF_REQUIRE(pw != NULL);
146 ATF_REQUIRE(revoke(path) == 0);
147
148 pid = fork();
149 ATF_REQUIRE(pid >= 0);
150
151 if (pid == 0) {
152
153 if (setuid(pw->pw_uid) != 0)
154 _exit(EXIT_FAILURE);
155
156 errno = 0;
157
158 if (revoke(path) == 0)
159 _exit(EXIT_FAILURE);
160
161 if (errno != EACCES)
162 _exit(EXIT_FAILURE);
163
164 if (close(fd) != 0)
165 _exit(EXIT_FAILURE);
166
167 _exit(EXIT_SUCCESS);
168 }
169
170 (void)wait(&sta);
171
172 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
173 atf_tc_fail("revoke(2) did not obey permissions");
174
175 (void)close(fd);
176 ATF_REQUIRE(unlink(path) == 0);
177}
178
179ATF_TC_CLEANUP(revoke_perm, tc)
180{
181 (void)unlink(path);
182}
183
184ATF_TP_ADD_TCS(tp)
185{
186
187 /*
188 * Adjusted for OpenBSD, revoke only on ttys supported
189 * ATF_TP_ADD_TC(tp, revoke_basic);
190 */
191 ATF_TP_ADD_TC(tp, revoke_err);
192 /*
193 * Adjusted for OpenBSD, revoke only on ttys supported
194 * ATF_TP_ADD_TC(tp, revoke_perm);
195 */
196
197 return atf_no_error();
198}
diff --git a/src/regress/lib/libc/sys/t_select.c b/src/regress/lib/libc/sys/t_select.c
new file mode 100644
index 0000000000..94ff3d3410
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_select.c
@@ -0,0 +1,219 @@
1/* $OpenBSD: t_select.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_select.c,v 1.4 2017/01/13 21:18:33 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundatiom
9 * by Christos Zoulas.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <assert.h>
36#include <sys/types.h>
37#include <sys/select.h>
38#include <sys/wait.h>
39#include <err.h>
40#include <stdio.h>
41#include <string.h>
42#include <signal.h>
43#include <stdlib.h>
44#include <unistd.h>
45#include <errno.h>
46#include <fcntl.h>
47
48#include "atf-c.h"
49
50static sig_atomic_t keep_going = 1;
51
52static void
53sig_handler(int signum __unused)
54{
55 keep_going = 0;
56}
57
58static void
59sigchld(int signum __unused)
60{
61}
62
63static char
64xtoa(uint8_t n)
65{
66 static const char xarray[] = "0123456789abcdef";
67 assert(n < sizeof(xarray));
68 return xarray[n];
69}
70
71static const char *
72prmask(const sigset_t *m, char *buf, size_t len)
73{
74 size_t j = 2;
75 assert(len >= 3 + sizeof(*m));
76 buf[0] = '0';
77 buf[1] = 'x';
78#define N(p, a) (((p) >> ((a) * 4)) & 0xf)
79 /* Adjusted for OpenBSD, on NetBSD sigset_t is a struct */
80 uint32_t p = (*m);
81 for (size_t k = sizeof(p); k > 0; k--)
82 buf[j++] = xtoa(N(p, k - 1));
83 buf[j] = '\0';
84 return buf;
85}
86
87static __dead void
88child(const struct timespec *ts)
89{
90 struct sigaction sa;
91 sigset_t set, oset, nset;
92 char obuf[sizeof(oset) + 3], nbuf[sizeof(nset) + 3];
93 int fd;
94
95 memset(&sa, 0, sizeof(sa));
96 sa.sa_handler = sig_handler;
97 if ((fd = open("/dev/null", O_RDONLY)) == -1)
98 err(1, "open");
99
100 if (sigaction(SIGTERM, &sa, NULL) == -1)
101 err(1, "sigaction");
102
103 sigfillset(&set);
104 if (sigprocmask(SIG_BLOCK, &set, NULL) == -1)
105 err(1, "sigprocmask");
106
107 if (sigprocmask(SIG_BLOCK, NULL, &oset) == -1)
108 err(1, "sigprocmask");
109
110 sigemptyset(&set);
111
112 for (;;) {
113 fd_set rset;
114 FD_ZERO(&rset);
115 FD_SET(fd, &rset);
116 if (pselect(1, &rset, NULL, NULL, ts, &set) == -1) {
117 if(errno == EINTR) {
118 if (!keep_going)
119 break;
120 }
121 }
122 if (ts)
123 break;
124 }
125 if (sigprocmask(SIG_BLOCK, NULL, &nset) == -1)
126 err(1, "sigprocmask");
127 if (memcmp(&oset, &nset, sizeof(oset)) != 0)
128 atf_tc_fail("pselect() masks don't match "
129 "after timeout %s != %s",
130 prmask(&nset, nbuf, sizeof(nbuf)),
131 prmask(&oset, obuf, sizeof(obuf)));
132 _exit(0);
133}
134
135ATF_TC(pselect_sigmask);
136ATF_TC_HEAD(pselect_sigmask, tc)
137{
138 atf_tc_set_md_var(tc, "descr", "Checks pselect's temporary mask "
139 "setting when a signal is received (PR lib/43625)");
140}
141
142ATF_TC_BODY(pselect_sigmask, tc)
143{
144 pid_t pid;
145 int status;
146
147 signal(SIGCHLD, sigchld);
148
149 switch (pid = fork()) {
150 case 0:
151 child(NULL);
152 /*NOTREACHED*/
153 case -1:
154 err(1, "fork");
155 default:
156 sleep(1);
157 if (kill(pid, SIGTERM) == -1)
158 err(1, "kill");
159 sleep(1);
160 switch (waitpid(pid, &status, WNOHANG)) {
161 case -1:
162 err(1, "wait");
163 case 0:
164 if (kill(pid, SIGKILL) == -1)
165 err(1, "kill");
166 atf_tc_fail("pselect() did not receive signal");
167 break;
168 default:
169 break;
170 }
171 }
172}
173
174ATF_TC(pselect_timeout);
175ATF_TC_HEAD(pselect_timeout, tc)
176{
177
178 atf_tc_set_md_var(tc, "descr", "Checks pselect's temporary mask "
179 "setting when a timeout occurs");
180}
181
182ATF_TC_BODY(pselect_timeout, tc)
183{
184 pid_t pid;
185 int status;
186 static const struct timespec zero = { 0, 0 };
187
188 signal(SIGCHLD, sigchld);
189
190 switch (pid = fork()) {
191 case 0:
192 child(&zero);
193 break;
194 case -1:
195 err(1, "fork");
196 default:
197 sleep(1);
198 switch (waitpid(pid, &status, WNOHANG)) {
199 case -1:
200 err(1, "wait");
201 case 0:
202 if (kill(pid, SIGKILL) == -1)
203 err(1, "kill");
204 atf_tc_fail("pselect() did not receive signal");
205 break;
206 default:
207 break;
208 }
209 }
210}
211
212ATF_TP_ADD_TCS(tp)
213{
214
215 ATF_TP_ADD_TC(tp, pselect_sigmask);
216 ATF_TP_ADD_TC(tp, pselect_timeout);
217
218 return atf_no_error();
219}
diff --git a/src/regress/lib/libc/sys/t_sendrecv.c b/src/regress/lib/libc/sys/t_sendrecv.c
new file mode 100644
index 0000000000..cf44af2b3e
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_sendrecv.c
@@ -0,0 +1,186 @@
1/* $OpenBSD: t_sendrecv.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_sendrecv.c,v 1.6 2019/02/03 03:19:28 mrg Exp $ */
3
4/*-
5 * Copyright (c) 2018 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Christos Zoulas.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_sendrecv.c,v 1.6 2019/02/03 03:19:28 mrg Exp $");
37
38#include "atf-c.h"
39#include <sys/types.h>
40#include <sys/socket.h>
41
42#include <string.h>
43#include <stdint.h>
44#include <errno.h>
45#include <stdio.h>
46#include <stdlib.h>
47#include <unistd.h>
48#include <sched.h>
49#include <signal.h>
50
51
52#define COUNT 100
53
54union packet {
55 uint8_t buf[1316];
56 uintmax_t seq;
57};
58
59static volatile sig_atomic_t rdied;
60
61static void
62handle_sigchld(__unused int pid)
63{
64
65 rdied = 1;
66}
67
68static void
69sender(int fd)
70{
71 union packet p;
72 ssize_t n;
73 p.seq = 0;
74 for (size_t i = 0; i < COUNT; i++) {
75 for (; (n = send(fd, &p, sizeof(p), 0)) == sizeof(p);
76 p.seq++)
77 continue;
78 printf(">>%zd %d %ju\n", n, errno, p.seq);
79 ATF_REQUIRE_MSG(errno == ENOBUFS, "send %s", strerror(errno));
80// sched_yield();
81 }
82 printf("sender done\n");
83}
84
85static void
86receiver(int fd)
87{
88 union packet p;
89 ssize_t n;
90 uintmax_t seq = 0;
91
92 do {
93 if (rdied)
94 return;
95 while ((n = recv(fd, &p, sizeof(p), 0), sizeof(p))
96 == sizeof(p))
97 {
98 if (rdied)
99 return;
100 if (p.seq != seq)
101 printf("%ju != %ju\n", p.seq, seq);
102 seq = p.seq + 1;
103 }
104 printf("<<%zd %d %ju\n", n, errno, seq);
105 if (n == 0)
106 return;
107 ATF_REQUIRE_EQ(n, -1);
108 ATF_REQUIRE_MSG(errno == ENOBUFS, "recv %s", strerror(errno));
109 } while (p.seq < COUNT);
110}
111
112static void
113sendrecv(int rerror)
114{
115 int fd[2], error;
116 struct sigaction sa;
117
118 error = socketpair(AF_UNIX, SOCK_DGRAM, 0, fd);
119// error = pipe(fd);
120 ATF_REQUIRE_MSG(error != -1, "socketpair failed (%s)", strerror(errno));
121
122 for (size_t i = 0; i < __arraycount(fd); i++) {
123 error = setsockopt(fd[i], SOL_SOCKET, SO_RERROR, &rerror,
124 sizeof(rerror));
125 ATF_REQUIRE_MSG(error != -1,
126 "setsockopt(SO_RERROR) failed (%s)", strerror(errno));
127 }
128
129 memset(&sa, 0, sizeof(sa));
130 sa.sa_flags = 0;
131 sa.sa_handler = &handle_sigchld;
132 sigemptyset(&sa.sa_mask);
133 error = sigaction(SIGCHLD, &sa, 0);
134 ATF_REQUIRE_MSG(error != -1, "sigaction failed (%s)",
135 strerror(errno));
136
137 switch (fork()) {
138 case -1:
139 ATF_REQUIRE_MSG(errno == 0,
140 "socketpair failed (%s)", strerror(errno));
141 __unreachable();
142 /*NOTREACHED*/
143 case 0:
144 sched_yield();
145 sender(fd[0]);
146 close(fd[0]);
147 exit(EXIT_SUCCESS);
148 /*NOTREACHED*/
149 default:
150 receiver(fd[1]);
151 return;
152 }
153}
154
155ATF_TC(sendrecv_basic);
156
157ATF_TC_HEAD(sendrecv_basic, tc)
158{
159 atf_tc_set_md_var(tc, "descr", "A basic test of send/recv(2)");
160}
161
162ATF_TC_BODY(sendrecv_basic, tc)
163{
164 sendrecv(0);
165}
166
167ATF_TC(sendrecv_rerror);
168
169ATF_TC_HEAD(sendrecv_rerror, tc)
170{
171 atf_tc_set_md_var(tc, "descr", "Test send/recv(2) with receiver error");
172}
173
174ATF_TC_BODY(sendrecv_rerror, tc)
175{
176 sendrecv(1);
177}
178
179ATF_TP_ADD_TCS(tp)
180{
181
182 ATF_TP_ADD_TC(tp, sendrecv_basic);
183 ATF_TP_ADD_TC(tp, sendrecv_rerror);
184
185 return atf_no_error();
186}
diff --git a/src/regress/lib/libc/sys/t_setuid.c b/src/regress/lib/libc/sys/t_setuid.c
new file mode 100644
index 0000000000..7d3bd1986b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_setuid.c
@@ -0,0 +1,126 @@
1/* $OpenBSD: t_setuid.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_setuid.c,v 1.1 2011/07/07 06:57:54 jruoho Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_setuid.c,v 1.1 2011/07/07 06:57:54 jruoho Exp $");
37
38#include <sys/wait.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <pwd.h>
43#include <stdlib.h>
44#include <unistd.h>
45
46ATF_TC(setuid_perm);
47ATF_TC_HEAD(setuid_perm, tc)
48{
49 atf_tc_set_md_var(tc, "descr", "Test setuid(0) as normal user");
50 atf_tc_set_md_var(tc, "require.user", "unprivileged");
51}
52
53ATF_TC_BODY(setuid_perm, tc)
54{
55 errno = 0;
56
57 ATF_REQUIRE(setuid(0) == -1);
58 ATF_REQUIRE(errno == EPERM);
59}
60
61ATF_TC(setuid_real);
62ATF_TC_HEAD(setuid_real, tc)
63{
64 atf_tc_set_md_var(tc, "descr", "Test setuid(2) with real UID");
65}
66
67ATF_TC_BODY(setuid_real, tc)
68{
69 uid_t uid = getuid();
70
71 ATF_REQUIRE(setuid(uid) == 0);
72
73 ATF_REQUIRE(getuid() == uid);
74 ATF_REQUIRE(geteuid() == uid);
75}
76
77ATF_TC(setuid_root);
78ATF_TC_HEAD(setuid_root, tc)
79{
80 atf_tc_set_md_var(tc, "descr", "A basic test of setuid(2)");
81 atf_tc_set_md_var(tc, "require.user", "root");
82}
83
84ATF_TC_BODY(setuid_root, tc)
85{
86 struct passwd *pw;
87 int rv, sta;
88 pid_t pid;
89 uid_t uid;
90
91 while ((pw = getpwent()) != NULL) {
92
93 pid = fork();
94 ATF_REQUIRE(pid >= 0);
95
96 if (pid == 0) {
97
98 rv = setuid(pw->pw_uid);
99
100 if (rv != 0)
101 _exit(EXIT_FAILURE);
102
103 uid = getuid();
104
105 if (uid != pw->pw_uid)
106 _exit(EXIT_FAILURE);
107
108 _exit(EXIT_SUCCESS);
109 }
110
111 (void)wait(&sta);
112
113 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
114 atf_tc_fail("failed to change UID to %u", pw->pw_uid);
115 }
116}
117
118ATF_TP_ADD_TCS(tp)
119{
120
121 ATF_TP_ADD_TC(tp, setuid_perm);
122 ATF_TP_ADD_TC(tp, setuid_real);
123 ATF_TP_ADD_TC(tp, setuid_root);
124
125 return atf_no_error();
126}
diff --git a/src/regress/lib/libc/sys/t_sigaction.c b/src/regress/lib/libc/sys/t_sigaction.c
new file mode 100644
index 0000000000..21c793d74a
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_sigaction.c
@@ -0,0 +1,156 @@
1/* $OpenBSD: t_sigaction.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_sigaction.c,v 1.5 2017/01/13 21:30:41 christos Exp $ */
3
4/*-
5 * Copyright (c) 2010 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/cdefs.h>
33__COPYRIGHT("@(#) Copyright (c) 2010\
34 The NetBSD Foundation, inc. All rights reserved.");
35__RCSID("$NetBSD: t_sigaction.c,v 1.5 2017/01/13 21:30:41 christos Exp $");
36
37#include <sys/wait.h>
38
39#include <signal.h>
40#include <stdbool.h>
41#include <stdlib.h>
42#include <string.h>
43#include <unistd.h>
44
45#include "atf-c.h"
46
47#include "h_macros.h"
48
49static bool handler_called = false;
50
51static void
52handler(int signo __unused)
53{
54 handler_called = true;
55}
56
57static void
58sa_resethand_child(const int flags)
59{
60 struct sigaction sa;
61
62 sa.sa_flags = flags;
63 sa.sa_handler = &handler;
64 sigemptyset(&sa.sa_mask);
65
66 sigaction(SIGUSR1, &sa, NULL);
67 kill(getpid(), SIGUSR1);
68 exit(handler_called ? EXIT_SUCCESS : EXIT_FAILURE);
69}
70
71static void
72wait_and_check_child(const pid_t pid, const char *fail_message)
73{
74 int status;
75
76 (void)waitpid(pid, &status, 0);
77
78 if (WIFEXITED(status))
79 ATF_CHECK_EQ(EXIT_SUCCESS, WEXITSTATUS(status));
80 else
81 atf_tc_fail("%s; raw exit status was %d", fail_message, status);
82}
83
84static void
85catch(int sig __unused)
86{
87 return;
88}
89
90ATF_TC(sigaction_basic);
91ATF_TC_HEAD(sigaction_basic, tc)
92{
93
94 atf_tc_set_md_var(tc, "descr", "Checks for correct I&D cache"
95 "synchronization after copying out the trampoline code.");
96}
97
98ATF_TC_BODY(sigaction_basic, tc)
99{
100 static struct sigaction sa;
101
102 sa.sa_handler = catch;
103
104 sigaction(SIGUSR1, &sa, 0);
105 kill(getpid(), SIGUSR1);
106 atf_tc_pass();
107}
108
109ATF_TC(sigaction_noflags);
110ATF_TC_HEAD(sigaction_noflags, tc)
111{
112 atf_tc_set_md_var(tc, "descr", "Checks programming a signal with "
113 "sigaction(2) but without any flags");
114}
115
116ATF_TC_BODY(sigaction_noflags, tc)
117{
118 const pid_t pid = fork();
119 if (pid == -1)
120 atf_tc_fail_errno("fork(2) failed");
121 else if (pid == 0)
122 sa_resethand_child(0);
123 else
124 wait_and_check_child(pid, "Child process did not exit cleanly;"
125 " it failed to process the signal");
126}
127
128ATF_TC(sigaction_resethand);
129ATF_TC_HEAD(sigaction_resethand, tc)
130{
131 atf_tc_set_md_var(tc, "descr", "Checks that SA_RESETHAND works");
132}
133
134ATF_TC_BODY(sigaction_resethand, tc)
135{
136 const pid_t pid = fork();
137 if (pid == -1)
138 atf_tc_fail_errno("fork(2) failed");
139 else if (pid == 0)
140 sa_resethand_child(SA_RESETHAND);
141 else {
142 wait_and_check_child(pid, "Child process did not exit cleanly;"
143 " it either failed to process the signal or SA_RESETHAND"
144 " is broken");
145 }
146}
147
148ATF_TP_ADD_TCS(tp)
149{
150
151 ATF_TP_ADD_TC(tp, sigaction_basic);
152 ATF_TP_ADD_TC(tp, sigaction_noflags);
153 ATF_TP_ADD_TC(tp, sigaction_resethand);
154
155 return atf_no_error();
156}
diff --git a/src/regress/lib/libc/sys/t_socketpair.c b/src/regress/lib/libc/sys/t_socketpair.c
new file mode 100644
index 0000000000..076d2fa057
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_socketpair.c
@@ -0,0 +1,141 @@
1/* $OpenBSD: t_socketpair.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_socketpair.c,v 1.2 2017/01/13 20:04:52 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Christos Zoulas.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 * 3. All advertising materials mentioning features or use of this software
20 * must display the following acknowledgement:
21 * This product includes software developed by the NetBSD
22 * Foundation, Inc. and its contributors.
23 * 4. Neither the name of The NetBSD Foundation nor the names of its
24 * contributors may be used to endorse or promote products derived
25 * from this software without specific prior written permission.
26 *
27 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37 * POSSIBILITY OF SUCH DAMAGE.
38 */
39
40#include "macros.h"
41
42#include <sys/cdefs.h>
43__RCSID("$NetBSD: t_socketpair.c,v 1.2 2017/01/13 20:04:52 christos Exp $");
44
45#include "atf-c.h"
46#include <fcntl.h>
47#include <unistd.h>
48#include <stdlib.h>
49#include <sys/socket.h>
50#include <sys/un.h>
51#include <errno.h>
52
53static void
54connected(int fd)
55{
56 struct sockaddr_un addr;
57 socklen_t len = (socklen_t)sizeof(addr);
58 ATF_REQUIRE(getpeername(fd, (struct sockaddr*)(void *)&addr,
59 &len) == 0);
60}
61
62static void
63run(int flags)
64{
65 int fd[2], i;
66
67 while ((i = open("/", O_RDONLY)) < 3)
68 ATF_REQUIRE(i != -1);
69
70 ATF_REQUIRE(closefrom(3) != -1);
71
72 ATF_REQUIRE(socketpair(AF_UNIX, SOCK_DGRAM | flags, 0, fd) == 0);
73
74 ATF_REQUIRE(fd[0] == 3);
75 ATF_REQUIRE(fd[1] == 4);
76
77 connected(fd[0]);
78 connected(fd[1]);
79
80 if (flags & SOCK_CLOEXEC) {
81 ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) != 0);
82 ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) != 0);
83 } else {
84 ATF_REQUIRE((fcntl(fd[0], F_GETFD) & FD_CLOEXEC) == 0);
85 ATF_REQUIRE((fcntl(fd[1], F_GETFD) & FD_CLOEXEC) == 0);
86 }
87
88 if (flags & SOCK_NONBLOCK) {
89 ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) != 0);
90 ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) != 0);
91 } else {
92 ATF_REQUIRE((fcntl(fd[0], F_GETFL) & O_NONBLOCK) == 0);
93 ATF_REQUIRE((fcntl(fd[1], F_GETFL) & O_NONBLOCK) == 0);
94 }
95
96 ATF_REQUIRE(close(fd[0]) != -1);
97 ATF_REQUIRE(close(fd[1]) != -1);
98}
99
100ATF_TC(socketpair_basic);
101ATF_TC_HEAD(socketpair_basic, tc)
102{
103 atf_tc_set_md_var(tc, "descr", "A basic test of socketpair(2)");
104}
105
106ATF_TC_BODY(socketpair_basic, tc)
107{
108 run(0);
109}
110
111ATF_TC(socketpair_nonblock);
112ATF_TC_HEAD(socketpair_nonblock, tc)
113{
114 atf_tc_set_md_var(tc, "descr", "A non-blocking test of socketpair(2)");
115}
116
117ATF_TC_BODY(socketpair_nonblock, tc)
118{
119 run(SOCK_NONBLOCK);
120}
121
122ATF_TC(socketpair_cloexec);
123ATF_TC_HEAD(socketpair_cloexec, tc)
124{
125 atf_tc_set_md_var(tc, "descr", "A close-on-exec of socketpair(2)");
126}
127
128ATF_TC_BODY(socketpair_cloexec, tc)
129{
130 run(SOCK_CLOEXEC);
131}
132
133ATF_TP_ADD_TCS(tp)
134{
135
136 ATF_TP_ADD_TC(tp, socketpair_basic);
137 ATF_TP_ADD_TC(tp, socketpair_nonblock);
138 ATF_TP_ADD_TC(tp, socketpair_cloexec);
139
140 return atf_no_error();
141}
diff --git a/src/regress/lib/libc/sys/t_stat.c b/src/regress/lib/libc/sys/t_stat.c
new file mode 100644
index 0000000000..ea7f4b24a2
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_stat.c
@@ -0,0 +1,423 @@
1/* $OpenBSD: t_stat.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_stat.c,v 1.5 2017/01/13 20:06:50 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_stat.c,v 1.5 2017/01/13 20:06:50 christos Exp $");
37
38#include <sys/stat.h>
39#include <sys/socket.h>
40#include <sys/types.h>
41
42#include <arpa/inet.h>
43#include <netinet/in.h>
44
45#include "atf-c.h"
46#include <errno.h>
47#include <fcntl.h>
48#include <fts.h>
49#include <limits.h>
50#include <string.h>
51#include <unistd.h>
52
53#include <stdio.h>
54
55static const char *path = "stat";
56
57ATF_TC_WITH_CLEANUP(stat_chflags);
58ATF_TC_HEAD(stat_chflags, tc)
59{
60 atf_tc_set_md_var(tc, "descr", "Test chflags(2) with stat(2)");
61}
62
63ATF_TC_BODY(stat_chflags, tc)
64{
65 struct stat sa, sb;
66 int fd;
67
68 (void)memset(&sa, 0, sizeof(struct stat));
69 (void)memset(&sb, 0, sizeof(struct stat));
70
71 fd = open(path, O_RDONLY | O_CREAT);
72
73 ATF_REQUIRE(fd != -1);
74 ATF_REQUIRE(stat(path, &sa) == 0);
75 ATF_REQUIRE(chflags(path, UF_NODUMP) == 0);
76 ATF_REQUIRE(stat(path, &sb) == 0);
77
78 if (sa.st_flags == sb.st_flags)
79 atf_tc_fail("stat(2) did not detect chflags(2)");
80
81 ATF_REQUIRE(close(fd) == 0);
82 ATF_REQUIRE(unlink(path) == 0);
83}
84
85ATF_TC_CLEANUP(stat_chflags, tc)
86{
87 (void)unlink(path);
88}
89
90ATF_TC(stat_dir);
91ATF_TC_HEAD(stat_dir, tc)
92{
93 atf_tc_set_md_var(tc, "descr", "Test stat(2) with directories");
94}
95
96ATF_TC_BODY(stat_dir, tc)
97{
98 const short depth = 2;
99 struct stat sa, sb;
100 char *argv[2];
101 FTSENT *ftse;
102 FTS *fts;
103 int ops;
104
105 argv[1] = NULL;
106 argv[0] = __UNCONST("/");
107
108 ops = FTS_NOCHDIR;
109 ops |= FTS_PHYSICAL;
110
111 fts = fts_open(argv, ops, NULL);
112 ATF_REQUIRE(fts != NULL);
113
114 while ((ftse = fts_read(fts)) != NULL) {
115
116 if (ftse->fts_level < 1)
117 continue;
118
119 if (ftse->fts_level > depth) {
120 (void)fts_set(fts, ftse, FTS_SKIP);
121 continue;
122 }
123
124 switch(ftse->fts_info) {
125
126 case FTS_DP:
127
128 (void)memset(&sa, 0, sizeof(struct stat));
129 (void)memset(&sb, 0, sizeof(struct stat));
130
131 ATF_REQUIRE(stat(ftse->fts_parent->fts_path,&sa) == 0);
132 ATF_REQUIRE(chdir(ftse->fts_path) == 0);
133 ATF_REQUIRE(stat(".", &sb) == 0);
134
135 /*
136 * The previous two stat(2) calls
137 * should be for the same directory.
138 */
139 if (sa.st_dev != sb.st_dev || sa.st_ino != sb.st_ino)
140 atf_tc_fail("inconsistent stat(2)");
141
142 /*
143 * Check that fts(3)'s stat(2)
144 * call equals the manual one.
145 */
146 if (sb.st_ino != ftse->fts_statp->st_ino)
147 atf_tc_fail("stat(2) and fts(3) differ");
148
149 break;
150
151 default:
152 break;
153 }
154 }
155
156 (void)fts_close(fts);
157}
158
159ATF_TC(stat_err);
160ATF_TC_HEAD(stat_err, tc)
161{
162 atf_tc_set_md_var(tc, "descr", "Test errors from the stat(2) family");
163}
164
165ATF_TC_BODY(stat_err, tc)
166{
167 char buf[NAME_MAX + 1];
168 struct stat st;
169
170 (void)memset(buf, 'x', sizeof(buf));
171
172 errno = 0;
173 ATF_REQUIRE_ERRNO(EBADF, fstat(-1, &st) == -1);
174
175 errno = 0;
176 ATF_REQUIRE_ERRNO(ENAMETOOLONG, stat(buf, &st) == -1);
177
178 errno = 0;
179 ATF_REQUIRE_ERRNO(ENAMETOOLONG, lstat(buf, &st) == -1);
180
181 errno = 0;
182 ATF_REQUIRE_ERRNO(EFAULT, stat((void *)-1, &st) == -1);
183
184 errno = 0;
185 ATF_REQUIRE_ERRNO(EFAULT, lstat((void *)-1, &st) == -1);
186
187 errno = 0;
188 ATF_REQUIRE_ERRNO(EFAULT, stat("/etc/passwd", (void *)-1) == -1);
189
190 errno = 0;
191 ATF_REQUIRE_ERRNO(EFAULT, lstat("/etc/passwd", (void *)-1) == -1);
192
193 errno = 0;
194 ATF_REQUIRE_ERRNO(ENOENT, stat("/a/b/c/d/e/f/g/h/i/j/k", &st) == -1);
195
196 errno = 0;
197 ATF_REQUIRE_ERRNO(ENOENT, lstat("/a/b/c/d/e/f/g/h/i/j/k", &st) == -1);
198}
199
200ATF_TC_WITH_CLEANUP(stat_mtime);
201ATF_TC_HEAD(stat_mtime, tc)
202{
203 atf_tc_set_md_var(tc, "descr", "Test modification times with stat(2)");
204}
205
206ATF_TC_BODY(stat_mtime, tc)
207{
208 struct stat sa, sb;
209 int fd[3];
210 size_t i;
211
212 for (i = 0; i < __arraycount(fd); i++) {
213
214 (void)memset(&sa, 0, sizeof(struct stat));
215 (void)memset(&sb, 0, sizeof(struct stat));
216
217 fd[i] = open(path, O_WRONLY | O_CREAT);
218
219 ATF_REQUIRE(fd[i] != -1);
220 ATF_REQUIRE(write(fd[i], "X", 1) == 1);
221 ATF_REQUIRE(stat(path, &sa) == 0);
222
223 (void)sleep(1);
224
225 ATF_REQUIRE(write(fd[i], "X", 1) == 1);
226 ATF_REQUIRE(stat(path, &sb) == 0);
227
228 ATF_REQUIRE(close(fd[i]) == 0);
229 ATF_REQUIRE(unlink(path) == 0);
230
231 if (sa.st_mtime == sb.st_mtime)
232 atf_tc_fail("mtimes did not change");
233 }
234}
235
236ATF_TC_CLEANUP(stat_mtime, tc)
237{
238 (void)unlink(path);
239}
240
241ATF_TC_WITH_CLEANUP(stat_perm);
242ATF_TC_HEAD(stat_perm, tc)
243{
244 atf_tc_set_md_var(tc, "descr", "Test permissions with stat(2)");
245 atf_tc_set_md_var(tc, "require.user", "root");
246}
247
248ATF_TC_BODY(stat_perm, tc)
249{
250 struct stat sa, sb;
251 gid_t gid;
252 uid_t uid;
253 int fd;
254
255 (void)memset(&sa, 0, sizeof(struct stat));
256 (void)memset(&sb, 0, sizeof(struct stat));
257
258 uid = getuid();
259 gid = getgid();
260
261 fd = open(path, O_RDONLY | O_CREAT);
262
263 ATF_REQUIRE(fd != -1);
264 ATF_REQUIRE(fstat(fd, &sa) == 0);
265 ATF_REQUIRE(stat(path, &sb) == 0);
266
267 if (gid != sa.st_gid || sa.st_gid != sb.st_gid)
268 atf_tc_fail("invalid GID");
269
270 if (uid != sa.st_uid || sa.st_uid != sb.st_uid)
271 atf_tc_fail("invalid UID");
272
273 ATF_REQUIRE(close(fd) == 0);
274 ATF_REQUIRE(unlink(path) == 0);
275}
276
277ATF_TC_CLEANUP(stat_perm, tc)
278{
279 (void)unlink(path);
280}
281
282ATF_TC_WITH_CLEANUP(stat_size);
283ATF_TC_HEAD(stat_size, tc)
284{
285 atf_tc_set_md_var(tc, "descr", "Test file sizes with stat(2)");
286}
287
288ATF_TC_BODY(stat_size, tc)
289{
290 struct stat sa, sb, sc;
291 const size_t n = 10;
292 size_t i;
293 int fd;
294
295 fd = open(path, O_WRONLY | O_CREAT);
296 ATF_REQUIRE(fd >= 0);
297
298 for (i = 0; i < n; i++) {
299
300 (void)memset(&sa, 0, sizeof(struct stat));
301 (void)memset(&sb, 0, sizeof(struct stat));
302 (void)memset(&sc, 0, sizeof(struct stat));
303
304 ATF_REQUIRE(fstat(fd, &sa) == 0);
305 ATF_REQUIRE(write(fd, "X", 1) == 1);
306 ATF_REQUIRE(fstat(fd, &sb) == 0);
307 ATF_REQUIRE(stat(path, &sc) == 0);
308
309 if (sa.st_size + 1 != sb.st_size)
310 atf_tc_fail("invalid file size");
311
312 if (sb.st_size != sc.st_size)
313 atf_tc_fail("stat(2) and fstat(2) mismatch");
314 }
315
316 ATF_REQUIRE(close(fd) == 0);
317 ATF_REQUIRE(unlink(path) == 0);
318}
319
320ATF_TC_CLEANUP(stat_size, tc)
321{
322 (void)unlink(path);
323}
324
325ATF_TC(stat_socket);
326ATF_TC_HEAD(stat_socket, tc)
327{
328 atf_tc_set_md_var(tc, "descr", "Test fstat(2) with "
329 "a socket (PR kern/46077)");
330}
331
332ATF_TC_BODY(stat_socket, tc)
333{
334 struct sockaddr_in addr;
335 struct stat st;
336 uint32_t iaddr;
337 int fd, flags;
338
339 (void)memset(&st, 0, sizeof(struct stat));
340 (void)memset(&addr, 0, sizeof(struct sockaddr_in));
341
342 fd = socket(AF_INET, SOCK_STREAM, 0);
343 ATF_REQUIRE(fd >= 0);
344
345 flags = fcntl(fd, F_GETFL);
346
347 ATF_REQUIRE(flags != -1);
348 ATF_REQUIRE(fcntl(fd, F_SETFL, flags | O_NONBLOCK) != -1);
349 ATF_REQUIRE(inet_pton(AF_INET, "127.0.0.1", &iaddr) == 1);
350
351 addr.sin_port = htons(42);
352 addr.sin_family = AF_INET;
353 addr.sin_addr.s_addr = iaddr;
354
355 errno = 0;
356
357 ATF_REQUIRE_ERRNO(EINPROGRESS,
358 connect(fd, (struct sockaddr *)&addr,
359 sizeof(struct sockaddr_in)) == -1);
360
361 errno = 0;
362
363 if (fstat(fd, &st) != 0 || errno != 0)
364 atf_tc_fail("fstat(2) failed for a EINPROGRESS socket");
365
366 (void)close(fd);
367}
368
369ATF_TC_WITH_CLEANUP(stat_symlink);
370ATF_TC_HEAD(stat_symlink, tc)
371{
372 atf_tc_set_md_var(tc, "descr", "Test symbolic links with stat(2)");
373}
374
375ATF_TC_BODY(stat_symlink, tc)
376{
377 const char *pathlink = "pathlink";
378 struct stat sa, sb;
379 int fd;
380
381 (void)memset(&sa, 0, sizeof(struct stat));
382 (void)memset(&sb, 0, sizeof(struct stat));
383
384 fd = open(path, O_WRONLY | O_CREAT);
385
386 ATF_REQUIRE(fd >= 0);
387 ATF_REQUIRE(symlink(path, pathlink) == 0);
388 ATF_REQUIRE(stat(pathlink, &sa) == 0);
389 ATF_REQUIRE(lstat(pathlink, &sb) == 0);
390
391 if (S_ISLNK(sa.st_mode) != 0)
392 atf_tc_fail("stat(2) detected symbolic link");
393
394 if (S_ISLNK(sb.st_mode) == 0)
395 atf_tc_fail("lstat(2) did not detect symbolic link");
396
397 if (sa.st_mode == sb.st_mode)
398 atf_tc_fail("inconsistencies between stat(2) and lstat(2)");
399
400 (void)close(fd);
401 ATF_REQUIRE(unlink(path) == 0);
402 ATF_REQUIRE(unlink(pathlink) == 0);
403}
404
405ATF_TC_CLEANUP(stat_symlink, tc)
406{
407 (void)unlink(path);
408}
409
410ATF_TP_ADD_TCS(tp)
411{
412
413 ATF_TP_ADD_TC(tp, stat_chflags);
414 ATF_TP_ADD_TC(tp, stat_dir);
415 ATF_TP_ADD_TC(tp, stat_err);
416 ATF_TP_ADD_TC(tp, stat_mtime);
417 ATF_TP_ADD_TC(tp, stat_perm);
418 ATF_TP_ADD_TC(tp, stat_size);
419 ATF_TP_ADD_TC(tp, stat_socket);
420 ATF_TP_ADD_TC(tp, stat_symlink);
421
422 return atf_no_error();
423}
diff --git a/src/regress/lib/libc/sys/t_syscall.c b/src/regress/lib/libc/sys/t_syscall.c
new file mode 100644
index 0000000000..e864970262
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_syscall.c
@@ -0,0 +1,122 @@
1/* $OpenBSD: t_syscall.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_syscall.c,v 1.3 2018/05/28 07:55:56 martin Exp $ */
3
4/*-
5 * Copyright (c) 2018 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Martin Husemann.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_syscall.c,v 1.3 2018/05/28 07:55:56 martin Exp $");
37
38
39#include "atf-c.h"
40#include <stdio.h>
41#include <unistd.h>
42#include <fcntl.h>
43#include <err.h>
44#include <string.h>
45#include <stdlib.h>
46#include <sys/mman.h>
47#include <sys/endian.h>
48#include <sys/syscall.h>
49
50#if !defined(_LP64) && BYTE_ORDER == _BIG_ENDIAN
51#define __SYSCALL_TO_UINTPTR_T(V) ((uintptr_t)((V)>>32))
52#else
53#define __SYSCALL_TO_UINTPTR_T(V) ((uintptr_t)(V))
54#endif
55
56static const char secrect_data[1024] = {
57 "my secret key\n"
58};
59
60#define FILE_NAME "dummy"
61
62#ifndef _LP64
63ATF_TC(mmap_syscall);
64
65ATF_TC_HEAD(mmap_syscall, tc)
66{
67 atf_tc_set_md_var(tc, "descr", "Tests mmap(2) via syscall(2)");
68}
69
70ATF_TC_BODY(mmap_syscall, tc)
71{
72 int fd;
73 const char *p;
74
75 fd = open(FILE_NAME, O_RDWR|O_CREAT|O_TRUNC, 0666);
76 ATF_REQUIRE(fd != -1);
77
78 write(fd, secrect_data, sizeof(secrect_data));
79
80 p = (const char *)syscall(SYS_mmap,
81 0, sizeof(secrect_data), PROT_READ, MAP_PRIVATE, fd, 0, 0, 0);
82 ATF_REQUIRE(p != NULL);
83
84 ATF_REQUIRE(strcmp(p, secrect_data) == 0);
85}
86#endif
87
88ATF_TC(mmap___syscall);
89
90ATF_TC_HEAD(mmap___syscall, tc)
91{
92 atf_tc_set_md_var(tc, "descr", "Tests mmap(2) via __syscall(2)");
93}
94
95ATF_TC_BODY(mmap___syscall, tc)
96{
97 int fd;
98 const char *p;
99
100 fd = open(FILE_NAME, O_RDWR|O_CREAT|O_TRUNC, 0666);
101 ATF_REQUIRE(fd != -1);
102
103 write(fd, secrect_data, sizeof(secrect_data));
104
105 p = (const char *)__SYSCALL_TO_UINTPTR_T(__syscall(SYS_mmap,
106 0, sizeof(secrect_data), PROT_READ, MAP_PRIVATE, fd,
107 /* pad*/ 0, (off_t)0));
108 ATF_REQUIRE(p != NULL);
109
110 ATF_REQUIRE(strcmp(p, secrect_data) == 0);
111}
112
113ATF_TP_ADD_TCS(tp)
114{
115
116#ifndef _LP64
117 ATF_TP_ADD_TC(tp, mmap_syscall);
118#endif
119 ATF_TP_ADD_TC(tp, mmap___syscall);
120
121 return atf_no_error();
122}
diff --git a/src/regress/lib/libc/sys/t_truncate.c b/src/regress/lib/libc/sys/t_truncate.c
new file mode 100644
index 0000000000..1d059af5f5
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_truncate.c
@@ -0,0 +1,183 @@
1/* $OpenBSD: t_truncate.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_truncate.c,v 1.3 2017/01/13 20:03:51 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_truncate.c,v 1.3 2017/01/13 20:03:51 christos Exp $");
37
38#include <sys/stat.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <fcntl.h>
43#include <limits.h>
44#include <stdio.h>
45#include <string.h>
46#include <unistd.h>
47
48static const char path[] = "truncate";
49static const size_t sizes[] = { 8, 16, 512, 1024, 2048, 4094, 3000, 30 };
50
51ATF_TC_WITH_CLEANUP(ftruncate_basic);
52ATF_TC_HEAD(ftruncate_basic, tc)
53{
54 atf_tc_set_md_var(tc, "descr", "A basic test of ftruncate(2)");
55}
56
57ATF_TC_BODY(ftruncate_basic, tc)
58{
59 struct stat st;
60 size_t i;
61 int fd;
62
63 fd = open(path, O_RDWR | O_CREAT, 0600);
64 ATF_REQUIRE(fd >= 0);
65
66 for (i = 0; i < __arraycount(sizes); i++) {
67
68 (void)memset(&st, 0, sizeof(struct stat));
69
70 ATF_REQUIRE(ftruncate(fd, sizes[i]) == 0);
71 ATF_REQUIRE(fstat(fd, &st) == 0);
72
73 (void)fprintf(stderr, "truncating to %zu bytes\n", sizes[i]);
74
75 if (sizes[i] != (size_t)st.st_size)
76 atf_tc_fail("ftruncate(2) did not truncate");
77 }
78
79 (void)close(fd);
80 (void)unlink(path);
81}
82
83ATF_TC_CLEANUP(ftruncate_basic, tc)
84{
85 (void)unlink(path);
86}
87
88ATF_TC(ftruncate_err);
89ATF_TC_HEAD(ftruncate_err, tc)
90{
91 atf_tc_set_md_var(tc, "descr", "Test errors from ftruncate(2)");
92 atf_tc_set_md_var(tc, "require.user", "unprivileged");
93}
94
95ATF_TC_BODY(ftruncate_err, tc)
96{
97 int fd;
98
99 fd = open("/etc/passwd", O_RDONLY, 0400);
100 ATF_REQUIRE(fd >= 0);
101
102 errno = 0;
103 ATF_REQUIRE_ERRNO(EBADF, ftruncate(-1, 999) == -1);
104
105 errno = 0;
106 ATF_REQUIRE_ERRNO(EINVAL, ftruncate(fd, 999) == -1);
107
108 (void)close(fd);
109}
110
111ATF_TC_WITH_CLEANUP(truncate_basic);
112ATF_TC_HEAD(truncate_basic, tc)
113{
114 atf_tc_set_md_var(tc, "descr", "A basic test of truncate(2)");
115}
116
117ATF_TC_BODY(truncate_basic, tc)
118{
119 struct stat st;
120 size_t i;
121 int fd;
122
123 fd = open(path, O_RDWR | O_CREAT, 0600);
124 ATF_REQUIRE(fd >= 0);
125
126 for (i = 0; i < __arraycount(sizes); i++) {
127
128 (void)memset(&st, 0, sizeof(struct stat));
129
130 ATF_REQUIRE(truncate(path, sizes[i]) == 0);
131 ATF_REQUIRE(fstat(fd, &st) == 0);
132
133 (void)fprintf(stderr, "truncating to %zu bytes\n", sizes[i]);
134
135 if (sizes[i] != (size_t)st.st_size)
136 atf_tc_fail("truncate(2) did not truncate");
137 }
138
139 (void)close(fd);
140 (void)unlink(path);
141}
142
143ATF_TC_CLEANUP(truncate_basic, tc)
144{
145 (void)unlink(path);
146}
147
148ATF_TC(truncate_err);
149ATF_TC_HEAD(truncate_err, tc)
150{
151 atf_tc_set_md_var(tc, "descr", "Test errors from truncate(2)");
152 atf_tc_set_md_var(tc, "require.user", "unprivileged");
153}
154
155ATF_TC_BODY(truncate_err, tc)
156{
157 char buf[PATH_MAX];
158
159 errno = 0;
160 ATF_REQUIRE_ERRNO(EFAULT, truncate((void *)-1, 999) == -1);
161
162 errno = 0;
163 ATF_REQUIRE_ERRNO(EISDIR, truncate("/etc", 999) == -1);
164
165 errno = 0;
166 ATF_REQUIRE_ERRNO(ENOENT, truncate("/a/b/c/d/e/f/g", 999) == -1);
167
168 errno = 0;
169 snprintf(buf, sizeof(buf), "%s/truncate_test.root_owned",
170 atf_tc_get_config_var(tc, "srcdir"));
171 ATF_REQUIRE_ERRNO(EACCES, truncate(buf, 999) == -1);
172}
173
174ATF_TP_ADD_TCS(tp)
175{
176
177 ATF_TP_ADD_TC(tp, ftruncate_basic);
178 ATF_TP_ADD_TC(tp, ftruncate_err);
179 ATF_TP_ADD_TC(tp, truncate_basic);
180 ATF_TP_ADD_TC(tp, truncate_err);
181
182 return atf_no_error();
183}
diff --git a/src/regress/lib/libc/sys/t_umask.c b/src/regress/lib/libc/sys/t_umask.c
new file mode 100644
index 0000000000..b312e8183b
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_umask.c
@@ -0,0 +1,210 @@
1/* $OpenBSD: t_umask.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_umask.c,v 1.2 2017/01/13 19:34:19 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_umask.c,v 1.2 2017/01/13 19:34:19 christos Exp $");
37
38#include <sys/stat.h>
39#include <sys/wait.h>
40
41#include "atf-c.h"
42#include <fcntl.h>
43#include <stdlib.h>
44#include <string.h>
45#include <unistd.h>
46
47static const char path[] = "umask";
48static const mode_t mask[] = {
49 S_IRWXU,
50 S_IRUSR,
51 S_IWUSR,
52 S_IXUSR,
53 S_IRWXG,
54 S_IRGRP,
55 S_IWGRP,
56 S_IXGRP,
57 S_IRWXO,
58 S_IROTH,
59 S_IWOTH,
60 S_IXOTH
61};
62
63ATF_TC_WITH_CLEANUP(umask_fork);
64ATF_TC_HEAD(umask_fork, tc)
65{
66 atf_tc_set_md_var(tc, "descr", "Check that umask(2) is inherited");
67}
68
69ATF_TC_BODY(umask_fork, tc)
70{
71 mode_t mode;
72 pid_t pid;
73 size_t i;
74 int sta;
75
76 for (i = 0; i < __arraycount(mask) - 1; i++) {
77
78 (void)umask(mask[i] | mask[i + 1]);
79
80 pid = fork();
81
82 if (pid < 0)
83 continue;
84
85 if (pid == 0) {
86
87 mode = umask(mask[i]);
88
89 if (mode != (mask[i] | mask[i + 1]))
90 _exit(EXIT_FAILURE);
91
92 _exit(EXIT_SUCCESS);
93 }
94
95 (void)wait(&sta);
96
97 if (WIFEXITED(sta) == 0 || WEXITSTATUS(sta) != EXIT_SUCCESS)
98 goto fail;
99 }
100
101 return;
102
103fail:
104 (void)umask(S_IWGRP | S_IWOTH);
105
106 atf_tc_fail("umask(2) was not inherited");
107}
108
109ATF_TC_CLEANUP(umask_fork, tc)
110{
111 (void)umask(S_IWGRP | S_IWOTH);
112}
113
114ATF_TC_WITH_CLEANUP(umask_open);
115ATF_TC_HEAD(umask_open, tc)
116{
117 atf_tc_set_md_var(tc, "descr", "A basic test of open(2) and umask(2)");
118}
119
120ATF_TC_BODY(umask_open, tc)
121{
122 const char *str = NULL;
123 struct stat st;
124 size_t i;
125 int fd;
126
127 for (i = 0; i < __arraycount(mask); i++) {
128
129 (void)umask(mask[i]);
130
131 fd = open(path, O_RDWR | O_CREAT, 0777);
132
133 if (fd < 0)
134 continue;
135
136 (void)close(fd);
137 (void)memset(&st, 0, sizeof(struct stat));
138
139 if (stat(path, &st) != 0) {
140 str = "failed to stat(2)";
141 goto out;
142 }
143
144 if ((st.st_mode & mask[i]) != 0) {
145 str = "invalid umask(2)";
146 goto out;
147 }
148
149 if (unlink(path) != 0) {
150 str = "failed to unlink(2)";
151 goto out;
152 }
153
154 }
155
156out:
157 (void)umask(S_IWGRP | S_IWOTH);
158
159 if (str != NULL)
160 atf_tc_fail("%s", str);
161}
162
163ATF_TC_CLEANUP(umask_open, tc)
164{
165 (void)umask(S_IWGRP | S_IWOTH);
166 (void)unlink(path);
167}
168
169ATF_TC_WITH_CLEANUP(umask_previous);
170ATF_TC_HEAD(umask_previous, tc)
171{
172 atf_tc_set_md_var(tc, "descr", "Test the return value from umask(2)");
173}
174
175ATF_TC_BODY(umask_previous, tc)
176{
177 mode_t mode;
178 size_t i;
179
180 for (i = 0; i < __arraycount(mask); i++) {
181
182 mode = umask(mask[i]);
183 mode = umask(mask[i]);
184
185 if (mode != mask[i])
186 goto fail;
187 }
188
189 return;
190
191fail:
192 (void)umask(S_IWGRP | S_IWOTH);
193
194 atf_tc_fail("umask(2) did not return the previous mask");
195}
196
197ATF_TC_CLEANUP(umask_previous, tc)
198{
199 (void)umask(S_IWGRP | S_IWOTH);
200}
201
202ATF_TP_ADD_TCS(tp)
203{
204
205 ATF_TP_ADD_TC(tp, umask_fork);
206 ATF_TP_ADD_TC(tp, umask_open);
207 ATF_TP_ADD_TC(tp, umask_previous);
208
209 return atf_no_error();
210}
diff --git a/src/regress/lib/libc/sys/t_unlink.c b/src/regress/lib/libc/sys/t_unlink.c
new file mode 100644
index 0000000000..9736d77593
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_unlink.c
@@ -0,0 +1,162 @@
1/* $OpenBSD: t_unlink.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_unlink.c,v 1.4 2017/01/14 20:55:26 christos Exp $ */
3
4/*-
5 * Copyright (c) 2011 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * This code is derived from software contributed to The NetBSD Foundation
9 * by Jukka Ruohonen.
10 *
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
13 * are met:
14 * 1. Redistributions of source code must retain the above copyright
15 * notice, this list of conditions and the following disclaimer.
16 * 2. Redistributions in binary form must reproduce the above copyright
17 * notice, this list of conditions and the following disclaimer in the
18 * documentation and/or other materials provided with the distribution.
19 *
20 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33#include "macros.h"
34
35#include <sys/cdefs.h>
36__RCSID("$NetBSD: t_unlink.c,v 1.4 2017/01/14 20:55:26 christos Exp $");
37
38#include <sys/stat.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <fcntl.h>
43#include <limits.h>
44#include <string.h>
45#include <unistd.h>
46
47static char path[] = "unlink";
48
49ATF_TC_WITH_CLEANUP(unlink_basic);
50ATF_TC_HEAD(unlink_basic, tc)
51{
52 atf_tc_set_md_var(tc, "descr", "A basic test of unlink(2)");
53}
54
55ATF_TC_BODY(unlink_basic, tc)
56{
57 const size_t n = 512;
58 size_t i;
59 int fd;
60
61 for (i = 0; i < n; i++) {
62
63 fd = open(path, O_RDWR | O_CREAT, 0666);
64
65 ATF_REQUIRE(fd != -1);
66 ATF_REQUIRE(close(fd) == 0);
67 ATF_REQUIRE(unlink(path) == 0);
68
69 errno = 0;
70 ATF_REQUIRE_ERRNO(ENOENT, open(path, O_RDONLY) == -1);
71 }
72}
73
74ATF_TC_CLEANUP(unlink_basic, tc)
75{
76 (void)unlink(path);
77}
78
79ATF_TC_WITH_CLEANUP(unlink_err);
80ATF_TC_HEAD(unlink_err, tc)
81{
82 atf_tc_set_md_var(tc, "descr", "Test error conditions of unlink(2)");
83}
84
85ATF_TC_BODY(unlink_err, tc)
86{
87 char buf[PATH_MAX + 1];
88
89 (void)memset(buf, 'x', sizeof(buf));
90
91 errno = 0;
92 ATF_REQUIRE_ERRNO(EBUSY, unlink("/") == -1);
93
94 errno = 0;
95 ATF_REQUIRE_ERRNO(ENAMETOOLONG, unlink(buf) == -1);
96
97 errno = 0;
98 ATF_REQUIRE_ERRNO(ENOENT, unlink("/a/b/c/d/e/f/g/h/i/j/k/l/m") == -1);
99}
100
101ATF_TC_CLEANUP(unlink_err, tc)
102{
103 (void)unlink(path);
104}
105
106ATF_TC_WITH_CLEANUP(unlink_fifo);
107ATF_TC_HEAD(unlink_fifo, tc)
108{
109 atf_tc_set_md_var(tc, "descr", "Test unlink(2) for a FIFO");
110}
111
112ATF_TC_BODY(unlink_fifo, tc)
113{
114
115 ATF_REQUIRE(mkfifo(path, 0666) == 0);
116 ATF_REQUIRE(unlink(path) == 0);
117
118 errno = 0;
119 ATF_REQUIRE_ERRNO(ENOENT, open(path, O_RDONLY) == -1);
120}
121
122ATF_TC_CLEANUP(unlink_fifo, tc)
123{
124 (void)unlink(path);
125}
126
127ATF_TC_WITH_CLEANUP(unlink_perm);
128ATF_TC_HEAD(unlink_perm, tc)
129{
130 atf_tc_set_md_var(tc, "descr", "Test permissions with unlink(2)");
131 atf_tc_set_md_var(tc, "require.user", "unprivileged");
132}
133
134ATF_TC_BODY(unlink_perm, tc)
135{
136 int rv;
137
138 errno = 0;
139 rv = unlink("/etc");
140 ATF_REQUIRE_MSG(rv == -1 && (errno == EACCES || errno == EPERM),
141 "unlinking a directory did not fail with EPERM or EACCESS; "
142 "unlink() returned %d, errno %d", rv, errno);
143
144 errno = 0;
145 ATF_REQUIRE_ERRNO(EACCES, unlink("/root/.profile") == -1);
146}
147
148ATF_TC_CLEANUP(unlink_perm, tc)
149{
150 (void)unlink(path);
151}
152
153ATF_TP_ADD_TCS(tp)
154{
155
156 ATF_TP_ADD_TC(tp, unlink_basic);
157 ATF_TP_ADD_TC(tp, unlink_err);
158 ATF_TP_ADD_TC(tp, unlink_fifo);
159 ATF_TP_ADD_TC(tp, unlink_perm);
160
161 return atf_no_error();
162}
diff --git a/src/regress/lib/libc/sys/t_write.c b/src/regress/lib/libc/sys/t_write.c
new file mode 100644
index 0000000000..d22f32383a
--- /dev/null
+++ b/src/regress/lib/libc/sys/t_write.c
@@ -0,0 +1,287 @@
1/* $OpenBSD: t_write.c,v 1.1.1.1 2019/11/19 19:57:04 bluhm Exp $ */
2/* $NetBSD: t_write.c,v 1.6 2017/07/09 22:18:43 christos Exp $ */
3
4/*-
5 * Copyright (c) 2001, 2008 The NetBSD Foundation, Inc.
6 * All rights reserved.
7 *
8 * Redistribution and use in source and binary forms, with or without
9 * modification, are permitted provided that the following conditions
10 * are met:
11 * 1. Redistributions of source code must retain the above copyright
12 * notice, this list of conditions and the following disclaimer.
13 * 2. Redistributions in binary form must reproduce the above copyright
14 * notice, this list of conditions and the following disclaimer in the
15 * documentation and/or other materials provided with the distribution.
16 *
17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
27 * POSSIBILITY OF SUCH DAMAGE.
28 */
29
30#include "macros.h"
31
32#include <sys/cdefs.h>
33__COPYRIGHT("@(#) Copyright (c) 2008\
34 The NetBSD Foundation, inc. All rights reserved.");
35__RCSID("$NetBSD: t_write.c,v 1.6 2017/07/09 22:18:43 christos Exp $");
36
37#include <sys/uio.h>
38#include <sys/mman.h>
39
40#include "atf-c.h"
41#include <errno.h>
42#include <fcntl.h>
43#include <signal.h>
44#include <limits.h>
45#include <stdio.h>
46#include <stdint.h>
47#include <string.h>
48#include <unistd.h>
49#include <paths.h>
50
51static void sighandler(int);
52
53static bool fail = false;
54static const char *path = "write";
55
56static void
57sighandler(int signo __unused)
58{
59 fail = false;
60}
61
62ATF_TC_WITH_CLEANUP(write_err);
63ATF_TC_HEAD(write_err, tc)
64{
65 atf_tc_set_md_var(tc, "descr", "Checks errors from write(2)");
66}
67
68ATF_TC_BODY(write_err, tc)
69{
70 char rbuf[3] = { 'a', 'b', 'c' };
71 char wbuf[3] = { 'x', 'y', 'z' };
72 int fd;
73
74 errno = 0;
75 ATF_REQUIRE_ERRNO(EBADF, write(-1, wbuf, sizeof(wbuf)) == -1);
76
77 fd = open(path, O_RDWR | O_CREAT);
78
79 if (fd >= 0) {
80
81 errno = 0;
82 ATF_REQUIRE_ERRNO(0, write(fd, wbuf, 3) == 3);
83
84 errno = 0;
85 ATF_REQUIRE_ERRNO(EINVAL, write(fd, wbuf, SIZE_MAX) == -1);
86
87 errno = 0;
88 ATF_REQUIRE_ERRNO(EFAULT, write(fd, (void *)-1, 1) == -1);
89
90 /*
91 * Check that the above bogus write(2)
92 * calls did not corrupt the file.
93 */
94 ATF_REQUIRE(lseek(fd, 0, SEEK_SET) == 0);
95 ATF_REQUIRE(read(fd, rbuf, 3) == 3);
96 ATF_REQUIRE(memcmp(rbuf, wbuf, 3) == 0);
97
98 (void)close(fd);
99 (void)unlink(path);
100 }
101}
102
103ATF_TC_CLEANUP(write_err, tc)
104{
105 (void)unlink(path);
106}
107
108ATF_TC(write_pipe);
109ATF_TC_HEAD(write_pipe, tc)
110{
111 atf_tc_set_md_var(tc, "descr", "Checks for EPIPE from write(2)");
112}
113
114ATF_TC_BODY(write_pipe, tc)
115{
116 int fds[2];
117
118 ATF_REQUIRE(pipe(fds) == 0);
119 ATF_REQUIRE(signal(SIGPIPE, sighandler) == 0);
120
121 ATF_REQUIRE(write(fds[1], "x", 1) != -1);
122 ATF_REQUIRE(close(fds[0]) == 0);
123
124 errno = 0;
125 fail = true;
126
127 if (write(fds[1], "x", 1) != -1 || errno != EPIPE)
128 atf_tc_fail_nonfatal("expected EPIPE but write(2) succeeded");
129
130 ATF_REQUIRE(close(fds[1]) == 0);
131
132 if (fail != false)
133 atf_tc_fail_nonfatal("SIGPIPE was not raised");
134}
135
136ATF_TC_WITH_CLEANUP(write_pos);
137ATF_TC_HEAD(write_pos, tc)
138{
139 atf_tc_set_md_var(tc, "descr", "Checks that write(2) "
140 "updates the file position");
141}
142
143ATF_TC_BODY(write_pos, tc)
144{
145 const size_t n = 123;
146 size_t i;
147 int fd;
148
149 fd = open(path, O_RDWR | O_CREAT);
150 ATF_REQUIRE(fd >= 0);
151
152 for (i = 0; i < n; i++) {
153 ATF_REQUIRE(write(fd, "x", 1) == 1);
154 ATF_REQUIRE(lseek(fd, 0, SEEK_CUR) == (off_t)(i + 1));
155 }
156
157 ATF_REQUIRE(close(fd) == 0);
158 ATF_REQUIRE(unlink(path) == 0);
159}
160
161ATF_TC_CLEANUP(write_pos, tc)
162{
163 (void)unlink(path);
164}
165
166ATF_TC_WITH_CLEANUP(write_ret);
167ATF_TC_HEAD(write_ret, tc)
168{
169 atf_tc_set_md_var(tc, "descr", "Checks return values from write(2)");
170}
171
172ATF_TC_BODY(write_ret, tc)
173{
174 const size_t n = 99;
175 char buf[123];
176 size_t i, j;
177 int fd;
178
179 fd = open(path, O_WRONLY | O_CREAT);
180 ATF_REQUIRE(fd >= 0);
181
182 (void)memset(buf, 'x', sizeof(buf));
183
184 for (i = j = 0; i < n; i++)
185 j += write(fd, buf, sizeof(buf));
186
187 if (j != n * 123)
188 atf_tc_fail("inconsistent return values from write(2)");
189
190 (void)close(fd);
191 (void)unlink(path);
192}
193
194ATF_TC_CLEANUP(write_ret, tc)
195{
196 (void)unlink(path);
197}
198
199ATF_TC(writev_iovmax);
200ATF_TC_HEAD(writev_iovmax, tc)
201{
202 atf_tc_set_md_var(tc, "timeout", "10");
203 atf_tc_set_md_var(tc, "descr",
204 "Checks that file descriptor is properly FILE_UNUSE()d "
205 "when iovcnt is greater than IOV_MAX");
206}
207
208ATF_TC_BODY(writev_iovmax, tc)
209{
210 ssize_t retval;
211
212 (void)printf("Calling writev(2, NULL, IOV_MAX + 1)...\n");
213
214 errno = 0;
215 retval = writev(2, NULL, IOV_MAX + 1);
216
217 ATF_REQUIRE_EQ_MSG(retval, -1, "got: %zd", retval);
218 ATF_REQUIRE_EQ_MSG(errno, EINVAL, "got: %s", strerror(errno));
219}
220
221ATF_TC(write_fault);
222
223ATF_TC_HEAD(write_fault, tc)
224{
225 atf_tc_set_md_var(tc, "descr",
226 "Check that writing to non-permitted space returns EFAULT");
227}
228
229#define SIZE 8192
230
231ATF_TC_BODY(write_fault, tc)
232{
233 int fd[2];
234 ATF_REQUIRE(pipe(fd) != -1);
235 // Can't use /dev/null cause it doesn't access the buffer.
236
237 void *map = mmap(NULL, SIZE, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
238 ATF_REQUIRE(map != MAP_FAILED);
239
240 ssize_t retval = write(fd[1], map, SIZE);
241
242 ATF_REQUIRE_EQ_MSG(retval, -1, "got: %zd", retval);
243 ATF_REQUIRE_EQ_MSG(errno, EFAULT, "got: %s", strerror(errno));
244
245 munmap(map, SIZE);
246 close(fd[0]);
247 close(fd[1]);
248}
249
250ATF_TC(read_fault);
251
252ATF_TC_HEAD(read_fault, tc)
253{
254 atf_tc_set_md_var(tc, "descr",
255 "Check that reading from non-permitted space returns EFAULT");
256}
257
258ATF_TC_BODY(read_fault, tc)
259{
260 int fd = open(_PATH_DEVZERO, O_RDONLY);
261 ATF_REQUIRE(fd != -1);
262
263 void *map = mmap(NULL, SIZE, PROT_NONE, MAP_ANON | MAP_PRIVATE, -1, 0);
264 ATF_REQUIRE(map != MAP_FAILED);
265
266 ssize_t retval = read(fd, map, SIZE);
267
268 ATF_REQUIRE_EQ_MSG(retval, -1, "got: %zd", retval);
269 ATF_REQUIRE_EQ_MSG(errno, EFAULT, "got: %s", strerror(errno));
270
271 munmap(map, SIZE);
272 close(fd);
273}
274
275ATF_TP_ADD_TCS(tp)
276{
277
278 ATF_TP_ADD_TC(tp, write_err);
279 ATF_TP_ADD_TC(tp, write_pipe);
280 ATF_TP_ADD_TC(tp, write_pos);
281 ATF_TP_ADD_TC(tp, write_ret);
282 ATF_TP_ADD_TC(tp, writev_iovmax);
283 ATF_TP_ADD_TC(tp, write_fault);
284 ATF_TP_ADD_TC(tp, read_fault);
285
286 return atf_no_error();
287}
generated by cgit v1.2.3-55-g6feb (git 2.39.1) at 2025-03-21 14:30:53 +0000