Example #1
0
int main(int argc, char **argv)
{
    int nbytes, ret;

    int lc;			/* loop counter */
    char *msg;		/* message returned from parse_opts */

    /* parse standard options */
    if ((msg = parse_opts(argc, argv, (option_t *) NULL, NULL)) !=
            (char *)NULL) {
        tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
        /*NOTREACHED*/
    }

    /* set "tstdir", and "testfile" vars */
    setup();

    /* The following loop checks looping state if -i option given */
    for (lc = 0; TEST_LOOPING(lc); lc++) {

        /* reset Tst_count in case we are looping */
        Tst_count = 0;

        buf_list[0] = buf1;
        buf_list[1] = buf2;
        buf_list[2] = buf3;
        buf_list[3] = (char *)NULL;

        fd[1] = -1;	/* Invalid file descriptor  */

        if (signal(SIGTERM, sighandler) == SIG_ERR) {
            perror("signal: SIGTERM");
            cleanup();
            /*NOTREACHED*/
        }

        if (signal(SIGPIPE, sighandler) == SIG_ERR) {
            perror("signal: SIGPIPE");
            cleanup();
            /*NOTREACHED*/
        }

        init_buffs(buf_list);

        if ((fd[0] = open(f_name, O_WRONLY | O_CREAT, 0666)) < 0) {
            tst_resm(TFAIL, "open failed: fname = %s, errno = %d",
                     f_name, errno);
            cleanup();
            /*NOTREACHED*/
        }
        else if ((nbytes = write(fd[0], buf_list[2], K_1)) != K_1) {
            tst_resm(TFAIL,
                     "write failed: nbytes = %d, " "errno = %d",
                     nbytes, errno);
            cleanup();
            /*NOTREACHED*/
        }

        if (close(fd[0]) < 0) {
            tst_resm(TFAIL, "close failed: errno: %d", errno);
            cleanup();
            /*NOTREACHED*/
        }

        if ((fd[0] = open(f_name, O_RDWR, 0666)) < 0) {
            tst_resm(TFAIL, "open failed: fname = %s, errno = %d",
                     f_name, errno);
            cleanup();
            /*NOTREACHED*/
        }
//block1: /* given vector length -1, writev() return EINVAL. */
        tst_resm(TINFO, "Enter Block 1");
        fail = 0;

        TEST(writev(fd[0], wr_iovec, 1));
        if (TEST_RETURN < 0) {
            TEST_ERROR_LOG(TEST_ERRNO);
            if (TEST_ERRNO == EINVAL) {
                tst_resm(TINFO, "Received EINVAL as expected");
            } else {
                tst_resm(TFAIL, "Expected errno = EINVAL, "
                         "got %d", TEST_ERRNO);
                fail = 1;
            }
        } else {
            tst_resm(TFAIL, "writev() failed to fail");
            fail = 1;
        }
        if (fail) {
            tst_resm(TINFO, "block 1 FAILED");
        } else {
            tst_resm(TINFO, "block 1 PASSED");
        }
        tst_resm(TINFO, "Exit block 1");

//block2:
        /* This testcases doesn't look like what it intent to do
         * 1. it is not using the wr_iovec initialized
         * 2. read() and following message is not consistent
         */
        tst_resm(TINFO, "Enter block 2");
        fail = 0;

        if (l_seek(fd[0], CHUNK * 6, 0) < 0) {
            TEST_ERROR_LOG(errno);
            tst_resm(TBROK, "block2: 1st lseek failed");
            fail = 1;
        }

        if ((ret = writev(fd[0], (wr_iovec + 6), 3)) == CHUNK) {
            if (l_seek(fd[0], CHUNK * 6, 0) < 0) {
                TEST_ERROR_LOG(errno);
                tst_resm(TFAIL, "block2: 2nd lseek failed");
                fail = 1;
            }
            if ((nbytes = read(fd[0], buf_list[0], CHUNK)) != CHUNK) {
                perror("read error");
                tst_resm(TFAIL, "expected nbytes = 1024, "
                         "got = %d", nbytes);
                fail = 1;
            } else if (memcmp((buf_list[0] + CHUNK * 6),
                              (buf_list[2] + CHUNK * 6),
                              CHUNK) != 0) {
                tst_resm(TFAIL, "Error: writev() over "
                         "wrote %s", f_name);
                fail = 1;
            }
        } else {
            tst_resm(TFAIL, "writev() failed unexpectedly");
            fail = 1;
        }
        if (fail) {
            tst_resm(TINFO, "block 2 FAILED");
        } else {
            tst_resm(TINFO, "block 2 PASSED");
        }
        tst_resm(TINFO, "Exit block 2");

//block3: /* given 1 bad vector buffer with good ones, writev() success */
        tst_resm(TINFO, "Enter block 3");
        fail = 0;

        if (lseek(fd[0], CHUNK * 6, 0) < 0) {
            TEST_ERROR_LOG(errno);
            tst_resm(TFAIL, "block3: 1st lseek failed");
            fail = 1;
        }
        if ((nbytes = writev(fd[0], (wr_iovec + 6), 3)) < 0) {
            TEST_ERROR_LOG(errno);
            if (errno == EFAULT) {
                tst_resm(TFAIL, "Got EFAULT");
                fail = 1;
            }
        }
        if (l_seek(fd[0], 0, 0) < 0) {
            TEST_ERROR_LOG(errno);
            tst_resm(TFAIL, "block3: 2nd lseek failed");
            fail = 1;
        }
        if ((nbytes = read(fd[0], buf_list[0], K_1)) != K_1) {
            perror("read error");
            tst_resm(TFAIL, "expected nbytes = 1024, got = %d",
                     nbytes);
            fail = 1;
        } else if (memcmp((buf_list[0] + CHUNK * 6),
                          (buf_list[2] + CHUNK * 6), CHUNK * 3) != 0) {
            tst_resm(TFAIL, "Error: writev() over wrote %s",
                     f_name);
            fail = 1;
        }

        if (fail) {
            tst_resm(TINFO, "block 3 FAILED");
        } else {
            tst_resm(TINFO, "block 3 PASSED");
        }
        tst_resm(TINFO, "Exit block 3");

//block4: /* given bad file discriptor, writev() return EBADF. */
        tst_resm(TINFO, "Enter block 4");
        fail = 0;

        TEST(writev(fd[1], (wr_iovec + 9), 1));
        if (TEST_RETURN < 0) {
            TEST_ERROR_LOG(TEST_ERRNO);
            if (TEST_ERRNO == EBADF) {
                tst_resm(TINFO, "Received EBADF as expected");
            } else {
                tst_resm(TFAIL, "expected errno = EBADF, "
                         "got %d", TEST_ERRNO);
                fail = 1;
            }
        } else {
            tst_resm(TFAIL, "Error: writev() returned a "
                     "positive value");
            fail = 1;
        }

        if (fail) {
            tst_resm(TINFO, "block 4 FAILED");
        } else {
            tst_resm(TINFO, "block 4 PASSED");
        }
        tst_resm(TINFO, "Exit block 4");

//block5: /* given invalid vector count, writev() return EINVAL */
        tst_resm(TINFO, "Enter block 5");
        fail = 0;

        TEST(writev(fd[0], (wr_iovec + 10), -1));
        if (TEST_RETURN < 0) {
            TEST_ERROR_LOG(TEST_ERRNO);
            if (TEST_ERRNO == EINVAL) {
                tst_resm(TINFO, "Received EINVAL as expected");
            } else {
                tst_resm(TFAIL, "expected errno = EINVAL, "
                         "got %d", TEST_ERRNO);
                fail = 1;
            }
        } else {
            tst_resm(TFAIL, "Error: writev() returned a "
                     "positive value");
            fail = 1;
        }

        if (fail) {
            tst_resm(TINFO, "block 5 FAILED");
        } else {
            tst_resm(TINFO, "block 5 PASSED");
        }
        tst_resm(TINFO, "Exit block 5");

//block6: /* given no buffer vector, writev() success */
        tst_resm(TINFO, "Enter block 6");
        fail = 0;

        TEST(writev(fd[0], (wr_iovec + 11), 0));
        if (TEST_RETURN < 0) {
            TEST_ERROR_LOG(TEST_ERRNO);
            tst_resm(TFAIL, "writev() failed with unexpected errno "
                     "%d", TEST_ERRNO);
            fail = 1;
        } else {
            tst_resm(TPASS, "writev() wrote 0 iovectors");
        }

        if (fail) {
            tst_resm(TINFO, "block 6 FAILED");
        } else {
            tst_resm(TINFO, "block 6 PASSED");
        }
        tst_resm(TINFO, "Exit block 6");

//block7:
        /* given 4 vectors, 2 are NULL, 1 with 0 length and 1 with fixed length,
         * writev() success writing fixed length.
         */
        tst_resm(TINFO, "Enter block 7");
        fail = 0;

        l_seek(fd[0], CHUNK * 12, 0);
        if ((ret = writev(fd[0], (wr_iovec + 12), 4)) != CHUNK) {
            tst_resm(TFAIL, "writev() failed writing %d bytes, "
                     "followed by two NULL vectors", CHUNK);
            fail = 1;
        } else {
            tst_resm(TPASS, "writev passed writing %d bytes, "
                     "followed by two NULL vectors", CHUNK);
        }

        if (fail) {
            tst_resm(TINFO, "block 7 FAILED");
        } else {
            tst_resm(TINFO, "block 7 PASSED");
        }
        tst_resm(TINFO, "Exit block 7");

//block8: /* try to write to a closed pipe, writev() return EPIPE. */
        tst_resm(TINFO, "Enter block 8");
        fail = 0;

        if (pipe(pfd) < 0) {
            TEST_ERROR_LOG(errno);
            perror("pipe");
            tst_resm(TFAIL, "pipe failed: errno = %d", errno);
            fail = 1;
        } else {
            if (close(pfd[0]) < 0) {
                TEST_ERROR_LOG(errno);
                perror("close");
                tst_resm(TFAIL, "close failed: errno = %d",
                         errno);
                fail = 1;
            } else if ((writev(pfd[1], (wr_iovec + 12), 1)
                        < 0) && in_sighandler) {
                TEST_ERROR_LOG(errno);
                if (errno == EPIPE) {
                    tst_resm(TINFO, "Received EPIPE as "
                             "expected");
                } else {
                    tst_resm(TFAIL, "expected errno = "
                             "EPIPE, got %d", errno);
                    fail = 1;
                }
            } else {
                tst_resm(TFAIL, "Error: writev() returned a "
                         "positive value");
                fail = 1;
            }
        }
        if (fail) {
            tst_resm(TINFO, "block 8 FAILED");
        } else {
            tst_resm(TINFO, "block 8 PASSED");
        }
        tst_resm(TINFO, "Exit block 8");
    }
    close(fd[0]);
    close(fd[1]);
    cleanup();
    /*NOTREACHED*/ return 0;
}
Example #2
0
int main(int ac, char **av)
{
    int lc;
    const char *msg;
    int val;		/* value for SETVAL */

    int i;

    if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
        tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

    setup();		/* global setup */

    /* The following loop checks looping state if -i option given */

    for (lc = 0; TEST_LOOPING(lc); lc++) {
        /* reset tst_count in case we are looping */
        tst_count = 0;

        val = 1;
        for (i = 0; i < TST_TOTAL; i++) {

            /* initialize the s_buf buffer */
            s_buf.sem_op = TC[i].op;
            s_buf.sem_flg = TC[i].flg;
            s_buf.sem_num = TC[i].num;

            /* initialize all the primitive semaphores */
            TC[i].get_arr.val = val--;
            if (semctl(sem_id_1, TC[i].num, SETVAL, TC[i].get_arr)
                    == -1) {
                tst_brkm(TBROK, cleanup, "semctl() failed");
            }

            /*
             * make the call with the TEST macro
             */

            TEST(semop(sem_id_1, &s_buf, 1));

            if (TEST_RETURN != -1) {
                tst_resm(TFAIL, "call succeeded unexpectedly");
                continue;
            }

            TEST_ERROR_LOG(TEST_ERRNO);

            if (TEST_ERRNO == TC[i].error) {
                tst_resm(TPASS,
                         "expected failure - errno = %d"
                         " : %s", TEST_ERRNO,
                         strerror(TEST_ERRNO));
            } else {
                tst_resm(TFAIL, "unexpected error - "
                         "%d : %s", TEST_ERRNO,
                         strerror(TEST_ERRNO));
            }
        }
    }

    cleanup();

    tst_exit();
}
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */

	int exec_return;	/* return from do_exec */
	int **tcp;		/* testcase pointer (pointer to FD) */
	char **tcd;		/* testcase description pointer */

    /***************************************************************
     * parse standard options, and exit if there is an error
     ***************************************************************/
	if ((msg = parse_opts(ac, av, options, &help)) != (char *)NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	}

	if (fflag)		/* -F option */
		File1 = fopt;

	if (Tflag) {		/* -T option */
		exit(test_open(Topt));
	}

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
	setup(av[0]);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		/* reset Tst_count in case we are looping. */
		Tst_count = 0;

		for (tcp = testfds, tcd = testfdtypes; *tcp; tcp++, tcd++) {

			TEST(fcntl(**tcp, F_SETFD, FD_CLOEXEC));

			/* check return code */
			if (TEST_RETURN == -1) {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TFAIL,
					 "fcntl(%s[%d], F_SETFD, FD_CLOEXEC) Failed, errno=%d : %s",
					 *tcd, **tcp, TEST_ERRNO,
					 strerror(TEST_ERRNO));
			} else {

		/*************************************************************
		 * only perform functional verification if flag set
		 * (-f not given)
		 *************************************************************/
				if (STD_FUNCTIONAL_TEST) {

					exec_return =
					    do_exec(subprog_path, **tcp, *tcd);

					switch (exec_return) {
					case -1:
						tst_resm(TBROK,
							 "fork failed.  Errno %s [%d]",
							 strerror(errno),
							 errno);
						break;
					case 1:
						tst_resm(TBROK,
							 "waitpid return was 0%o",
							 stat_loc);
						break;
					case 2:
						tst_resm(TBROK, "exec failed");	/* errno was in child */
						break;
					case 0:
						tst_resm(TPASS,
							 "%s child exited 0, indicating that the file was closed",
							 *tcd);
						break;
					default:
						tst_resm(TFAIL,
							 "%s child exited non-zero, %d",
							 *tcd, exec_return);
						break;
					}
				}
			}
		}
	}			/* End for TEST_LOOPING */

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();

	return 0;
}				/* End main */
Example #4
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	int i;

       /* Disable test if the version of the kernel is less than 2.6.16 */
        if((tst_kvercmp(2,6,16)) < 0)
          {
             tst_resm(TWARN, "This test can only run on kernels that are ");
             tst_resm(TWARN, "2.6.16 and higher");
             exit(0);
          }

	/***************************************************************
	 * parse standard options
	 ***************************************************************/
	if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL)
		tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);

	/***************************************************************
	 * perform global setup for test
	 ***************************************************************/
	setup();

	/***************************************************************
	 * check looping state if -c option given
	 ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		setup_every_copy();

		/* reset Tst_count in case we are looping. */
		Tst_count = 0;

		/* 
		 * Call fchmodat 
		 */
		for (i = 0; i < TST_TOTAL; i++) {
			TEST(myfchmodat(fds[i], filenames[i], 0600));

			/* check return code */
			if (TEST_ERRNO == expected_errno[i]) {

				/***************************************************************
				 * only perform functional verification if flag set (-f not given)
				 ***************************************************************/
				if (STD_FUNCTIONAL_TEST) {
					/* No Verification test, yet... */
					tst_resm(TPASS,
						 "fchmodat() returned the expected  errno %d: %s",
						 TEST_ERRNO,
						 strerror(TEST_ERRNO));
				}
			} else {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TFAIL,
					 "fchmodat() Failed, errno=%d : %s",
					 TEST_ERRNO, strerror(TEST_ERRNO));
			}
		}

	}			/* End for TEST_LOOPING */

	/***************************************************************
	 * cleanup and exit
	 ***************************************************************/
	cleanup();

	return (0);
}				/* End main */
Example #5
0
/*
 * do_master_child()
 */
void do_master_child()
{
	int lc;
	int pid;
	int status;

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		int tst_fd;

		/* Reset tst_count in case we are looping */
		tst_count = 0;

		if (setresuid(0, ltpuser->pw_uid, 0) == -1) {
			perror("setfsuid failed");
			exit(1);
		}

		/* Test 1: Check the process with new uid cannot open the file
		 *         with RDWR permissions.
		 */
		TEST(tst_fd = open(testfile, O_RDWR));

		if (TEST_RETURN != -1) {
			printf("open succeeded unexpectedly\n");
			close(tst_fd);
			exit(1);
		}

		if (TEST_ERRNO == EACCES) {
			printf("open failed with EACCES as expected\n");
		} else {
			perror("open failed unexpectedly");
			exit(1);
		}

		/* Test 2: Check a son process cannot open the file
		 *         with RDWR permissions.
		 */
		pid = FORK_OR_VFORK();
		if (pid < 0)
			tst_brkm(TBROK, cleanup, "Fork failed");

		if (pid == 0) {
			int tst_fd2;

			/* Test to open the file in son process */
			TEST(tst_fd2 = open(testfile, O_RDWR));

			if (TEST_RETURN != -1) {
				printf("call succeeded unexpectedly\n");
				close(tst_fd2);
				exit(1);
			}

			TEST_ERROR_LOG(TEST_ERRNO);

			if (TEST_ERRNO == EACCES) {
				printf("open failed with EACCES as expected\n");
				exit(0);
			} else {
				printf("open failed unexpectedly\n");
				exit(1);
			}
		} else {
			/* Wait for son completion */
			if (waitpid(pid, &status, 0) == -1) {
				perror("waitpid failed");
				exit(1);
			}
			if (!WIFEXITED(status) || (WEXITSTATUS(status) != 0))
				exit(WEXITSTATUS(status));
		}

		/* Test 3: Fallback to initial uid and check we can again open
		 *         the file with RDWR permissions.
		 */
		tst_count++;
		if (setresuid(0, 0, 0) == -1) {
			perror("setfsuid failed");
			exit(1);
		}

		TEST(tst_fd = open(testfile, O_RDWR));

		if (TEST_RETURN == -1) {
			perror("open failed unexpectedly");
			exit(1);
		} else {
			printf("open call succeeded\n");
			close(tst_fd);
		}
	}
	exit(0);
}
Example #6
0
/***********************************************************************
 * Main
 ***********************************************************************/
int
main(int ac, char **av)
{
    int lc;		/* loop counter */
    const char *msg;		/* message returned from parse_opts */
    struct stat fbuf, lbuf;
    int cnt;
    int nlinks;
    char lname[255];

    Tst_nobuf=1;

    /***************************************************************
     * parse standard options
     ***************************************************************/
    if ( (msg=parse_opts(ac, av, options, &help)) != (char *) NULL ) {
	tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	tst_exit();
    }

    if ( Nflag ) {
	if (sscanf(Nlinkarg, "%i", &Nlinks) != 1 ) {
	    tst_brkm(TBROK, NULL, "--N option arg is not a number");
	    tst_exit();
	}
	if ( Nlinks > 1000 ) {
	    tst_resm(TWARN, "--N option arg > 1000 - may get errno:%d (EMLINK)",
		EMLINK);
	}
    }

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
    setup();

    /* set the expected errnos... */
    TEST_EXP_ENOS(exp_enos);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
    for (lc=0; TEST_LOOPING(lc); lc++) {

	/* reset Tst_count in case we are looping. */
	Tst_count=0;

	if ( Nlinks )
	    nlinks = Nlinks;
	else
	    /* min of 10 links and max of a 100 links */
	    nlinks = (lc%90)+10;

	for(cnt=1; cnt < nlinks; cnt++) {
	
	    sprintf(lname, "%s%d", Basename, cnt);
            /*
	     *  Call link(2)
	     */
	    TEST(link(Fname, lname));
	
	    /* check return code */
	    if ( TEST_RETURN == -1 ) {
	        TEST_ERROR_LOG(TEST_ERRNO);
	        tst_brkm(TFAIL, cleanup, "link(%s, %s) Failed, errno=%d : %s",
		     Fname, lname, TEST_ERRNO, strerror(TEST_ERRNO));
	    } 
	}
	    
	/***************************************************************
	 * only perform functional verification if flag set (-f not given)
	 ***************************************************************/
	if ( STD_FUNCTIONAL_TEST ) {
	    stat(Fname, &fbuf);

	    for(cnt=1; cnt < nlinks; cnt++) {
                sprintf(lname, "%s%d", Basename, cnt);

		stat(lname, &lbuf);
		if ( fbuf.st_nlink <= 1 || lbuf.st_nlink <= 1 ||
			(fbuf.st_nlink != lbuf.st_nlink) ) {

		    tst_resm(TFAIL,
			"link(%s, %s[1-%d]) ret %d for %d files, stat values do not match %d %d",
			Fname, Basename, nlinks, TEST_RETURN, nlinks,
			fbuf.st_nlink, lbuf.st_nlink);
		    break;
		}
	    }
	    if ( cnt >= nlinks ) {
		tst_resm(TPASS,
		    "link(%s, %s[1-%d]) ret %d for %d files, stat linkcounts match %d",
		    Fname, Basename, nlinks, TEST_RETURN, nlinks,
		    fbuf.st_nlink);
	    }
	} 
	else
	    Tst_count++;

	for(cnt=1; cnt < nlinks; cnt++) {
        
            sprintf(lname, "%s%d", Basename, cnt);

	    if (unlink(lname) == -1) {
		tst_res(TWARN, "unlink(%s) Failed, errno=%d : %s",
			Fname, errno, strerror(errno));
	    }
	}

    }	/* End for TEST_LOOPING */

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
    cleanup();

    return 0;
}	/* End main */
Example #7
0
int main(int ac, char **av)
{
	struct stat stat_buf;	/* stat(2) struct contents */
	int lc, i;		/* loop counter */
	char *msg;		/* message returned from parse_opts */
	off_t file_length2;	/* test file length */
	off_t file_length1;	/* test file length */
	int rbytes;		/* bytes read from testfile */
	int read_len = 0;	/* total no. of bytes read from testfile */
	int err_flag = 0;	/* error indicator flag */

	/* Parse standard options given to run the test. */
	msg = parse_opts(ac, av, (option_t *) NULL, NULL);
	if (msg != (char *)NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	}

	/* Perform global setup for test */
	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	/* Check looping state if -i option given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* Reset Tst_count in case we are looping. */
		Tst_count = 0;

		/*
		 * Call truncate(2) to truncate a test file to a
		 * specified length (TRUNC_LEN1).
		 */
		TEST(truncate(TESTFILE, TRUNC_LEN1));

		/* check return code of truncate(2) */
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL,
				 "truncate(%s, %d) Failed, errno=%d : %s",
				 TESTFILE, TRUNC_LEN1, TEST_ERRNO,
				 strerror(TEST_ERRNO));
		} else {
			/*
			 * Perform functional verification if test
			 * executed without (-f) option.
			 */
			if (STD_FUNCTIONAL_TEST) {
				/*
				 * Get the testfile information using
				 * stat(2).
				 */
				if (stat(TESTFILE, &stat_buf) < 0) {
					tst_brkm(TFAIL, cleanup, "stat(2) of "
						 "%s failed after 1st truncate, "
						 "error:%d", TESTFILE, errno);
				 /*NOTREACHED*/}
				file_length1 = stat_buf.st_size;

				/*
				 * Set the file pointer of testfile to the
				 * beginning of the file.
				 */
				if (lseek(fd, 0, SEEK_SET) < 0) {
					tst_brkm(TFAIL, cleanup, "lseek(2) on "
						 "%s failed after 1st truncate, "
						 "error:%d", TESTFILE, errno);
				 /*NOTREACHED*/}

				/* Read the testfile from the beginning. */
				while ((rbytes = read(fd, tst_buff,
						      sizeof(tst_buff))) > 0) {
					read_len += rbytes;
				}

				/*
				 * Execute truncate(2) again to truncate
				 * testfile to a size TRUNC_LEN2.
				 */
				TEST(truncate(TESTFILE, TRUNC_LEN2));

				/* check return code of truncate(2) */
				if (TEST_RETURN == -1) {
					TEST_ERROR_LOG(TEST_ERRNO);
					tst_resm(TFAIL, "truncate of %s to "
						 "size %d Failed, errno=%d : %s",
						 TESTFILE, TRUNC_LEN2,
						 TEST_ERRNO,
						 strerror(TEST_ERRNO));
				}

				/*
				 * Get the testfile information using
				 * stat(2)
				 */
				if (stat(TESTFILE, &stat_buf) < 0) {
					tst_brkm(TFAIL, cleanup, "stat(2) of "
						 "%s failed after 2nd truncate, "
						 "error:%d", TESTFILE, errno);
				 /*NOTREACHED*/}
				file_length2 = stat_buf.st_size;

				/*
				 * Set the file pointer of testfile to the
				 * offset TRUNC_LEN1 of testfile.
				 */
				if (lseek(fd, TRUNC_LEN1, SEEK_SET) < 0) {
					tst_brkm(TFAIL, cleanup, "lseek(2) on "
						 "%s failed after 2nd truncate, "
						 "error:%d", TESTFILE, errno);
				 /*NOTREACHED*/}

				/* Read the testfile contents till EOF */
				while ((rbytes = read(fd, tst_buff,
						      sizeof(tst_buff))) > 0) {
					for (i = 0; i < rbytes; i++) {
						if (tst_buff[i] != 0) {
							err_flag++;
						}
					}
				}

				/*
				 * Check for expected size of testfile after
				 * issuing truncate(2) on it.
				 */
				if ((file_length1 != TRUNC_LEN1) ||
				    (file_length2 != TRUNC_LEN2) ||
				    (read_len != TRUNC_LEN1) ||
				    (err_flag != 0)) {
					tst_resm(TFAIL, "Functionality of "
						 "truncate(2) on %s Failed",
						 TESTFILE);
				} else {
					tst_resm(TPASS,
						 "Functionality of truncate(2) "
						 "on %s successful", TESTFILE);
				}
			} else {
				tst_resm(TPASS, "%s call succeeded", TCID);
			}
		}
		Tst_count++;	/* incr. TEST_LOOP counter */
	}			/* End for TEST_LOOPING */

	/* Call cleanup() to undo setup done for the test. */
	cleanup();
	 /*NOTREACHED*/ return 0;

}				/* End main */
Example #8
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	int count, rval, fd;
	size_t size = 0;
	char *dir_name = NULL;
	struct dirent *dirp;
	struct stat *sbuf;
	char *newfile;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		Tst_count = 0;

		if ((dir_name = getcwd(dir_name, size)) == NULL)
			tst_brkm(TBROK, cleanup, "Can not get current "
				 "directory name");

		if ((dirp = malloc(sizeof(struct dirent))) == NULL)
			tst_brkm(TBROK, cleanup, "malloc failed");

		count = (int)sizeof(struct dirent);

		/* set up some space for a file name */
		if ((newfile = malloc(sizeof(char) * 20)) == NULL)
			tst_brkm(TBROK, cleanup, "newfile malloc failed");

		if ((rval = sprintf(newfile, "getdents03.%d", getpid())) < 0)
			tst_brkm(TBROK, cleanup, "sprintf failed");

		if ((fd = open(newfile, O_CREAT | O_RDWR, 0777)) == -1)
			tst_brkm(TBROK|TERRNO, cleanup, "open of file failed");

		/* set up some space for the stat buffer */
		if ((sbuf = malloc(sizeof(struct stat))) == NULL)
			tst_brkm(TBROK, cleanup, "stat malloc failed");

		/* make sure fd is not a directory */
		if ((rval = fstat(fd, sbuf)) == -1)
			tst_brkm(TBROK, cleanup, "fstat failed");

		if (S_ISDIR(sbuf->st_mode))
			tst_brkm(TBROK, cleanup, "fd is a directory");

		rval = getdents(fd, dirp, count);

		/*
		 * Calling with a non directory file descriptor should give
		 * an ENOTDIR error.
		 */

		if (rval < 0) {
			TEST_ERROR_LOG(errno);

			switch (errno) {
			case ENOTDIR:
				tst_resm(TPASS,
				    "getdents failed as expected with ENOTDIR");
				break;
			default:
				tst_resm(TFAIL|TERRNO,
				    "getdents failed unexpectedly");
				break;
			}
		} else
			tst_resm(TFAIL, "getdents call succeeded unexpectedly");

		free(dir_name);
		dir_name = NULL;

		free(dirp);

		if ((rval = close(fd)) == -1)
			tst_brkm(TBROK, cleanup, "fd close failed");
		if ((rval = unlink(newfile)) == -1)
			tst_brkm(TBROK, cleanup, "file unlink failed");
	}

	cleanup();

	tst_exit();
}
Example #9
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	int fails;
	int kid_status, wait_status;

	msg = parse_opts(ac, av, NULL, NULL);
	if (msg != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		Tst_count = 0;
		fails = 0;

		TEST(fork());
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			if (STD_FUNCTIONAL_TEST) {
				tst_resm(TFAIL, "fork() Failed, errno=%d : %s",
					 TEST_ERRNO, strerror(TEST_ERRNO));
				tst_resm(TBROK, "unable to continue");
			}
		}
		if (TEST_RETURN == 0) {
			/* child */
			if (STD_FUNCTIONAL_TEST)
				child_pid();
			exit(KIDEXIT);
		} else {
			/* parent */
			if (STD_FUNCTIONAL_TEST) {
				tst_resm(TPASS, "fork() returned %ld",
					 TEST_RETURN);
			}
			/* wait for the child to complete */
			wait_status = waitpid(TEST_RETURN, &kid_status, 0);
			if (STD_FUNCTIONAL_TEST) {
				if (wait_status == TEST_RETURN) {
					if (kid_status != KIDEXIT << 8) {
						tst_resm(TBROK,
							 "incorrect child status returned on wait(): %d",
							 kid_status);
						fails++;
					}
				} else {
					tst_resm(TBROK,
						 "wait() for child status failed with %d errno: %d : %s",
						 wait_status, errno,
						 strerror(errno));
					fails++;
				}
				if (fails == 0) {
					/* verification tests */
					parent_pid();
				}
			}	/* STD_FUNCTIONAL_TEST */
		}		/* TEST_RETURN */
	}

	cleanup();
	tst_exit();
}
Example #10
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */

    /***************************************************************
     * parse standard options
     ***************************************************************/
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
	setup();

	/*
	 * check if the current filesystem is nfs
	 */
	if (tst_is_cwd_nfs()) {
		tst_brkm(TCONF, cleanup,
			 "Cannot do fcntl on a file located on an NFS filesystem");
	}

	/*
	 * check if the current filesystem is tmpfs
	 */
	if (tst_is_cwd_tmpfs()) {
		tst_brkm(TCONF, cleanup,
			 "Cannot do fcntl on a file located on an TMPFS filesystem");
	}

	/*
	 * check if the current filesystem is ramfs
	 */
	if (tst_is_cwd_ramfs()) {
		tst_brkm(TCONF, cleanup,
			 "Cannot do fcntl on a file located on an RAMFS filesystem");
	}

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		Tst_count = 0;

#ifdef F_SETLEASE
		/*
		 * Call fcntl(2) with F_SETLEASE & F_WRLCK argument on fname
		 */
		TEST(fcntl(fd, F_SETLEASE, F_WRLCK));

		/* check return code */
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL,
				 "fcntl(%s, F_SETLEASE, F_WRLCK) Failed, errno=%d : %s",
				 fname, TEST_ERRNO, strerror(TEST_ERRNO));
		} else {
			if (STD_FUNCTIONAL_TEST) {
				TEST(fcntl(fd, F_GETLEASE));
				if (TEST_RETURN != F_WRLCK)
					tst_resm(TFAIL,
						 "fcntl(%s, F_GETLEASE) did not return F_WRLCK, returned %ld",
						 fname, TEST_RETURN);
				else {
					TEST(fcntl(fd, F_SETLEASE, F_UNLCK));
					if (TEST_RETURN != 0)
						tst_resm(TFAIL,
							 "fcntl(%s, F_SETLEASE, F_UNLCK) did not return 0, returned %ld",
							 fname, TEST_RETURN);
					else
						tst_resm(TPASS,
							 "fcntl(%s, F_SETLEASE, F_WRLCK)",
							 fname);
				}
			}
		}
#else
		tst_resm(TINFO, "F_SETLEASE not defined, skipping test");
#endif
	}

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();
	tst_exit();

}
Example #11
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	pid_t pid, pid1;
	int retval = 3, status;
	char *argv[1], *env[1];

	if ((msg = parse_opts(ac, av, options, &help)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
#ifdef UCLINUX
	maybe_run_child(&do_child_1, "nS", 1, &test_app);
#endif

	if (!Fflag)
		tst_brkm(TBROK, NULL,
		    "You must specify an executable file with the -F option.");

	setup(*av);

	TEST_EXP_ENOS(exp_enos);

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		Tst_count = 0;

		if (sync_pipe_create(start_sync_pipes, PIPE_NAME_START) == -1)
			tst_brkm(TBROK, cleanup, "sync_pipe_create failed");
		if (sync_pipe_create(end_sync_pipes, PIPE_NAME_END) == -1)
			tst_brkm(TBROK, cleanup, "sync_pipe_create failed");

		/*
		 * to test whether execve(2) sets ETXTBSY when a second
		 * child process attempts to execve the executable opened
		 * by the first child process
		 */
		if ((pid = FORK_OR_VFORK()) == -1)
			tst_brkm(TBROK, cleanup, "fork #1 failed");
		else if (pid == 0) {
#ifdef UCLINUX
			if (self_exec(av[0], "nS", 1, test_app) < 0)
				tst_brkm(TBROK, cleanup, "self_exec failed");
#else
			do_child_1();
#endif
		}

		if (sync_pipe_wait(start_sync_pipes) == -1)
			tst_brkm(TBROK, cleanup, "sync_pipe_wait failed");

		if (sync_pipe_close(start_sync_pipes, PIPE_NAME_START) == -1)
			tst_brkm(TBROK, cleanup, "sync_pipe_close failed");

		if ((pid1 = FORK_OR_VFORK()) == -1)
			tst_brkm(TBROK, cleanup, "fork #2 failed");

		if (pid1 == 0) {

			retval = 3;

			argv[0] = 0;
			env[0] = 0;

			/* do not interfere with end synchronization of first
			 * child */
			sync_pipe_close(end_sync_pipes, PIPE_NAME_END);

			TEST(execve(test_app, argv, env));

			TEST_ERROR_LOG(TEST_ERRNO);

			if (TEST_ERRNO != ETXTBSY) {
				retval = 1;
				perror("didn't get ETXTBSY\n");
			} else
				printf("execve failed with ETXTBSY as "
				    "expected\n");
			exit(retval);
		}
		/* wait for the child to finish */
		if (waitpid(pid1, &status, 0) == -1)
			tst_brkm(TBROK|TERRNO, cleanup, "waitpid failed");
		if (WIFEXITED(status) && WEXITSTATUS(status) == 3)
			tst_resm(TPASS, "execve failed as expected");
		else
			tst_resm(TFAIL, "execve succeeded, expected failure");

		/*  terminate first child */
		sync_pipe_notify(end_sync_pipes);
		(void) waitpid(pid, NULL, 0);
	}
	cleanup();

	tst_exit();
}
Example #12
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	pid_t pid, fake_pid;
	int exno, status, fake_status, nsig;

	/* parse standard options */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	}
#ifdef UCLINUX
	maybe_run_child(&do_child, "");
#endif

	setup();		/* global setup */

	TEST_EXP_ENOS(exp_enos);

	/* The following loop checks looping state if -i option given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		/* reset Tst_count in case we are looping */
		Tst_count = 0;
		status = 1;
		exno = 1;
		pid = FORK_OR_VFORK();
		if (pid < 0) {
			tst_brkm(TBROK, cleanup, "Fork failed");
		} else if (pid == 0) {
#ifdef UCLINUX
			if (self_exec(av[0], "") < 0) {
				tst_brkm(TBROK, cleanup,
					 "self_exec of child failed");
			}
#else
			do_child();
#endif
		} else {
			fake_pid = FORK_OR_VFORK();
			if (fake_pid < 0) {
				tst_brkm(TBROK, cleanup, "Second fork failed");
			} else if (fake_pid == 0) {
#ifdef UCLINUX
				if (self_exec(av[0], "") < 0) {
					tst_brkm(TBROK, cleanup,
						 "second self_exec "
						 "of child failed");
				}
#else
				do_child();
#endif
			}
			kill(fake_pid, TEST_SIG);
			waitpid(fake_pid, &fake_status, 0);
			TEST(kill(fake_pid, TEST_SIG));
			kill(pid, TEST_SIG);
			waitpid(pid, &status, 0);
		}

		if (TEST_RETURN != -1) {
			tst_brkm(TFAIL, cleanup, "%s failed - errno = %d : %s "
				 "Expected a return value of -1 got %ld",
				 TCID, TEST_ERRNO, strerror(TEST_ERRNO),
				 TEST_RETURN);
		 }

		if (STD_FUNCTIONAL_TEST) {
			/*
			 * Check to see if the errno was set to the expected
			 * value of 3 : ESRCH
			 */
			nsig = WTERMSIG(status);
			TEST_ERROR_LOG(TEST_ERRNO);
			if (TEST_ERRNO == ESRCH) {
				tst_resm(TPASS, "errno set to %d : %s, as "
					 "expected", TEST_ERRNO,
					 strerror(TEST_ERRNO));
			} else {
				tst_resm(TFAIL, "errno set to %d : %s expected "
					 "%d : %s", TEST_ERRNO,
					 strerror(TEST_ERRNO), 3, strerror(3));
			}
		}
	}
	cleanup();

	tst_exit();
}
Example #13
0
File: fcntl10.c Project: sozong/ltp
int main(int ac, char **av)
{
	int lc;
	const char *msg;

    /***************************************************************
     * parse standard options
     ***************************************************************/
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		int type;
		for (type = 0; type < 2; type++) {

			tst_count = 0;

			flocks.l_type = type ? F_RDLCK : F_WRLCK;

			/*
			 * Call fcntl(2) with F_SETLKW flocks.l_type = F_UNLCK argument on fname
			 */
			TEST(fcntl(fd, F_SETLKW, &flocks));

			/* check return code */
			if (TEST_RETURN == -1) {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TFAIL,
					 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = %s Failed, errno=%d : %s",
					 fname, type ? "F_RDLCK" : "F_WRLCK",
					 TEST_ERRNO, strerror(TEST_ERRNO));
			} else {

	    /***************************************************************
	     * only perform functional verification if flag set (-f not given)
	     ***************************************************************/
				if (STD_FUNCTIONAL_TEST) {
					/* No Verification test, yet... */
					tst_resm(TPASS,
						 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = %s returned %ld",
						 fname,
						 type ? "F_RDLCK" : "F_WRLCK",
						 TEST_RETURN);
				}
			}

			flocks.l_type = F_UNLCK;
			/*
			 * Call fcntl(2) with F_SETLKW flocks.l_type = F_UNLCK argument on fname
			 */
			TEST(fcntl(fd, F_SETLKW, &flocks));

			/* check return code */
			if (TEST_RETURN == -1) {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TFAIL,
					 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = F_UNLCK Failed, errno=%d : %s",
					 fname, TEST_ERRNO,
					 strerror(TEST_ERRNO));
			} else {

	    /***************************************************************
	     * only perform functional verification if flag set (-f not given)
	     ***************************************************************/
				if (STD_FUNCTIONAL_TEST) {
					/* No Verification test, yet... */
					tst_resm(TPASS,
						 "fcntl(%s, F_SETLKW, &flocks) flocks.l_type = F_UNLCK returned %ld",
						 fname, TEST_RETURN);
				}
			}

		}
	}

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();
	tst_exit();

}
Example #14
0
int main(int ac, char **av)
{
	int lc;
	const char *msg;
	struct itimerval *value, *ovalue;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	}

	setup();		/* global setup */

	/* The following loop checks looping state if -i option given */

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* reset tst_count in case we are looping */
		tst_count = 0;

		/* allocate some space for timer structures */

		if ((value = (struct itimerval *)malloc((size_t)
							sizeof(struct
							       itimerval))) ==
		    NULL) {
			tst_brkm(TBROK, cleanup, "value malloc failed");
		}

		if ((ovalue = (struct itimerval *)malloc((size_t)
							 sizeof(struct
								itimerval))) ==
		    NULL) {
			tst_brkm(TBROK, cleanup, "value malloc failed");
		}

		/* set up some reasonable values */

		value->it_value.tv_sec = 30;
		value->it_value.tv_usec = 0;
		value->it_interval.tv_sec = 0;
		value->it_interval.tv_usec = 0;

		/*
		 * issue the system call with the TEST() macro
		 * ITIMER_REAL = 0, ITIMER_VIRTUAL = 1 and ITIMER_PROF = 2
		 */

		/* make the first value negative to get a failure */
		TEST(setitimer(-ITIMER_PROF, value, ovalue));

		if (TEST_RETURN == 0) {
			tst_resm(TFAIL, "call failed to produce expected error "
				 "- errno = %d - %s", TEST_ERRNO,
				 strerror(TEST_ERRNO));
			continue;
		}

		TEST_ERROR_LOG(TEST_ERRNO);

		switch (TEST_ERRNO) {
		case EINVAL:
			tst_resm(TPASS, "expected failure - errno = %d - %s",
				 TEST_ERRNO, strerror(TEST_ERRNO));
			break;
		default:
			tst_resm(TFAIL, "call failed to produce expected error "
				 "- errno = %d - %s", TEST_ERRNO,
				 strerror(TEST_ERRNO));
		}

		/*
		 * clean up things in case we are looping
		 */
		free(value);
		free(ovalue);
		value = NULL;
		ovalue = NULL;
	}

	cleanup();
	tst_exit();

}
Example #15
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	int rval, fd;
	int count;
	size_t size = 0;
	char *dir_name = NULL;
	struct dirent *dirp;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		Tst_count = 0;


		if ((dir_name = getcwd(dir_name, size)) == NULL)
			tst_brkm(TBROK, cleanup, "Can not get current "
				 "directory name");

		if ((dirp = malloc(sizeof(struct dirent))) == NULL)
			tst_brkm(TBROK, cleanup, "malloc failed");

		/* Set count to be very small.  The result should be EINVAL */

		count = 1;

		if ((fd = open(dir_name, O_RDONLY)) == -1)
			tst_brkm(TBROK, cleanup, "open of directory failed");

		rval = getdents(fd, dirp, count);

		/*
		 * Hopefully we get an error due to the small buffer.
		 */

		if (rval < 0) {
			TEST_ERROR_LOG(errno);

			switch (errno) {
			case EINVAL:
				tst_resm(TPASS,
				    "getdents failed with EINVAL as expected");
				break;
			default:
				tst_resm(TFAIL|TERRNO,
				    "getdents call failed unexpectedly");
				break;
			}
		} else
			tst_resm(TFAIL, "getdents passed unexpectedly");

		free(dir_name);
		dir_name = NULL;

		free(dirp);

		if ((rval = close(fd)) == -1)
			tst_brkm(TBROK, cleanup, "fd close failed");
	}

	cleanup();

	tst_exit();
}
Example #16
0
int main(int argc, char **argv)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */

	/* parse standard options */
	if ((msg = parse_opts(argc, argv, NULL, NULL)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	}

	setup();		/* set "tstdir", and "testfile" vars */

	/* The following loop checks looping state if -i option given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		/* reset Tst_count in case we are looping */
		Tst_count = 0;

		fd[1] = -1;	/* Invalid file descriptor */

		if (signal(SIGTERM, sighandler) == SIG_ERR) {
			perror("signal");
			tst_resm(TFAIL, "signal() SIGTERM FAILED");
			cleanup();

		}

		if (signal(SIGPIPE, sighandler) == SIG_ERR) {
			perror("signal");
			tst_resm(TFAIL, "signal() SIGPIPE FAILED");
			cleanup();

		}

		if ((fd[0] = open(f_name, O_WRONLY | O_CREAT, 0666)) < 0) {
			tst_resm(TFAIL, "open(2) failed: fname = %s, "
				 "errno = %d", f_name, errno);
			cleanup();

		}

		/*
		 * Iovecs passed to writev points to valid (readable) regions,
		 * so all bytes must be successfully written.
		 */
//block1:

		tst_resm(TINFO, "Enter block 1");
		fail = 0;

		TEST(writev(fd[0], wr_iovec, 2));
		if (TEST_RETURN >= 0) {
			if (TEST_RETURN == 2) {
				tst_resm(TINFO, "writev returned %d as expected", 2);
			} else {
				tst_resm(TFAIL, "Expected nbytes = %d, got "
					 "%ld", 2, TEST_RETURN);
				fail = 1;
			}
		} else {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL|TTERRNO, "Error writev return value = %ld",
				 TEST_RETURN);
			fail = 1;
		}
		if (fail) {
			tst_resm(TINFO, "block 1 FAILED");
		} else {
			tst_resm(TINFO, "block 1 PASSED");
		}
		tst_resm(TINFO, "Exit block 1");
	}
	cleanup();
	tst_exit();

}
Example #17
0
int main(int ac, char **av)
{
	int lc;
	char *msg;
	pid_t cpid;		/* process id of the child process */
	int exit_status;	/* exit status of child process */
	sigset_t PendSig;	/* variable to hold pending signal */

	msg = parse_opts(ac, av, NULL, NULL);
	if (msg != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	}

	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		/*
		 * Call vfork(2) to create a child process without
		 * fully copying the address space of parent.
		 */
		TEST(vfork());

		if ((cpid = TEST_RETURN) == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL, "vfork() Failed, errno=%d : %s",
				 TEST_ERRNO, strerror(TEST_ERRNO));
		} else if (cpid == 0) {	/* Child process */
			/*
			 * Perform functional verification if test
			 * executed without (-f) option.
			 */
			if (STD_FUNCTIONAL_TEST) {
				/*
				 * Check whether the pending signal SIGUSR1
				 * in the parent is also pending in the child
				 * process by storing it in a variable.
				 */
				if (sigpending(&PendSig) == -1) {
					tst_resm(TFAIL, "sigpending function "
						 "failed in child");
					_exit(1);
				}

				/* Check if SIGUSR1 is pending in child */
				if (sigismember(&PendSig, SIGUSR1) != 0) {
					tst_resm(TFAIL, "SIGUSR1 also pending "
						 "in child process");
					_exit(1);
				}

				/*
				 * Exit with normal exit code if everything
				 * fine
				 */
				_exit(0);
			}
		} else {	/* parent process */
			/*
			 * Let the parent process wait till child completes
			 * its execution.
			 */
			wait(&exit_status);

			/* Check for the exit status of child process */
			if (WEXITSTATUS(exit_status) == 0) {
				tst_resm(TPASS, "Call to vfork() "
					 "successful");
			} else if (WEXITSTATUS(exit_status) == 1) {
				tst_resm(TFAIL,
					 "Child process exited abnormally");
			}
		}
		tst_count++;	/* incr. TEST_LOOP counter */
	}

	cleanup();
	tst_exit();

}
Example #18
0
int main(int ac, char **av)
{
	int lc;
	char *msg;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		/*
		 * TEST CASE: 1
		 * mkdir() call with pointer below allocated address space.
		 */

		/* Call mkdir(2) */
		TEST(mkdir(bad_addr, 0777));

		/* check return code */
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
		}

		if (STD_FUNCTIONAL_TEST) {
			if (TEST_RETURN == -1) {
				if (TEST_ERRNO == EFAULT) {
					tst_resm(TPASS,
						 "mkdir - path argument pointing below allocated address space failed as expected with errno %d : %s",
						 TEST_ERRNO,
						 strerror(TEST_ERRNO));
				} else {
					tst_resm(TFAIL,
						 "mkdir - path argument pointing below allocated address space failed with errno %d : %s but expected %d (EFAULT)",
						 TEST_ERRNO,
						 strerror(TEST_ERRNO), EFAULT);
				}
			} else {
				tst_resm(TFAIL,
					 "mkdir - path argument pointing below allocated address space succeeded unexpectedly.");

			}
		}
#if !defined(UCLINUX)
		/*
		 * TEST CASE: 2
		 * mkdir() call with pointer above allocated address space.
		 */

		/* Call mkdir(2) */
		TEST(mkdir(get_high_address(), 0777));

		/* check return code */
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
		}

		if (STD_FUNCTIONAL_TEST) {
			if (TEST_RETURN == -1) {
				if (TEST_ERRNO == EFAULT) {
					tst_resm(TPASS,
						 "mkdir - path argument pointing above allocated address space failed as expected with errno %d : %s",
						 TEST_ERRNO,
						 strerror(TEST_ERRNO));
				} else {
					tst_resm(TFAIL,
						 "mkdir - path argument pointing above allocated address space failed with errno %d : %s but expected %d (EFAULT)",
						 TEST_ERRNO,
						 strerror(TEST_ERRNO), EFAULT);
				}
			} else {
				tst_resm(TFAIL,
					 "mkdir - path argument pointing above allocated address space succeeded unexpectedly.");

			}
		}
#endif /* if !defined(UCLINUX) */

	}

	cleanup();
	tst_exit();

}
Example #19
0
int
main(int ac, char **av)
{
    int lc;		/* loop counter */
    const char *msg;		/* message returned from parse_opts */
    
    /***************************************************************
     * parse standard options
     ***************************************************************/
    if ( (msg=parse_opts(ac, av, (option_t *)NULL, NULL)) != (char *) NULL ) {
	tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	tst_exit();
    }

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
    setup();

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
    for (lc=0; TEST_LOOPING(lc); lc++) {

	/* reset Tst_count in case we are looping. */
	Tst_count=0;
		
	/* 
	 * TEST CASE:
	 *  Set the effective user ID to the current real uid
	 */
	uid=getuid();

	/* Call setuid(2) */
	TEST(setuid(uid));
	
	/* check return code */
	if ( TEST_RETURN == -1 ) {
	    TEST_ERROR_LOG(TEST_ERRNO);
	    tst_resm(TFAIL, "setuid -  Set the effective user ID to the current real uid failed, errno=%d : %s",
		     TEST_ERRNO, strerror(TEST_ERRNO));
	} else {
	    /***************************************************************
	     * only perform functional verification if flag set (-f not given)
	     ***************************************************************/
	    if ( STD_FUNCTIONAL_TEST ) {
		/* No Verification test, yet... */
		tst_resm(TPASS, "setuid -  Set the effective user ID to the current real uid returned %d", TEST_RETURN);
	    } 
	}
	

    }	/* End for TEST_LOOPING */

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
    cleanup();

    return 0;
}	/* End main */
Example #20
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	int i;

	/*
	 * parse standard options
	 */
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
	}

	/*
	 * perform global setup for test
	 */
	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	/*
	 * check looping state if -i option given
	 */
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		Tst_count = 0;

		/* loop through the test cases */
		for (i = 0; i < TST_TOTAL; i++) {

			/* perform test specific setup if necessary */
			if (TC[i].setupfunc != NULL) {
				(*TC[i].setupfunc) ();
			}

			TEST(mkdir(TC[i].dir, TC[i].perms));

			if (TEST_RETURN != -1) {
				tst_resm(TFAIL, "call succeeded unexpectedly");
				continue;
			}

			TEST_ERROR_LOG(TEST_ERRNO);

			if (TEST_ERRNO == TC[i].error) {
				tst_resm(TPASS, "expected failure - "
					 "errno = %d : %s", TEST_ERRNO,
					 strerror(TEST_ERRNO));
			} else {
				tst_resm(TFAIL, "unexpected error - %d : %s - "
					 "expected %d", TEST_ERRNO,
					 strerror(TEST_ERRNO), TC[i].error);
			}
		}
	}

	/*
	 * cleanup and exit
	 */
	cleanup();

	tst_exit();
}
Example #21
0
int main(int ac, char **av)
{
	struct stat stat_buf;	/* stat structure buffer */
	int lc;
	char *msg;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		/*
		 * Call stat(2) to get the status of
		 * specified 'file' into stat structure.
		 */
		TEST(stat(TESTFILE, &stat_buf));

		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL,
				 "stat(%s, &stat_buf) Failed, errno=%d : %s",
				 TESTFILE, TEST_ERRNO, strerror(TEST_ERRNO));
		} else {
			/*
			 * Perform functional verification if test
			 * executed without (-f) option.
			 */
			if (STD_FUNCTIONAL_TEST) {
				stat_buf.st_mode &= ~S_IFREG;
				/*
				 * Verify the data returned by stat(2)
				 * aganist the expected data.
				 */
				if ((stat_buf.st_uid != user_id) ||
				    (stat_buf.st_gid != group_id) ||
				    (stat_buf.st_size != FILE_SIZE) ||
				    ((stat_buf.st_mode & MASK) != NEW_MODE)) {
					tst_resm(TFAIL, "Functionality of "
						 "stat(2) on '%s' Failed",
						 TESTFILE);
				} else {
					tst_resm(TPASS, "Functionality of "
						 "stat(2) on '%s' Succcessful",
						 TESTFILE);
				}
			} else {
				tst_resm(TPASS, "Call succeeded");
			}
		}
		tst_count++;	/* incr TEST_LOOP counter */
	}

	cleanup();
	tst_exit();
	tst_exit();

}
Example #22
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */

	TST_TOTAL = (sizeof(tcases) / sizeof(tcases[0]));
    /***************************************************************
     * parse standard options
     ***************************************************************/
	if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	}

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
	setup();

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		/* reset Tst_count in case we are looping. */
		Tst_count = 0;

		/*
		 * TEST CASES:
		 *  Make nodes in tcases array
		 */
		for (i = 0; i < TST_TOTAL; i++) {
			/* Call mknod(2) */
			TEST(mknod(Path, tcases[i], 0));

			/* check return code */
			if (TEST_RETURN == -1) {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TFAIL,
					 "mknod(%s, %#o, 0) failed, errno=%d : %s",
					 Path, tcases[i], TEST_ERRNO,
					 strerror(TEST_ERRNO));
			} else {
		/***************************************************************
		 * only perform functional verification if flag set (-f not given)
		 ***************************************************************/
				if (STD_FUNCTIONAL_TEST) {
					/* No Verification test, yet... */
					tst_resm(TPASS,
						 "mknod(%s, %#o, 0) returned %ld",
						 Path, tcases[i], TEST_RETURN);
				}
			}

			/* remove the node for the next go `round */
			if (unlink(Path) == -1) {
				if (rmdir(Path) == -1) {
					tst_resm(TWARN,
						 "unlink(%s) & rmdir(%s) failed, errno:%d %s",
						 Path, Path, errno,
						 strerror(errno));
				}
			}
		}

	}			/* End for TEST_LOOPING */

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();

	return 0;
}				/* End main */
Example #23
0
int main(int ac, char **av)
{
	int lc;
	char *msg;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	 }

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {
		int i;

		/* reset Tst_count in case we are looping */
		Tst_count = 0;

		for (i = 0; i < TST_TOTAL; i++) {

			/* Set the real or effective user id */
			TEST(setreuid(*test_data[i].real_uid,
				      *test_data[i].eff_uid));

			if (TEST_RETURN == *test_data[i].exp_ret) {
				if (TEST_RETURN == neg_one) {
					if (TEST_ERRNO != EPERM) {
						tst_resm(TFAIL,
							 "setreuid(%d, %d) "
							 "did not set errno "
							 "value as expected.",
							 *test_data[i].real_uid,
							 *test_data[i].eff_uid);
						continue;
					}
					tst_resm(TPASS, "setreuid(%d, %d) "
						 "failed as expected.",
						 *test_data[i].real_uid,
						 *test_data[i].eff_uid);
				} else {
					tst_resm(TPASS, "setreuid(%d, %d) "
						 "succeeded as expected.",
						 *test_data[i].real_uid,
						 *test_data[i].eff_uid);
				}
			} else {
				tst_resm(TFAIL, "setreuid(%d, %d) "
					 "did not return as expected.",
					 *test_data[i].real_uid,
					 *test_data[i].eff_uid);
			}

			if (TEST_RETURN == -1) {
				TEST_ERROR_LOG(TEST_ERRNO);
			}
			/*
			 * Perform functional verification if test
			 * executed without (-f) option.
			 */
			if (STD_FUNCTIONAL_TEST) {
				uid_verify(test_data[i].exp_real_usr,
					   test_data[i].exp_eff_usr,
					   test_data[i].test_msg);
			}
		}
	}

	cleanup();
	tst_exit();

}
Example #24
0
int main(int ac, char **av)
{

	int lc, i;
	char *msg;

	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		for (i = 0; i < TST_TOTAL; ++i) {
			/*
			 * since Linux 2.6.26, if buf.offset value is outside
			 * the acceptable range, it is simply normalized instead
			 * of letting the syscall fail. so just skip this test
			 * case.
			 */
			if ((i == 3 || i == 4) && tst_kvercmp(2, 6, 25) > 0) {
				tst_resm(TCONF, "this kernel normalizes buf."
					 "offset value if it is outside"
					 " the acceptable range.");
				continue;
			}

			buff = tim_save;
			buff.modes = SET_MODE;
			if ((test_cases[i].setup) && (test_cases[i].setup())) {
				tst_resm(TWARN, "setup() failed, skipping"
					 " this test case");
				continue;
			}

			/* Call adjtimex(2) */
			TEST(adjtimex(test_cases[i].buffp));

			if ((TEST_RETURN == -1) && (TEST_ERRNO ==
						    test_cases[i].exp_errno)) {
				tst_resm(TPASS | TTERRNO,
					 "Test Passed, adjtimex() returned -1");
			} else {
				tst_resm(TFAIL | TTERRNO,
					 "Test Failed, adjtimex() returned %ld",
					 TEST_RETURN);
			}
			TEST_ERROR_LOG(TEST_ERRNO);
			if (test_cases[i].cleanup) {
				test_cases[i].cleanup();
			}
		}
	}

	/* cleanup and exit */
	cleanup();

	tst_exit();

}
Example #25
0
int
main(int ac, char **av)
{
    int lc;		/* loop counter */
    char *msg;		/* message returned from parse_opts */
    
    /***************************************************************
     * parse standard options
     ***************************************************************/
    if ( (msg=parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *) NULL )
	tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
    setup();

    /* set the expected errnos... */
    TEST_EXP_ENOS(exp_enos);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
    for (lc=0; TEST_LOOPING(lc); lc++) {

	/* reset Tst_count in case we are looping. */
	Tst_count=0;

	/* 
	 * Call open(2)
	 */
	TEST(open(fname,O_RDWR|O_CREAT,0700));
	
	fd=TEST_RETURN;

	/* check return code */
	if ( TEST_RETURN == -1 ) {
	    TEST_ERROR_LOG(TEST_ERRNO);
	    tst_resm(TFAIL, "open(%s,O_RDWR|O_CREAT,0700) Failed, errno=%d : %s", fname,
		     TEST_ERRNO, strerror(TEST_ERRNO));
	} else {
	    /***************************************************************
	     * only perform functional verification if flag set (-f not given)
	     ***************************************************************/
	    if ( STD_FUNCTIONAL_TEST ) {
		/* No Verification test, yet... */
		tst_resm(TPASS, "open(%s, O_RDWR|O_CREAT,0700) returned %d",
			 fname, TEST_RETURN);
	    } 
	    
	    if (close(fd) == -1) {
		tst_brkm(TBROK, cleanup,
			 "close(%s) Failed, errno=%d : %s",
			 fname, errno, strerror(errno));
	    } else if (unlink(fname) == -1) {
		tst_brkm(TBROK, cleanup,
			 "unlink(%s) Failed, errno=%d : %s",
			 fname, errno, strerror(errno));
	    }
	}
    }	/* End for TEST_LOOPING */

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
    cleanup();

    return 0;
}	/* End main */
Example #26
0
int main(int ac, char **av)
{
	int lc, i;
	char *msg;

	if ((msg = parse_opts(ac, av, options, &help)) != NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	}

	/* Check for mandatory option of the testcase */
	if (Dflag == 0) {
		tst_brkm(TBROK, NULL, "You must specifiy the device used for "
			 " mounting with -D option, Run '%s  -h' for option "
			 " information.", TCID);
		tst_exit();
	}

	if (STD_COPIES != 1) {
		tst_resm(TINFO, "-c option has no effect for this testcase - "
			 "%s doesn't allow running more than one instance "
			 "at a time", TCID);
		STD_COPIES = 1;
	}

	setup();

	for (lc = 0; TEST_LOOPING(lc); lc++) {

		tst_count = 0;

		for (i = 0; i < TST_TOTAL; ++i) {

			if (setup_test(i, lc)) {
				tst_resm(TWARN, "Not able to test mount(2) for "
					 "error %s as setup failed",
					 testcases[i].exp_errval);
				continue;
			}

			/* Call umount(2) to test different test conditions.
			 * verify that it fails with -1 return value and
			 * sets appropriate errno.*/

			TEST(umount(Mntpoint));

			/* check return code */
			if ((TEST_RETURN == -1) &&
			    (TEST_ERRNO == testcases[i].exp_errno)) {
				tst_resm(TPASS, "umount(2) expected failure; "
					 "Got errno - %s : %s",
					 testcases[i].exp_errval,
					 testcases[i].err_desc);
			} else {
				tst_resm(TFAIL, "umount(2) failed to produce "
					 "expected error; %d, errno:%s got %d",
					 testcases[i].exp_errno,
					 testcases[i].exp_errval, TEST_ERRNO);
			}

			TEST_ERROR_LOG(TEST_ERRNO);

			cleanup_test(i);
		}
	}

	cleanup();
	tst_exit();
}
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */
	void *alt_stk;		/* address of alternate stack for signal */

	/* Parse standard options given to run the test. */
	msg = parse_opts(ac, av, (option_t *) NULL, NULL);
	if (msg != (char *)NULL) {
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);
		tst_exit();
	 /*NOTREACHED*/}

	/* Perform global setup for test */
	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

	/* Check looping state if -i option given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* Reset Tst_count in case we are looping. */
		Tst_count = 0;

		/* Call sigaltstack() to set up an alternate stack */
		sigstk.ss_size = SIGSTKSZ;
		sigstk.ss_flags = 0;
		TEST(sigaltstack(&sigstk, &osigstk));

		/* check return code of sigaltstack */
		if (TEST_RETURN == -1) {
			TEST_ERROR_LOG(TEST_ERRNO);
			tst_resm(TFAIL,
				 "sigaltstack() Failed, errno=%d : %s",
				 TEST_ERRNO, strerror(TEST_ERRNO));
		} else {
			/*
			 * Perform functional verification if test
			 * executed without (-f) option.
			 */
			if (STD_FUNCTIONAL_TEST) {
				/* Set up the signal handler for 'SIGUSR1' */
				act.sa_flags = SA_ONSTACK;
				act.sa_handler = (void (*)())sig_handler;
				if ((sigaction(SIGUSR1, &act, &oact)) == -1) {
					tst_brkm(TFAIL, cleanup, "sigaction() "
						 "fails to trap signal "
						 "delivered on alt. stack, "
						 "error=%d", errno);
				}

				/* Deliver signal onto the alternate stack */
				kill(my_pid, SIGUSR1);

				/* wait till the signal arrives */
				while (!got_signal) ;

				got_signal = 0;
				alt_stk = addr;

				/*
				 * First,
				 * Check that alt_stk is within the
				 * alternate stk boundaries
				 *
				 * Second,
				 * Check that main_stk is outside the
				 * alternate stk boundaries.
				 */
				if ((alt_stk < sigstk.ss_sp) ||
				    (alt_stk > (sigstk.ss_sp + SIGSTKSZ))) {
					tst_resm(TFAIL,
						 "alt. stack is not within the "
						 "alternate stk boundaries");
				} else if ((main_stk >= sigstk.ss_sp) &&
					   (main_stk <=
					    (sigstk.ss_sp + SIGSTKSZ))) {
					tst_resm(TFAIL,
						 "main stk. not outside the "
						 "alt. stack boundaries");
				} else {
					tst_resm(TPASS,
						 "Functionality of "
						 "sigaltstack() successful");
				}
			} else {
				tst_resm(TPASS, "CALL succeeded.");
			}
		}
		Tst_count++;	/* incr. TEST_LOOP counter */
	}			/* End for TEST_LOOPING */

	/* Call cleanup() to undo setup done for the test. */
	cleanup();
	 /*NOTREACHED*/ return 0;

}				/* End main */
Example #28
0
int main(int ac, char **av)
{
	int lc;			/* loop counter */
	char *msg;		/* message returned from parse_opts */

	pid_t pid;
	int status;

	/* parse standard options */
	if ((msg = parse_opts(ac, av, (option_t *) NULL, NULL)) != (char *)NULL) {
		tst_brkm(TBROK, cleanup, "OPTION PARSING ERROR - %s", msg);
	}

	setup();

	/* set up the expected errnos */
	TEST_EXP_ENOS(exp_enos);

	/* check for looping state if -i option is given */
	for (lc = 0; TEST_LOOPING(lc); lc++) {
		/* reset Tst_count in case we are looping */
		Tst_count = 0;

		if ((pid = FORK_OR_VFORK()) < 0) {
			tst_brkm(TBROK, cleanup, "fork failed");
		}

		if (pid == 0) {	/* child */
			/*
			 * set the child's ID to ltpuser1 using seteuid()
			 * so that the ID can be changed back after the
			 * TEST call is made.
			 */
			if (seteuid(ltpuser1->pw_uid) != 0) {
				tst_resm(TINFO, "setreuid failed in child #1");
				exit(1);
			}
			if (mkdir(good_dir, 00400) != 0) {
				tst_resm(TINFO, "mkdir failed in child #1");
				exit(1);
			}
			if ((fd = open(good_dir, O_RDONLY)) == -1) {
				tst_brkm(TBROK, cleanup,
					 "open of directory failed");
			}

			TEST(fchdir(fd));

			if (TEST_RETURN != -1) {
				tst_resm(TFAIL, "call succeeded unexpectedly");
			} else if (TEST_ERRNO != EACCES) {
				tst_resm(TFAIL, "expected EACCES - got %d",
					 TEST_ERRNO);
			} else {
				TEST_ERROR_LOG(TEST_ERRNO);
				tst_resm(TPASS, "expected failure - errno = %d"
					 " : %s", TEST_ERRNO,
					 strerror(TEST_ERRNO));
			}

			/* reset the process ID to the saved ID (root) */
			if (setuid(0) == -1) {
				tst_resm(TINFO, "setuid(0) failed");
			}

		} else {	/* parent */
			wait(&status);

			/* let the child carry on */
			exit(0);
		}

		/* clean up things in case we are looping */
		if (rmdir(good_dir) == -1) {
			tst_brkm(TBROK, cleanup, "Couldn't remove directory");
		}

	}
	cleanup();

	 /*NOTREACHED*/ return 0;
}
Example #29
0
int main(int ac, char **av)
{
	int lc;
	char *msg;

    /***************************************************************
     * parse standard options
     ***************************************************************/
	if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
		tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

    /***************************************************************
     * perform global setup for test
     ***************************************************************/
	setup();

	/* set the expected errnos... */
	TEST_EXP_ENOS(exp_enos);

    /***************************************************************
     * check looping state if -c option given
     ***************************************************************/
	for (lc = 0; TEST_LOOPING(lc); lc++) {

		Tst_count = 0;

		(void)signal(SIGALRM, go);
		alarm(1);
		/*
		 * Call pause(2)
		 */
		TEST(pause());

		/* check return code.  Pause returns -1 and EINTR errno */
		if (TEST_RETURN != -1) {
			tst_resm(TFAIL,
				 "pause() returned WITHOUT an error return code : %d",
				 TEST_ERRNO);
		} else {
			/* log the errno */
			TEST_ERROR_LOG(TEST_ERRNO);
	    /***************************************************************
	     * only perform functional verification if flag set (-f not given)
	     ***************************************************************/
			if (STD_FUNCTIONAL_TEST) {
				/* check the errno */
				if (TEST_ERRNO == EINTR)
					tst_resm(TPASS, "pause() returned %ld",
						 TEST_RETURN);
				else
					tst_resm(TFAIL,
						 "pause() returned %ld. Expected %d (EINTR)",
						 TEST_RETURN, EINTR);
			}
		}
	}

    /***************************************************************
     * cleanup and exit
     ***************************************************************/
	cleanup();
	tst_exit();

}
Example #30
0
int main(int ac, char **av)
{
    int lc;			/* loop counter */
    int retval = 0;
    char *msg;		/* message returned from parse_opts */

    pid_t pid, pid1;
    int i, status, fd;

    /* parse standard options */
    if ((msg = parse_opts(ac, av, NULL, NULL)) != NULL)
        tst_brkm(TBROK, NULL, "OPTION PARSING ERROR - %s", msg);

    setup();

    TEST_EXP_ENOS(exp_enos);

    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|TERRNO, cleanup, "fork() #1 failed");
        }

        if (pid == 0) {	/* first child */
            if (mkdir(good_dir, DMODE) != 0) {
                perror("mkdir() failed");
                exit(1);
            }
            if ((fd = open(fname1, O_RDWR | O_CREAT, 0444)) == -1) {
                perror("open failed");
                exit(1);
            }
            exit(0);
        }
        wait(&status);

        /* make sure the child returned a good exit status */
        if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
            tst_brkm(TBROK, cleanup, "child #1 failed");
        }

        if ((pid1 = FORK_OR_VFORK()) == -1) {
            tst_brkm(TBROK|TERRNO, cleanup, "fork() #2 failed");
        }

        if (pid1 == 0) {	/* second child */

            ltpuser1 = my_getpwnam(user1name);

            if (ltpuser1 == NULL) {
                perror("getpwnam");
                exit(1);
            }
            if (seteuid(ltpuser1->pw_uid) == -1) {
                perror("seteuid");
                exit(1);
            }

            /* loop through the test cases */
            for (i = 0; i < TST_TOTAL; i++) {

                TEST(creat(TC[i].fname, FMODE));

                if (TEST_RETURN != -1) {
                    retval = 1;
                    tst_resm(TFAIL, "call succeeded "
                             "unexpectedly");
                    continue;
                }

                TEST_ERROR_LOG(TEST_ERRNO);

                if (TEST_ERRNO != EACCES) {
                    retval = 1;
                    tst_resm(TFAIL|TTERRNO, "Expected EACCES");
                } else {
                    tst_resm(TPASS, "call failed with "
                             "EACCES as expected");
                }
            }

            seteuid(0);

            /* clean up things in case we are looping */
            unlink(fname);
            unlink(fname1);
            rmdir(good_dir);
            exit(retval);

        } else {	/* parent */
            /* wait for the child to finish */
            wait(&status);
            /* make sure the child returned a good exit status */
            if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
                tst_resm(TFAIL, "see failures reported above");
            }
        }
    }
    cleanup();

    tst_exit();
}