759 lines
23 KiB
C
759 lines
23 KiB
C
/*
|
|
*
|
|
* Copyright (c) International Business Machines Corp., 2002
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
|
|
* the GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
/* 10/31/2002 Port to LTP robbiew@us.ibm.com */
|
|
/* 06/30/2001 Port to Linux nsharoff@us.ibm.com */
|
|
|
|
/*
|
|
* NAME
|
|
* nftw64.c - Test of nftw64()
|
|
*/
|
|
|
|
#include <pwd.h>
|
|
#include "nftw64.h"
|
|
|
|
void setup(void);
|
|
void blenter(void);
|
|
void blexit(void);
|
|
void anyfail(void);
|
|
|
|
char progname[] = "nftw64.c";
|
|
|
|
/** LTP Port **/
|
|
#define FAILED 0
|
|
#define PASSED 1
|
|
|
|
int local_flag = PASSED;
|
|
int block_number;
|
|
|
|
FILE *temp;
|
|
char *TCID = "nftw6401";
|
|
int TST_TOTAL = 10;
|
|
|
|
struct passwd *ltpuser; /* password struct for ltpuser */
|
|
/**************/
|
|
|
|
/* Used for error return for some library routines */
|
|
int s2;
|
|
|
|
/* error messages formatted here. */
|
|
char ebuf[ERR_BUF_SIZ];
|
|
|
|
/*
|
|
* Local data declarations.
|
|
*/
|
|
char *dirlist[NDIRLISTENTS];
|
|
|
|
int visit;
|
|
int next_fd[4];
|
|
|
|
pathdata pathdat[] = {
|
|
{
|
|
"./tmp/data",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH,
|
|
DIR, ""}, {
|
|
"./tmp/byebye",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
REG, "byebye!\n"}, {
|
|
"./tmp/data/d333",
|
|
S_IRWXU | S_IRWXG | S_IRWXO,
|
|
DIR, ""}, {
|
|
"./tmp/data/d666",
|
|
S_IRWXU | S_IRWXG | S_IRWXO,
|
|
DIR, ""}, {
|
|
"./tmp/data/d777",
|
|
S_IRWXU | S_IRWXG
|
|
| S_IRWXO,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirg",
|
|
S_IRWXU
|
|
|
|
|
S_IRWXG
|
|
|
|
|
S_IROTH
|
|
|
|
|
S_IWOTH,
|
|
DIR,
|
|
""}, {
|
|
"./tmp/data/dirh",
|
|
S_IRWXU
|
|
|
|
|
S_IRWXG
|
|
|
|
|
S_IROTH
|
|
|
|
|
S_IWOTH,
|
|
DIR,
|
|
""},
|
|
{
|
|
"./tmp/data/dirl",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/d333/errs",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
REG, "Do not eat yellow snow!\n"}, {
|
|
"./tmp/data/d666/errs",
|
|
S_IRWXU | S_IRWXG |
|
|
S_IROTH | S_IWOTH,
|
|
REG,
|
|
"Do not eat yellow snow!\n"},
|
|
{
|
|
"./tmp/data/d777/errs",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
REG, "Do not eat yellow snow!\n"}, {
|
|
"./tmp/data/dirg/filebad",
|
|
S_IRUSR | S_IWUSR | S_IRGRP |
|
|
S_IROTH,
|
|
REG, ""}, {
|
|
"./tmp/data/dirg/fileok",
|
|
S_IRUSR | S_IWUSR |
|
|
S_IRGRP | S_IROTH,
|
|
REG, ""}, {
|
|
"./tmp/data/dirg/symlink",
|
|
S_IRWXU |
|
|
S_IRWXG |
|
|
S_IRWXO,
|
|
SYM,
|
|
"../../byebye"},
|
|
{
|
|
"./tmp/data/dirg/dir_left.1",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirg/dir_left.1/dir_left.2",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirg/dir_right.1",
|
|
S_IRWXU | S_IRWXG | S_IRWXO,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirg/dir_left.1/dir_left.2/left.3",
|
|
S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP
|
|
| S_IROTH,
|
|
REG, ""}, {
|
|
"./tmp/data/dirh/dir_left.1",
|
|
S_IRWXU | S_IRWXG | S_IROTH
|
|
| S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirh/dir_right.1",
|
|
S_IRWXU |
|
|
S_IRWXG |
|
|
S_IROTH |
|
|
S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirh/dir_left.1/dir_left.2",
|
|
S_IRWXU
|
|
|
|
|
S_IRWXG
|
|
|
|
|
S_IROTH
|
|
|
|
|
S_IWOTH,
|
|
DIR,
|
|
""},
|
|
{
|
|
"./tmp/data/dirh/dir_left.1/dir_left.2/left.3",
|
|
S_IRWXU | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH,
|
|
REG, "left leaf\n"}, {
|
|
"./tmp/data/dirh/dir_right.1/dir_right.2",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirh/dir_right.1/dir_right.2/right.3",
|
|
S_IRWXU | S_IRGRP | S_IWGRP | S_IROTH
|
|
| S_IWOTH,
|
|
REG, "right leaf\n"}, {
|
|
"./tmp/data/dirl/dir_left.1",
|
|
S_IRWXU |
|
|
S_IRWXG |
|
|
S_IROTH |
|
|
S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirl/dir_left.1/dir_left.2",
|
|
S_IRWXU
|
|
|
|
|
S_IRWXG
|
|
|
|
|
S_IROTH
|
|
|
|
|
S_IWOTH,
|
|
DIR,
|
|
""},
|
|
{
|
|
"./tmp/data/dirl/dir_left.1/dir_left.2/left.3",
|
|
0,
|
|
SYM, "../../../dirh"}, {
|
|
"./tmp/data/dirl/dir_right.1",
|
|
S_IRWXU | S_IRWXG | S_IROTH | S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirl/dir_right.1/dir_right.2",
|
|
S_IRWXU | S_IRWXG | S_IROTH |
|
|
S_IWOTH,
|
|
DIR, ""}, {
|
|
"./tmp/data/dirl/dir_right.1/dir_right.2/right.3",
|
|
0,
|
|
SYM, "../dir_right.2"}, {
|
|
"./tmp/data/loop",
|
|
0,
|
|
SYM,
|
|
"./loop"}
|
|
};
|
|
|
|
char *goodlist[] = {
|
|
"/dirh",
|
|
"/dirh/dir_left.1",
|
|
"/dirh/dir_right.1",
|
|
"/dirh/dir_left.1/dir_left.2",
|
|
"/dirh/dir_right.1/dir_right.2",
|
|
"/dirh/dir_left.1/dir_left.2/left.3",
|
|
"/dirh/dir_right.1/dir_right.2/right.3"
|
|
};
|
|
|
|
struct list badlist[] = {
|
|
{"/dirg", FTW_D},
|
|
{"/dirg/dir_left.1", FTW_D},
|
|
/* not FTW_NS in following since stat can't fail if file exists */
|
|
{"/dirg/filebad", FTW_F},
|
|
{"/dirg/fileok", FTW_F},
|
|
{"/dirg/symlink", FTW_SL},
|
|
{"/dirg/dir_right.1", FTW_DNR},
|
|
{"/dirg/dir_left.1/dir_left.2", FTW_D},
|
|
{"/dirg/dir_left.1/dir_left.2/left.3", FTW_F},
|
|
};
|
|
|
|
struct list mnem[] = {
|
|
{"FTW_F", FTW_F},
|
|
{"FTW_D", FTW_D},
|
|
{"FTW_DNR", FTW_DNR},
|
|
{"FTW_NS", FTW_NS},
|
|
{"FTW_SL", FTW_SL},
|
|
{"FTW_DP", FTW_DP},
|
|
{"FTW_SLN", FTW_SLN},
|
|
};
|
|
|
|
int npathdats, ngoods, nbads, nmnem;
|
|
|
|
/*--------------------------------------------------------------*/
|
|
int main(void)
|
|
{
|
|
setup(); /* temp file is now open */
|
|
|
|
npathdats = ARRAY_SIZE(pathdat);
|
|
ngoods = ARRAY_SIZE(goodlist);
|
|
nbads = ARRAY_SIZE(badlist);
|
|
nmnem = ARRAY_SIZE(mnem);
|
|
|
|
setup_path();
|
|
|
|
/*---------------- ENTER BLOCK 0 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall recursively descend the\n");
|
|
fprintf(temp, "directory hierarchy rooted in path until it has\n");
|
|
fprintf(temp,
|
|
"traversed the whole tree, calling the function fn for\n");
|
|
fprintf(temp, "each object in the directory tree, and return 0.\n\n");
|
|
#endif
|
|
test1A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 0 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 1 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) when flags contains FTW_PHYS shall\n");
|
|
fprintf(temp, "not traverse symbolic links.\n\n");
|
|
#endif
|
|
test2A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 1 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 2 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp,
|
|
"depth, int flags) when flags does not contain FTW_PHYS\n");
|
|
fprintf(temp,
|
|
"shall follow links instead of reporting them and shall\n");
|
|
fprintf(temp, "not report the same file twice.\n\n");
|
|
#endif
|
|
test3A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 2 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 3 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp,
|
|
"depth, int flags) when flags contains FTW_DEPTH shall\n");
|
|
fprintf(temp, "report all files in a directory before reporting the\n");
|
|
fprintf(temp, "directory.\n\n");
|
|
#endif
|
|
test4A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 3 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 4 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) when flags does not contain\n");
|
|
fprintf(temp, "FTW_DEPTH shall report a directory before reporting\n");
|
|
fprintf(temp, "the files in that directory.\n\n");
|
|
#endif
|
|
test5A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 4 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 5 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp,
|
|
"depth, int flags) when flags contains FTW_CHDIR shall\n");
|
|
fprintf(temp,
|
|
"change the current working directory to each directory\n");
|
|
fprintf(temp, "as it reports files in that directory.\n\n");
|
|
#endif
|
|
test6A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 5 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 6 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass the path-name of the\n");
|
|
fprintf(temp, "current object as the first argument of the function\n");
|
|
fprintf(temp, "fn.\n\n");
|
|
#endif
|
|
test7A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 6 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 7 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass a pointer to a stat\n");
|
|
fprintf(temp, "structure containing information about the current\n");
|
|
fprintf(temp, "object as the second argument to fn.\n\n");
|
|
#endif
|
|
test8A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 7 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 8 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_F as the third\n");
|
|
fprintf(temp,
|
|
"argument of the function fn when the object is a file.\n\n");
|
|
#endif
|
|
test9A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 8 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 9 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_D as the third\n");
|
|
fprintf(temp, "argument of the function fn when the object is a\n");
|
|
fprintf(temp, "directory.\n\n");
|
|
#endif
|
|
test10A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 9 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 10 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_DP as the third\n");
|
|
fprintf(temp, "argument of the function fn when the object is a\n");
|
|
fprintf(temp, "directory and subdirectories have been visited.\n\n");
|
|
#endif
|
|
test11A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 10 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 11 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
|
|
fprintf(temp, "argument of the function fn when the object is a\n");
|
|
fprintf(temp, "symbolic link.\n\n");
|
|
#endif
|
|
test12A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 11 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 12 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
|
|
fprintf(temp, "argument of the function fn when the object is a\n");
|
|
fprintf(temp, "symbolic link that does not name an existing file.\n\n");
|
|
#endif
|
|
test13A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 12 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 13 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_DNR as the third\n");
|
|
fprintf(temp, "argument of the function fn when the object is a\n");
|
|
fprintf(temp, "directory that cannot be read.\n\n");
|
|
#endif
|
|
test14A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 13 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 14 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_NS as the third\n");
|
|
fprintf(temp,
|
|
"argument of the function fn when stat() failed on the\n");
|
|
fprintf(temp, "object because of lack of appropriate permission.\n\n");
|
|
#endif
|
|
test15A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 14 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 15 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass a structure which\n");
|
|
fprintf(temp, "contains the offset into the pathname of the object\n");
|
|
fprintf(temp, "and the depth relative to the root of the walk\n");
|
|
fprintf(temp,
|
|
"starting from 0 as the fourth argument of the function\n");
|
|
fprintf(temp, "fn.\n\n");
|
|
#endif
|
|
test16A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 15 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 16 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_SL as the third\n");
|
|
fprintf(temp, "argument to the function fn if and only if the\n");
|
|
fprintf(temp, "FTW_PHYS flag is included in flags.\n\n");
|
|
#endif
|
|
test17A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 16 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 17 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall pass FTW_SLN as the third\n");
|
|
fprintf(temp, "argument to the function fn if and only if the\n");
|
|
fprintf(temp, "FTW_PHYS flag is not included in flags.\n\n");
|
|
#endif
|
|
test18A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 17 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 18 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "On a call to int nftw64(const char *path, int\n");
|
|
fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
|
|
fprintf(temp,
|
|
"FTW *), int depth, int flags) when the third argument\n");
|
|
fprintf(temp, "passed to the function fn is FTW_DNR then the\n");
|
|
fprintf(temp,
|
|
"descendants of the directory shall not be processed.\n\n");
|
|
#endif
|
|
test19A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 18 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 19 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp,
|
|
"depth, int flags) shall close any file descriptors or\n");
|
|
fprintf(temp,
|
|
"directory streams used to traverse the directory tree.\n\n");
|
|
#endif
|
|
test20A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 19 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 20 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "On a call to int nftw64(const char *path, int\n");
|
|
fprintf(temp, "(*fn)(const char *, const struct stat *, int, struct\n");
|
|
fprintf(temp, "FTW *), int depth, int flags) depth shall be the\n");
|
|
fprintf(temp,
|
|
"maximum number of file descriptors used for the search.\n\n");
|
|
#endif
|
|
test21A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 20 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 21 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) shall use at most one file\n");
|
|
fprintf(temp, "descriptor for each directory level.\n\n");
|
|
#endif
|
|
test22A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 21 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 22 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp,
|
|
"A call to int nftw64(const char *path, int (*fn)(const\n");
|
|
fprintf(temp, "char *, const struct stat *, int, struct FTW *), int\n");
|
|
fprintf(temp, "depth, int flags) when the function fn returns a\n");
|
|
fprintf(temp, "non-zero value shall stop and return the value\n");
|
|
fprintf(temp, "returned by fn.\n\n");
|
|
#endif
|
|
test23A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 22 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 23 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when the length of path exceeds PATH_MAX.\n\n");
|
|
#endif
|
|
test24A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 23 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 24 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "ENAMETOOLONG in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when a component of path exceeds NAME_MAX.\n\n");
|
|
#endif
|
|
test25A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 24 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 25 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp,
|
|
"flags) when path points to a file which does not exist.\n\n");
|
|
#endif
|
|
test26A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 25 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 26 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "ENOENT in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when path points to an empty string.\n\n");
|
|
#endif
|
|
test27A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 26 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 27 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "ENOTDIR in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when path is not a directory.\n\n");
|
|
#endif
|
|
test28A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 27 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 28 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when search permission is denied for any\n");
|
|
fprintf(temp, "component of path.\n\n");
|
|
#endif
|
|
test29A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 28 ---------------------------------*/
|
|
|
|
/*---------------- ENTER BLOCK 29 --------------------------------*/
|
|
blenter();
|
|
#ifdef DEBUG
|
|
fprintf(temp, "EACCES in errno and return -1 on a call to int\n");
|
|
fprintf(temp,
|
|
"nftw64(const char *path, int (*fn)(const char *, const\n");
|
|
fprintf(temp, "struct stat *, int, struct FTW *), int depth, int\n");
|
|
fprintf(temp, "flags) when read permission is denied for path.\n\n");
|
|
#endif
|
|
test30A();
|
|
blexit();
|
|
/*--------------- EXIT BLOCK 29 ---------------------------------*/
|
|
|
|
cleanup_function();
|
|
|
|
anyfail(); /* THIS CALL DOES NOT RETURN - EXITS!! */
|
|
|
|
tst_exit();
|
|
}
|
|
|
|
/*--------------------------------------------------------------*/
|
|
|
|
/** LTP Port **/
|
|
/*
|
|
* setup
|
|
*
|
|
* Do set up - here its a dummy function
|
|
*/
|
|
void setup(void)
|
|
{
|
|
/* Direct debug output to stderr */
|
|
temp = stderr;
|
|
|
|
/* Get the user id "nobody" */
|
|
if ((ltpuser = getpwnam("nobody")) == NULL) {
|
|
perror("change_owner: nobody not found in /etc/passwd");
|
|
exit(1);
|
|
}
|
|
|
|
/* Switch to "nobody" */
|
|
setuid(ltpuser->pw_uid);
|
|
|
|
tst_tmpdir();
|
|
}
|
|
|
|
/*
|
|
* Function: blenter()
|
|
*
|
|
* Description: Print message on entering a new block
|
|
*/
|
|
void blenter(void)
|
|
{
|
|
local_flag = PASSED;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Function: blexit()
|
|
*
|
|
* Description: This function will exit a block, a block may be a logical unit
|
|
* of a test. It will report the status if the test ie fail or
|
|
* pass.
|
|
*/
|
|
void blexit(void)
|
|
{
|
|
(local_flag == PASSED) ? tst_resm(TPASS, "Test block %d", block_number)
|
|
: tst_resm(TFAIL, "Test block %d", block_number);
|
|
block_number++;
|
|
return;
|
|
}
|
|
|
|
/*
|
|
*
|
|
* Function: anyfail()
|
|
*
|
|
* Description: Exit a test.
|
|
*/
|
|
void anyfail(void)
|
|
{
|
|
(local_flag == FAILED) ? tst_resm(TFAIL, "Test failed")
|
|
: tst_resm(TPASS, "Test passed");
|
|
tst_rmdir();
|
|
tst_exit();
|
|
}
|
|
|
|
/**************/
|