static void setup(void)
{
int fildes;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
umask(0);
TEST_PAUSE;
/* Switch to nobody user for correct error code collection */
ltpuser = getpwnam(nobody_uid);
SAFE_SETGID(NULL, ltpuser->pw_gid);
SAFE_SETUID(NULL, ltpuser->pw_uid);
tst_tmpdir();
sprintf(filename, "open3.%d", getpid());
fildes = SAFE_CREAT(cleanup, filename, 0600);
close(fildes);
#if !defined(UCLINUX)
bad_addr = mmap(0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
if (bad_addr == MAP_FAILED)
tst_brkm(TBROK, cleanup, "mmap failed");
TC[5].fname = bad_addr;
#endif
}
void setup(void)
{
int fd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root();
ltpuser = getpwnam(nobody_uid);
if (ltpuser == NULL)
tst_brkm(TBROK | TERRNO, NULL, "getpwnam failed");
SAFE_SETUID(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(%s, O_RDWR|O_CREAT, %#o) failed",
TESTFILE, FILE_MODE);
}
SAFE_CLOSE(cleanup, fd);
}
static void setup(void)
{
int fd;
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(cleanup, nobody_uid);
SAFE_SETUID(cleanup, ltpuser->pw_uid);
TEST_PAUSE;
#if !defined(UCLINUX)
bad_addr = mmap(0, 1, PROT_NONE,
MAP_PRIVATE_EXCEPT_UCLINUX | MAP_ANONYMOUS, 0, 0);
if (bad_addr == MAP_FAILED)
tst_brkm(TBROK | TERRNO, NULL, "mmap failed");
test_cases[4].pathname = bad_addr;
test_cases[5].pathname = get_high_address();
#endif
tst_tmpdir();
/*
* create TEST_FILE1 to test R_OK EACCESS
*/
fd = SAFE_CREAT(cleanup, TEST_FILE1, 0333);
SAFE_CLOSE(cleanup, fd);
/*
* create TEST_FILE2 to test W_OK EACCESS
*/
fd = SAFE_CREAT(cleanup, TEST_FILE2, 0555);
SAFE_CLOSE(cleanup, fd);
/*
* create TEST_FILE3 to test X_OK EACCESS
*/
fd = SAFE_CREAT(cleanup, TEST_FILE3, 0666);
SAFE_CLOSE(cleanup, fd);
/*
* create TEST_FILE4 to test EINVAL
*/
fd = SAFE_CREAT(cleanup, TEST_FILE4, 0333);
SAFE_CLOSE(cleanup, fd);
/*
*setup to create a node with a name length exceeding
*the MAX length of PATH_MAX.
*/
memset(longpathname, 'a', sizeof(longpathname) - 1);
}
void setup(void)
{
char nobody_uid[] = "nobody";
struct passwd *ltpuser;
key_t semkey2;
struct seminfo ipc_buf;
union semun arr;
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(NULL, nobody_uid);
SAFE_SETUID(NULL, ltpuser->pw_uid);
tst_sig(NOFORK, DEF_HANDLER, cleanup);
TEST_PAUSE;
tst_tmpdir();
/* get an IPC resource key */
semkey = getipckey();
/* create a semaphore set with read and alter permissions */
sem_id_1 = semget(semkey, PSEMS, IPC_CREAT | IPC_EXCL | SEM_RA);
if (sem_id_1 == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"couldn't create semaphore in setup");
}
/* Get an new IPC resource key. */
semkey2 = getipckey();
/* create a semaphore set without read and alter permissions */
sem_id_2 = semget(semkey2, PSEMS, IPC_CREAT | IPC_EXCL);
if (sem_id_2 == -1) {
tst_brkm(TBROK | TERRNO, cleanup,
"couldn't create semaphore in setup");
}
arr.ipc_buf = &ipc_buf;
if (semctl(sem_id_1, 0, IPC_INFO, arr) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "semctl() IPC_INFO failed");
/* for ERANGE errno test */
arr.val = 1;
s_buf[0].sem_op = ipc_buf.semvmx;
if (semctl(sem_id_1, 0, SETVAL, arr) == -1)
tst_brkm(TBROK | TERRNO, cleanup, "semctl() SETVAL failed");
}
static void test_hugeshmctl(void)
{
pid_t pid;
int status;
switch (pid = SAFE_FORK()) {
case 0:
/* set the user ID of the child to the non root user */
SAFE_SETUID(ltp_uid);
do_child();
exit(0);
default:
SAFE_WAITPID(pid, &status, 0);
}
}
static void verify_access(unsigned int n)
{
struct tcase *tc = tcases + n;
pid_t pid;
access_test(tc, "root");
pid = SAFE_FORK();
if (pid) {
SAFE_WAITPID(pid, NULL, 0);
} else {
SAFE_SETUID(uid);
access_test(tc, "nobody");
}
}
static void do_shmat(unsigned int n)
{
pid_t pid;
struct test_case_t *tc = &tcases[n];
if (!tc->exp_user) {
verify_shmat(tc);
} else {
pid = SAFE_FORK();
if (pid) {
tst_reap_children();
} else {
SAFE_SETUID(pw->pw_uid);
verify_shmat(tc);
exit(0);
}
}
}
static void setup(void)
{
tst_require_root();
tst_sig(FORK, DEF_HANDLER, NULL);
ltpuser = getpwnam("nobody");
if (ltpuser == NULL)
tst_brkm(TBROK, NULL, "getpwnam(\"nobody\") failed");
SAFE_SETGID(NULL, ltpuser->pw_gid);
SAFE_SETUID(NULL, ltpuser->pw_uid);
root = get_group_by_name("root");
ltpgroup = get_group_by_gid(ltpuser->pw_gid);
bin = get_group_by_name("bin");
TEST_PAUSE;
}
static void setup(void)
{
int fildes;
char nobody_uid[] = "nobody";
struct passwd *ltpuser;
umask(0);
SAFE_CREAT(user2_fname, 0600);
/* Switch to nobody user for correct error code collection */
ltpuser = getpwnam(nobody_uid);
SAFE_SETGID(ltpuser->pw_gid);
SAFE_SETUID(ltpuser->pw_uid);
fildes = SAFE_CREAT(existing_fname, 0600);
close(fildes);
unmapped_fname = tst_get_bad_addr(NULL);
}
static void setup(void)
{
tst_sig(NOFORK, DEF_HANDLER, cleanup);
tst_require_root(NULL);
ltpuser = SAFE_GETPWNAM(NULL, nobody_uid);
SAFE_SETUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
if (tst_fill_file(TESTFILE, 'a', 1024, 1))
tst_brkm(TBROK, cleanup, "Failed to create " TESTFILE);
SAFE_SYMLINK(cleanup, TESTFILE, SFILE);
user_id = getuid();
group_id = getgid();
}
void dirtyc0w_test(void)
{
int i, fd, pid, fail = 0;
char c;
/* Create file */
fd = SAFE_OPEN(FNAME, O_WRONLY|O_CREAT|O_EXCL, 0444);
SAFE_WRITE(1, fd, STR, sizeof(STR)-1);
SAFE_CLOSE(fd);
pid = SAFE_FORK();
if (!pid) {
SAFE_SETGID(nobody_gid);
SAFE_SETUID(nobody_uid);
SAFE_EXECLP("dirtyc0w_child", "dirtyc0w_child", NULL);
}
TST_CHECKPOINT_WAIT(0);
for (i = 0; i < 100; i++) {
usleep(10000);
SAFE_FILE_SCANF(FNAME, "%c", &c);
if (c != 't') {
fail = 1;
break;
}
}
SAFE_KILL(pid, SIGUSR1);
tst_reap_children();
SAFE_UNLINK(FNAME);
if (fail)
tst_res(TFAIL, "Bug reproduced!");
else
tst_res(TPASS, "Bug not reproduced");
}
static void setup(void)
{
struct passwd *ltpuser;
char tst_buff[BUF_SIZE];
int wbytes;
int write_len = 0;
int fd;
tst_require_root();
tst_sig(NOFORK, DEF_HANDLER, cleanup);
ltpuser = SAFE_GETPWNAM(NULL, "nobody");
SAFE_SETUID(NULL, ltpuser->pw_uid);
TEST_PAUSE;
tst_tmpdir();
umask(022);
fd = SAFE_OPEN(tst_rmdir, TESTFILE, O_WRONLY | O_CREAT, FILE_MODE);
/* Fill the test buffer with the known data */
memset(tst_buff, 'a', BUF_SIZE - 1);
/* Write to the file 1k data from the buffer */
while (write_len < FILE_SIZE) {
if ((wbytes = write(fd, tst_buff, sizeof(tst_buff))) <= 0)
tst_brkm(TBROK | TERRNO, cleanup, "write failed");
else
write_len += wbytes;
}
SAFE_CLOSE(tst_rmdir, fd);
user_id = getuid();
group_id = getgid();
}