static int open_testfile(char *filename)
{
int fd;
/* file might be around from an earlier run, nuke it. */
(void) unlink(filename);
if (rand_bool()) {
fd = open_with_fopen(filename, O_RDWR);
if (fd != -1)
output(2, "fd[%d] = fopen(\"%s\", O_RDWR)\n", fd, filename);
fcntl(fd, F_SETFL, random_fcntl_setfl_flags());
} else {
const unsigned long open_flags[] = { O_DIRECT, O_DSYNC, O_SYNC, };
int flags = 0;
flags = set_rand_bitmask(ARRAY_SIZE(open_flags), open_flags);;
fd = open(filename, O_CREAT | flags, 0666);
if (fd != -1)
output(2, "fd[%d] = open(\"%s\", flags:%x)\n", fd, filename, flags); //TODO: decode flags
}
return fd;
}
static int open_file(void)
{
const char *filename;
const char *modestr;
struct stat sb;
int fd;
int ret;
int tries = 0;
int fcntl_flags;
int flags, randflags;
bool opened_with_fopen = FALSE;
retry:
filename = get_filename();
ret = lstat(filename, &sb);
if (ret == -1)
goto retry;
flags = check_stat_file(&sb);
if (flags == -1)
goto retry;
/* OR in some random flags. */
retry_flags:
if (rand_bool()) {
randflags = get_o_flags();
fd = open(filename, flags | randflags | O_NONBLOCK);
} else {
fd = open_with_fopen(filename, flags);
fcntl_flags = random_fcntl_setfl_flags();
fcntl(fd, F_SETFL, fcntl_flags);
opened_with_fopen = TRUE;
}
if (fd < 0) {
/*
* if we failed to open the file, retry with different flags.
* we should eventually succeed, but set an arbitary upper limit of
* 50 tries before just giving up.
*/
tries++;
if (tries == 50) {
output(2, "Couldn't open %s : %s\n", filename, strerror(errno));
return fd;
}
goto retry_flags;
}
switch (flags) {
case O_RDONLY: modestr = "read-only"; break;
case O_WRONLY: modestr = "write-only"; break;
case O_RDWR: modestr = "read-write"; break;
default: modestr = "unknown"; break;
}
if (opened_with_fopen == FALSE) {
output(2, "fd[%i] = open %s (%s) flags:%x\n", fd, filename, modestr, flags | randflags);
if (victim_dev!=NULL) victim_fd=0;
}
else
{
output(2, "fd[%i] = fopen %s (%s) flags:%x fcntl_flags:%x\n",
fd, filename, modestr, flags, fcntl_flags);
//try to keep track of the victim fd in case victim_dev was specified
//and taking it valid only if the fd is read/write or write
if (victim_dev!=NULL && (flags==O_WRONLY||flags==O_RDWR)) victim_fd=fd;
else victim_fd=0;
}
return fd;
}
static void sanitise_fcntl(struct syscallrecord *rec)
{
switch (rec->a2) {
/* arg = fd */
case F_DUPFD:
case F_DUPFD_CLOEXEC:
case F_SETLEASE:
rec->a3 = (unsigned long) get_random_fd();
break;
/* no arg */
case F_GETFD:
case F_GETFL:
case F_GETOWN:
case F_GETSIG:
case F_GETLEASE:
case F_GETPIPE_SZ:
case F_GETOWNER_UIDS:
break;
case F_SETFD: /* arg = flags */
rec->a3 = (unsigned int) rand32();
break;
case F_SETFL:
rec->a3 = (unsigned long) random_fcntl_setfl_flags();
break;
/* arg = (struct flock *) */
case F_GETLK:
case F_SETLK:
case F_SETLKW:
break;
#ifdef HAVE_LK64
case F_GETLK64:
break;
case F_SETLK64:
break;
case F_SETLKW64:
break;
#endif
case F_SETOWN:
rec->a3 = (unsigned long) get_pid();
break;
/* arg = struct f_owner_ex *) */
case F_GETOWN_EX:
case F_SETOWN_EX:
break;
case F_SETSIG:
rec->a3 = (unsigned long) rand32();
if (rec->a3 == SIGINT)
rec->a3 = 0; /* restore default (SIGIO) */
break;
case F_NOTIFY:
rec->a3 = 0L;
if (rand_bool())
rec->a3 |= DN_ACCESS;
if (rand_bool())
rec->a3 |= DN_MODIFY;
if (rand_bool())
rec->a3 |= DN_CREATE;
if (rand_bool())
rec->a3 |= DN_DELETE;
if (rand_bool())
rec->a3 |= DN_RENAME;
if (rand_bool())
rec->a3 |= DN_ATTRIB;
break;
case F_SETPIPE_SZ:
rec->a3 = rand32();
break;
default:
break;
}
}
static int open_file(void)
{
const char *filename;
const char *modestr;
struct stat sb;
int fd;
int ret;
int tries = 0;
int fcntl_flags = 0;
int flags, randflags = 0;
bool opened_with_fopen = FALSE;
retry:
filename = get_filename();
ret = lstat(filename, &sb);
if (ret == -1)
goto retry;
flags = check_stat_file(&sb);
if (flags == -1)
goto retry;
/* OR in some random flags. */
retry_flags:
if (RAND_BOOL()) {
randflags = get_o_flags();
fd = open(filename, flags | randflags | O_NONBLOCK, 0666);
} else {
fd = open_with_fopen(filename, flags);
fcntl_flags = random_fcntl_setfl_flags();
fcntl(fd, F_SETFL, fcntl_flags);
opened_with_fopen = TRUE;
}
if (fd < 0) {
/*
* if we failed to open the file, retry with different flags.
* we should eventually succeed, but set an arbitary upper limit of
* 50 tries before just giving up.
*/
tries++;
if (tries == 50) {
output(2, "Couldn't open %s : %s\n", filename, strerror(errno));
return fd;
}
goto retry_flags;
}
switch (flags) {
case O_RDONLY: modestr = "read-only"; break;
case O_WRONLY: modestr = "write-only"; break;
case O_RDWR: modestr = "read-write"; break;
default: modestr = "unknown"; break;
}
if (opened_with_fopen == FALSE)
output(2, "fd[%i] = open %s (%s) flags:%x\n", fd, filename, modestr, flags | randflags);
else
output(2, "fd[%i] = fopen %s (%s) flags:%x fcntl_flags:%x\n",
fd, filename, modestr, flags, fcntl_flags);
return fd;
}