diff options
Diffstat (limited to 'lib/libc/tests/secure/fortify_unistd_test.c')
| -rw-r--r-- | lib/libc/tests/secure/fortify_unistd_test.c | 462 |
1 files changed, 322 insertions, 140 deletions
diff --git a/lib/libc/tests/secure/fortify_unistd_test.c b/lib/libc/tests/secure/fortify_unistd_test.c index e467ba849bd4..b12ef2bbb8ea 100644 --- a/lib/libc/tests/secure/fortify_unistd_test.c +++ b/lib/libc/tests/secure/fortify_unistd_test.c @@ -4,6 +4,7 @@ #define TMPFILE_SIZE (1024 * 32) #include <sys/param.h> +#include <sys/jail.h> #include <sys/random.h> #include <sys/resource.h> #include <sys/select.h> @@ -162,7 +163,31 @@ replace_stdin(void) close(fd); } -ATF_TC_WITHOUT_HEAD(getcwd_before_end); +#define JAIL_HOSTNAME "host.example.com" +#define JAIL_DOMAINNAME "example.com" +static void +dhost_jail(void) +{ + struct iovec iov[4]; + int jid; + + iov[0].iov_base = __DECONST(char *, "host.hostname"); + iov[0].iov_len = sizeof("host.hostname"); + iov[1].iov_base = __DECONST(char *, JAIL_HOSTNAME); + iov[1].iov_len = sizeof(JAIL_HOSTNAME); + iov[2].iov_base = __DECONST(char *, "host.domainname"); + iov[2].iov_len = sizeof("host.domainname"); + iov[3].iov_base = __DECONST(char *, JAIL_DOMAINNAME); + iov[3].iov_len = sizeof(JAIL_DOMAINNAME); + + jid = jail_set(iov, nitems(iov), JAIL_CREATE | JAIL_ATTACH); + ATF_REQUIRE_MSG(jid > 0, "Jail creation failed: %s", strerror(errno)); +} + +ATF_TC(getcwd_before_end); +ATF_TC_HEAD(getcwd_before_end, tc) +{ +} ATF_TC_BODY(getcwd_before_end, tc) { #define BUF &__stack.__buf @@ -180,7 +205,10 @@ ATF_TC_BODY(getcwd_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getcwd_end); +ATF_TC(getcwd_end); +ATF_TC_HEAD(getcwd_end, tc) +{ +} ATF_TC_BODY(getcwd_end, tc) { #define BUF &__stack.__buf @@ -198,7 +226,10 @@ ATF_TC_BODY(getcwd_end, tc) } -ATF_TC_WITHOUT_HEAD(getcwd_heap_before_end); +ATF_TC(getcwd_heap_before_end); +ATF_TC_HEAD(getcwd_heap_before_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_before_end, tc) { #define BUF __stack.__buf @@ -218,7 +249,10 @@ ATF_TC_BODY(getcwd_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getcwd_heap_end); +ATF_TC(getcwd_heap_end); +ATF_TC_HEAD(getcwd_heap_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_end, tc) { #define BUF __stack.__buf @@ -238,7 +272,10 @@ ATF_TC_BODY(getcwd_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getcwd_heap_after_end); +ATF_TC(getcwd_heap_after_end); +ATF_TC_HEAD(getcwd_heap_after_end, tc) +{ +} ATF_TC_BODY(getcwd_heap_after_end, tc) { #define BUF __stack.__buf @@ -289,7 +326,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getgrouplist_before_end); +ATF_TC(getgrouplist_before_end); +ATF_TC_HEAD(getgrouplist_before_end, tc) +{ +} ATF_TC_BODY(getgrouplist_before_end, tc) { #define BUF &__stack.__buf @@ -308,7 +348,10 @@ ATF_TC_BODY(getgrouplist_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getgrouplist_end); +ATF_TC(getgrouplist_end); +ATF_TC_HEAD(getgrouplist_end, tc) +{ +} ATF_TC_BODY(getgrouplist_end, tc) { #define BUF &__stack.__buf @@ -327,7 +370,10 @@ ATF_TC_BODY(getgrouplist_end, tc) } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_before_end); +ATF_TC(getgrouplist_heap_before_end); +ATF_TC_HEAD(getgrouplist_heap_before_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_before_end, tc) { #define BUF __stack.__buf @@ -348,7 +394,10 @@ ATF_TC_BODY(getgrouplist_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_end); +ATF_TC(getgrouplist_heap_end); +ATF_TC_HEAD(getgrouplist_heap_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_end, tc) { #define BUF __stack.__buf @@ -369,7 +418,10 @@ ATF_TC_BODY(getgrouplist_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getgrouplist_heap_after_end); +ATF_TC(getgrouplist_heap_after_end); +ATF_TC_HEAD(getgrouplist_heap_after_end, tc) +{ +} ATF_TC_BODY(getgrouplist_heap_after_end, tc) { #define BUF __stack.__buf @@ -421,7 +473,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getgroups_before_end); +ATF_TC(getgroups_before_end); +ATF_TC_HEAD(getgroups_before_end, tc) +{ +} ATF_TC_BODY(getgroups_before_end, tc) { #define BUF &__stack.__buf @@ -439,7 +494,10 @@ ATF_TC_BODY(getgroups_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getgroups_end); +ATF_TC(getgroups_end); +ATF_TC_HEAD(getgroups_end, tc) +{ +} ATF_TC_BODY(getgroups_end, tc) { #define BUF &__stack.__buf @@ -457,7 +515,10 @@ ATF_TC_BODY(getgroups_end, tc) } -ATF_TC_WITHOUT_HEAD(getgroups_heap_before_end); +ATF_TC(getgroups_heap_before_end); +ATF_TC_HEAD(getgroups_heap_before_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_before_end, tc) { #define BUF __stack.__buf @@ -477,7 +538,10 @@ ATF_TC_BODY(getgroups_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getgroups_heap_end); +ATF_TC(getgroups_heap_end); +ATF_TC_HEAD(getgroups_heap_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_end, tc) { #define BUF __stack.__buf @@ -497,7 +561,10 @@ ATF_TC_BODY(getgroups_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getgroups_heap_after_end); +ATF_TC(getgroups_heap_after_end); +ATF_TC_HEAD(getgroups_heap_after_end, tc) +{ +} ATF_TC_BODY(getgroups_heap_after_end, tc) { #define BUF __stack.__buf @@ -548,7 +615,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getloginclass_before_end); +ATF_TC(getloginclass_before_end); +ATF_TC_HEAD(getloginclass_before_end, tc) +{ +} ATF_TC_BODY(getloginclass_before_end, tc) { #define BUF &__stack.__buf @@ -566,7 +636,10 @@ ATF_TC_BODY(getloginclass_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getloginclass_end); +ATF_TC(getloginclass_end); +ATF_TC_HEAD(getloginclass_end, tc) +{ +} ATF_TC_BODY(getloginclass_end, tc) { #define BUF &__stack.__buf @@ -584,7 +657,10 @@ ATF_TC_BODY(getloginclass_end, tc) } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_before_end); +ATF_TC(getloginclass_heap_before_end); +ATF_TC_HEAD(getloginclass_heap_before_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_before_end, tc) { #define BUF __stack.__buf @@ -604,7 +680,10 @@ ATF_TC_BODY(getloginclass_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_end); +ATF_TC(getloginclass_heap_end); +ATF_TC_HEAD(getloginclass_heap_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_end, tc) { #define BUF __stack.__buf @@ -624,7 +703,10 @@ ATF_TC_BODY(getloginclass_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getloginclass_heap_after_end); +ATF_TC(getloginclass_heap_after_end); +ATF_TC_HEAD(getloginclass_heap_after_end, tc) +{ +} ATF_TC_BODY(getloginclass_heap_after_end, tc) { #define BUF __stack.__buf @@ -675,7 +757,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(pread_before_end); +ATF_TC(pread_before_end); +ATF_TC_HEAD(pread_before_end, tc) +{ +} ATF_TC_BODY(pread_before_end, tc) { #define BUF &__stack.__buf @@ -696,7 +781,10 @@ ATF_TC_BODY(pread_before_end, tc) } -ATF_TC_WITHOUT_HEAD(pread_end); +ATF_TC(pread_end); +ATF_TC_HEAD(pread_end, tc) +{ +} ATF_TC_BODY(pread_end, tc) { #define BUF &__stack.__buf @@ -717,7 +805,10 @@ ATF_TC_BODY(pread_end, tc) } -ATF_TC_WITHOUT_HEAD(pread_heap_before_end); +ATF_TC(pread_heap_before_end); +ATF_TC_HEAD(pread_heap_before_end, tc) +{ +} ATF_TC_BODY(pread_heap_before_end, tc) { #define BUF __stack.__buf @@ -739,7 +830,10 @@ ATF_TC_BODY(pread_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(pread_heap_end); +ATF_TC(pread_heap_end); +ATF_TC_HEAD(pread_heap_end, tc) +{ +} ATF_TC_BODY(pread_heap_end, tc) { #define BUF __stack.__buf @@ -761,7 +855,10 @@ ATF_TC_BODY(pread_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(pread_heap_after_end); +ATF_TC(pread_heap_after_end); +ATF_TC_HEAD(pread_heap_after_end, tc) +{ +} ATF_TC_BODY(pread_heap_after_end, tc) { #define BUF __stack.__buf @@ -814,7 +911,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(read_before_end); +ATF_TC(read_before_end); +ATF_TC_HEAD(read_before_end, tc) +{ +} ATF_TC_BODY(read_before_end, tc) { #define BUF &__stack.__buf @@ -835,7 +935,10 @@ ATF_TC_BODY(read_before_end, tc) } -ATF_TC_WITHOUT_HEAD(read_end); +ATF_TC(read_end); +ATF_TC_HEAD(read_end, tc) +{ +} ATF_TC_BODY(read_end, tc) { #define BUF &__stack.__buf @@ -856,7 +959,10 @@ ATF_TC_BODY(read_end, tc) } -ATF_TC_WITHOUT_HEAD(read_heap_before_end); +ATF_TC(read_heap_before_end); +ATF_TC_HEAD(read_heap_before_end, tc) +{ +} ATF_TC_BODY(read_heap_before_end, tc) { #define BUF __stack.__buf @@ -878,7 +984,10 @@ ATF_TC_BODY(read_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(read_heap_end); +ATF_TC(read_heap_end); +ATF_TC_HEAD(read_heap_end, tc) +{ +} ATF_TC_BODY(read_heap_end, tc) { #define BUF __stack.__buf @@ -900,7 +1009,10 @@ ATF_TC_BODY(read_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(read_heap_after_end); +ATF_TC(read_heap_after_end); +ATF_TC_HEAD(read_heap_after_end, tc) +{ +} ATF_TC_BODY(read_heap_after_end, tc) { #define BUF __stack.__buf @@ -953,7 +1065,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(readlink_before_end); +ATF_TC(readlink_before_end); +ATF_TC_HEAD(readlink_before_end, tc) +{ +} ATF_TC_BODY(readlink_before_end, tc) { #define BUF &__stack.__buf @@ -974,7 +1089,10 @@ ATF_TC_BODY(readlink_before_end, tc) } -ATF_TC_WITHOUT_HEAD(readlink_end); +ATF_TC(readlink_end); +ATF_TC_HEAD(readlink_end, tc) +{ +} ATF_TC_BODY(readlink_end, tc) { #define BUF &__stack.__buf @@ -995,7 +1113,10 @@ ATF_TC_BODY(readlink_end, tc) } -ATF_TC_WITHOUT_HEAD(readlink_heap_before_end); +ATF_TC(readlink_heap_before_end); +ATF_TC_HEAD(readlink_heap_before_end, tc) +{ +} ATF_TC_BODY(readlink_heap_before_end, tc) { #define BUF __stack.__buf @@ -1017,7 +1138,10 @@ ATF_TC_BODY(readlink_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(readlink_heap_end); +ATF_TC(readlink_heap_end); +ATF_TC_HEAD(readlink_heap_end, tc) +{ +} ATF_TC_BODY(readlink_heap_end, tc) { #define BUF __stack.__buf @@ -1039,7 +1163,10 @@ ATF_TC_BODY(readlink_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(readlink_heap_after_end); +ATF_TC(readlink_heap_after_end); +ATF_TC_HEAD(readlink_heap_after_end, tc) +{ +} ATF_TC_BODY(readlink_heap_after_end, tc) { #define BUF __stack.__buf @@ -1092,7 +1219,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(readlinkat_before_end); +ATF_TC(readlinkat_before_end); +ATF_TC_HEAD(readlinkat_before_end, tc) +{ +} ATF_TC_BODY(readlinkat_before_end, tc) { #define BUF &__stack.__buf @@ -1113,7 +1243,10 @@ ATF_TC_BODY(readlinkat_before_end, tc) } -ATF_TC_WITHOUT_HEAD(readlinkat_end); +ATF_TC(readlinkat_end); +ATF_TC_HEAD(readlinkat_end, tc) +{ +} ATF_TC_BODY(readlinkat_end, tc) { #define BUF &__stack.__buf @@ -1134,7 +1267,10 @@ ATF_TC_BODY(readlinkat_end, tc) } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_before_end); +ATF_TC(readlinkat_heap_before_end); +ATF_TC_HEAD(readlinkat_heap_before_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_before_end, tc) { #define BUF __stack.__buf @@ -1156,7 +1292,10 @@ ATF_TC_BODY(readlinkat_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_end); +ATF_TC(readlinkat_heap_end); +ATF_TC_HEAD(readlinkat_heap_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_end, tc) { #define BUF __stack.__buf @@ -1178,7 +1317,10 @@ ATF_TC_BODY(readlinkat_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(readlinkat_heap_after_end); +ATF_TC(readlinkat_heap_after_end); +ATF_TC_HEAD(readlinkat_heap_after_end, tc) +{ +} ATF_TC_BODY(readlinkat_heap_after_end, tc) { #define BUF __stack.__buf @@ -1231,53 +1373,57 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getdomainname_before_end); +ATF_TC(getdomainname_before_end); +ATF_TC_HEAD(getdomainname_before_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(getdomainname_before_end, tc) { #define BUF &__stack.__buf struct { uint8_t padding_l; - unsigned char __buf[4]; + unsigned char __buf[12]; uint8_t padding_r; } __stack; const size_t __bufsz __unused = sizeof(__stack.__buf); - const size_t __len = 4 - 1; + const size_t __len = 12 - 1; const size_t __idx __unused = __len - 1; - char sysdomain[256]; - - (void)getdomainname(sysdomain, __len); - if (strlen(sysdomain) <= __len) - atf_tc_skip("domain name too short for testing"); + dhost_jail(); getdomainname(__stack.__buf, __len); #undef BUF } -ATF_TC_WITHOUT_HEAD(getdomainname_end); +ATF_TC(getdomainname_end); +ATF_TC_HEAD(getdomainname_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(getdomainname_end, tc) { #define BUF &__stack.__buf struct { uint8_t padding_l; - unsigned char __buf[4]; + unsigned char __buf[12]; uint8_t padding_r; } __stack; const size_t __bufsz __unused = sizeof(__stack.__buf); - const size_t __len = 4; + const size_t __len = 12; const size_t __idx __unused = __len - 1; - char sysdomain[256]; - - (void)getdomainname(sysdomain, __len); - if (strlen(sysdomain) <= __len) - atf_tc_skip("domain name too short for testing"); + dhost_jail(); getdomainname(__stack.__buf, __len); #undef BUF } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_before_end); +ATF_TC(getdomainname_heap_before_end); +ATF_TC_HEAD(getdomainname_heap_before_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(getdomainname_heap_before_end, tc) { #define BUF __stack.__buf @@ -1286,15 +1432,11 @@ ATF_TC_BODY(getdomainname_heap_before_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4 - 1; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); + const size_t __len = 12 - 1; const size_t __idx __unused = __len - 1; - char sysdomain[256]; - - (void)getdomainname(sysdomain, __len); - if (strlen(sysdomain) <= __len) - atf_tc_skip("domain name too short for testing"); + dhost_jail(); __stack.__buf = malloc(__bufsz); getdomainname(__stack.__buf, __len); @@ -1302,7 +1444,11 @@ ATF_TC_BODY(getdomainname_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_end); +ATF_TC(getdomainname_heap_end); +ATF_TC_HEAD(getdomainname_heap_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(getdomainname_heap_end, tc) { #define BUF __stack.__buf @@ -1311,15 +1457,11 @@ ATF_TC_BODY(getdomainname_heap_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); + const size_t __len = 12; const size_t __idx __unused = __len - 1; - char sysdomain[256]; - - (void)getdomainname(sysdomain, __len); - if (strlen(sysdomain) <= __len) - atf_tc_skip("domain name too short for testing"); + dhost_jail(); __stack.__buf = malloc(__bufsz); getdomainname(__stack.__buf, __len); @@ -1327,7 +1469,11 @@ ATF_TC_BODY(getdomainname_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getdomainname_heap_after_end); +ATF_TC(getdomainname_heap_after_end); +ATF_TC_HEAD(getdomainname_heap_after_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(getdomainname_heap_after_end, tc) { #define BUF __stack.__buf @@ -1336,17 +1482,13 @@ ATF_TC_BODY(getdomainname_heap_after_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4 + 1; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (12); + const size_t __len = 12 + 1; const size_t __idx __unused = __len - 1; pid_t __child; int __status; - char sysdomain[256]; - - (void)getdomainname(sysdomain, __len); - if (strlen(sysdomain) <= __len) - atf_tc_skip("domain name too short for testing"); + dhost_jail(); __child = fork(); ATF_REQUIRE(__child >= 0); if (__child > 0) @@ -1383,7 +1525,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getentropy_before_end); +ATF_TC(getentropy_before_end); +ATF_TC_HEAD(getentropy_before_end, tc) +{ +} ATF_TC_BODY(getentropy_before_end, tc) { #define BUF &__stack.__buf @@ -1401,7 +1546,10 @@ ATF_TC_BODY(getentropy_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getentropy_end); +ATF_TC(getentropy_end); +ATF_TC_HEAD(getentropy_end, tc) +{ +} ATF_TC_BODY(getentropy_end, tc) { #define BUF &__stack.__buf @@ -1419,7 +1567,10 @@ ATF_TC_BODY(getentropy_end, tc) } -ATF_TC_WITHOUT_HEAD(getentropy_heap_before_end); +ATF_TC(getentropy_heap_before_end); +ATF_TC_HEAD(getentropy_heap_before_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_before_end, tc) { #define BUF __stack.__buf @@ -1439,7 +1590,10 @@ ATF_TC_BODY(getentropy_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getentropy_heap_end); +ATF_TC(getentropy_heap_end); +ATF_TC_HEAD(getentropy_heap_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_end, tc) { #define BUF __stack.__buf @@ -1459,7 +1613,10 @@ ATF_TC_BODY(getentropy_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getentropy_heap_after_end); +ATF_TC(getentropy_heap_after_end); +ATF_TC_HEAD(getentropy_heap_after_end, tc) +{ +} ATF_TC_BODY(getentropy_heap_after_end, tc) { #define BUF __stack.__buf @@ -1510,55 +1667,57 @@ monitor: } -ATF_TC_WITHOUT_HEAD(gethostname_before_end); +ATF_TC(gethostname_before_end); +ATF_TC_HEAD(gethostname_before_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(gethostname_before_end, tc) { #define BUF &__stack.__buf struct { uint8_t padding_l; - unsigned char __buf[4]; + unsigned char __buf[17]; uint8_t padding_r; } __stack; const size_t __bufsz __unused = sizeof(__stack.__buf); - const size_t __len = 4 - 1; + const size_t __len = 17 - 1; const size_t __idx __unused = __len - 1; - char syshost[256]; - int error; - - error = gethostname(syshost, __len); - if (error != 0 || strlen(syshost) <= __len) - atf_tc_skip("hostname too short for testing"); + dhost_jail(); gethostname(__stack.__buf, __len); #undef BUF } -ATF_TC_WITHOUT_HEAD(gethostname_end); +ATF_TC(gethostname_end); +ATF_TC_HEAD(gethostname_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(gethostname_end, tc) { #define BUF &__stack.__buf struct { uint8_t padding_l; - unsigned char __buf[4]; + unsigned char __buf[17]; uint8_t padding_r; } __stack; const size_t __bufsz __unused = sizeof(__stack.__buf); - const size_t __len = 4; + const size_t __len = 17; const size_t __idx __unused = __len - 1; - char syshost[256]; - int error; - - error = gethostname(syshost, __len); - if (error != 0 || strlen(syshost) <= __len) - atf_tc_skip("hostname too short for testing"); + dhost_jail(); gethostname(__stack.__buf, __len); #undef BUF } -ATF_TC_WITHOUT_HEAD(gethostname_heap_before_end); +ATF_TC(gethostname_heap_before_end); +ATF_TC_HEAD(gethostname_heap_before_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(gethostname_heap_before_end, tc) { #define BUF __stack.__buf @@ -1567,16 +1726,11 @@ ATF_TC_BODY(gethostname_heap_before_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4 - 1; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); + const size_t __len = 17 - 1; const size_t __idx __unused = __len - 1; - char syshost[256]; - int error; - - error = gethostname(syshost, __len); - if (error != 0 || strlen(syshost) <= __len) - atf_tc_skip("hostname too short for testing"); + dhost_jail(); __stack.__buf = malloc(__bufsz); gethostname(__stack.__buf, __len); @@ -1584,7 +1738,11 @@ ATF_TC_BODY(gethostname_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(gethostname_heap_end); +ATF_TC(gethostname_heap_end); +ATF_TC_HEAD(gethostname_heap_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(gethostname_heap_end, tc) { #define BUF __stack.__buf @@ -1593,16 +1751,11 @@ ATF_TC_BODY(gethostname_heap_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); + const size_t __len = 17; const size_t __idx __unused = __len - 1; - char syshost[256]; - int error; - - error = gethostname(syshost, __len); - if (error != 0 || strlen(syshost) <= __len) - atf_tc_skip("hostname too short for testing"); + dhost_jail(); __stack.__buf = malloc(__bufsz); gethostname(__stack.__buf, __len); @@ -1610,7 +1763,11 @@ ATF_TC_BODY(gethostname_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(gethostname_heap_after_end); +ATF_TC(gethostname_heap_after_end); +ATF_TC_HEAD(gethostname_heap_after_end, tc) +{ + atf_tc_set_md_var(tc, "require.user", "root"); +} ATF_TC_BODY(gethostname_heap_after_end, tc) { #define BUF __stack.__buf @@ -1619,18 +1776,13 @@ ATF_TC_BODY(gethostname_heap_after_end, tc) unsigned char * __buf; uint8_t padding_r; } __stack; - const size_t __bufsz __unused = sizeof(*__stack.__buf) * (4); - const size_t __len = 4 + 1; + const size_t __bufsz __unused = sizeof(*__stack.__buf) * (17); + const size_t __len = 17 + 1; const size_t __idx __unused = __len - 1; pid_t __child; int __status; - char syshost[256]; - int error; - - error = gethostname(syshost, __len); - if (error != 0 || strlen(syshost) <= __len) - atf_tc_skip("hostname too short for testing"); + dhost_jail(); __child = fork(); ATF_REQUIRE(__child >= 0); if (__child > 0) @@ -1667,7 +1819,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(getlogin_r_before_end); +ATF_TC(getlogin_r_before_end); +ATF_TC_HEAD(getlogin_r_before_end, tc) +{ +} ATF_TC_BODY(getlogin_r_before_end, tc) { #define BUF &__stack.__buf @@ -1685,7 +1840,10 @@ ATF_TC_BODY(getlogin_r_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getlogin_r_end); +ATF_TC(getlogin_r_end); +ATF_TC_HEAD(getlogin_r_end, tc) +{ +} ATF_TC_BODY(getlogin_r_end, tc) { #define BUF &__stack.__buf @@ -1703,7 +1861,10 @@ ATF_TC_BODY(getlogin_r_end, tc) } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_before_end); +ATF_TC(getlogin_r_heap_before_end); +ATF_TC_HEAD(getlogin_r_heap_before_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_before_end, tc) { #define BUF __stack.__buf @@ -1723,7 +1884,10 @@ ATF_TC_BODY(getlogin_r_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_end); +ATF_TC(getlogin_r_heap_end); +ATF_TC_HEAD(getlogin_r_heap_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_end, tc) { #define BUF __stack.__buf @@ -1743,7 +1907,10 @@ ATF_TC_BODY(getlogin_r_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(getlogin_r_heap_after_end); +ATF_TC(getlogin_r_heap_after_end); +ATF_TC_HEAD(getlogin_r_heap_after_end, tc) +{ +} ATF_TC_BODY(getlogin_r_heap_after_end, tc) { #define BUF __stack.__buf @@ -1794,7 +1961,10 @@ monitor: } -ATF_TC_WITHOUT_HEAD(ttyname_r_before_end); +ATF_TC(ttyname_r_before_end); +ATF_TC_HEAD(ttyname_r_before_end, tc) +{ +} ATF_TC_BODY(ttyname_r_before_end, tc) { #define BUF &__stack.__buf @@ -1817,7 +1987,10 @@ ATF_TC_BODY(ttyname_r_before_end, tc) } -ATF_TC_WITHOUT_HEAD(ttyname_r_end); +ATF_TC(ttyname_r_end); +ATF_TC_HEAD(ttyname_r_end, tc) +{ +} ATF_TC_BODY(ttyname_r_end, tc) { #define BUF &__stack.__buf @@ -1840,7 +2013,10 @@ ATF_TC_BODY(ttyname_r_end, tc) } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_before_end); +ATF_TC(ttyname_r_heap_before_end); +ATF_TC_HEAD(ttyname_r_heap_before_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_before_end, tc) { #define BUF __stack.__buf @@ -1865,7 +2041,10 @@ ATF_TC_BODY(ttyname_r_heap_before_end, tc) } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_end); +ATF_TC(ttyname_r_heap_end); +ATF_TC_HEAD(ttyname_r_heap_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_end, tc) { #define BUF __stack.__buf @@ -1890,7 +2069,10 @@ ATF_TC_BODY(ttyname_r_heap_end, tc) } -ATF_TC_WITHOUT_HEAD(ttyname_r_heap_after_end); +ATF_TC(ttyname_r_heap_after_end); +ATF_TC_HEAD(ttyname_r_heap_after_end, tc) +{ +} ATF_TC_BODY(ttyname_r_heap_after_end, tc) { #define BUF __stack.__buf |