int main(int argc, char *argv[])
{
struct passwd *pwent;
setup();
/* EISDIR */
if (acct("/") == -1 && errno == EISDIR)
tst_resm(TPASS, "Failed with EISDIR as expected");
else
tst_brkm(TFAIL | TERRNO, cleanup,
"didn't fail as expected; expected EISDIR");
/* EACCES */
if (acct("/dev/null") == -1 && errno == EACCES)
tst_resm(TPASS, "Failed with EACCES as expected");
else
tst_brkm(TFAIL | TERRNO, cleanup,
"didn't fail as expected; expected EACCES");
/* ENOENT */
if (acct("/tmp/does/not/exist") == -1 && errno == ENOENT)
tst_resm(TPASS, "Failed with ENOENT as expected");
else
tst_brkm(TBROK | TERRNO, cleanup,
"didn't fail as expected; expected ENOENT");
/* ENOTDIR */
if (acct("/etc/fstab/") == -1 && errno == ENOTDIR)
tst_resm(TPASS, "Failed with ENOTDIR as expected");
else
tst_brkm(TFAIL | TERRNO, cleanup,
"didn't fail as expected; expected ENOTDIR");
/* EPERM */
sprintf(tmpbuf, "./%s.%d", TCID, getpid());
fd = SAFE_CREAT(cleanup, tmpbuf, 0777);
SAFE_CLOSE(cleanup, fd);
if (acct(tmpbuf) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "acct failed unexpectedly");
pwent = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, pwent->pw_uid);
if (acct(tmpbuf) == -1 && errno == EPERM)
tst_resm(TPASS, "Failed with EPERM as expected");
else
tst_brkm(TBROK | TERRNO, cleanup,
"didn't fail as expected; expected EPERM");
SAFE_SETEUID(cleanup, 0);
SAFE_UNLINK(cleanup, tmpbuf);
cleanup();
tst_exit();
}
int main(int ac, char **av)
{
int lc;
pid_t pid;
struct sched_param param;
int status;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
/* reset tst_count in case we are looping */
tst_count = 0;
if ((pid = FORK_OR_VFORK()) == -1) {
tst_brkm(TBROK, cleanup, "fork failed");
}
if (pid == 0) { /* child */
param.sched_priority = 1;
SAFE_SETEUID(cleanup, nobody_uid);
TEST(sched_setscheduler(pid, SCHED_FIFO, ¶m));
if (TEST_ERRNO) {
}
if (TEST_RETURN != -1) {
tst_resm(TFAIL, "sched_setscheduler(2) passed "
"with non root priveledges");
} else if (TEST_ERRNO != EPERM) {
tst_resm(TFAIL, "Expected EPERM, got %d",
TEST_ERRNO);
} else {
tst_resm(TPASS, "got EPERM");
}
} else { /* parent */
/* let the child carry on */
wait(&status);
if (WIFEXITED(status) != 0) { /* Exit with errors */
exit(WEXITSTATUS(status));
} else {
exit(0);
}
}
SAFE_SETEUID(cleanup, 0);
}
cleanup();
tst_exit();
}
static void setup(void)
{
const char *fs_type;
struct passwd *ltpuser;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(NULL, "nobody");
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, MNTPOINT, DIR_MODE);
if (mount(device, MNTPOINT, fs_type, 0, NULL))
tst_brkm(TBROK | TERRNO, cleanup, "mount() failed");
mount_flag = 1;
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
}
static void setup(void)
{
char nobody_uid[] = "nobody";
struct passwd *ltpuser;
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_require_root();
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
tst_mkfs(cleanup, device, fs_type, NULL);
ltpuser = SAFE_GETPWNAM(cleanup, nobody_uid);
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
SAFE_MKDIR(cleanup, mntpoint, DIR_MODE);
TEST_PAUSE;
}
void setup(void)
{
int i;
int fd;
tst_require_root(NULL);
tst_mkfs(NULL, device, fstype, NULL);
tst_sig(FORK, DEF_HANDLER, cleanup);
ltpuser = getpwnam("nobody");
if (ltpuser == NULL)
tst_brkm(TBROK | TERRNO, NULL, "getpwnam(\"nobody\") failed");
if (seteuid(ltpuser->pw_uid) == -1)
tst_brkm(TBROK | TERRNO, NULL, "seteuid(%d) failed",
ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
bad_addr = mmap(0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
if (bad_addr == MAP_FAILED)
tst_brkm(TBROK | TERRNO, cleanup, "mmap failed");
test_cases[3].pathname = bad_addr;
SAFE_SYMLINK(cleanup, "test_eloop1", "test_eloop2");
SAFE_SYMLINK(cleanup, "test_eloop2", "test_eloop1");
SAFE_SETEUID(cleanup, 0);
SAFE_MKDIR(cleanup, "mntpoint", DIR_MODE);
if (mount(device, "mntpoint", fstype, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
for (i = 0; i < TST_TOTAL; i++)
if (test_cases[i].setupfunc != NULL)
test_cases[i].setupfunc();
}
void setup(void)
{
struct passwd *pw;
pw = SAFE_GETPWNAM("nobody");
SAFE_SETEUID(pw->pw_uid);
SAFE_MKDIR(DIRNAME, 0400);
fd = SAFE_OPEN(DIRNAME, O_RDONLY);
}
int main(int ac, char **av)
{
int lc, i;
tst_parse_opts(ac, av, NULL, NULL);
setup();
for (lc = 0; TEST_LOOPING(lc); lc++) {
tst_count = 0;
for (i = 0; i < TST_TOTAL; i++) {
if (setup_test(i) < 0)
continue;
TEST(ltp_syscall(__NR_clock_settime, clocks[i], temp));
/* Change the UID back to root */
if (i == TST_TOTAL - 1) {
SAFE_SETEUID(cleanup, 0);
}
/* check return code */
if (TEST_RETURN == -1 && TEST_ERRNO == testcases[i]) {
tst_resm(TPASS | TTERRNO,
"clock_settime(2) got expected "
"failure.");
} else {
tst_resm(TFAIL | TTERRNO,
"clock_settime(2) failed to produce "
"expected error (return code = %ld)",
TEST_RETURN);
/* Restore the clock to its previous state. */
if (TEST_RETURN == 0) {
if (ltp_syscall(__NR_clock_settime,
CLOCK_REALTIME,
&saved) < 0) {
tst_resm(TWARN | TERRNO,
"FATAL: could not set "
"the clock!");
}
}
}
}
}
cleanup();
tst_exit();
}
static void setup(void)
{
struct passwd *pw;
SAFE_MKFS(tst_device->dev, tst_device->fs_type, NULL, NULL);
SAFE_MKDIR(MNTPOINT, 0775);
SAFE_MOUNT(tst_device->dev, MNTPOINT, tst_device->fs_type, 0, NULL);
mount_flag = 1;
pw = SAFE_GETPWNAM("nobody");
SAFE_SETEUID(pw->pw_uid);
}
static void setup(void)
{
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_EXP_ENOS(exp_enos);
}
static void setup(void)
{
tst_sig(FORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(cleanup, nobody_uid);
SAFE_SETEUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
fildes = SAFE_OPEN(cleanup, TESTFILE, O_RDWR | O_CREAT, FILE_MODE);
SAFE_SETEUID(cleanup, 0);
SAFE_FCHOWN(cleanup, fildes, -1, 0);
SAFE_FCHMOD(cleanup, fildes, NEW_PERMS);
SAFE_SETEGID(cleanup, ltpuser->pw_gid);
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
}
void setup(void)
{
struct passwd *ltpuser;
char *bad_addr;
struct rlimit rlim;
sigset_t signalset;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_TOUCH(cleanup, TEST_FILE1, NEW_MODE, NULL);
SAFE_TOUCH(cleanup, "t_file", FILE_MODE, NULL);
#if !defined(UCLINUX)
test_cases[2].pathname = (char *)get_high_address();
bad_addr = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
test_cases[3].pathname = bad_addr;
#endif
memset(long_pathname, 'a', PATH_MAX + 1);
SAFE_MKDIR(cleanup, TEST_DIR1, DIR_MODE);
SAFE_TOUCH(cleanup, TEST_FILE3, FILE_MODE, NULL);
SAFE_SYMLINK(cleanup, TEST_SYM1, TEST_SYM2);
SAFE_SYMLINK(cleanup, TEST_SYM2, TEST_SYM1);
rlim.rlim_cur = MAX_FSIZE;
rlim.rlim_max = MAX_FSIZE;
SAFE_SETRLIMIT(cleanup, RLIMIT_FSIZE, &rlim);
sigemptyset(&signalset);
sigaddset(&signalset, SIGXFSZ);
TEST(sigprocmask(SIG_BLOCK, &signalset, NULL));
if (TEST_RETURN != 0)
tst_brkm(TBROK | TTERRNO, cleanup, "sigprocmask");
}
static void setup(void)
{
struct passwd *ltpuser;
const char *fs_type;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to obtain block device");
SAFE_TOUCH(cleanup, TESTFILE1, FILE_MODE, NULL);
ltpuser = SAFE_GETPWNAM(cleanup, LTPUSER1);
SAFE_CHOWN(cleanup, TESTFILE1, ltpuser->pw_uid,
ltpuser->pw_gid);
SAFE_TOUCH(cleanup, TESTFILE2, FILE_MODE, NULL);
ltpuser = SAFE_GETPWNAM(cleanup, LTPUSER2);
SAFE_CHOWN(cleanup, TESTFILE2, ltpuser->pw_uid,
ltpuser->pw_gid);
tst_mkfs(cleanup, device, fs_type, NULL);
SAFE_MKDIR(cleanup, MNTPOINT, DIR_MODE);
if (mount(device, MNTPOINT, fs_type, 0, NULL) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
SAFE_TOUCH(cleanup, TESTFILE3, FILE_MODE, NULL);
ltpuser = SAFE_GETPWNAM(cleanup, LTPUSER1);
SAFE_CHOWN(cleanup, TESTFILE3, ltpuser->pw_uid,
ltpuser->pw_gid);
if (mount(device, MNTPOINT, fs_type,
MS_REMOUNT | MS_RDONLY, NULL) == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
ltpuser = SAFE_GETPWNAM(cleanup, LTPUSER1);
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
}
/* setup() - performs all ONE TIME setup for this test. */
void setup(void)
{
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
/* switch to nobody user */
if ((ltpuser = getpwnam(nobody_uid)) == NULL) {
tst_brkm(TBROK, NULL, "\"nobody\"user not present");
}
SAFE_SETEUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
}
static void setup(void)
{
struct passwd *ltpuser;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
SAFE_TOUCH(cleanup, TEST_FILE2, 0644, NULL);
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
}
static void setup(void)
{
int i;
struct passwd *ltpuser;
const char *fs_type;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_tmpdir();
fs_type = tst_dev_fs_type();
device = tst_acquire_device(cleanup);
if (!device)
tst_brkm(TCONF, cleanup, "Failed to acquire device");
tst_mkfs(cleanup, device, fs_type, NULL);
TEST_PAUSE;
/* mount a read-only file system for EROFS test */
SAFE_MKDIR(cleanup, MNT_POINT, DIR_MODE);
if (mount(device, MNT_POINT, fs_type, MS_RDONLY, NULL) < 0) {
tst_brkm(TBROK | TERRNO, cleanup,
"mount device:%s failed", device);
}
mount_flag = 1;
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
SAFE_MKDIR(cleanup, DIR_TEMP, DIR_TEMP_MODE);
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limits in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", DIR_MODE);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOPFILE);
}
static void setup(void)
{
tst_require_root(NULL);
uid = geteuid();
ncpus = tst_ncpus_max();
/* Current mask */
mask = CPU_ALLOC(ncpus);
if (mask == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "CPU_ALLOC(%ld) failed",
ncpus);
mask_size = CPU_ALLOC_SIZE(ncpus);
if (sched_getaffinity(0, mask_size, mask) < 0)
tst_brkm(TBROK | TERRNO, cleanup, "sched_getaffinity() failed");
/* Mask with one more cpu than available on the system */
emask = CPU_ALLOC(ncpus + 1);
if (emask == NULL)
tst_brkm(TBROK | TERRNO, cleanup, "CPU_ALLOC(%ld) failed",
ncpus + 1);
emask_size = CPU_ALLOC_SIZE(ncpus + 1);
CPU_ZERO_S(emask_size, emask);
CPU_SET_S(ncpus, emask_size, emask);
privileged_pid = tst_fork();
if (privileged_pid == 0) {
pause();
exit(0);
} else if (privileged_pid < 0) {
tst_brkm(TBROK | TERRNO, cleanup, "fork() failed");
}
/* Dropping the root privileges */
ltpuser = getpwnam(nobody_uid);
if (ltpuser == NULL)
tst_brkm(TBROK | TERRNO, cleanup,
"getpwnam failed for user id %s", nobody_uid);
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
/* this pid is not used by the OS */
free_pid = tst_get_unused_pid(cleanup);
}
static void do_child(void)
{
char *argv[2] = {TEST_APP, NULL};
SAFE_SETEUID(NULL, nobody_uid);
TEST(execve(TEST_APP, argv, NULL));
if (!TEST_RETURN)
tst_brkm(TFAIL, NULL, "execve() passed unexpectedly");
if (TEST_ERRNO != EACCES) {
tst_brkm(TFAIL | TTERRNO, NULL,
"execve() failed unexpectedly");
}
tst_resm(TPASS | TTERRNO, "execve() failed expectedly");
tst_exit();
}
static void cleanup(void)
{
if (mask != NULL) {
CPU_FREE(mask);
mask = NULL;
}
if (emask != NULL) {
CPU_FREE(emask);
emask = NULL;
}
SAFE_SETEUID(NULL, uid);
if (privileged_pid != 0) {
kill(privileged_pid, SIGKILL);
waitpid(privileged_pid, NULL, 0);
privileged_pid = 0;
}
}
void setup(void)
{
struct passwd *ltpuser;
char *bad_addr;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_TOUCH(cleanup, TEST_FILE1, NEW_MODE, NULL);
SAFE_TOUCH(cleanup, "t_file", FILE_MODE, NULL);
#if !defined(UCLINUX)
test_cases[2].pathname = (char *)get_high_address();
bad_addr = SAFE_MMAP(cleanup, 0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
test_cases[3].pathname = bad_addr;
#endif
memset(long_pathname, 'a', PATH_MAX + 1);
SAFE_MKDIR(cleanup, TEST_DIR1, DIR_MODE);
SAFE_TOUCH(cleanup, TEST_FILE3, FILE_MODE, NULL);
SAFE_SYMLINK(cleanup, TEST_SYM1, TEST_SYM2);
SAFE_SYMLINK(cleanup, TEST_SYM2, TEST_SYM1);
}
void setup(void)
{
struct passwd *ltpuser;
int i;
tst_require_root(NULL);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
ltpuser = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
SAFE_MKDIR(cleanup, DIR_TEMP, MODE_RWX);
SAFE_TOUCH(cleanup, TEST_FILE1, 0666, NULL);
SAFE_SYMLINK(cleanup, TEST_FILE1, SYM_FILE1);
SAFE_CHMOD(cleanup, DIR_TEMP, FILE_MODE);
SAFE_TOUCH(cleanup, TEST_FILE2, 0666, NULL);
SAFE_SYMLINK(cleanup, TEST_FILE2, SYM_FILE2);
memset(longpathname, 'a', PATH_MAX + 1);
SAFE_TOUCH(cleanup, TEST_FILE3, 0666, NULL);
/*
* NOTE: the ELOOP test is written based on that the consecutive
* symlinks limit in kernel is hardwired to 40.
*/
SAFE_MKDIR(cleanup, "test_eloop", MODE_RWX);
SAFE_SYMLINK(cleanup, "../test_eloop", "test_eloop/test_eloop");
for (i = 0; i < 43; i++)
strcat(elooppathname, ELOOPFILE);
}
void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
ltpuser = getpwnam(nobody_uid);
if (ltpuser == NULL)
tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
SAFE_SETEUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
/*
* Create a test file under temporary directory with specified
* mode permissios and set the ownership of the test file to the
* uid/gid of guest user.
*/
if ((fd = open(TESTFILE, O_RDWR | O_CREAT, FILE_MODE)) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "open failed");
}
static void setup(void)
{
struct passwd *nobody_pwd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
TEST_PAUSE;
tst_tmpdir();
/* Modify mode permissions on test directory */
SAFE_CHMOD(cleanup, ".", MODE_TO);
SAFE_MKDIR(cleanup, DIR_TEMP, MODE_RWX);
SAFE_TOUCH(cleanup, TEST_FILE2, 0666, NULL);
/* Modify mode permissions on test directory - test conditions */
SAFE_CHMOD(cleanup, DIR_TEMP, MODE_TE);
nobody_pwd = SAFE_GETPWNAM(cleanup, "nobody");
SAFE_SETEUID(cleanup, nobody_pwd->pw_uid);
}
static void test6_setup(void)
{
SAFE_SETEUID(ltpuser->pw_uid);
}
static void cleanup_eacces(void)
{
SAFE_SETEUID(cleanup, 0);
}
static void setup_eacces(void)
{
SAFE_SETEUID(cleanup, ltpuser->pw_uid);
}
static void cleanup1(void)
{
SAFE_SETEUID(cleanup, 0);
}
static void test6_cleanup(void)
{
SAFE_SETEUID(0);
}
/* cleanup1() - reset to super user for second test case */
void cleanup1(void)
{
/* reset user as root */
SAFE_SETEUID(NULL, 0);
}
static int setup01(void)
{
SAFE_SETEUID(cleanup, nobody_uid);
return 0;
}
